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-2020 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
56 #include "lcms2_internal.h"
57
58
59 // ----------------------------------------------------------------------------------
60 // Encoding & Decoding support functions
61 // ----------------------------------------------------------------------------------
62
63 // Little-Endian to Big-Endian
64
65 // Adjust a word value after being read/ before being written from/to an ICC profile
66 cmsUInt16Number CMSEXPORT _cmsAdjustEndianess16(cmsUInt16Number Word)
67 {
68 #ifndef CMS_USE_BIG_ENDIAN
69
70 cmsUInt8Number* pByte = (cmsUInt8Number*) &Word;
71 cmsUInt8Number tmp;
72
73 tmp = pByte[0];
74 pByte[0] = pByte[1];
75 pByte[1] = tmp;
76 #endif
77
78 return Word;
79 }
80
81
82 // Transports to properly encoded values - note that icc profiles does use big endian notation.
83
84 // 1 2 3 4
85 // 4 3 2 1
86
87 cmsUInt32Number CMSEXPORT _cmsAdjustEndianess32(cmsUInt32Number DWord)
88 {
89 #ifndef CMS_USE_BIG_ENDIAN
90
91 cmsUInt8Number* pByte = (cmsUInt8Number*) &DWord;
92 cmsUInt8Number temp1;
93 cmsUInt8Number temp2;
94
95 temp1 = *pByte++;
96 temp2 = *pByte++;
97 *(pByte-1) = *pByte;
98 *pByte++ = temp2;
99 *(pByte-3) = *pByte;
100 *pByte = temp1;
101 #endif
102 return DWord;
103 }
104
105 // 1 2 3 4 5 6 7 8
106 // 8 7 6 5 4 3 2 1
107
108 void CMSEXPORT _cmsAdjustEndianess64(cmsUInt64Number* Result, cmsUInt64Number* QWord)
109 {
110
111 #ifndef CMS_USE_BIG_ENDIAN
112
113 cmsUInt8Number* pIn = (cmsUInt8Number*) QWord;
114 cmsUInt8Number* pOut = (cmsUInt8Number*) Result;
115
116 _cmsAssert(Result != NULL);
117
118 pOut[7] = pIn[0];
119 pOut[6] = pIn[1];
120 pOut[5] = pIn[2];
121 pOut[4] = pIn[3];
122 pOut[3] = pIn[4];
123 pOut[2] = pIn[5];
124 pOut[1] = pIn[6];
125 pOut[0] = pIn[7];
126
127 #else
128 _cmsAssert(Result != NULL);
129
130 # ifdef CMS_DONT_USE_INT64
131 (*Result)[0] = (*QWord)[0];
132 (*Result)[1] = (*QWord)[1];
133 # else
134 *Result = *QWord;
135 # endif
136 #endif
137 }
138
139 // Auxiliary -- read 8, 16 and 32-bit numbers
140 cmsBool CMSEXPORT _cmsReadUInt8Number(cmsIOHANDLER* io, cmsUInt8Number* n)
141 {
142 cmsUInt8Number tmp;
143
144 _cmsAssert(io != NULL);
145
146 if (io -> Read(io, &tmp, sizeof(cmsUInt8Number), 1) != 1)
147 return FALSE;
148
149 if (n != NULL) *n = tmp;
150 return TRUE;
151 }
152
153 cmsBool CMSEXPORT _cmsReadUInt16Number(cmsIOHANDLER* io, cmsUInt16Number* n)
154 {
155 cmsUInt16Number tmp;
156
157 _cmsAssert(io != NULL);
158
159 if (io -> Read(io, &tmp, sizeof(cmsUInt16Number), 1) != 1)
160 return FALSE;
161
162 if (n != NULL) *n = _cmsAdjustEndianess16(tmp);
163 return TRUE;
164 }
165
166 cmsBool CMSEXPORT _cmsReadUInt16Array(cmsIOHANDLER* io, cmsUInt32Number n, cmsUInt16Number* Array)
167 {
168 cmsUInt32Number i;
169
170 _cmsAssert(io != NULL);
171
172 for (i=0; i < n; i++) {
173
174 if (Array != NULL) {
175 if (!_cmsReadUInt16Number(io, Array + i)) return FALSE;
176 }
177 else {
178 if (!_cmsReadUInt16Number(io, NULL)) return FALSE;
179 }
180
181 }
182 return TRUE;
183 }
184
185 cmsBool CMSEXPORT _cmsReadUInt32Number(cmsIOHANDLER* io, cmsUInt32Number* n)
186 {
187 cmsUInt32Number tmp;
188
189 _cmsAssert(io != NULL);
190
191 if (io -> Read(io, &tmp, sizeof(cmsUInt32Number), 1) != 1)
192 return FALSE;
193
194 if (n != NULL) *n = _cmsAdjustEndianess32(tmp);
195 return TRUE;
196 }
197
198 cmsBool CMSEXPORT _cmsReadFloat32Number(cmsIOHANDLER* io, cmsFloat32Number* n)
199 {
200 cmsUInt32Number tmp;
201
202 _cmsAssert(io != NULL);
203
204 if (io->Read(io, &tmp, sizeof(cmsUInt32Number), 1) != 1)
205 return FALSE;
206
207 if (n != NULL) {
208
209 tmp = _cmsAdjustEndianess32(tmp);
210 *n = *(cmsFloat32Number*)(void*)&tmp;
211
212 // Safeguard which covers against absurd values
213 if (*n > 1E+20 || *n < -1E+20) return FALSE;
214
215 #if defined(_MSC_VER) && _MSC_VER < 1800
216 return TRUE;
217 #elif defined (__BORLANDC__)
218 return TRUE;
219 #elif !defined(_MSC_VER) && (defined(__STDC_VERSION__) && __STDC_VERSION__ < 199901L)
220 return TRUE;
221 #else
222
223 // fpclassify() required by C99 (only provided by MSVC >= 1800, VS2013 onwards)
224 return ((fpclassify(*n) == FP_ZERO) || (fpclassify(*n) == FP_NORMAL));
225 #endif
226 }
227
228 return TRUE;
229 }
230
231
232 cmsBool CMSEXPORT _cmsReadUInt64Number(cmsIOHANDLER* io, cmsUInt64Number* n)
233 {
234 cmsUInt64Number tmp;
235
236 _cmsAssert(io != NULL);
237
238 if (io -> Read(io, &tmp, sizeof(cmsUInt64Number), 1) != 1)
239 return FALSE;
240
241 if (n != NULL) {
242
243 _cmsAdjustEndianess64(n, &tmp);
244 }
245
246 return TRUE;
247 }
248
249
250 cmsBool CMSEXPORT _cmsRead15Fixed16Number(cmsIOHANDLER* io, cmsFloat64Number* n)
251 {
252 cmsUInt32Number tmp;
253
254 _cmsAssert(io != NULL);
255
256 if (io -> Read(io, &tmp, sizeof(cmsUInt32Number), 1) != 1)
257 return FALSE;
258
259 if (n != NULL) {
260 *n = _cms15Fixed16toDouble((cmsS15Fixed16Number) _cmsAdjustEndianess32(tmp));
261 }
262
263 return TRUE;
264 }
265
266
267 cmsBool CMSEXPORT _cmsReadXYZNumber(cmsIOHANDLER* io, cmsCIEXYZ* XYZ)
268 {
269 cmsEncodedXYZNumber xyz;
270
271 _cmsAssert(io != NULL);
272
273 if (io ->Read(io, &xyz, sizeof(cmsEncodedXYZNumber), 1) != 1) return FALSE;
274
275 if (XYZ != NULL) {
276
277 XYZ->X = _cms15Fixed16toDouble((cmsS15Fixed16Number) _cmsAdjustEndianess32((cmsUInt32Number) xyz.X));
278 XYZ->Y = _cms15Fixed16toDouble((cmsS15Fixed16Number) _cmsAdjustEndianess32((cmsUInt32Number) xyz.Y));
279 XYZ->Z = _cms15Fixed16toDouble((cmsS15Fixed16Number) _cmsAdjustEndianess32((cmsUInt32Number) xyz.Z));
280 }
281 return TRUE;
282 }
283
284 cmsBool CMSEXPORT _cmsWriteUInt8Number(cmsIOHANDLER* io, cmsUInt8Number n)
285 {
286 _cmsAssert(io != NULL);
287
288 if (io -> Write(io, sizeof(cmsUInt8Number), &n) != 1)
289 return FALSE;
290
291 return TRUE;
292 }
293
294 cmsBool CMSEXPORT _cmsWriteUInt16Number(cmsIOHANDLER* io, cmsUInt16Number n)
295 {
296 cmsUInt16Number tmp;
297
298 _cmsAssert(io != NULL);
299
300 tmp = _cmsAdjustEndianess16(n);
301 if (io -> Write(io, sizeof(cmsUInt16Number), &tmp) != 1)
302 return FALSE;
303
304 return TRUE;
305 }
306
307 cmsBool CMSEXPORT _cmsWriteUInt16Array(cmsIOHANDLER* io, cmsUInt32Number n, const cmsUInt16Number* Array)
308 {
309 cmsUInt32Number i;
310
311 _cmsAssert(io != NULL);
312 _cmsAssert(Array != NULL);
313
314 for (i=0; i < n; i++) {
315 if (!_cmsWriteUInt16Number(io, Array[i])) return FALSE;
316 }
317
318 return TRUE;
319 }
320
321 cmsBool CMSEXPORT _cmsWriteUInt32Number(cmsIOHANDLER* io, cmsUInt32Number n)
322 {
323 cmsUInt32Number tmp;
324
325 _cmsAssert(io != NULL);
326
327 tmp = _cmsAdjustEndianess32(n);
328 if (io -> Write(io, sizeof(cmsUInt32Number), &tmp) != 1)
329 return FALSE;
330
331 return TRUE;
332 }
333
334
335 cmsBool CMSEXPORT _cmsWriteFloat32Number(cmsIOHANDLER* io, cmsFloat32Number n)
336 {
337 cmsUInt32Number tmp;
338
339 _cmsAssert(io != NULL);
340
341 tmp = *(cmsUInt32Number*) (void*) &n;
342 tmp = _cmsAdjustEndianess32(tmp);
343 if (io -> Write(io, sizeof(cmsUInt32Number), &tmp) != 1)
344 return FALSE;
345
346 return TRUE;
347 }
348
349 cmsBool CMSEXPORT _cmsWriteUInt64Number(cmsIOHANDLER* io, cmsUInt64Number* n)
350 {
351 cmsUInt64Number tmp;
352
353 _cmsAssert(io != NULL);
354
355 _cmsAdjustEndianess64(&tmp, n);
356 if (io -> Write(io, sizeof(cmsUInt64Number), &tmp) != 1)
357 return FALSE;
358
359 return TRUE;
360 }
361
362 cmsBool CMSEXPORT _cmsWrite15Fixed16Number(cmsIOHANDLER* io, cmsFloat64Number n)
363 {
364 cmsUInt32Number tmp;
365
366 _cmsAssert(io != NULL);
367
368 tmp = _cmsAdjustEndianess32((cmsUInt32Number) _cmsDoubleTo15Fixed16(n));
369 if (io -> Write(io, sizeof(cmsUInt32Number), &tmp) != 1)
370 return FALSE;
371
372 return TRUE;
373 }
374
375 cmsBool CMSEXPORT _cmsWriteXYZNumber(cmsIOHANDLER* io, const cmsCIEXYZ* XYZ)
376 {
377 cmsEncodedXYZNumber xyz;
378
379 _cmsAssert(io != NULL);
380 _cmsAssert(XYZ != NULL);
381
382 xyz.X = (cmsS15Fixed16Number) _cmsAdjustEndianess32((cmsUInt32Number) _cmsDoubleTo15Fixed16(XYZ->X));
383 xyz.Y = (cmsS15Fixed16Number) _cmsAdjustEndianess32((cmsUInt32Number) _cmsDoubleTo15Fixed16(XYZ->Y));
384 xyz.Z = (cmsS15Fixed16Number) _cmsAdjustEndianess32((cmsUInt32Number) _cmsDoubleTo15Fixed16(XYZ->Z));
385
386 return io -> Write(io, sizeof(cmsEncodedXYZNumber), &xyz);
387 }
388
389 // from Fixed point 8.8 to double
390 cmsFloat64Number CMSEXPORT _cms8Fixed8toDouble(cmsUInt16Number fixed8)
391 {
392 cmsUInt8Number msb, lsb;
393
394 lsb = (cmsUInt8Number) (fixed8 & 0xff);
395 msb = (cmsUInt8Number) (((cmsUInt16Number) fixed8 >> 8) & 0xff);
396
397 return (cmsFloat64Number) ((cmsFloat64Number) msb + ((cmsFloat64Number) lsb / 256.0));
398 }
399
400 cmsUInt16Number CMSEXPORT _cmsDoubleTo8Fixed8(cmsFloat64Number val)
401 {
402 cmsS15Fixed16Number GammaFixed32 = _cmsDoubleTo15Fixed16(val);
403 return (cmsUInt16Number) ((GammaFixed32 >> 8) & 0xFFFF);
404 }
405
406 // from Fixed point 15.16 to double
407 cmsFloat64Number CMSEXPORT _cms15Fixed16toDouble(cmsS15Fixed16Number fix32)
408 {
409 cmsFloat64Number floater, sign, mid;
410 int Whole, FracPart;
411
412 sign = (fix32 < 0 ? -1 : 1);
413 fix32 = abs(fix32);
414
415 Whole = (cmsUInt16Number)(fix32 >> 16) & 0xffff;
416 FracPart = (cmsUInt16Number)(fix32 & 0xffff);
417
418 mid = (cmsFloat64Number) FracPart / 65536.0;
419 floater = (cmsFloat64Number) Whole + mid;
420
421 return sign * floater;
422 }
423
424 // from double to Fixed point 15.16
425 cmsS15Fixed16Number CMSEXPORT _cmsDoubleTo15Fixed16(cmsFloat64Number v)
426 {
427 return ((cmsS15Fixed16Number) floor((v)*65536.0 + 0.5));
428 }
429
430 // Date/Time functions
431
432 void CMSEXPORT _cmsDecodeDateTimeNumber(const cmsDateTimeNumber *Source, struct tm *Dest)
433 {
434
435 _cmsAssert(Dest != NULL);
436 _cmsAssert(Source != NULL);
437
438 Dest->tm_sec = _cmsAdjustEndianess16(Source->seconds);
439 Dest->tm_min = _cmsAdjustEndianess16(Source->minutes);
440 Dest->tm_hour = _cmsAdjustEndianess16(Source->hours);
441 Dest->tm_mday = _cmsAdjustEndianess16(Source->day);
442 Dest->tm_mon = _cmsAdjustEndianess16(Source->month) - 1;
443 Dest->tm_year = _cmsAdjustEndianess16(Source->year) - 1900;
444 Dest->tm_wday = -1;
445 Dest->tm_yday = -1;
446 Dest->tm_isdst = 0;
447 }
448
449 void CMSEXPORT _cmsEncodeDateTimeNumber(cmsDateTimeNumber *Dest, const struct tm *Source)
450 {
451 _cmsAssert(Dest != NULL);
452 _cmsAssert(Source != NULL);
453
454 Dest->seconds = _cmsAdjustEndianess16((cmsUInt16Number) Source->tm_sec);
455 Dest->minutes = _cmsAdjustEndianess16((cmsUInt16Number) Source->tm_min);
456 Dest->hours = _cmsAdjustEndianess16((cmsUInt16Number) Source->tm_hour);
457 Dest->day = _cmsAdjustEndianess16((cmsUInt16Number) Source->tm_mday);
458 Dest->month = _cmsAdjustEndianess16((cmsUInt16Number) (Source->tm_mon + 1));
459 Dest->year = _cmsAdjustEndianess16((cmsUInt16Number) (Source->tm_year + 1900));
460 }
461
462 // Read base and return type base
463 cmsTagTypeSignature CMSEXPORT _cmsReadTypeBase(cmsIOHANDLER* io)
464 {
465 _cmsTagBase Base;
466
467 _cmsAssert(io != NULL);
468
469 if (io -> Read(io, &Base, sizeof(_cmsTagBase), 1) != 1)
470 return (cmsTagTypeSignature) 0;
471
472 return (cmsTagTypeSignature) _cmsAdjustEndianess32(Base.sig);
473 }
474
475 // Setup base marker
476 cmsBool CMSEXPORT _cmsWriteTypeBase(cmsIOHANDLER* io, cmsTagTypeSignature sig)
477 {
478 _cmsTagBase Base;
479
480 _cmsAssert(io != NULL);
481
482 Base.sig = (cmsTagTypeSignature) _cmsAdjustEndianess32(sig);
483 memset(&Base.reserved, 0, sizeof(Base.reserved));
484 return io -> Write(io, sizeof(_cmsTagBase), &Base);
485 }
486
487 cmsBool CMSEXPORT _cmsReadAlignment(cmsIOHANDLER* io)
488 {
489 cmsUInt8Number Buffer[4];
490 cmsUInt32Number NextAligned, At;
491 cmsUInt32Number BytesToNextAlignedPos;
492
493 _cmsAssert(io != NULL);
494
495 At = io -> Tell(io);
496 NextAligned = _cmsALIGNLONG(At);
497 BytesToNextAlignedPos = NextAligned - At;
498 if (BytesToNextAlignedPos == 0) return TRUE;
499 if (BytesToNextAlignedPos > 4) return FALSE;
500
501 return (io ->Read(io, Buffer, BytesToNextAlignedPos, 1) == 1);
502 }
503
504 cmsBool CMSEXPORT _cmsWriteAlignment(cmsIOHANDLER* io)
505 {
506 cmsUInt8Number Buffer[4];
507 cmsUInt32Number NextAligned, At;
508 cmsUInt32Number BytesToNextAlignedPos;
509
510 _cmsAssert(io != NULL);
511
512 At = io -> Tell(io);
513 NextAligned = _cmsALIGNLONG(At);
514 BytesToNextAlignedPos = NextAligned - At;
515 if (BytesToNextAlignedPos == 0) return TRUE;
516 if (BytesToNextAlignedPos > 4) return FALSE;
517
518 memset(Buffer, 0, BytesToNextAlignedPos);
519 return io -> Write(io, BytesToNextAlignedPos, Buffer);
520 }
521
522
523 // To deal with text streams. 2K at most
524 cmsBool CMSEXPORT _cmsIOPrintf(cmsIOHANDLER* io, const char* frm, ...)
525 {
526 va_list args;
527 int len;
528 cmsUInt8Number Buffer[2048];
529 cmsBool rc;
530
531 _cmsAssert(io != NULL);
532 _cmsAssert(frm != NULL);
533
534 va_start(args, frm);
535
536 len = vsnprintf((char*) Buffer, 2047, frm, args);
537 if (len < 0) {
538 va_end(args);
539 return FALSE; // Truncated, which is a fatal error for us
540 }
541
542 rc = io ->Write(io, (cmsUInt32Number) len, Buffer);
543
544 va_end(args);
545
546 return rc;
547 }
548
549
550 // Plugin memory management -------------------------------------------------------------------------------------------------
551
552 // Specialized malloc for plug-ins, that is freed upon exit.
553 void* _cmsPluginMalloc(cmsContext ContextID, cmsUInt32Number size)
554 {
555 struct _cmsContext_struct* ctx = _cmsGetContext(ContextID);
556
557 if (ctx ->MemPool == NULL) {
558
559 if (ContextID == NULL) {
560
561 ctx->MemPool = _cmsCreateSubAlloc(0, 2*1024);
562 if (ctx->MemPool == NULL) return NULL;
563 }
564 else {
565 cmsSignalError(ContextID, cmsERROR_CORRUPTION_DETECTED, "NULL memory pool on context");
566 return NULL;
567 }
568 }
569
570 return _cmsSubAlloc(ctx->MemPool, size);
571 }
572
573
574 // Main plug-in dispatcher
575 cmsBool CMSEXPORT cmsPlugin(void* Plug_in)
576 {
577 return cmsPluginTHR(NULL, Plug_in);
578 }
579
580 cmsBool CMSEXPORT cmsPluginTHR(cmsContext id, void* Plug_in)
581 {
582 cmsPluginBase* Plugin;
583
584 for (Plugin = (cmsPluginBase*) Plug_in;
585 Plugin != NULL;
586 Plugin = Plugin -> Next) {
587
588 if (Plugin -> Magic != cmsPluginMagicNumber) {
589 cmsSignalError(id, cmsERROR_UNKNOWN_EXTENSION, "Unrecognized plugin");
590 return FALSE;
591 }
592
593 if (Plugin ->ExpectedVersion > LCMS_VERSION) {
594 cmsSignalError(id, cmsERROR_UNKNOWN_EXTENSION, "plugin needs Little CMS %d, current version is %d",
595 Plugin ->ExpectedVersion, LCMS_VERSION);
596 return FALSE;
597 }
598
599 switch (Plugin -> Type) {
600
601 case cmsPluginMemHandlerSig:
602 if (!_cmsRegisterMemHandlerPlugin(id, Plugin)) return FALSE;
603 break;
604
605 case cmsPluginInterpolationSig:
606 if (!_cmsRegisterInterpPlugin(id, Plugin)) return FALSE;
607 break;
608
609 case cmsPluginTagTypeSig:
610 if (!_cmsRegisterTagTypePlugin(id, Plugin)) return FALSE;
611 break;
612
613 case cmsPluginTagSig:
614 if (!_cmsRegisterTagPlugin(id, Plugin)) return FALSE;
615 break;
616
617 case cmsPluginFormattersSig:
618 if (!_cmsRegisterFormattersPlugin(id, Plugin)) return FALSE;
619 break;
620
621 case cmsPluginRenderingIntentSig:
622 if (!_cmsRegisterRenderingIntentPlugin(id, Plugin)) return FALSE;
623 break;
624
625 case cmsPluginParametricCurveSig:
626 if (!_cmsRegisterParametricCurvesPlugin(id, Plugin)) return FALSE;
627 break;
628
629 case cmsPluginMultiProcessElementSig:
630 if (!_cmsRegisterMultiProcessElementPlugin(id, Plugin)) return FALSE;
631 break;
632
633 case cmsPluginOptimizationSig:
634 if (!_cmsRegisterOptimizationPlugin(id, Plugin)) return FALSE;
635 break;
636
637 case cmsPluginTransformSig:
638 if (!_cmsRegisterTransformPlugin(id, Plugin)) return FALSE;
639 break;
640
641 case cmsPluginMutexSig:
642 if (!_cmsRegisterMutexPlugin(id, Plugin)) return FALSE;
643 break;
644
645 default:
646 cmsSignalError(id, cmsERROR_UNKNOWN_EXTENSION, "Unrecognized plugin type '%X'", Plugin -> Type);
647 return FALSE;
648 }
649 }
650
651 // Keep a reference to the plug-in
652 return TRUE;
653 }
654
655
656 // Revert all plug-ins to default
657 void CMSEXPORT cmsUnregisterPlugins(void)
658 {
659 cmsUnregisterPluginsTHR(NULL);
660 }
661
662
663 // The Global storage for system context. This is the one and only global variable
664 // pointers structure. All global vars are referenced here.
665 static struct _cmsContext_struct globalContext = {
666
667 NULL, // Not in the linked list
668 NULL, // No suballocator
669 {
670 NULL, // UserPtr,
671 &_cmsLogErrorChunk, // Logger,
672 &_cmsAlarmCodesChunk, // AlarmCodes,
673 &_cmsAdaptationStateChunk, // AdaptationState,
674 &_cmsMemPluginChunk, // MemPlugin,
675 &_cmsInterpPluginChunk, // InterpPlugin,
676 &_cmsCurvesPluginChunk, // CurvesPlugin,
677 &_cmsFormattersPluginChunk, // FormattersPlugin,
678 &_cmsTagTypePluginChunk, // TagTypePlugin,
679 &_cmsTagPluginChunk, // TagPlugin,
680 &_cmsIntentsPluginChunk, // IntentPlugin,
681 &_cmsMPETypePluginChunk, // MPEPlugin,
682 &_cmsOptimizationPluginChunk, // OptimizationPlugin,
683 &_cmsTransformPluginChunk, // TransformPlugin,
684 &_cmsMutexPluginChunk // MutexPlugin
685 },
686
687 { NULL, NULL, NULL, NULL, NULL, NULL } // The default memory allocator is not used for context 0
688 };
689
690
691 // The context pool (linked list head)
692 static _cmsMutex _cmsContextPoolHeadMutex = CMS_MUTEX_INITIALIZER;
693 static struct _cmsContext_struct* _cmsContextPoolHead = NULL;
694
695 // Internal, get associated pointer, with guessing. Never returns NULL.
696 struct _cmsContext_struct* _cmsGetContext(cmsContext ContextID)
697 {
698 struct _cmsContext_struct* id = (struct _cmsContext_struct*) ContextID;
699 struct _cmsContext_struct* ctx;
700
701
702 // On 0, use global settings
703 if (id == NULL)
704 return &globalContext;
705
706 // Search
707 _cmsEnterCriticalSectionPrimitive(&_cmsContextPoolHeadMutex);
708
709 for (ctx = _cmsContextPoolHead;
710 ctx != NULL;
711 ctx = ctx ->Next) {
712
713 // Found it?
714 if (id == ctx)
715 {
716 _cmsLeaveCriticalSectionPrimitive(&_cmsContextPoolHeadMutex);
717 return ctx; // New-style context
718 }
719 }
720
721 _cmsLeaveCriticalSectionPrimitive(&_cmsContextPoolHeadMutex);
722 return &globalContext;
723 }
724
725
726 // Internal: get the memory area associanted with each context client
727 // Returns the block assigned to the specific zone. Never return NULL.
728 void* _cmsContextGetClientChunk(cmsContext ContextID, _cmsMemoryClient mc)
729 {
730 struct _cmsContext_struct* ctx;
731 void *ptr;
732
733 if ((int) mc < 0 || mc >= MemoryClientMax) {
734
735 cmsSignalError(ContextID, cmsERROR_INTERNAL, "Bad context client -- possible corruption");
736
737 // This is catastrophic. Should never reach here
738 _cmsAssert(0);
739
740 // Reverts to global context
741 return globalContext.chunks[UserPtr];
742 }
743
744 ctx = _cmsGetContext(ContextID);
745 ptr = ctx ->chunks[mc];
746
747 if (ptr != NULL)
748 return ptr;
749
750 // A null ptr means no special settings for that context, and this
751 // reverts to Context0 globals
752 return globalContext.chunks[mc];
753 }
754
755
756 // This function returns the given context its default pristine state,
757 // as no plug-ins were declared. There is no way to unregister a single
758 // plug-in, as a single call to cmsPluginTHR() function may register
759 // many different plug-ins simultaneously, then there is no way to
760 // identify which plug-in to unregister.
761 void CMSEXPORT cmsUnregisterPluginsTHR(cmsContext ContextID)
762 {
763 _cmsRegisterMemHandlerPlugin(ContextID, NULL);
764 _cmsRegisterInterpPlugin(ContextID, NULL);
765 _cmsRegisterTagTypePlugin(ContextID, NULL);
766 _cmsRegisterTagPlugin(ContextID, NULL);
767 _cmsRegisterFormattersPlugin(ContextID, NULL);
768 _cmsRegisterRenderingIntentPlugin(ContextID, NULL);
769 _cmsRegisterParametricCurvesPlugin(ContextID, NULL);
770 _cmsRegisterMultiProcessElementPlugin(ContextID, NULL);
771 _cmsRegisterOptimizationPlugin(ContextID, NULL);
772 _cmsRegisterTransformPlugin(ContextID, NULL);
773 _cmsRegisterMutexPlugin(ContextID, NULL);
774 }
775
776
777 // Returns the memory manager plug-in, if any, from the Plug-in bundle
778 static
779 cmsPluginMemHandler* _cmsFindMemoryPlugin(void* PluginBundle)
780 {
781 cmsPluginBase* Plugin;
782
783 for (Plugin = (cmsPluginBase*) PluginBundle;
784 Plugin != NULL;
785 Plugin = Plugin -> Next) {
786
787 if (Plugin -> Magic == cmsPluginMagicNumber &&
788 Plugin -> ExpectedVersion <= LCMS_VERSION &&
789 Plugin -> Type == cmsPluginMemHandlerSig) {
790
791 // Found!
792 return (cmsPluginMemHandler*) Plugin;
793 }
794 }
795
796 // Nope, revert to defaults
797 return NULL;
798 }
799
800
801 // Creates a new context with optional associated plug-ins. Caller may also specify an optional pointer to user-defined
802 // data that will be forwarded to plug-ins and logger.
803 cmsContext CMSEXPORT cmsCreateContext(void* Plugin, void* UserData)
804 {
805 struct _cmsContext_struct* ctx;
806 struct _cmsContext_struct fakeContext;
807
808 // See the comments regarding locking in lcms2_internal.h
809 // for an explanation of why we need the following code.
810 #ifndef CMS_NO_PTHREADS
811 #ifdef CMS_IS_WINDOWS_
812 #ifndef CMS_RELY_ON_WINDOWS_STATIC_MUTEX_INIT
813 {
814 static HANDLE _cmsWindowsInitMutex = NULL;
815 static volatile HANDLE* mutex = &_cmsWindowsInitMutex;
816
817 if (*mutex == NULL)
818 {
819 HANDLE p = CreateMutex(NULL, FALSE, NULL);
820 if (p && InterlockedCompareExchangePointer((void **)mutex, (void*)p, NULL) != NULL)
821 CloseHandle(p);
822 }
823 if (*mutex == NULL || WaitForSingleObject(*mutex, INFINITE) == WAIT_FAILED)
824 return NULL;
825 if (((void **)&_cmsContextPoolHeadMutex)[0] == NULL)
826 InitializeCriticalSection(&_cmsContextPoolHeadMutex);
827 if (*mutex == NULL || !ReleaseMutex(*mutex))
828 return NULL;
829 }
830 #endif
831 #endif
832 #endif
833
834 _cmsInstallAllocFunctions(_cmsFindMemoryPlugin(Plugin), &fakeContext.DefaultMemoryManager);
835
836 fakeContext.chunks[UserPtr] = UserData;
837 fakeContext.chunks[MemPlugin] = &fakeContext.DefaultMemoryManager;
838
839 // Create the context structure.
840 ctx = (struct _cmsContext_struct*) _cmsMalloc(&fakeContext, sizeof(struct _cmsContext_struct));
841 if (ctx == NULL)
842 return NULL; // Something very wrong happened!
843
844 // Init the structure and the memory manager
845 memset(ctx, 0, sizeof(struct _cmsContext_struct));
846
847 // Keep memory manager
848 memcpy(&ctx->DefaultMemoryManager, &fakeContext.DefaultMemoryManager, sizeof(_cmsMemPluginChunk));
849
850 // Maintain the linked list (with proper locking)
851 _cmsEnterCriticalSectionPrimitive(&_cmsContextPoolHeadMutex);
852 ctx ->Next = _cmsContextPoolHead;
853 _cmsContextPoolHead = ctx;
854 _cmsLeaveCriticalSectionPrimitive(&_cmsContextPoolHeadMutex);
855
856 ctx ->chunks[UserPtr] = UserData;
857 ctx ->chunks[MemPlugin] = &ctx->DefaultMemoryManager;
858
859 // Now we can allocate the pool by using default memory manager
860 ctx ->MemPool = _cmsCreateSubAlloc(ctx, 22 * sizeof(void*)); // default size about 22 pointers
861 if (ctx ->MemPool == NULL) {
862
863 cmsDeleteContext(ctx);
864 return NULL;
865 }
866
867 _cmsAllocLogErrorChunk(ctx, NULL);
868 _cmsAllocAlarmCodesChunk(ctx, NULL);
869 _cmsAllocAdaptationStateChunk(ctx, NULL);
870 _cmsAllocMemPluginChunk(ctx, NULL);
871 _cmsAllocInterpPluginChunk(ctx, NULL);
872 _cmsAllocCurvesPluginChunk(ctx, NULL);
873 _cmsAllocFormattersPluginChunk(ctx, NULL);
874 _cmsAllocTagTypePluginChunk(ctx, NULL);
875 _cmsAllocMPETypePluginChunk(ctx, NULL);
876 _cmsAllocTagPluginChunk(ctx, NULL);
877 _cmsAllocIntentsPluginChunk(ctx, NULL);
878 _cmsAllocOptimizationPluginChunk(ctx, NULL);
879 _cmsAllocTransformPluginChunk(ctx, NULL);
880 _cmsAllocMutexPluginChunk(ctx, NULL);
881
882 // Setup the plug-ins
883 if (!cmsPluginTHR(ctx, Plugin)) {
884
885 cmsDeleteContext(ctx);
886 return NULL;
887 }
888
889 return (cmsContext) ctx;
890 }
891
892 // Duplicates a context with all associated plug-ins.
893 // Caller may specify an optional pointer to user-defined
894 // data that will be forwarded to plug-ins and logger.
895 cmsContext CMSEXPORT cmsDupContext(cmsContext ContextID, void* NewUserData)
896 {
897 int i;
898 struct _cmsContext_struct* ctx;
899 const struct _cmsContext_struct* src = _cmsGetContext(ContextID);
900
901 void* userData = (NewUserData != NULL) ? NewUserData : src -> chunks[UserPtr];
902
903
904 ctx = (struct _cmsContext_struct*) _cmsMalloc(ContextID, sizeof(struct _cmsContext_struct));
905 if (ctx == NULL)
906 return NULL; // Something very wrong happened
907
908 // Setup default memory allocators
909 memcpy(&ctx->DefaultMemoryManager, &src->DefaultMemoryManager, sizeof(ctx->DefaultMemoryManager));
910
911 // Maintain the linked list
912 _cmsEnterCriticalSectionPrimitive(&_cmsContextPoolHeadMutex);
913 ctx ->Next = _cmsContextPoolHead;
914 _cmsContextPoolHead = ctx;
915 _cmsLeaveCriticalSectionPrimitive(&_cmsContextPoolHeadMutex);
916
917 ctx ->chunks[UserPtr] = userData;
918 ctx ->chunks[MemPlugin] = &ctx->DefaultMemoryManager;
919
920 ctx ->MemPool = _cmsCreateSubAlloc(ctx, 22 * sizeof(void*));
921 if (ctx ->MemPool == NULL) {
922
923 cmsDeleteContext(ctx);
924 return NULL;
925 }
926
927 // Allocate all required chunks.
928 _cmsAllocLogErrorChunk(ctx, src);
929 _cmsAllocAlarmCodesChunk(ctx, src);
930 _cmsAllocAdaptationStateChunk(ctx, src);
931 _cmsAllocMemPluginChunk(ctx, src);
932 _cmsAllocInterpPluginChunk(ctx, src);
933 _cmsAllocCurvesPluginChunk(ctx, src);
934 _cmsAllocFormattersPluginChunk(ctx, src);
935 _cmsAllocTagTypePluginChunk(ctx, src);
936 _cmsAllocMPETypePluginChunk(ctx, src);
937 _cmsAllocTagPluginChunk(ctx, src);
938 _cmsAllocIntentsPluginChunk(ctx, src);
939 _cmsAllocOptimizationPluginChunk(ctx, src);
940 _cmsAllocTransformPluginChunk(ctx, src);
941 _cmsAllocMutexPluginChunk(ctx, src);
942
943 // Make sure no one failed
944 for (i=Logger; i < MemoryClientMax; i++) {
945
946 if (src ->chunks[i] == NULL) {
947 cmsDeleteContext((cmsContext) ctx);
948 return NULL;
949 }
950 }
951
952 return (cmsContext) ctx;
953 }
954
955
956 // Frees any resources associated with the given context,
957 // and destroys the context placeholder.
958 // The ContextID can no longer be used in any THR operation.
959 void CMSEXPORT cmsDeleteContext(cmsContext ContextID)
960 {
961 if (ContextID != NULL) {
962
963 struct _cmsContext_struct* ctx = (struct _cmsContext_struct*) ContextID;
964 struct _cmsContext_struct fakeContext;
965 struct _cmsContext_struct* prev;
966
967 memcpy(&fakeContext.DefaultMemoryManager, &ctx->DefaultMemoryManager, sizeof(ctx->DefaultMemoryManager));
968
969 fakeContext.chunks[UserPtr] = ctx ->chunks[UserPtr];
970 fakeContext.chunks[MemPlugin] = &fakeContext.DefaultMemoryManager;
971
972 // Get rid of plugins
973 cmsUnregisterPluginsTHR(ContextID);
974
975 // Since all memory is allocated in the private pool, all what we need to do is destroy the pool
976 if (ctx -> MemPool != NULL)
977 _cmsSubAllocDestroy(ctx ->MemPool);
978 ctx -> MemPool = NULL;
979
980 // Maintain list
981 _cmsEnterCriticalSectionPrimitive(&_cmsContextPoolHeadMutex);
982 if (_cmsContextPoolHead == ctx) {
983
984 _cmsContextPoolHead = ctx->Next;
985 }
986 else {
987
988 // Search for previous
989 for (prev = _cmsContextPoolHead;
990 prev != NULL;
991 prev = prev ->Next)
992 {
993 if (prev -> Next == ctx) {
994 prev -> Next = ctx ->Next;
995 break;
996 }
997 }
998 }
999 _cmsLeaveCriticalSectionPrimitive(&_cmsContextPoolHeadMutex);
1000
1001 // free the memory block itself
1002 _cmsFree(&fakeContext, ctx);
1003 }
1004 }
1005
1006 // Returns the user data associated to the given ContextID, or NULL if no user data was attached on context creation
1007 void* CMSEXPORT cmsGetContextUserData(cmsContext ContextID)
1008 {
1009 return _cmsContextGetClientChunk(ContextID, UserPtr);
1010 }
1011
1012