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