Fix uninitialized Storage in _LUTeval16
[pdfium.git] / core / src / fxcodec / lcms2 / lcms2-2.6 / src / cmslut.c
1 //---------------------------------------------------------------------------------
2 //
3 //  Little Color Management System
4 //  Copyright (c) 1998-2012 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 // Allocates an empty multi profile element
31 cmsStage* CMSEXPORT _cmsStageAllocPlaceholder(cmsContext ContextID,
32                                 cmsStageSignature Type,
33                                 cmsUInt32Number InputChannels,
34                                 cmsUInt32Number OutputChannels,
35                                 _cmsStageEvalFn     EvalPtr,
36                                 _cmsStageDupElemFn  DupElemPtr,
37                                 _cmsStageFreeElemFn FreePtr,
38                                 void*             Data)
39 {
40     cmsStage* ph = (cmsStage*) _cmsMallocZero(ContextID, sizeof(cmsStage));
41
42     if (ph == NULL) return NULL;
43
44
45     ph ->ContextID = ContextID;
46
47     ph ->Type       = Type;
48     ph ->Implements = Type;   // By default, no clue on what is implementing
49
50     ph ->InputChannels  = InputChannels;
51     ph ->OutputChannels = OutputChannels;
52     ph ->EvalPtr        = EvalPtr;
53     ph ->DupElemPtr     = DupElemPtr;
54     ph ->FreePtr        = FreePtr;
55     ph ->Data           = Data;
56
57     return ph;
58 }
59
60
61 static
62 void EvaluateIdentity(const cmsFloat32Number In[],
63                             cmsFloat32Number Out[],
64                       const cmsStage *mpe)
65 {
66     memmove(Out, In, mpe ->InputChannels * sizeof(cmsFloat32Number));
67 }
68
69
70 cmsStage* CMSEXPORT cmsStageAllocIdentity(cmsContext ContextID, cmsUInt32Number nChannels)
71 {
72     return _cmsStageAllocPlaceholder(ContextID,
73                                    cmsSigIdentityElemType,
74                                    nChannels, nChannels,
75                                    EvaluateIdentity,
76                                    NULL,
77                                    NULL,
78                                    NULL);
79  }
80
81 // Conversion functions. From floating point to 16 bits
82 static
83 void FromFloatTo16(const cmsFloat32Number In[], cmsUInt16Number Out[], cmsUInt32Number n)
84 {
85     cmsUInt32Number i;
86
87     for (i=0; i < n; i++) {
88         Out[i] = _cmsQuickSaturateWord(In[i] * 65535.0);
89     }
90 }
91
92 // From 16 bits to floating point
93 static
94 void From16ToFloat(const cmsUInt16Number In[], cmsFloat32Number Out[], cmsUInt32Number n)
95 {
96     cmsUInt32Number i;
97
98     for (i=0; i < n; i++) {
99         Out[i] = (cmsFloat32Number) In[i] / 65535.0F;
100     }
101 }
102
103
104 // This function is quite useful to analyze the structure of a LUT and retrieve the MPE elements
105 // that conform the LUT. It should be called with the LUT, the number of expected elements and
106 // then a list of expected types followed with a list of cmsFloat64Number pointers to MPE elements. If
107 // the function founds a match with current pipeline, it fills the pointers and returns TRUE
108 // if not, returns FALSE without touching anything. Setting pointers to NULL does bypass
109 // the storage process.
110 cmsBool  CMSEXPORT cmsPipelineCheckAndRetreiveStages(const cmsPipeline* Lut, cmsUInt32Number n, ...)
111 {
112     va_list args;
113     cmsUInt32Number i;
114     cmsStage* mpe;
115     cmsStageSignature Type;
116     void** ElemPtr;
117
118     // Make sure same number of elements
119     if (cmsPipelineStageCount(Lut) != n) return FALSE;
120
121     va_start(args, n);
122
123     // Iterate across asked types
124     mpe = Lut ->Elements;
125     for (i=0; i < n; i++) {
126
127         // Get asked type
128         Type  = (cmsStageSignature)va_arg(args, cmsStageSignature);
129         if (mpe ->Type != Type) {
130
131             va_end(args);       // Mismatch. We are done.
132             return FALSE;
133         }
134         mpe = mpe ->Next;
135     }
136
137     // Found a combination, fill pointers if not NULL
138     mpe = Lut ->Elements;
139     for (i=0; i < n; i++) {
140
141         ElemPtr = va_arg(args, void**);
142         if (ElemPtr != NULL)
143             *ElemPtr = mpe;
144
145         mpe = mpe ->Next;
146     }
147
148     va_end(args);
149     return TRUE;
150 }
151
152 // Below there are implementations for several types of elements. Each type may be implemented by a
153 // evaluation function, a duplication function, a function to free resources and a constructor.
154
155 // *************************************************************************************************
156 // Type cmsSigCurveSetElemType (curves)
157 // *************************************************************************************************
158
159 cmsToneCurve** _cmsStageGetPtrToCurveSet(const cmsStage* mpe)
160 {
161     _cmsStageToneCurvesData* Data = (_cmsStageToneCurvesData*) mpe ->Data;
162
163     return Data ->TheCurves;
164 }
165
166 static
167 void EvaluateCurves(const cmsFloat32Number In[],
168                     cmsFloat32Number Out[],
169                     const cmsStage *mpe)
170 {
171     _cmsStageToneCurvesData* Data;
172     cmsUInt32Number i;
173
174     _cmsAssert(mpe != NULL);
175
176     Data = (_cmsStageToneCurvesData*) mpe ->Data;
177     if (Data == NULL) return;
178
179     if (Data ->TheCurves == NULL) return;
180
181     for (i=0; i < Data ->nCurves; i++) {
182         Out[i] = cmsEvalToneCurveFloat(Data ->TheCurves[i], In[i]);
183     }
184 }
185
186 static
187 void CurveSetElemTypeFree(cmsStage* mpe)
188 {
189     _cmsStageToneCurvesData* Data;
190     cmsUInt32Number i;
191
192     _cmsAssert(mpe != NULL);
193
194     Data = (_cmsStageToneCurvesData*) mpe ->Data;
195     if (Data == NULL) return;
196
197     if (Data ->TheCurves != NULL) {
198         for (i=0; i < Data ->nCurves; i++) {
199             if (Data ->TheCurves[i] != NULL)
200                 cmsFreeToneCurve(Data ->TheCurves[i]);
201         }
202     }
203     _cmsFree(mpe ->ContextID, Data ->TheCurves);
204     _cmsFree(mpe ->ContextID, Data);
205 }
206
207
208 static
209 void* CurveSetDup(cmsStage* mpe)
210 {
211     _cmsStageToneCurvesData* Data = (_cmsStageToneCurvesData*) mpe ->Data;
212     _cmsStageToneCurvesData* NewElem;
213     cmsUInt32Number i;
214
215     NewElem = (_cmsStageToneCurvesData*) _cmsMallocZero(mpe ->ContextID, sizeof(_cmsStageToneCurvesData));
216     if (NewElem == NULL) return NULL;
217
218     NewElem ->nCurves   = Data ->nCurves;
219     NewElem ->TheCurves = (cmsToneCurve**) _cmsCalloc(mpe ->ContextID, NewElem ->nCurves, sizeof(cmsToneCurve*));
220
221     if (NewElem ->TheCurves == NULL) goto Error;
222
223     for (i=0; i < NewElem ->nCurves; i++) {
224
225         // Duplicate each curve. It may fail.
226         NewElem ->TheCurves[i] = cmsDupToneCurve(Data ->TheCurves[i]);
227         if (NewElem ->TheCurves[i] == NULL) goto Error;
228
229
230     }
231     return (void*) NewElem;
232
233 Error:
234
235     if (NewElem ->TheCurves != NULL) {
236         for (i=0; i < NewElem ->nCurves; i++) {
237             if (NewElem ->TheCurves[i])
238                 cmsFreeToneCurve(NewElem ->TheCurves[i]);
239         }
240     }
241     _cmsFree(mpe ->ContextID, NewElem ->TheCurves);
242     _cmsFree(mpe ->ContextID, NewElem);
243     return NULL;
244 }
245
246
247 // Curves == NULL forces identity curves
248 cmsStage* CMSEXPORT cmsStageAllocToneCurves(cmsContext ContextID, cmsUInt32Number nChannels, cmsToneCurve* const Curves[])
249 {
250     cmsUInt32Number i;
251     _cmsStageToneCurvesData* NewElem;
252     cmsStage* NewMPE;
253
254
255     NewMPE = _cmsStageAllocPlaceholder(ContextID, cmsSigCurveSetElemType, nChannels, nChannels,
256                                      EvaluateCurves, CurveSetDup, CurveSetElemTypeFree, NULL );
257     if (NewMPE == NULL) return NULL;
258
259     NewElem = (_cmsStageToneCurvesData*) _cmsMallocZero(ContextID, sizeof(_cmsStageToneCurvesData));
260     if (NewElem == NULL) {
261         cmsStageFree(NewMPE);
262         return NULL;
263     }
264
265     NewMPE ->Data  = (void*) NewElem;
266
267     NewElem ->nCurves   = nChannels;
268     NewElem ->TheCurves = (cmsToneCurve**) _cmsCalloc(ContextID, nChannels, sizeof(cmsToneCurve*));
269     if (NewElem ->TheCurves == NULL) {
270         cmsStageFree(NewMPE);
271         return NULL;
272     }
273
274     for (i=0; i < nChannels; i++) {
275
276         if (Curves == NULL) {
277             NewElem ->TheCurves[i] = cmsBuildGamma(ContextID, 1.0);
278         }
279         else {
280             NewElem ->TheCurves[i] = cmsDupToneCurve(Curves[i]);
281         }
282
283         if (NewElem ->TheCurves[i] == NULL) {
284             cmsStageFree(NewMPE);
285             return NULL;
286         }
287
288     }
289
290    return NewMPE;
291 }
292
293
294 // Create a bunch of identity curves
295 cmsStage* _cmsStageAllocIdentityCurves(cmsContext ContextID, int nChannels)
296 {
297     cmsStage* mpe = cmsStageAllocToneCurves(ContextID, nChannels, NULL);
298
299     if (mpe == NULL) return NULL;
300     mpe ->Implements = cmsSigIdentityElemType;
301     return mpe;
302 }
303
304
305 // *************************************************************************************************
306 // Type cmsSigMatrixElemType (Matrices)
307 // *************************************************************************************************
308
309
310 // Special care should be taken here because precision loss. A temporary cmsFloat64Number buffer is being used
311 static
312 void EvaluateMatrix(const cmsFloat32Number In[],
313                     cmsFloat32Number Out[],
314                     const cmsStage *mpe)
315 {
316     cmsUInt32Number i, j;
317     _cmsStageMatrixData* Data = (_cmsStageMatrixData*) mpe ->Data;
318     cmsFloat64Number Tmp;
319
320     // Input is already in 0..1.0 notation
321     for (i=0; i < mpe ->OutputChannels; i++) {
322
323         Tmp = 0;
324         for (j=0; j < mpe->InputChannels; j++) {
325             Tmp += In[j] * Data->Double[i*mpe->InputChannels + j];
326         }
327
328         if (Data ->Offset != NULL)
329             Tmp += Data->Offset[i];
330
331         Out[i] = (cmsFloat32Number) Tmp;
332     }
333
334
335     // Output in 0..1.0 domain
336 }
337
338
339 // Duplicate a yet-existing matrix element
340 static
341 void* MatrixElemDup(cmsStage* mpe)
342 {
343     _cmsStageMatrixData* Data = (_cmsStageMatrixData*) mpe ->Data;
344     _cmsStageMatrixData* NewElem;
345     cmsUInt32Number sz;
346
347     NewElem = (_cmsStageMatrixData*) _cmsMallocZero(mpe ->ContextID, sizeof(_cmsStageMatrixData));
348     if (NewElem == NULL) return NULL;
349
350     sz = mpe ->InputChannels * mpe ->OutputChannels;
351
352     NewElem ->Double = (cmsFloat64Number*) _cmsDupMem(mpe ->ContextID, Data ->Double, sz * sizeof(cmsFloat64Number)) ;
353
354     if (Data ->Offset)
355         NewElem ->Offset = (cmsFloat64Number*) _cmsDupMem(mpe ->ContextID,
356                                                 Data ->Offset, mpe -> OutputChannels * sizeof(cmsFloat64Number)) ;
357
358     return (void*) NewElem;
359 }
360
361
362 static
363 void MatrixElemTypeFree(cmsStage* mpe)
364 {
365     _cmsStageMatrixData* Data = (_cmsStageMatrixData*) mpe ->Data;
366     if (Data == NULL)
367         return;
368     if (Data ->Double)
369         _cmsFree(mpe ->ContextID, Data ->Double);
370
371     if (Data ->Offset)
372         _cmsFree(mpe ->ContextID, Data ->Offset);
373
374     _cmsFree(mpe ->ContextID, mpe ->Data);
375 }
376
377
378
379 cmsStage*  CMSEXPORT cmsStageAllocMatrix(cmsContext ContextID, cmsUInt32Number Rows, cmsUInt32Number Cols,
380                                      const cmsFloat64Number* Matrix, const cmsFloat64Number* Offset)
381 {
382     cmsUInt32Number i, n;
383     _cmsStageMatrixData* NewElem;
384     cmsStage* NewMPE;
385
386     n = Rows * Cols;
387
388     // Check for overflow
389     if (n == 0) return NULL;
390     if (n >= UINT_MAX / Cols) return NULL;
391     if (n >= UINT_MAX / Rows) return NULL;
392     if (n < Rows || n < Cols) return NULL;
393
394     NewMPE = _cmsStageAllocPlaceholder(ContextID, cmsSigMatrixElemType, Cols, Rows,
395                                      EvaluateMatrix, MatrixElemDup, MatrixElemTypeFree, NULL );
396     if (NewMPE == NULL) return NULL;
397
398
399     NewElem = (_cmsStageMatrixData*) _cmsMallocZero(ContextID, sizeof(_cmsStageMatrixData));
400     if (NewElem == NULL) return NULL;
401
402
403     NewElem ->Double = (cmsFloat64Number*) _cmsCalloc(ContextID, n, sizeof(cmsFloat64Number));
404
405     if (NewElem->Double == NULL) {
406         MatrixElemTypeFree(NewMPE);
407         return NULL;
408     }
409
410     for (i=0; i < n; i++) {
411         NewElem ->Double[i] = Matrix[i];
412     }
413
414
415     if (Offset != NULL) {
416
417         NewElem ->Offset = (cmsFloat64Number*) _cmsCalloc(ContextID, Cols, sizeof(cmsFloat64Number));
418         if (NewElem->Offset == NULL) {
419            MatrixElemTypeFree(NewMPE);
420            return NULL;
421         }
422
423         for (i=0; i < Cols; i++) {
424                 NewElem ->Offset[i] = Offset[i];
425         }
426
427     }
428
429     NewMPE ->Data  = (void*) NewElem;
430     return NewMPE;
431 }
432
433
434 // *************************************************************************************************
435 // Type cmsSigCLutElemType
436 // *************************************************************************************************
437
438
439 // Evaluate in true floating point
440 static
441 void EvaluateCLUTfloat(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
442 {
443     _cmsStageCLutData* Data = (_cmsStageCLutData*) mpe ->Data;
444
445     Data -> Params ->Interpolation.LerpFloat(In, Out, Data->Params);
446 }
447
448
449 // Convert to 16 bits, evaluate, and back to floating point
450 static
451 void EvaluateCLUTfloatIn16(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
452 {
453     _cmsStageCLutData* Data = (_cmsStageCLutData*) mpe ->Data;
454     cmsUInt16Number In16[MAX_STAGE_CHANNELS], Out16[MAX_STAGE_CHANNELS];
455
456     _cmsAssert(mpe ->InputChannels  <= MAX_STAGE_CHANNELS);
457     _cmsAssert(mpe ->OutputChannels <= MAX_STAGE_CHANNELS);
458
459     FromFloatTo16(In, In16, mpe ->InputChannels);
460     Data -> Params ->Interpolation.Lerp16(In16, Out16, Data->Params);
461     From16ToFloat(Out16, Out,  mpe ->OutputChannels);
462 }
463
464
465 // Given an hypercube of b dimensions, with Dims[] number of nodes by dimension, calculate the total amount of nodes
466 static
467 cmsUInt32Number CubeSize(const cmsUInt32Number Dims[], cmsUInt32Number b)
468 {
469     cmsUInt32Number rv, dim;
470
471     _cmsAssert(Dims != NULL);
472
473     for (rv = 1; b > 0; b--) {
474
475         dim = Dims[b-1];
476         if (dim == 0) return 0;  // Error
477
478         rv *= dim;
479
480         // Check for overflow
481         if (rv > UINT_MAX / dim) return 0;
482     }
483
484     return rv;
485 }
486
487 static
488 void* CLUTElemDup(cmsStage* mpe)
489 {
490     _cmsStageCLutData* Data = (_cmsStageCLutData*) mpe ->Data;
491     _cmsStageCLutData* NewElem;
492
493
494     NewElem = (_cmsStageCLutData*) _cmsMallocZero(mpe ->ContextID, sizeof(_cmsStageCLutData));
495     if (NewElem == NULL) return NULL;
496
497     NewElem ->nEntries       = Data ->nEntries;
498     NewElem ->HasFloatValues = Data ->HasFloatValues;
499
500     if (Data ->Tab.T) {
501
502         if (Data ->HasFloatValues) {
503             NewElem ->Tab.TFloat = (cmsFloat32Number*) _cmsDupMem(mpe ->ContextID, Data ->Tab.TFloat, Data ->nEntries * sizeof (cmsFloat32Number));
504             if (NewElem ->Tab.TFloat == NULL)
505                 goto Error;
506         } else {
507             NewElem ->Tab.T = (cmsUInt16Number*) _cmsDupMem(mpe ->ContextID, Data ->Tab.T, Data ->nEntries * sizeof (cmsUInt16Number));
508             if (NewElem ->Tab.TFloat == NULL)
509                 goto Error;
510         }
511     }
512
513     NewElem ->Params   = _cmsComputeInterpParamsEx(mpe ->ContextID,
514                                                    Data ->Params ->nSamples,
515                                                    Data ->Params ->nInputs,
516                                                    Data ->Params ->nOutputs,
517                                                    NewElem ->Tab.T,
518                                                    Data ->Params ->dwFlags);
519     if (NewElem->Params != NULL)
520         return (void*) NewElem;
521  Error:
522     if (NewElem->Tab.T)
523         // This works for both types
524         _cmsFree(mpe ->ContextID, NewElem -> Tab.T);
525     _cmsFree(mpe ->ContextID, NewElem);
526     return NULL;
527 }
528
529
530 static
531 void CLutElemTypeFree(cmsStage* mpe)
532 {
533
534     _cmsStageCLutData* Data = (_cmsStageCLutData*) mpe ->Data;
535
536     // Already empty
537     if (Data == NULL) return;
538
539     // This works for both types
540     if (Data -> Tab.T)
541         _cmsFree(mpe ->ContextID, Data -> Tab.T);
542
543     _cmsFreeInterpParams(Data ->Params);
544     _cmsFree(mpe ->ContextID, mpe ->Data);
545 }
546
547
548 // Allocates a 16-bit multidimensional CLUT. This is evaluated at 16-bit precision. Table may have different
549 // granularity on each dimension.
550 cmsStage* CMSEXPORT cmsStageAllocCLut16bitGranular(cmsContext ContextID,
551                                          const cmsUInt32Number clutPoints[],
552                                          cmsUInt32Number inputChan,
553                                          cmsUInt32Number outputChan,
554                                          const cmsUInt16Number* Table)
555 {
556     cmsUInt32Number i, n;
557     _cmsStageCLutData* NewElem;
558     cmsStage* NewMPE;
559
560     _cmsAssert(clutPoints != NULL);
561
562     if (inputChan > MAX_INPUT_DIMENSIONS) {
563         cmsSignalError(ContextID, cmsERROR_RANGE, "Too many input channels (%d channels, max=%d)", inputChan, MAX_INPUT_DIMENSIONS);
564         return NULL;
565     }
566
567     NewMPE = _cmsStageAllocPlaceholder(ContextID, cmsSigCLutElemType, inputChan, outputChan,
568                                      EvaluateCLUTfloatIn16, CLUTElemDup, CLutElemTypeFree, NULL );
569
570     if (NewMPE == NULL) return NULL;
571
572     NewElem = (_cmsStageCLutData*) _cmsMallocZero(ContextID, sizeof(_cmsStageCLutData));
573     if (NewElem == NULL) {
574         cmsStageFree(NewMPE);
575         return NULL;
576     }
577
578     NewMPE ->Data  = (void*) NewElem;
579
580     NewElem -> nEntries = n = outputChan * CubeSize(clutPoints, inputChan);
581     NewElem -> HasFloatValues = FALSE;
582
583     if (n == 0) {
584         cmsStageFree(NewMPE);
585         return NULL;
586     }
587
588
589     NewElem ->Tab.T  = (cmsUInt16Number*) _cmsCalloc(ContextID, n, sizeof(cmsUInt16Number));
590     if (NewElem ->Tab.T == NULL) {
591         cmsStageFree(NewMPE);
592         return NULL;
593     }
594
595     if (Table != NULL) {
596         for (i=0; i < n; i++) {
597             NewElem ->Tab.T[i] = Table[i];
598         }
599     }
600
601     NewElem ->Params = _cmsComputeInterpParamsEx(ContextID, clutPoints, inputChan, outputChan, NewElem ->Tab.T, CMS_LERP_FLAGS_16BITS);
602     if (NewElem ->Params == NULL) {
603         cmsStageFree(NewMPE);
604         return NULL;
605     }
606
607     return NewMPE;
608 }
609
610 cmsStage* CMSEXPORT cmsStageAllocCLut16bit(cmsContext ContextID,
611                                     cmsUInt32Number nGridPoints,
612                                     cmsUInt32Number inputChan,
613                                     cmsUInt32Number outputChan,
614                                     const cmsUInt16Number* Table)
615 {
616     cmsUInt32Number Dimensions[MAX_INPUT_DIMENSIONS];
617     int i;
618
619    // Our resulting LUT would be same gridpoints on all dimensions
620     for (i=0; i < MAX_INPUT_DIMENSIONS; i++)
621         Dimensions[i] = nGridPoints;
622
623     return cmsStageAllocCLut16bitGranular(ContextID, Dimensions, inputChan, outputChan, Table);
624 }
625
626
627 cmsStage* CMSEXPORT cmsStageAllocCLutFloat(cmsContext ContextID,
628                                        cmsUInt32Number nGridPoints,
629                                        cmsUInt32Number inputChan,
630                                        cmsUInt32Number outputChan,
631                                        const cmsFloat32Number* Table)
632 {
633    cmsUInt32Number Dimensions[MAX_INPUT_DIMENSIONS];
634    int i;
635
636     // Our resulting LUT would be same gridpoints on all dimensions
637     for (i=0; i < MAX_INPUT_DIMENSIONS; i++)
638         Dimensions[i] = nGridPoints;
639
640     return cmsStageAllocCLutFloatGranular(ContextID, Dimensions, inputChan, outputChan, Table);
641 }
642
643
644
645 cmsStage* CMSEXPORT cmsStageAllocCLutFloatGranular(cmsContext ContextID, const cmsUInt32Number clutPoints[], cmsUInt32Number inputChan, cmsUInt32Number outputChan, const cmsFloat32Number* Table)
646 {
647     cmsUInt32Number i, n;
648     _cmsStageCLutData* NewElem;
649     cmsStage* NewMPE;
650
651     _cmsAssert(clutPoints != NULL);
652
653     if (inputChan > MAX_INPUT_DIMENSIONS) {
654         cmsSignalError(ContextID, cmsERROR_RANGE, "Too many input channels (%d channels, max=%d)", inputChan, MAX_INPUT_DIMENSIONS);
655         return NULL;
656     }
657
658     NewMPE = _cmsStageAllocPlaceholder(ContextID, cmsSigCLutElemType, inputChan, outputChan,
659                                              EvaluateCLUTfloat, CLUTElemDup, CLutElemTypeFree, NULL);
660     if (NewMPE == NULL) return NULL;
661
662
663     NewElem = (_cmsStageCLutData*) _cmsMallocZero(ContextID, sizeof(_cmsStageCLutData));
664     if (NewElem == NULL) {
665         cmsStageFree(NewMPE);
666         return NULL;
667     }
668
669     NewMPE ->Data  = (void*) NewElem;
670
671     // There is a potential integer overflow on conputing n and nEntries.
672     NewElem -> nEntries = n = outputChan * CubeSize(clutPoints, inputChan);
673     NewElem -> HasFloatValues = TRUE;
674
675     if (n == 0) {
676         cmsStageFree(NewMPE);
677         return NULL;
678     }
679
680     NewElem ->Tab.TFloat  = (cmsFloat32Number*) _cmsCalloc(ContextID, n, sizeof(cmsFloat32Number));
681     if (NewElem ->Tab.TFloat == NULL) {
682         cmsStageFree(NewMPE);
683         return NULL;
684     }
685
686     if (Table != NULL) {
687         for (i=0; i < n; i++) {
688             NewElem ->Tab.TFloat[i] = Table[i];
689         }
690     }
691
692     NewElem ->Params = _cmsComputeInterpParamsEx(ContextID, clutPoints,  inputChan, outputChan, NewElem ->Tab.TFloat, CMS_LERP_FLAGS_FLOAT);
693     if (NewElem ->Params == NULL) {
694         cmsStageFree(NewMPE);
695         return NULL;
696     }
697
698     return NewMPE;
699 }
700
701
702 static
703 int IdentitySampler(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register void * Cargo)
704 {
705     int nChan = *(int*) Cargo;
706     int i;
707
708     for (i=0; i < nChan; i++)
709         Out[i] = In[i];
710
711     return 1;
712 }
713
714 // Creates an MPE that just copies input to output
715 cmsStage* _cmsStageAllocIdentityCLut(cmsContext ContextID, int nChan)
716 {
717     cmsUInt32Number Dimensions[MAX_INPUT_DIMENSIONS];
718     cmsStage* mpe ;
719     int i;
720
721     for (i=0; i < MAX_INPUT_DIMENSIONS; i++)
722         Dimensions[i] = 2;
723
724     mpe = cmsStageAllocCLut16bitGranular(ContextID, Dimensions, nChan, nChan, NULL);
725     if (mpe == NULL) return NULL;
726
727     if (!cmsStageSampleCLut16bit(mpe, IdentitySampler, &nChan, 0)) {
728         cmsStageFree(mpe);
729         return NULL;
730     }
731
732     mpe ->Implements = cmsSigIdentityElemType;
733     return mpe;
734 }
735
736
737
738 // Quantize a value 0 <= i < MaxSamples to 0..0xffff
739 cmsUInt16Number _cmsQuantizeVal(cmsFloat64Number i, int MaxSamples)
740 {
741     cmsFloat64Number x;
742
743     x = ((cmsFloat64Number) i * 65535.) / (cmsFloat64Number) (MaxSamples - 1);
744     return _cmsQuickSaturateWord(x);
745 }
746
747
748 // This routine does a sweep on whole input space, and calls its callback
749 // function on knots. returns TRUE if all ok, FALSE otherwise.
750 cmsBool CMSEXPORT cmsStageSampleCLut16bit(cmsStage* mpe, cmsSAMPLER16 Sampler, void * Cargo, cmsUInt32Number dwFlags)
751 {
752     int i, t, nTotalPoints, index, rest;
753     int nInputs, nOutputs;
754     cmsUInt32Number* nSamples;
755     cmsUInt16Number In[MAX_INPUT_DIMENSIONS+1], Out[MAX_STAGE_CHANNELS];
756     _cmsStageCLutData* clut;
757
758     if (mpe == NULL) return FALSE;
759
760     clut = (_cmsStageCLutData*) mpe->Data;
761
762     if (clut == NULL) return FALSE;
763
764     nSamples = clut->Params ->nSamples;
765     nInputs  = clut->Params ->nInputs;
766     nOutputs = clut->Params ->nOutputs;
767
768     if (nInputs <= 0) return FALSE;
769     if (nOutputs <= 0) return FALSE;
770     if (nInputs > MAX_INPUT_DIMENSIONS) return FALSE;
771     if (nOutputs >= MAX_STAGE_CHANNELS) return FALSE;
772
773     nTotalPoints = CubeSize(nSamples, nInputs);
774     if (nTotalPoints == 0) return FALSE;
775
776     index = 0;
777     for (i = 0; i < nTotalPoints; i++) {
778
779         rest = i;
780         for (t = nInputs-1; t >=0; --t) {
781
782             cmsUInt32Number  Colorant = rest % nSamples[t];
783
784             rest /= nSamples[t];
785
786             In[t] = _cmsQuantizeVal(Colorant, nSamples[t]);
787         }
788
789         if (clut ->Tab.T != NULL) {
790             for (t=0; t < nOutputs; t++)
791                 Out[t] = clut->Tab.T[index + t];
792         }
793
794         if (!Sampler(In, Out, Cargo))
795             return FALSE;
796
797         if (!(dwFlags & SAMPLER_INSPECT)) {
798
799             if (clut ->Tab.T != NULL) {
800                 for (t=0; t < nOutputs; t++)
801                     clut->Tab.T[index + t] = Out[t];
802             }
803         }
804
805         index += nOutputs;
806     }
807
808     return TRUE;
809 }
810
811 // Same as anterior, but for floting point
812 cmsBool CMSEXPORT cmsStageSampleCLutFloat(cmsStage* mpe, cmsSAMPLERFLOAT Sampler, void * Cargo, cmsUInt32Number dwFlags)
813 {
814     int i, t, nTotalPoints, index, rest;
815     int nInputs, nOutputs;
816     cmsUInt32Number* nSamples;
817     cmsFloat32Number In[MAX_INPUT_DIMENSIONS+1], Out[MAX_STAGE_CHANNELS];
818     _cmsStageCLutData* clut = (_cmsStageCLutData*) mpe->Data;
819
820     nSamples = clut->Params ->nSamples;
821     nInputs  = clut->Params ->nInputs;
822     nOutputs = clut->Params ->nOutputs;
823
824     if (nInputs <= 0) return FALSE;
825     if (nOutputs <= 0) return FALSE;
826     if (nInputs  > MAX_INPUT_DIMENSIONS) return FALSE;
827     if (nOutputs >= MAX_STAGE_CHANNELS) return FALSE;
828
829     nTotalPoints = CubeSize(nSamples, nInputs);
830     if (nTotalPoints == 0) return FALSE;
831
832     index = 0;
833     for (i = 0; i < nTotalPoints; i++) {
834
835         rest = i;
836         for (t = nInputs-1; t >=0; --t) {
837
838             cmsUInt32Number  Colorant = rest % nSamples[t];
839
840             rest /= nSamples[t];
841
842             In[t] =  (cmsFloat32Number) (_cmsQuantizeVal(Colorant, nSamples[t]) / 65535.0);
843         }
844
845         if (clut ->Tab.TFloat != NULL) {
846             for (t=0; t < nOutputs; t++)
847                 Out[t] = clut->Tab.TFloat[index + t];
848         }
849
850         if (!Sampler(In, Out, Cargo))
851             return FALSE;
852
853         if (!(dwFlags & SAMPLER_INSPECT)) {
854
855             if (clut ->Tab.TFloat != NULL) {
856                 for (t=0; t < nOutputs; t++)
857                     clut->Tab.TFloat[index + t] = Out[t];
858             }
859         }
860
861         index += nOutputs;
862     }
863
864     return TRUE;
865 }
866
867
868
869 // This routine does a sweep on whole input space, and calls its callback
870 // function on knots. returns TRUE if all ok, FALSE otherwise.
871 cmsBool CMSEXPORT cmsSliceSpace16(cmsUInt32Number nInputs, const cmsUInt32Number clutPoints[],
872                                          cmsSAMPLER16 Sampler, void * Cargo)
873 {
874     int i, t, nTotalPoints, rest;
875     cmsUInt16Number In[cmsMAXCHANNELS];
876
877     if (nInputs >= cmsMAXCHANNELS) return FALSE;
878
879     nTotalPoints = CubeSize(clutPoints, nInputs);
880     if (nTotalPoints == 0) return FALSE;
881
882     for (i = 0; i < nTotalPoints; i++) {
883
884         rest = i;
885         for (t = nInputs-1; t >=0; --t) {
886
887             cmsUInt32Number  Colorant = rest % clutPoints[t];
888
889             rest /= clutPoints[t];
890             In[t] = _cmsQuantizeVal(Colorant, clutPoints[t]);
891
892         }
893
894         if (!Sampler(In, NULL, Cargo))
895             return FALSE;
896     }
897
898     return TRUE;
899 }
900
901 cmsInt32Number CMSEXPORT cmsSliceSpaceFloat(cmsUInt32Number nInputs, const cmsUInt32Number clutPoints[],
902                                             cmsSAMPLERFLOAT Sampler, void * Cargo)
903 {
904     int i, t, nTotalPoints, rest;
905     cmsFloat32Number In[cmsMAXCHANNELS];
906
907     if (nInputs >= cmsMAXCHANNELS) return FALSE;
908
909     nTotalPoints = CubeSize(clutPoints, nInputs);
910     if (nTotalPoints == 0) return FALSE;
911
912     for (i = 0; i < nTotalPoints; i++) {
913
914         rest = i;
915         for (t = nInputs-1; t >=0; --t) {
916
917             cmsUInt32Number  Colorant = rest % clutPoints[t];
918
919             rest /= clutPoints[t];
920             In[t] =  (cmsFloat32Number) (_cmsQuantizeVal(Colorant, clutPoints[t]) / 65535.0);
921
922         }
923
924         if (!Sampler(In, NULL, Cargo))
925             return FALSE;
926     }
927
928     return TRUE;
929 }
930
931 // ********************************************************************************
932 // Type cmsSigLab2XYZElemType
933 // ********************************************************************************
934
935
936 static
937 void EvaluateLab2XYZ(const cmsFloat32Number In[],
938                      cmsFloat32Number Out[],
939                      const cmsStage *mpe)
940 {
941     cmsCIELab Lab;
942     cmsCIEXYZ XYZ;
943     const cmsFloat64Number XYZadj = MAX_ENCODEABLE_XYZ;
944
945     // V4 rules
946     Lab.L = In[0] * 100.0;
947     Lab.a = In[1] * 255.0 - 128.0;
948     Lab.b = In[2] * 255.0 - 128.0;
949
950     cmsLab2XYZ(NULL, &XYZ, &Lab);
951
952     // From XYZ, range 0..19997 to 0..1.0, note that 1.99997 comes from 0xffff
953     // encoded as 1.15 fixed point, so 1 + (32767.0 / 32768.0)
954
955     Out[0] = (cmsFloat32Number) ((cmsFloat64Number) XYZ.X / XYZadj);
956     Out[1] = (cmsFloat32Number) ((cmsFloat64Number) XYZ.Y / XYZadj);
957     Out[2] = (cmsFloat32Number) ((cmsFloat64Number) XYZ.Z / XYZadj);
958     return;
959
960     cmsUNUSED_PARAMETER(mpe);
961 }
962
963
964 // No dup or free routines needed, as the structure has no pointers in it.
965 cmsStage* _cmsStageAllocLab2XYZ(cmsContext ContextID)
966 {
967     return _cmsStageAllocPlaceholder(ContextID, cmsSigLab2XYZElemType, 3, 3, EvaluateLab2XYZ, NULL, NULL, NULL);
968 }
969
970 // ********************************************************************************
971
972 // v2 L=100 is supposed to be placed on 0xFF00. There is no reasonable
973 // number of gridpoints that would make exact match. However, a prelinearization
974 // of 258 entries, would map 0xFF00 exactly on entry 257, and this is good to avoid scum dot.
975 // Almost all what we need but unfortunately, the rest of entries should be scaled by
976 // (255*257/256) and this is not exact.
977
978 cmsStage* _cmsStageAllocLabV2ToV4curves(cmsContext ContextID)
979 {
980     cmsStage* mpe;
981     cmsToneCurve* LabTable[3];
982     int i, j;
983
984     LabTable[0] = cmsBuildTabulatedToneCurve16(ContextID, 258, NULL);
985     LabTable[1] = cmsBuildTabulatedToneCurve16(ContextID, 258, NULL);
986     LabTable[2] = cmsBuildTabulatedToneCurve16(ContextID, 258, NULL);
987
988     for (j=0; j < 3; j++) {
989
990         if (LabTable[j] == NULL) {
991             cmsFreeToneCurveTriple(LabTable);
992             return NULL;
993         }
994
995         // We need to map * (0xffff / 0xff00), thats same as (257 / 256)
996         // So we can use 258-entry tables to do the trick (i / 257) * (255 * 257) * (257 / 256);
997         for (i=0; i < 257; i++)  {
998
999             LabTable[j]->Table16[i] = (cmsUInt16Number) ((i * 0xffff + 0x80) >> 8);
1000         }
1001
1002         LabTable[j] ->Table16[257] = 0xffff;
1003     }
1004
1005     mpe = cmsStageAllocToneCurves(ContextID, 3, LabTable);
1006     cmsFreeToneCurveTriple(LabTable);
1007
1008     if (mpe == NULL) return NULL;
1009     mpe ->Implements = cmsSigLabV2toV4;
1010     return mpe;
1011 }
1012
1013 // ********************************************************************************
1014
1015 // Matrix-based conversion, which is more accurate, but slower and cannot properly be saved in devicelink profiles
1016 cmsStage* _cmsStageAllocLabV2ToV4(cmsContext ContextID)
1017 {
1018     static const cmsFloat64Number V2ToV4[] = { 65535.0/65280.0, 0, 0,
1019                                      0, 65535.0/65280.0, 0,
1020                                      0, 0, 65535.0/65280.0
1021                                      };
1022
1023     cmsStage *mpe = cmsStageAllocMatrix(ContextID, 3, 3, V2ToV4, NULL);
1024
1025     if (mpe == NULL) return mpe;
1026     mpe ->Implements = cmsSigLabV2toV4;
1027     return mpe;
1028 }
1029
1030
1031 // Reverse direction
1032 cmsStage* _cmsStageAllocLabV4ToV2(cmsContext ContextID)
1033 {
1034     static const cmsFloat64Number V4ToV2[] = { 65280.0/65535.0, 0, 0,
1035                                      0, 65280.0/65535.0, 0,
1036                                      0, 0, 65280.0/65535.0
1037                                      };
1038
1039      cmsStage *mpe = cmsStageAllocMatrix(ContextID, 3, 3, V4ToV2, NULL);
1040
1041     if (mpe == NULL) return mpe;
1042     mpe ->Implements = cmsSigLabV4toV2;
1043     return mpe;
1044 }
1045
1046
1047 // To Lab to float. Note that the MPE gives numbers in normal Lab range
1048 // and we need 0..1.0 range for the formatters
1049 // L* : 0...100 => 0...1.0  (L* / 100)
1050 // ab* : -128..+127 to 0..1  ((ab* + 128) / 255)
1051
1052 cmsStage* _cmsStageNormalizeFromLabFloat(cmsContext ContextID)
1053 {
1054     static const cmsFloat64Number a1[] = {
1055         1.0/100.0, 0, 0,
1056         0, 1.0/255.0, 0,
1057         0, 0, 1.0/255.0
1058     };
1059
1060     static const cmsFloat64Number o1[] = {
1061         0,
1062         128.0/255.0,
1063         128.0/255.0
1064     };
1065
1066     cmsStage *mpe = cmsStageAllocMatrix(ContextID, 3, 3, a1, o1);
1067
1068     if (mpe == NULL) return mpe;
1069     mpe ->Implements = cmsSigLab2FloatPCS;
1070     return mpe;
1071 }
1072
1073 // Fom XYZ to floating point PCS
1074 cmsStage* _cmsStageNormalizeFromXyzFloat(cmsContext ContextID)
1075 {
1076 #define n (32768.0/65535.0)
1077     static const cmsFloat64Number a1[] = {
1078         n, 0, 0,
1079         0, n, 0,
1080         0, 0, n
1081     };
1082 #undef n
1083
1084     cmsStage *mpe =  cmsStageAllocMatrix(ContextID, 3, 3, a1, NULL);
1085
1086     if (mpe == NULL) return mpe;
1087     mpe ->Implements = cmsSigXYZ2FloatPCS;
1088     return mpe;
1089 }
1090
1091 cmsStage* _cmsStageNormalizeToLabFloat(cmsContext ContextID)
1092 {
1093     static const cmsFloat64Number a1[] = {
1094         100.0, 0, 0,
1095         0, 255.0, 0,
1096         0, 0, 255.0
1097     };
1098
1099     static const cmsFloat64Number o1[] = {
1100         0,
1101         -128.0,
1102         -128.0
1103     };
1104
1105     cmsStage *mpe =  cmsStageAllocMatrix(ContextID, 3, 3, a1, o1);
1106     if (mpe == NULL) return mpe;
1107     mpe ->Implements = cmsSigFloatPCS2Lab;
1108     return mpe;
1109 }
1110
1111 cmsStage* _cmsStageNormalizeToXyzFloat(cmsContext ContextID)
1112 {
1113 #define n (65535.0/32768.0)
1114
1115     static const cmsFloat64Number a1[] = {
1116         n, 0, 0,
1117         0, n, 0,
1118         0, 0, n
1119     };
1120 #undef n
1121
1122     cmsStage *mpe = cmsStageAllocMatrix(ContextID, 3, 3, a1, NULL);
1123     if (mpe == NULL) return mpe;
1124     mpe ->Implements = cmsSigFloatPCS2XYZ;
1125     return mpe;
1126 }
1127
1128
1129
1130 // ********************************************************************************
1131 // Type cmsSigXYZ2LabElemType
1132 // ********************************************************************************
1133
1134 static
1135 void EvaluateXYZ2Lab(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsStage *mpe)
1136 {
1137     cmsCIELab Lab;
1138     cmsCIEXYZ XYZ;
1139     const cmsFloat64Number XYZadj = MAX_ENCODEABLE_XYZ;
1140
1141     // From 0..1.0 to XYZ
1142
1143     XYZ.X = In[0] * XYZadj;
1144     XYZ.Y = In[1] * XYZadj;
1145     XYZ.Z = In[2] * XYZadj;
1146
1147     cmsXYZ2Lab(NULL, &Lab, &XYZ);
1148
1149     // From V4 Lab to 0..1.0
1150
1151     Out[0] = (cmsFloat32Number) (Lab.L / 100.0);
1152     Out[1] = (cmsFloat32Number) ((Lab.a + 128.0) / 255.0);
1153     Out[2] = (cmsFloat32Number) ((Lab.b + 128.0) / 255.0);
1154     return;
1155
1156     cmsUNUSED_PARAMETER(mpe);
1157 }
1158
1159 cmsStage* _cmsStageAllocXYZ2Lab(cmsContext ContextID)
1160 {
1161     return _cmsStageAllocPlaceholder(ContextID, cmsSigXYZ2LabElemType, 3, 3, EvaluateXYZ2Lab, NULL, NULL, NULL);
1162
1163 }
1164
1165 // ********************************************************************************
1166
1167 // For v4, S-Shaped curves are placed in a/b axis to increase resolution near gray
1168
1169 cmsStage* _cmsStageAllocLabPrelin(cmsContext ContextID)
1170 {
1171     cmsToneCurve* LabTable[3];
1172     cmsFloat64Number Params[1] =  {2.4} ;
1173
1174     LabTable[0] = cmsBuildGamma(ContextID, 1.0);
1175     LabTable[1] = cmsBuildParametricToneCurve(ContextID, 108, Params);
1176     LabTable[2] = cmsBuildParametricToneCurve(ContextID, 108, Params);
1177
1178     return cmsStageAllocToneCurves(ContextID, 3, LabTable);
1179 }
1180
1181
1182 // Free a single MPE
1183 void CMSEXPORT cmsStageFree(cmsStage* mpe)
1184 {
1185     if (mpe ->FreePtr)
1186         mpe ->FreePtr(mpe);
1187
1188     _cmsFree(mpe ->ContextID, mpe);
1189 }
1190
1191
1192 cmsUInt32Number  CMSEXPORT cmsStageInputChannels(const cmsStage* mpe)
1193 {
1194     return mpe ->InputChannels;
1195 }
1196
1197 cmsUInt32Number  CMSEXPORT cmsStageOutputChannels(const cmsStage* mpe)
1198 {
1199     return mpe ->OutputChannels;
1200 }
1201
1202 cmsStageSignature CMSEXPORT cmsStageType(const cmsStage* mpe)
1203 {
1204     return mpe -> Type;
1205 }
1206
1207 void* CMSEXPORT cmsStageData(const cmsStage* mpe)
1208 {
1209     return mpe -> Data;
1210 }
1211
1212 cmsStage*  CMSEXPORT cmsStageNext(const cmsStage* mpe)
1213 {
1214     return mpe -> Next;
1215 }
1216
1217
1218 // Duplicates an MPE
1219 cmsStage* CMSEXPORT cmsStageDup(cmsStage* mpe)
1220 {
1221     cmsStage* NewMPE;
1222
1223     if (mpe == NULL) return NULL;
1224     NewMPE = _cmsStageAllocPlaceholder(mpe ->ContextID,
1225                                      mpe ->Type,
1226                                      mpe ->InputChannels,
1227                                      mpe ->OutputChannels,
1228                                      mpe ->EvalPtr,
1229                                      mpe ->DupElemPtr,
1230                                      mpe ->FreePtr,
1231                                      NULL);
1232     if (NewMPE == NULL) return NULL;
1233
1234     NewMPE ->Implements = mpe ->Implements;
1235
1236     if (mpe ->DupElemPtr) {
1237
1238         NewMPE ->Data = mpe ->DupElemPtr(mpe);
1239
1240         if (NewMPE->Data == NULL) {
1241
1242             cmsStageFree(NewMPE);
1243             return NULL;
1244         }
1245
1246     } else {
1247
1248         NewMPE ->Data       = NULL;
1249     }
1250
1251     return NewMPE;
1252 }
1253
1254
1255 // ***********************************************************************************************************
1256
1257 // This function sets up the channel count
1258
1259 static
1260 void BlessLUT(cmsPipeline* lut)
1261 {
1262     // We can set the input/ouput channels only if we have elements.
1263     if (lut ->Elements != NULL) {
1264
1265         cmsStage *First, *Last;
1266
1267         First  = cmsPipelineGetPtrToFirstStage(lut);
1268         Last   = cmsPipelineGetPtrToLastStage(lut);
1269
1270         if (First != NULL)lut ->InputChannels = First ->InputChannels;
1271         if (Last != NULL) lut ->OutputChannels = Last ->OutputChannels;
1272     }
1273 }
1274
1275
1276 // Default to evaluate the LUT on 16 bit-basis. Precision is retained.
1277 static
1278 void _LUTeval16(register const cmsUInt16Number In[], register cmsUInt16Number Out[],  register const void* D)
1279 {
1280     cmsPipeline* lut = (cmsPipeline*) D;
1281     cmsStage *mpe;
1282     cmsFloat32Number Storage[2][MAX_STAGE_CHANNELS] = {0.0f};
1283     int Phase = 0, NextPhase;
1284
1285     From16ToFloat(In, &Storage[Phase][0], lut ->InputChannels);
1286
1287     for (mpe = lut ->Elements;
1288          mpe != NULL;
1289          mpe = mpe ->Next) {
1290
1291              NextPhase = Phase ^ 1;
1292              mpe ->EvalPtr(&Storage[Phase][0], &Storage[NextPhase][0], mpe);
1293              Phase = NextPhase;
1294     }
1295
1296
1297     FromFloatTo16(&Storage[Phase][0], Out, lut ->OutputChannels);
1298 }
1299
1300
1301
1302 // Does evaluate the LUT on cmsFloat32Number-basis.
1303 static
1304 void _LUTevalFloat(register const cmsFloat32Number In[], register cmsFloat32Number Out[], const void* D)
1305 {
1306     cmsPipeline* lut = (cmsPipeline*) D;
1307     cmsStage *mpe;
1308     cmsFloat32Number Storage[2][MAX_STAGE_CHANNELS] = {0.0f};
1309     int Phase = 0, NextPhase;
1310
1311     memmove(&Storage[Phase][0], In, lut ->InputChannels  * sizeof(cmsFloat32Number));
1312
1313     for (mpe = lut ->Elements;
1314          mpe != NULL;
1315          mpe = mpe ->Next) {
1316
1317               NextPhase = Phase ^ 1;
1318               mpe ->EvalPtr(&Storage[Phase][0], &Storage[NextPhase][0], mpe);
1319               Phase = NextPhase;
1320     }
1321
1322     memmove(Out, &Storage[Phase][0], lut ->OutputChannels * sizeof(cmsFloat32Number));
1323 }
1324
1325
1326
1327
1328 // LUT Creation & Destruction
1329
1330 cmsPipeline* CMSEXPORT cmsPipelineAlloc(cmsContext ContextID, cmsUInt32Number InputChannels, cmsUInt32Number OutputChannels)
1331 {
1332        cmsPipeline* NewLUT;
1333
1334        if (InputChannels >= cmsMAXCHANNELS ||
1335            OutputChannels >= cmsMAXCHANNELS) return NULL;
1336
1337        NewLUT = (cmsPipeline*) _cmsMallocZero(ContextID, sizeof(cmsPipeline));
1338        if (NewLUT == NULL) return NULL;
1339
1340
1341        NewLUT -> InputChannels  = InputChannels;
1342        NewLUT -> OutputChannels = OutputChannels;
1343
1344        NewLUT ->Eval16Fn    = _LUTeval16;
1345        NewLUT ->EvalFloatFn = _LUTevalFloat;
1346        NewLUT ->DupDataFn   = NULL;
1347        NewLUT ->FreeDataFn  = NULL;
1348        NewLUT ->Data        = NewLUT;
1349        NewLUT ->ContextID   = ContextID;
1350
1351        BlessLUT(NewLUT);
1352
1353        return NewLUT;
1354 }
1355
1356 cmsContext CMSEXPORT cmsGetPipelineContextID(const cmsPipeline* lut)
1357 {
1358     _cmsAssert(lut != NULL);
1359     return lut ->ContextID;
1360 }
1361
1362 cmsUInt32Number CMSEXPORT cmsPipelineInputChannels(const cmsPipeline* lut)
1363 {
1364     _cmsAssert(lut != NULL);
1365     return lut ->InputChannels;
1366 }
1367
1368 cmsUInt32Number CMSEXPORT cmsPipelineOutputChannels(const cmsPipeline* lut)
1369 {
1370     _cmsAssert(lut != NULL);
1371     return lut ->OutputChannels;
1372 }
1373
1374 // Free a profile elements LUT
1375 void CMSEXPORT cmsPipelineFree(cmsPipeline* lut)
1376 {
1377     cmsStage *mpe, *Next;
1378
1379     if (lut == NULL) return;
1380
1381     for (mpe = lut ->Elements;
1382         mpe != NULL;
1383         mpe = Next) {
1384
1385             Next = mpe ->Next;
1386             cmsStageFree(mpe);
1387     }
1388
1389     if (lut ->FreeDataFn) lut ->FreeDataFn(lut ->ContextID, lut ->Data);
1390
1391     _cmsFree(lut ->ContextID, lut);
1392 }
1393
1394
1395 // Default to evaluate the LUT on 16 bit-basis.
1396 void CMSEXPORT cmsPipelineEval16(const cmsUInt16Number In[], cmsUInt16Number Out[],  const cmsPipeline* lut)
1397 {
1398     _cmsAssert(lut != NULL);
1399     lut ->Eval16Fn(In, Out, lut->Data);
1400 }
1401
1402
1403 // Does evaluate the LUT on cmsFloat32Number-basis.
1404 void CMSEXPORT cmsPipelineEvalFloat(const cmsFloat32Number In[], cmsFloat32Number Out[], const cmsPipeline* lut)
1405 {
1406     _cmsAssert(lut != NULL);
1407     lut ->EvalFloatFn(In, Out, lut);
1408 }
1409
1410
1411
1412 // Duplicates a LUT
1413 cmsPipeline* CMSEXPORT cmsPipelineDup(const cmsPipeline* lut)
1414 {
1415     cmsPipeline* NewLUT;
1416     cmsStage *NewMPE, *Anterior = NULL, *mpe;
1417     cmsBool  First = TRUE;
1418
1419     if (lut == NULL) return NULL;
1420
1421     NewLUT = cmsPipelineAlloc(lut ->ContextID, lut ->InputChannels, lut ->OutputChannels);
1422     if (NewLUT == NULL) return NULL;
1423
1424     for (mpe = lut ->Elements;
1425          mpe != NULL;
1426          mpe = mpe ->Next) {
1427
1428              NewMPE = cmsStageDup(mpe);
1429
1430              if (NewMPE == NULL) {
1431                  cmsPipelineFree(NewLUT);
1432                  return NULL;
1433              }
1434
1435              if (First) {
1436                  NewLUT ->Elements = NewMPE;
1437                  First = FALSE;
1438              }
1439              else {
1440                 Anterior ->Next = NewMPE;
1441              }
1442
1443             Anterior = NewMPE;
1444     }
1445
1446     NewLUT ->Eval16Fn    = lut ->Eval16Fn;
1447     NewLUT ->EvalFloatFn = lut ->EvalFloatFn;
1448     NewLUT ->DupDataFn   = lut ->DupDataFn;
1449     NewLUT ->FreeDataFn  = lut ->FreeDataFn;
1450
1451     if (NewLUT ->DupDataFn != NULL)
1452         NewLUT ->Data = NewLUT ->DupDataFn(lut ->ContextID, lut->Data);
1453
1454
1455     NewLUT ->SaveAs8Bits    = lut ->SaveAs8Bits;
1456
1457     BlessLUT(NewLUT);
1458     return NewLUT;
1459 }
1460
1461
1462 int CMSEXPORT cmsPipelineInsertStage(cmsPipeline* lut, cmsStageLoc loc, cmsStage* mpe)
1463 {
1464     cmsStage* Anterior = NULL, *pt;
1465
1466     if (lut == NULL || mpe == NULL)
1467         return FALSE;
1468
1469     switch (loc) {
1470
1471         case cmsAT_BEGIN:
1472             mpe ->Next = lut ->Elements;
1473             lut ->Elements = mpe;
1474             break;
1475
1476         case cmsAT_END:
1477
1478             if (lut ->Elements == NULL)
1479                 lut ->Elements = mpe;
1480             else {
1481
1482                 for (pt = lut ->Elements;
1483                      pt != NULL;
1484                      pt = pt -> Next) Anterior = pt;
1485
1486                 Anterior ->Next = mpe;
1487                 mpe ->Next = NULL;
1488             }
1489             break;
1490         default:;
1491             return FALSE;
1492     }
1493
1494     BlessLUT(lut);
1495     return TRUE;
1496 }
1497
1498 // Unlink an element and return the pointer to it
1499 void CMSEXPORT cmsPipelineUnlinkStage(cmsPipeline* lut, cmsStageLoc loc, cmsStage** mpe)
1500 {
1501     cmsStage *Anterior, *pt, *Last;
1502     cmsStage *Unlinked = NULL;
1503
1504
1505     // If empty LUT, there is nothing to remove
1506     if (lut ->Elements == NULL) {
1507         if (mpe) *mpe = NULL;
1508         return;
1509     }
1510
1511     // On depending on the strategy...
1512     switch (loc) {
1513
1514         case cmsAT_BEGIN:
1515             {
1516                 cmsStage* elem = lut ->Elements;
1517
1518                 lut ->Elements = elem -> Next;
1519                 elem ->Next = NULL;
1520                 Unlinked = elem;
1521
1522             }
1523             break;
1524
1525         case cmsAT_END:
1526             Anterior = Last = NULL;
1527             for (pt = lut ->Elements;
1528                 pt != NULL;
1529                 pt = pt -> Next) {
1530                     Anterior = Last;
1531                     Last = pt;
1532             }
1533
1534             Unlinked = Last;  // Next already points to NULL
1535
1536             // Truncate the chain
1537             if (Anterior)
1538                 Anterior ->Next = NULL;
1539             else
1540                 lut ->Elements = NULL;
1541             break;
1542         default:;
1543     }
1544
1545     if (mpe)
1546         *mpe = Unlinked;
1547     else
1548         cmsStageFree(Unlinked);
1549
1550     BlessLUT(lut);
1551 }
1552
1553
1554 // Concatenate two LUT into a new single one
1555 cmsBool  CMSEXPORT cmsPipelineCat(cmsPipeline* l1, const cmsPipeline* l2)
1556 {
1557     cmsStage* mpe;
1558
1559     // If both LUTS does not have elements, we need to inherit
1560     // the number of channels
1561     if (l1 ->Elements == NULL && l2 ->Elements == NULL) {
1562         l1 ->InputChannels  = l2 ->InputChannels;
1563         l1 ->OutputChannels = l2 ->OutputChannels;
1564     }
1565
1566     // Cat second
1567     for (mpe = l2 ->Elements;
1568          mpe != NULL;
1569          mpe = mpe ->Next) {
1570
1571             // We have to dup each element
1572             if (!cmsPipelineInsertStage(l1, cmsAT_END, cmsStageDup(mpe)))
1573                 return FALSE;
1574     }
1575
1576     BlessLUT(l1);
1577     return TRUE;
1578 }
1579
1580
1581 cmsBool CMSEXPORT cmsPipelineSetSaveAs8bitsFlag(cmsPipeline* lut, cmsBool On)
1582 {
1583     cmsBool Anterior = lut ->SaveAs8Bits;
1584
1585     lut ->SaveAs8Bits = On;
1586     return Anterior;
1587 }
1588
1589
1590 cmsStage* CMSEXPORT cmsPipelineGetPtrToFirstStage(const cmsPipeline* lut)
1591 {
1592     return lut ->Elements;
1593 }
1594
1595 cmsStage* CMSEXPORT cmsPipelineGetPtrToLastStage(const cmsPipeline* lut)
1596 {
1597     cmsStage *mpe, *Anterior = NULL;
1598
1599     for (mpe = lut ->Elements; mpe != NULL; mpe = mpe ->Next)
1600         Anterior = mpe;
1601
1602     return Anterior;
1603 }
1604
1605 cmsUInt32Number CMSEXPORT cmsPipelineStageCount(const cmsPipeline* lut)
1606 {
1607     cmsStage *mpe;
1608     cmsUInt32Number n;
1609
1610     for (n=0, mpe = lut ->Elements; mpe != NULL; mpe = mpe ->Next)
1611             n++;
1612
1613     return n;
1614 }
1615
1616 // This function may be used to set the optional evaluator and a block of private data. If private data is being used, an optional
1617 // duplicator and free functions should also be specified in order to duplicate the LUT construct. Use NULL to inhibit such functionality.
1618 void CMSEXPORT _cmsPipelineSetOptimizationParameters(cmsPipeline* Lut,
1619                                         _cmsOPTeval16Fn Eval16,
1620                                         void* PrivateData,
1621                                         _cmsFreeUserDataFn FreePrivateDataFn,
1622                                         _cmsDupUserDataFn  DupPrivateDataFn)
1623 {
1624
1625     Lut ->Eval16Fn = Eval16;
1626     Lut ->DupDataFn = DupPrivateDataFn;
1627     Lut ->FreeDataFn = FreePrivateDataFn;
1628     Lut ->Data = PrivateData;
1629 }
1630
1631
1632 // ----------------------------------------------------------- Reverse interpolation
1633 // Here's how it goes. The derivative Df(x) of the function f is the linear
1634 // transformation that best approximates f near the point x. It can be represented
1635 // by a matrix A whose entries are the partial derivatives of the components of f
1636 // with respect to all the coordinates. This is know as the Jacobian
1637 //
1638 // The best linear approximation to f is given by the matrix equation:
1639 //
1640 // y-y0 = A (x-x0)
1641 //
1642 // So, if x0 is a good "guess" for the zero of f, then solving for the zero of this
1643 // linear approximation will give a "better guess" for the zero of f. Thus let y=0,
1644 // and since y0=f(x0) one can solve the above equation for x. This leads to the
1645 // Newton's method formula:
1646 //
1647 // xn+1 = xn - A-1 f(xn)
1648 //
1649 // where xn+1 denotes the (n+1)-st guess, obtained from the n-th guess xn in the
1650 // fashion described above. Iterating this will give better and better approximations
1651 // if you have a "good enough" initial guess.
1652
1653
1654 #define JACOBIAN_EPSILON            0.001f
1655 #define INVERSION_MAX_ITERATIONS    30
1656
1657 // Increment with reflexion on boundary
1658 static
1659 void IncDelta(cmsFloat32Number *Val)
1660 {
1661     if (*Val < (1.0 - JACOBIAN_EPSILON))
1662
1663         *Val += JACOBIAN_EPSILON;
1664
1665     else
1666         *Val -= JACOBIAN_EPSILON;
1667
1668 }
1669
1670
1671
1672 // Euclidean distance between two vectors of n elements each one
1673 static
1674 cmsFloat32Number EuclideanDistance(cmsFloat32Number a[], cmsFloat32Number b[], int n)
1675 {
1676     cmsFloat32Number sum = 0;
1677     int i;
1678
1679     for (i=0; i < n; i++) {
1680         cmsFloat32Number dif = b[i] - a[i];
1681         sum +=  dif * dif;
1682     }
1683
1684     return sqrtf(sum);
1685 }
1686
1687
1688 // Evaluate a LUT in reverse direction. It only searches on 3->3 LUT. Uses Newton method
1689 //
1690 // x1 <- x - [J(x)]^-1 * f(x)
1691 //
1692 // lut: The LUT on where to do the search
1693 // Target: LabK, 3 values of Lab plus destination K which is fixed
1694 // Result: The obtained CMYK
1695 // Hint:   Location where begin the search
1696
1697 cmsBool CMSEXPORT cmsPipelineEvalReverseFloat(cmsFloat32Number Target[],
1698                                               cmsFloat32Number Result[],
1699                                               cmsFloat32Number Hint[],
1700                                               const cmsPipeline* lut)
1701 {
1702     cmsUInt32Number  i, j;
1703     cmsFloat64Number  error, LastError = 1E20;
1704     cmsFloat32Number  fx[4], x[4], xd[4], fxd[4];
1705     cmsVEC3 tmp, tmp2;
1706     cmsMAT3 Jacobian;
1707     
1708     // Only 3->3 and 4->3 are supported
1709     if (lut ->InputChannels != 3 && lut ->InputChannels != 4) return FALSE;
1710     if (lut ->OutputChannels != 3) return FALSE;
1711    
1712     // Take the hint as starting point if specified
1713     if (Hint == NULL) {
1714
1715         // Begin at any point, we choose 1/3 of CMY axis
1716         x[0] = x[1] = x[2] = 0.3f;
1717     }
1718     else {
1719
1720         // Only copy 3 channels from hint...
1721         for (j=0; j < 3; j++)
1722             x[j] = Hint[j];
1723     }
1724
1725     // If Lut is 4-dimensions, then grab target[3], which is fixed
1726     if (lut ->InputChannels == 4) {
1727         x[3] = Target[3];
1728     }
1729     else x[3] = 0; // To keep lint happy
1730
1731
1732     // Iterate
1733     for (i = 0; i < INVERSION_MAX_ITERATIONS; i++) {
1734
1735         // Get beginning fx
1736         cmsPipelineEvalFloat(x, fx, lut);
1737
1738         // Compute error
1739         error = EuclideanDistance(fx, Target, 3);
1740
1741         // If not convergent, return last safe value
1742         if (error >= LastError)
1743             break;
1744
1745         // Keep latest values
1746         LastError     = error;
1747         for (j=0; j < lut ->InputChannels; j++)
1748                 Result[j] = x[j];
1749
1750         // Found an exact match?
1751         if (error <= 0)
1752             break;
1753
1754         // Obtain slope (the Jacobian)
1755         for (j = 0; j < 3; j++) {
1756
1757             xd[0] = x[0];
1758             xd[1] = x[1];
1759             xd[2] = x[2];
1760             xd[3] = x[3];  // Keep fixed channel
1761
1762             IncDelta(&xd[j]);
1763
1764             cmsPipelineEvalFloat(xd, fxd, lut);
1765
1766             Jacobian.v[0].n[j] = ((fxd[0] - fx[0]) / JACOBIAN_EPSILON);
1767             Jacobian.v[1].n[j] = ((fxd[1] - fx[1]) / JACOBIAN_EPSILON);
1768             Jacobian.v[2].n[j] = ((fxd[2] - fx[2]) / JACOBIAN_EPSILON);
1769         }
1770
1771         // Solve system
1772         tmp2.n[0] = fx[0] - Target[0];
1773         tmp2.n[1] = fx[1] - Target[1];
1774         tmp2.n[2] = fx[2] - Target[2];
1775
1776         if (!_cmsMAT3solve(&tmp, &Jacobian, &tmp2))
1777             return FALSE;
1778
1779         // Move our guess
1780         x[0] -= (cmsFloat32Number) tmp.n[0];
1781         x[1] -= (cmsFloat32Number) tmp.n[1];
1782         x[2] -= (cmsFloat32Number) tmp.n[2];
1783
1784         // Some clipping....
1785         for (j=0; j < 3; j++) {
1786             if (x[j] < 0) x[j] = 0;
1787             else
1788                 if (x[j] > 1.0) x[j] = 1.0;
1789         }
1790     }
1791
1792     return TRUE;
1793 }