1 //---------------------------------------------------------------------------------
3 // Little Color Management System
4 // Copyright (c) 1998-2023 Marti Maria Saguer
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:
13 // The above copyright notice and this permission notice shall be included in
14 // all copies or substantial portions of the Software.
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.
24 //---------------------------------------------------------------------------------
27 #include "lcms2_internal.h"
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
,
40 cmsStage
* ph
= (cmsStage
*) _cmsMallocZero(ContextID
, sizeof(cmsStage
));
42 if (ph
== NULL
) return NULL
;
45 ph
->ContextID
= ContextID
;
48 ph
->Implements
= Type
; // By default, no clue on what is implementing
50 ph
->InputChannels
= InputChannels
;
51 ph
->OutputChannels
= OutputChannels
;
52 ph
->EvalPtr
= EvalPtr
;
53 ph
->DupElemPtr
= DupElemPtr
;
54 ph
->FreePtr
= FreePtr
;
62 void EvaluateIdentity(const cmsFloat32Number In
[],
63 cmsFloat32Number Out
[],
66 memmove(Out
, In
, mpe
->InputChannels
* sizeof(cmsFloat32Number
));
70 cmsStage
* CMSEXPORT
cmsStageAllocIdentity(cmsContext ContextID
, cmsUInt32Number nChannels
)
72 return _cmsStageAllocPlaceholder(ContextID
,
73 cmsSigIdentityElemType
,
81 // Conversion functions. From floating point to 16 bits
83 void FromFloatTo16(const cmsFloat32Number In
[], cmsUInt16Number Out
[], cmsUInt32Number n
)
87 for (i
=0; i
< n
; i
++) {
88 Out
[i
] = _cmsQuickSaturateWord(In
[i
] * 65535.0);
92 // From 16 bits to floating point
94 void From16ToFloat(const cmsUInt16Number In
[], cmsFloat32Number Out
[], cmsUInt32Number n
)
98 for (i
=0; i
< n
; i
++) {
99 Out
[i
] = (cmsFloat32Number
) In
[i
] / 65535.0F
;
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
, ...)
115 cmsStageSignature Type
;
118 // Make sure same number of elements
119 if (cmsPipelineStageCount(Lut
) != n
) return FALSE
;
123 // Iterate across asked types
124 mpe
= Lut
->Elements
;
125 for (i
=0; i
< n
; i
++) {
127 // Get asked type. cmsStageSignature is promoted to int by compiler
128 Type
= (cmsStageSignature
)va_arg(args
, int);
129 if (mpe
->Type
!= Type
) {
131 va_end(args
); // Mismatch. We are done.
137 // Found a combination, fill pointers if not NULL
138 mpe
= Lut
->Elements
;
139 for (i
=0; i
< n
; i
++) {
141 ElemPtr
= va_arg(args
, void**);
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.
155 // *************************************************************************************************
156 // Type cmsSigCurveSetElemType (curves)
157 // *************************************************************************************************
159 cmsToneCurve
** _cmsStageGetPtrToCurveSet(const cmsStage
* mpe
)
161 _cmsStageToneCurvesData
* Data
= (_cmsStageToneCurvesData
*) mpe
->Data
;
163 return Data
->TheCurves
;
167 void EvaluateCurves(const cmsFloat32Number In
[],
168 cmsFloat32Number Out
[],
171 _cmsStageToneCurvesData
* Data
;
174 _cmsAssert(mpe
!= NULL
);
176 Data
= (_cmsStageToneCurvesData
*) mpe
->Data
;
177 if (Data
== NULL
) return;
179 if (Data
->TheCurves
== NULL
) return;
181 for (i
=0; i
< Data
->nCurves
; i
++) {
182 Out
[i
] = cmsEvalToneCurveFloat(Data
->TheCurves
[i
], In
[i
]);
187 void CurveSetElemTypeFree(cmsStage
* mpe
)
189 _cmsStageToneCurvesData
* Data
;
192 _cmsAssert(mpe
!= NULL
);
194 Data
= (_cmsStageToneCurvesData
*) mpe
->Data
;
195 if (Data
== NULL
) return;
197 if (Data
->TheCurves
!= NULL
) {
198 for (i
=0; i
< Data
->nCurves
; i
++) {
199 if (Data
->TheCurves
[i
] != NULL
)
200 cmsFreeToneCurve(Data
->TheCurves
[i
]);
203 _cmsFree(mpe
->ContextID
, Data
->TheCurves
);
204 _cmsFree(mpe
->ContextID
, Data
);
209 void* CurveSetDup(cmsStage
* mpe
)
211 _cmsStageToneCurvesData
* Data
= (_cmsStageToneCurvesData
*) mpe
->Data
;
212 _cmsStageToneCurvesData
* NewElem
;
215 NewElem
= (_cmsStageToneCurvesData
*) _cmsMallocZero(mpe
->ContextID
, sizeof(_cmsStageToneCurvesData
));
216 if (NewElem
== NULL
) return NULL
;
218 NewElem
->nCurves
= Data
->nCurves
;
219 NewElem
->TheCurves
= (cmsToneCurve
**) _cmsCalloc(mpe
->ContextID
, NewElem
->nCurves
, sizeof(cmsToneCurve
*));
221 if (NewElem
->TheCurves
== NULL
) goto Error
;
223 for (i
=0; i
< NewElem
->nCurves
; i
++) {
225 // Duplicate each curve. It may fail.
226 NewElem
->TheCurves
[i
] = cmsDupToneCurve(Data
->TheCurves
[i
]);
227 if (NewElem
->TheCurves
[i
] == NULL
) goto Error
;
231 return (void*) NewElem
;
235 if (NewElem
->TheCurves
!= NULL
) {
236 for (i
=0; i
< NewElem
->nCurves
; i
++) {
237 if (NewElem
->TheCurves
[i
])
238 cmsFreeToneCurve(NewElem
->TheCurves
[i
]);
241 _cmsFree(mpe
->ContextID
, NewElem
->TheCurves
);
242 _cmsFree(mpe
->ContextID
, NewElem
);
247 // Curves == NULL forces identity curves
248 cmsStage
* CMSEXPORT
cmsStageAllocToneCurves(cmsContext ContextID
, cmsUInt32Number nChannels
, cmsToneCurve
* const Curves
[])
251 _cmsStageToneCurvesData
* NewElem
;
255 NewMPE
= _cmsStageAllocPlaceholder(ContextID
, cmsSigCurveSetElemType
, nChannels
, nChannels
,
256 EvaluateCurves
, CurveSetDup
, CurveSetElemTypeFree
, NULL
);
257 if (NewMPE
== NULL
) return NULL
;
259 NewElem
= (_cmsStageToneCurvesData
*) _cmsMallocZero(ContextID
, sizeof(_cmsStageToneCurvesData
));
260 if (NewElem
== NULL
) {
261 cmsStageFree(NewMPE
);
265 NewMPE
->Data
= (void*) NewElem
;
267 NewElem
->nCurves
= nChannels
;
268 NewElem
->TheCurves
= (cmsToneCurve
**) _cmsCalloc(ContextID
, nChannels
, sizeof(cmsToneCurve
*));
269 if (NewElem
->TheCurves
== NULL
) {
270 cmsStageFree(NewMPE
);
274 for (i
=0; i
< nChannels
; i
++) {
276 if (Curves
== NULL
) {
277 NewElem
->TheCurves
[i
] = cmsBuildGamma(ContextID
, 1.0);
280 NewElem
->TheCurves
[i
] = cmsDupToneCurve(Curves
[i
]);
283 if (NewElem
->TheCurves
[i
] == NULL
) {
284 cmsStageFree(NewMPE
);
294 // Create a bunch of identity curves
295 cmsStage
* CMSEXPORT
_cmsStageAllocIdentityCurves(cmsContext ContextID
, cmsUInt32Number nChannels
)
297 cmsStage
* mpe
= cmsStageAllocToneCurves(ContextID
, nChannels
, NULL
);
299 if (mpe
== NULL
) return NULL
;
300 mpe
->Implements
= cmsSigIdentityElemType
;
305 // *************************************************************************************************
306 // Type cmsSigMatrixElemType (Matrices)
307 // *************************************************************************************************
310 // Special care should be taken here because precision loss. A temporary cmsFloat64Number buffer is being used
312 void EvaluateMatrix(const cmsFloat32Number In
[],
313 cmsFloat32Number Out
[],
316 cmsUInt32Number i
, j
;
317 _cmsStageMatrixData
* Data
= (_cmsStageMatrixData
*) mpe
->Data
;
318 cmsFloat64Number Tmp
;
320 // Input is already in 0..1.0 notation
321 for (i
=0; i
< mpe
->OutputChannels
; i
++) {
324 for (j
=0; j
< mpe
->InputChannels
; j
++) {
325 Tmp
+= In
[j
] * Data
->Double
[i
*mpe
->InputChannels
+ j
];
328 if (Data
->Offset
!= NULL
)
329 Tmp
+= Data
->Offset
[i
];
331 Out
[i
] = (cmsFloat32Number
) Tmp
;
335 // Output in 0..1.0 domain
339 // Duplicate a yet-existing matrix element
341 void* MatrixElemDup(cmsStage
* mpe
)
343 _cmsStageMatrixData
* Data
= (_cmsStageMatrixData
*) mpe
->Data
;
344 _cmsStageMatrixData
* NewElem
;
347 NewElem
= (_cmsStageMatrixData
*) _cmsMallocZero(mpe
->ContextID
, sizeof(_cmsStageMatrixData
));
348 if (NewElem
== NULL
) return NULL
;
350 sz
= mpe
->InputChannels
* mpe
->OutputChannels
;
352 NewElem
->Double
= (cmsFloat64Number
*) _cmsDupMem(mpe
->ContextID
, Data
->Double
, sz
* sizeof(cmsFloat64Number
)) ;
355 NewElem
->Offset
= (cmsFloat64Number
*) _cmsDupMem(mpe
->ContextID
,
356 Data
->Offset
, mpe
-> OutputChannels
* sizeof(cmsFloat64Number
)) ;
358 return (void*) NewElem
;
363 void MatrixElemTypeFree(cmsStage
* mpe
)
365 _cmsStageMatrixData
* Data
= (_cmsStageMatrixData
*) mpe
->Data
;
369 _cmsFree(mpe
->ContextID
, Data
->Double
);
372 _cmsFree(mpe
->ContextID
, Data
->Offset
);
374 _cmsFree(mpe
->ContextID
, mpe
->Data
);
379 cmsStage
* CMSEXPORT
cmsStageAllocMatrix(cmsContext ContextID
, cmsUInt32Number Rows
, cmsUInt32Number Cols
,
380 const cmsFloat64Number
* Matrix
, const cmsFloat64Number
* Offset
)
382 cmsUInt32Number i
, n
;
383 _cmsStageMatrixData
* NewElem
;
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
;
394 NewMPE
= _cmsStageAllocPlaceholder(ContextID
, cmsSigMatrixElemType
, Cols
, Rows
,
395 EvaluateMatrix
, MatrixElemDup
, MatrixElemTypeFree
, NULL
);
396 if (NewMPE
== NULL
) return NULL
;
399 NewElem
= (_cmsStageMatrixData
*) _cmsMallocZero(ContextID
, sizeof(_cmsStageMatrixData
));
400 if (NewElem
== NULL
) goto Error
;
401 NewMPE
->Data
= (void*)NewElem
;
403 NewElem
->Double
= (cmsFloat64Number
*) _cmsCalloc(ContextID
, n
, sizeof(cmsFloat64Number
));
404 if (NewElem
->Double
== NULL
) goto Error
;
406 for (i
=0; i
< n
; i
++) {
407 NewElem
->Double
[i
] = Matrix
[i
];
410 if (Offset
!= NULL
) {
412 NewElem
->Offset
= (cmsFloat64Number
*) _cmsCalloc(ContextID
, Rows
, sizeof(cmsFloat64Number
));
413 if (NewElem
->Offset
== NULL
) goto Error
;
415 for (i
=0; i
< Rows
; i
++) {
416 NewElem
->Offset
[i
] = Offset
[i
];
423 cmsStageFree(NewMPE
);
428 // *************************************************************************************************
429 // Type cmsSigCLutElemType
430 // *************************************************************************************************
433 // Evaluate in true floating point
435 void EvaluateCLUTfloat(const cmsFloat32Number In
[], cmsFloat32Number Out
[], const cmsStage
*mpe
)
437 _cmsStageCLutData
* Data
= (_cmsStageCLutData
*) mpe
->Data
;
439 Data
-> Params
->Interpolation
.LerpFloat(In
, Out
, Data
->Params
);
443 // Convert to 16 bits, evaluate, and back to floating point
445 void EvaluateCLUTfloatIn16(const cmsFloat32Number In
[], cmsFloat32Number Out
[], const cmsStage
*mpe
)
447 _cmsStageCLutData
* Data
= (_cmsStageCLutData
*) mpe
->Data
;
448 cmsUInt16Number In16
[MAX_STAGE_CHANNELS
], Out16
[MAX_STAGE_CHANNELS
];
450 _cmsAssert(mpe
->InputChannels
<= MAX_STAGE_CHANNELS
);
451 _cmsAssert(mpe
->OutputChannels
<= MAX_STAGE_CHANNELS
);
453 FromFloatTo16(In
, In16
, mpe
->InputChannels
);
454 Data
-> Params
->Interpolation
.Lerp16(In16
, Out16
, Data
->Params
);
455 From16ToFloat(Out16
, Out
, mpe
->OutputChannels
);
459 // Given an hypercube of b dimensions, with Dims[] number of nodes by dimension, calculate the total amount of nodes
461 cmsUInt32Number
CubeSize(const cmsUInt32Number Dims
[], cmsUInt32Number b
)
463 cmsUInt32Number rv
, dim
;
465 _cmsAssert(Dims
!= NULL
);
467 for (rv
= 1; b
> 0; b
--) {
470 if (dim
<= 1) return 0; // Error
474 // Check for overflow
475 if (rv
> UINT_MAX
/ dim
) return 0;
482 void* CLUTElemDup(cmsStage
* mpe
)
484 _cmsStageCLutData
* Data
= (_cmsStageCLutData
*) mpe
->Data
;
485 _cmsStageCLutData
* NewElem
;
488 NewElem
= (_cmsStageCLutData
*) _cmsMallocZero(mpe
->ContextID
, sizeof(_cmsStageCLutData
));
489 if (NewElem
== NULL
) return NULL
;
491 NewElem
->nEntries
= Data
->nEntries
;
492 NewElem
->HasFloatValues
= Data
->HasFloatValues
;
496 if (Data
->HasFloatValues
) {
497 NewElem
->Tab
.TFloat
= (cmsFloat32Number
*) _cmsDupMem(mpe
->ContextID
, Data
->Tab
.TFloat
, Data
->nEntries
* sizeof (cmsFloat32Number
));
498 if (NewElem
->Tab
.TFloat
== NULL
)
501 NewElem
->Tab
.T
= (cmsUInt16Number
*) _cmsDupMem(mpe
->ContextID
, Data
->Tab
.T
, Data
->nEntries
* sizeof (cmsUInt16Number
));
502 if (NewElem
->Tab
.T
== NULL
)
507 NewElem
->Params
= _cmsComputeInterpParamsEx(mpe
->ContextID
,
508 Data
->Params
->nSamples
,
509 Data
->Params
->nInputs
,
510 Data
->Params
->nOutputs
,
512 Data
->Params
->dwFlags
);
513 if (NewElem
->Params
!= NULL
)
514 return (void*) NewElem
;
517 // This works for both types
518 _cmsFree(mpe
->ContextID
, NewElem
-> Tab
.T
);
519 _cmsFree(mpe
->ContextID
, NewElem
);
525 void CLutElemTypeFree(cmsStage
* mpe
)
528 _cmsStageCLutData
* Data
= (_cmsStageCLutData
*) mpe
->Data
;
531 if (Data
== NULL
) return;
533 // This works for both types
535 _cmsFree(mpe
->ContextID
, Data
-> Tab
.T
);
537 _cmsFreeInterpParams(Data
->Params
);
538 _cmsFree(mpe
->ContextID
, mpe
->Data
);
542 // Allocates a 16-bit multidimensional CLUT. This is evaluated at 16-bit precision. Table may have different
543 // granularity on each dimension.
544 cmsStage
* CMSEXPORT
cmsStageAllocCLut16bitGranular(cmsContext ContextID
,
545 const cmsUInt32Number clutPoints
[],
546 cmsUInt32Number inputChan
,
547 cmsUInt32Number outputChan
,
548 const cmsUInt16Number
* Table
)
550 cmsUInt32Number i
, n
;
551 _cmsStageCLutData
* NewElem
;
554 _cmsAssert(clutPoints
!= NULL
);
556 if (inputChan
> MAX_INPUT_DIMENSIONS
) {
557 cmsSignalError(ContextID
, cmsERROR_RANGE
, "Too many input channels (%d channels, max=%d)", inputChan
, MAX_INPUT_DIMENSIONS
);
561 NewMPE
= _cmsStageAllocPlaceholder(ContextID
, cmsSigCLutElemType
, inputChan
, outputChan
,
562 EvaluateCLUTfloatIn16
, CLUTElemDup
, CLutElemTypeFree
, NULL
);
564 if (NewMPE
== NULL
) return NULL
;
566 NewElem
= (_cmsStageCLutData
*) _cmsMallocZero(ContextID
, sizeof(_cmsStageCLutData
));
567 if (NewElem
== NULL
) {
568 cmsStageFree(NewMPE
);
572 NewMPE
->Data
= (void*) NewElem
;
574 NewElem
-> nEntries
= n
= outputChan
* CubeSize(clutPoints
, inputChan
);
575 NewElem
-> HasFloatValues
= FALSE
;
578 cmsStageFree(NewMPE
);
583 NewElem
->Tab
.T
= (cmsUInt16Number
*) _cmsCalloc(ContextID
, n
, sizeof(cmsUInt16Number
));
584 if (NewElem
->Tab
.T
== NULL
) {
585 cmsStageFree(NewMPE
);
590 for (i
=0; i
< n
; i
++) {
591 NewElem
->Tab
.T
[i
] = Table
[i
];
595 NewElem
->Params
= _cmsComputeInterpParamsEx(ContextID
, clutPoints
, inputChan
, outputChan
, NewElem
->Tab
.T
, CMS_LERP_FLAGS_16BITS
);
596 if (NewElem
->Params
== NULL
) {
597 cmsStageFree(NewMPE
);
604 cmsStage
* CMSEXPORT
cmsStageAllocCLut16bit(cmsContext ContextID
,
605 cmsUInt32Number nGridPoints
,
606 cmsUInt32Number inputChan
,
607 cmsUInt32Number outputChan
,
608 const cmsUInt16Number
* Table
)
610 cmsUInt32Number Dimensions
[MAX_INPUT_DIMENSIONS
];
613 // Our resulting LUT would be same gridpoints on all dimensions
614 for (i
=0; i
< MAX_INPUT_DIMENSIONS
; i
++)
615 Dimensions
[i
] = nGridPoints
;
617 return cmsStageAllocCLut16bitGranular(ContextID
, Dimensions
, inputChan
, outputChan
, Table
);
621 cmsStage
* CMSEXPORT
cmsStageAllocCLutFloat(cmsContext ContextID
,
622 cmsUInt32Number nGridPoints
,
623 cmsUInt32Number inputChan
,
624 cmsUInt32Number outputChan
,
625 const cmsFloat32Number
* Table
)
627 cmsUInt32Number Dimensions
[MAX_INPUT_DIMENSIONS
];
630 // Our resulting LUT would be same gridpoints on all dimensions
631 for (i
=0; i
< MAX_INPUT_DIMENSIONS
; i
++)
632 Dimensions
[i
] = nGridPoints
;
634 return cmsStageAllocCLutFloatGranular(ContextID
, Dimensions
, inputChan
, outputChan
, Table
);
639 cmsStage
* CMSEXPORT
cmsStageAllocCLutFloatGranular(cmsContext ContextID
, const cmsUInt32Number clutPoints
[], cmsUInt32Number inputChan
, cmsUInt32Number outputChan
, const cmsFloat32Number
* Table
)
641 cmsUInt32Number i
, n
;
642 _cmsStageCLutData
* NewElem
;
645 _cmsAssert(clutPoints
!= NULL
);
647 if (inputChan
> MAX_INPUT_DIMENSIONS
) {
648 cmsSignalError(ContextID
, cmsERROR_RANGE
, "Too many input channels (%d channels, max=%d)", inputChan
, MAX_INPUT_DIMENSIONS
);
652 NewMPE
= _cmsStageAllocPlaceholder(ContextID
, cmsSigCLutElemType
, inputChan
, outputChan
,
653 EvaluateCLUTfloat
, CLUTElemDup
, CLutElemTypeFree
, NULL
);
654 if (NewMPE
== NULL
) return NULL
;
657 NewElem
= (_cmsStageCLutData
*) _cmsMallocZero(ContextID
, sizeof(_cmsStageCLutData
));
658 if (NewElem
== NULL
) {
659 cmsStageFree(NewMPE
);
663 NewMPE
->Data
= (void*) NewElem
;
665 // There is a potential integer overflow on conputing n and nEntries.
666 NewElem
-> nEntries
= n
= outputChan
* CubeSize(clutPoints
, inputChan
);
667 NewElem
-> HasFloatValues
= TRUE
;
670 cmsStageFree(NewMPE
);
674 NewElem
->Tab
.TFloat
= (cmsFloat32Number
*) _cmsCalloc(ContextID
, n
, sizeof(cmsFloat32Number
));
675 if (NewElem
->Tab
.TFloat
== NULL
) {
676 cmsStageFree(NewMPE
);
681 for (i
=0; i
< n
; i
++) {
682 NewElem
->Tab
.TFloat
[i
] = Table
[i
];
686 NewElem
->Params
= _cmsComputeInterpParamsEx(ContextID
, clutPoints
, inputChan
, outputChan
, NewElem
->Tab
.TFloat
, CMS_LERP_FLAGS_FLOAT
);
687 if (NewElem
->Params
== NULL
) {
688 cmsStageFree(NewMPE
);
697 int IdentitySampler(CMSREGISTER
const cmsUInt16Number In
[], CMSREGISTER cmsUInt16Number Out
[], CMSREGISTER
void * Cargo
)
699 int nChan
= *(int*) Cargo
;
702 for (i
=0; i
< nChan
; i
++)
708 // Creates an MPE that just copies input to output
709 cmsStage
* CMSEXPORT
_cmsStageAllocIdentityCLut(cmsContext ContextID
, cmsUInt32Number nChan
)
711 cmsUInt32Number Dimensions
[MAX_INPUT_DIMENSIONS
];
715 for (i
=0; i
< MAX_INPUT_DIMENSIONS
; i
++)
718 mpe
= cmsStageAllocCLut16bitGranular(ContextID
, Dimensions
, nChan
, nChan
, NULL
);
719 if (mpe
== NULL
) return NULL
;
721 if (!cmsStageSampleCLut16bit(mpe
, IdentitySampler
, &nChan
, 0)) {
726 mpe
->Implements
= cmsSigIdentityElemType
;
732 // Quantize a value 0 <= i < MaxSamples to 0..0xffff
733 cmsUInt16Number CMSEXPORT
_cmsQuantizeVal(cmsFloat64Number i
, cmsUInt32Number MaxSamples
)
737 x
= ((cmsFloat64Number
) i
* 65535.) / (cmsFloat64Number
) (MaxSamples
- 1);
738 return _cmsQuickSaturateWord(x
);
742 // This routine does a sweep on whole input space, and calls its callback
743 // function on knots. returns TRUE if all ok, FALSE otherwise.
744 cmsBool CMSEXPORT
cmsStageSampleCLut16bit(cmsStage
* mpe
, cmsSAMPLER16 Sampler
, void * Cargo
, cmsUInt32Number dwFlags
)
746 int i
, t
, index
, rest
;
747 cmsUInt32Number nTotalPoints
;
748 cmsUInt32Number nInputs
, nOutputs
;
749 cmsUInt32Number
* nSamples
;
750 cmsUInt16Number In
[MAX_INPUT_DIMENSIONS
+1], Out
[MAX_STAGE_CHANNELS
];
751 _cmsStageCLutData
* clut
;
753 if (mpe
== NULL
) return FALSE
;
755 clut
= (_cmsStageCLutData
*) mpe
->Data
;
757 if (clut
== NULL
) return FALSE
;
759 nSamples
= clut
->Params
->nSamples
;
760 nInputs
= clut
->Params
->nInputs
;
761 nOutputs
= clut
->Params
->nOutputs
;
763 if (nInputs
<= 0) return FALSE
;
764 if (nOutputs
<= 0) return FALSE
;
765 if (nInputs
> MAX_INPUT_DIMENSIONS
) return FALSE
;
766 if (nOutputs
>= MAX_STAGE_CHANNELS
) return FALSE
;
768 memset(In
, 0, sizeof(In
));
769 memset(Out
, 0, sizeof(Out
));
771 nTotalPoints
= CubeSize(nSamples
, nInputs
);
772 if (nTotalPoints
== 0) return FALSE
;
775 for (i
= 0; i
< (int) nTotalPoints
; i
++) {
778 for (t
= (int)nInputs
- 1; t
>= 0; --t
) {
780 cmsUInt32Number Colorant
= rest
% nSamples
[t
];
784 In
[t
] = _cmsQuantizeVal(Colorant
, nSamples
[t
]);
787 if (clut
->Tab
.T
!= NULL
) {
788 for (t
= 0; t
< (int)nOutputs
; t
++)
789 Out
[t
] = clut
->Tab
.T
[index
+ t
];
792 if (!Sampler(In
, Out
, Cargo
))
795 if (!(dwFlags
& SAMPLER_INSPECT
)) {
797 if (clut
->Tab
.T
!= NULL
) {
798 for (t
=0; t
< (int) nOutputs
; t
++)
799 clut
->Tab
.T
[index
+ t
] = Out
[t
];
809 // Same as anterior, but for floating point
810 cmsBool CMSEXPORT
cmsStageSampleCLutFloat(cmsStage
* mpe
, cmsSAMPLERFLOAT Sampler
, void * Cargo
, cmsUInt32Number dwFlags
)
812 int i
, t
, index
, rest
;
813 cmsUInt32Number nTotalPoints
;
814 cmsUInt32Number nInputs
, nOutputs
;
815 cmsUInt32Number
* nSamples
;
816 cmsFloat32Number In
[MAX_INPUT_DIMENSIONS
+1], Out
[MAX_STAGE_CHANNELS
];
817 _cmsStageCLutData
* clut
= (_cmsStageCLutData
*) mpe
->Data
;
819 nSamples
= clut
->Params
->nSamples
;
820 nInputs
= clut
->Params
->nInputs
;
821 nOutputs
= clut
->Params
->nOutputs
;
823 if (nInputs
<= 0) return FALSE
;
824 if (nOutputs
<= 0) return FALSE
;
825 if (nInputs
> MAX_INPUT_DIMENSIONS
) return FALSE
;
826 if (nOutputs
>= MAX_STAGE_CHANNELS
) return FALSE
;
828 nTotalPoints
= CubeSize(nSamples
, nInputs
);
829 if (nTotalPoints
== 0) return FALSE
;
832 for (i
= 0; i
< (int)nTotalPoints
; i
++) {
835 for (t
= (int) nInputs
-1; t
>=0; --t
) {
837 cmsUInt32Number Colorant
= rest
% nSamples
[t
];
841 In
[t
] = (cmsFloat32Number
) (_cmsQuantizeVal(Colorant
, nSamples
[t
]) / 65535.0);
844 if (clut
->Tab
.TFloat
!= NULL
) {
845 for (t
=0; t
< (int) nOutputs
; t
++)
846 Out
[t
] = clut
->Tab
.TFloat
[index
+ t
];
849 if (!Sampler(In
, Out
, Cargo
))
852 if (!(dwFlags
& SAMPLER_INSPECT
)) {
854 if (clut
->Tab
.TFloat
!= NULL
) {
855 for (t
=0; t
< (int) nOutputs
; t
++)
856 clut
->Tab
.TFloat
[index
+ t
] = Out
[t
];
868 // This routine does a sweep on whole input space, and calls its callback
869 // function on knots. returns TRUE if all ok, FALSE otherwise.
870 cmsBool CMSEXPORT
cmsSliceSpace16(cmsUInt32Number nInputs
, const cmsUInt32Number clutPoints
[],
871 cmsSAMPLER16 Sampler
, void * Cargo
)
874 cmsUInt32Number nTotalPoints
;
875 cmsUInt16Number In
[cmsMAXCHANNELS
];
877 if (nInputs
>= cmsMAXCHANNELS
) return FALSE
;
879 nTotalPoints
= CubeSize(clutPoints
, nInputs
);
880 if (nTotalPoints
== 0) return FALSE
;
882 for (i
= 0; i
< (int) nTotalPoints
; i
++) {
885 for (t
= (int) nInputs
-1; t
>=0; --t
) {
887 cmsUInt32Number Colorant
= rest
% clutPoints
[t
];
889 rest
/= clutPoints
[t
];
890 In
[t
] = _cmsQuantizeVal(Colorant
, clutPoints
[t
]);
894 if (!Sampler(In
, NULL
, Cargo
))
901 cmsInt32Number CMSEXPORT
cmsSliceSpaceFloat(cmsUInt32Number nInputs
, const cmsUInt32Number clutPoints
[],
902 cmsSAMPLERFLOAT Sampler
, void * Cargo
)
905 cmsUInt32Number nTotalPoints
;
906 cmsFloat32Number In
[cmsMAXCHANNELS
];
908 if (nInputs
>= cmsMAXCHANNELS
) return FALSE
;
910 nTotalPoints
= CubeSize(clutPoints
, nInputs
);
911 if (nTotalPoints
== 0) return FALSE
;
913 for (i
= 0; i
< (int) nTotalPoints
; i
++) {
916 for (t
= (int) nInputs
-1; t
>=0; --t
) {
918 cmsUInt32Number Colorant
= rest
% clutPoints
[t
];
920 rest
/= clutPoints
[t
];
921 In
[t
] = (cmsFloat32Number
) (_cmsQuantizeVal(Colorant
, clutPoints
[t
]) / 65535.0);
925 if (!Sampler(In
, NULL
, Cargo
))
932 // ********************************************************************************
933 // Type cmsSigLab2XYZElemType
934 // ********************************************************************************
938 void EvaluateLab2XYZ(const cmsFloat32Number In
[],
939 cmsFloat32Number Out
[],
944 const cmsFloat64Number XYZadj
= MAX_ENCODEABLE_XYZ
;
947 Lab
.L
= In
[0] * 100.0;
948 Lab
.a
= In
[1] * 255.0 - 128.0;
949 Lab
.b
= In
[2] * 255.0 - 128.0;
951 cmsLab2XYZ(NULL
, &XYZ
, &Lab
);
953 // From XYZ, range 0..19997 to 0..1.0, note that 1.99997 comes from 0xffff
954 // encoded as 1.15 fixed point, so 1 + (32767.0 / 32768.0)
956 Out
[0] = (cmsFloat32Number
) ((cmsFloat64Number
) XYZ
.X
/ XYZadj
);
957 Out
[1] = (cmsFloat32Number
) ((cmsFloat64Number
) XYZ
.Y
/ XYZadj
);
958 Out
[2] = (cmsFloat32Number
) ((cmsFloat64Number
) XYZ
.Z
/ XYZadj
);
961 cmsUNUSED_PARAMETER(mpe
);
965 // No dup or free routines needed, as the structure has no pointers in it.
966 cmsStage
* CMSEXPORT
_cmsStageAllocLab2XYZ(cmsContext ContextID
)
968 return _cmsStageAllocPlaceholder(ContextID
, cmsSigLab2XYZElemType
, 3, 3, EvaluateLab2XYZ
, NULL
, NULL
, NULL
);
971 // ********************************************************************************
973 // v2 L=100 is supposed to be placed on 0xFF00. There is no reasonable
974 // number of gridpoints that would make exact match. However, a prelinearization
975 // of 258 entries, would map 0xFF00 exactly on entry 257, and this is good to avoid scum dot.
976 // Almost all what we need but unfortunately, the rest of entries should be scaled by
977 // (255*257/256) and this is not exact.
979 cmsStage
* _cmsStageAllocLabV2ToV4curves(cmsContext ContextID
)
982 cmsToneCurve
* LabTable
[3];
985 LabTable
[0] = cmsBuildTabulatedToneCurve16(ContextID
, 258, NULL
);
986 LabTable
[1] = cmsBuildTabulatedToneCurve16(ContextID
, 258, NULL
);
987 LabTable
[2] = cmsBuildTabulatedToneCurve16(ContextID
, 258, NULL
);
989 for (j
=0; j
< 3; j
++) {
991 if (LabTable
[j
] == NULL
) {
992 cmsFreeToneCurveTriple(LabTable
);
996 // We need to map * (0xffff / 0xff00), that's same as (257 / 256)
997 // So we can use 258-entry tables to do the trick (i / 257) * (255 * 257) * (257 / 256);
998 for (i
=0; i
< 257; i
++) {
1000 LabTable
[j
]->Table16
[i
] = (cmsUInt16Number
) ((i
* 0xffff + 0x80) >> 8);
1003 LabTable
[j
] ->Table16
[257] = 0xffff;
1006 mpe
= cmsStageAllocToneCurves(ContextID
, 3, LabTable
);
1007 cmsFreeToneCurveTriple(LabTable
);
1009 if (mpe
== NULL
) return NULL
;
1010 mpe
->Implements
= cmsSigLabV2toV4
;
1014 // ********************************************************************************
1016 // Matrix-based conversion, which is more accurate, but slower and cannot properly be saved in devicelink profiles
1017 cmsStage
* CMSEXPORT
_cmsStageAllocLabV2ToV4(cmsContext ContextID
)
1019 static const cmsFloat64Number V2ToV4
[] = { 65535.0/65280.0, 0, 0,
1020 0, 65535.0/65280.0, 0,
1021 0, 0, 65535.0/65280.0
1024 cmsStage
*mpe
= cmsStageAllocMatrix(ContextID
, 3, 3, V2ToV4
, NULL
);
1026 if (mpe
== NULL
) return mpe
;
1027 mpe
->Implements
= cmsSigLabV2toV4
;
1032 // Reverse direction
1033 cmsStage
* CMSEXPORT
_cmsStageAllocLabV4ToV2(cmsContext ContextID
)
1035 static const cmsFloat64Number V4ToV2
[] = { 65280.0/65535.0, 0, 0,
1036 0, 65280.0/65535.0, 0,
1037 0, 0, 65280.0/65535.0
1040 cmsStage
*mpe
= cmsStageAllocMatrix(ContextID
, 3, 3, V4ToV2
, NULL
);
1042 if (mpe
== NULL
) return mpe
;
1043 mpe
->Implements
= cmsSigLabV4toV2
;
1048 // To Lab to float. Note that the MPE gives numbers in normal Lab range
1049 // and we need 0..1.0 range for the formatters
1050 // L* : 0...100 => 0...1.0 (L* / 100)
1051 // ab* : -128..+127 to 0..1 ((ab* + 128) / 255)
1053 cmsStage
* _cmsStageNormalizeFromLabFloat(cmsContext ContextID
)
1055 static const cmsFloat64Number a1
[] = {
1061 static const cmsFloat64Number o1
[] = {
1067 cmsStage
*mpe
= cmsStageAllocMatrix(ContextID
, 3, 3, a1
, o1
);
1069 if (mpe
== NULL
) return mpe
;
1070 mpe
->Implements
= cmsSigLab2FloatPCS
;
1074 // Fom XYZ to floating point PCS
1075 cmsStage
* _cmsStageNormalizeFromXyzFloat(cmsContext ContextID
)
1077 #define n (32768.0/65535.0)
1078 static const cmsFloat64Number a1
[] = {
1085 cmsStage
*mpe
= cmsStageAllocMatrix(ContextID
, 3, 3, a1
, NULL
);
1087 if (mpe
== NULL
) return mpe
;
1088 mpe
->Implements
= cmsSigXYZ2FloatPCS
;
1092 cmsStage
* _cmsStageNormalizeToLabFloat(cmsContext ContextID
)
1094 static const cmsFloat64Number a1
[] = {
1100 static const cmsFloat64Number o1
[] = {
1106 cmsStage
*mpe
= cmsStageAllocMatrix(ContextID
, 3, 3, a1
, o1
);
1107 if (mpe
== NULL
) return mpe
;
1108 mpe
->Implements
= cmsSigFloatPCS2Lab
;
1112 cmsStage
* _cmsStageNormalizeToXyzFloat(cmsContext ContextID
)
1114 #define n (65535.0/32768.0)
1116 static const cmsFloat64Number a1
[] = {
1123 cmsStage
*mpe
= cmsStageAllocMatrix(ContextID
, 3, 3, a1
, NULL
);
1124 if (mpe
== NULL
) return mpe
;
1125 mpe
->Implements
= cmsSigFloatPCS2XYZ
;
1129 // Clips values smaller than zero
1131 void Clipper(const cmsFloat32Number In
[], cmsFloat32Number Out
[], const cmsStage
*mpe
)
1134 for (i
= 0; i
< mpe
->InputChannels
; i
++) {
1136 cmsFloat32Number n
= In
[i
];
1137 Out
[i
] = n
< 0 ? 0 : n
;
1141 cmsStage
* _cmsStageClipNegatives(cmsContext ContextID
, cmsUInt32Number nChannels
)
1143 return _cmsStageAllocPlaceholder(ContextID
, cmsSigClipNegativesElemType
,
1144 nChannels
, nChannels
, Clipper
, NULL
, NULL
, NULL
);
1147 // ********************************************************************************
1148 // Type cmsSigXYZ2LabElemType
1149 // ********************************************************************************
1152 void EvaluateXYZ2Lab(const cmsFloat32Number In
[], cmsFloat32Number Out
[], const cmsStage
*mpe
)
1156 const cmsFloat64Number XYZadj
= MAX_ENCODEABLE_XYZ
;
1158 // From 0..1.0 to XYZ
1160 XYZ
.X
= In
[0] * XYZadj
;
1161 XYZ
.Y
= In
[1] * XYZadj
;
1162 XYZ
.Z
= In
[2] * XYZadj
;
1164 cmsXYZ2Lab(NULL
, &Lab
, &XYZ
);
1166 // From V4 Lab to 0..1.0
1168 Out
[0] = (cmsFloat32Number
) (Lab
.L
/ 100.0);
1169 Out
[1] = (cmsFloat32Number
) ((Lab
.a
+ 128.0) / 255.0);
1170 Out
[2] = (cmsFloat32Number
) ((Lab
.b
+ 128.0) / 255.0);
1173 cmsUNUSED_PARAMETER(mpe
);
1176 cmsStage
* CMSEXPORT
_cmsStageAllocXYZ2Lab(cmsContext ContextID
)
1178 return _cmsStageAllocPlaceholder(ContextID
, cmsSigXYZ2LabElemType
, 3, 3, EvaluateXYZ2Lab
, NULL
, NULL
, NULL
);
1182 // ********************************************************************************
1184 // For v4, S-Shaped curves are placed in a/b axis to increase resolution near gray
1186 cmsStage
* _cmsStageAllocLabPrelin(cmsContext ContextID
)
1188 cmsToneCurve
* LabTable
[3];
1189 cmsFloat64Number Params
[1] = {2.4} ;
1191 LabTable
[0] = cmsBuildGamma(ContextID
, 1.0);
1192 LabTable
[1] = cmsBuildParametricToneCurve(ContextID
, 108, Params
);
1193 LabTable
[2] = cmsBuildParametricToneCurve(ContextID
, 108, Params
);
1195 return cmsStageAllocToneCurves(ContextID
, 3, LabTable
);
1199 // Free a single MPE
1200 void CMSEXPORT
cmsStageFree(cmsStage
* mpe
)
1205 _cmsFree(mpe
->ContextID
, mpe
);
1209 cmsUInt32Number CMSEXPORT
cmsStageInputChannels(const cmsStage
* mpe
)
1211 return mpe
->InputChannels
;
1214 cmsUInt32Number CMSEXPORT
cmsStageOutputChannels(const cmsStage
* mpe
)
1216 return mpe
->OutputChannels
;
1219 cmsStageSignature CMSEXPORT
cmsStageType(const cmsStage
* mpe
)
1224 void* CMSEXPORT
cmsStageData(const cmsStage
* mpe
)
1229 cmsContext CMSEXPORT
cmsGetStageContextID(const cmsStage
* mpe
)
1231 return mpe
-> ContextID
;
1234 cmsStage
* CMSEXPORT
cmsStageNext(const cmsStage
* mpe
)
1240 // Duplicates an MPE
1241 cmsStage
* CMSEXPORT
cmsStageDup(cmsStage
* mpe
)
1245 if (mpe
== NULL
) return NULL
;
1246 NewMPE
= _cmsStageAllocPlaceholder(mpe
->ContextID
,
1248 mpe
->InputChannels
,
1249 mpe
->OutputChannels
,
1254 if (NewMPE
== NULL
) return NULL
;
1256 NewMPE
->Implements
= mpe
->Implements
;
1258 if (mpe
->DupElemPtr
) {
1260 NewMPE
->Data
= mpe
->DupElemPtr(mpe
);
1262 if (NewMPE
->Data
== NULL
) {
1264 cmsStageFree(NewMPE
);
1270 NewMPE
->Data
= NULL
;
1277 // ***********************************************************************************************************
1279 // This function sets up the channel count
1281 cmsBool
BlessLUT(cmsPipeline
* lut
)
1283 // We can set the input/output channels only if we have elements.
1284 if (lut
->Elements
!= NULL
) {
1291 First
= cmsPipelineGetPtrToFirstStage(lut
);
1292 Last
= cmsPipelineGetPtrToLastStage(lut
);
1294 if (First
== NULL
|| Last
== NULL
) return FALSE
;
1296 lut
->InputChannels
= First
->InputChannels
;
1297 lut
->OutputChannels
= Last
->OutputChannels
;
1299 // Check chain consistency
1303 while (next
!= NULL
)
1305 if (next
->InputChannels
!= prev
->OutputChannels
)
1317 // Default to evaluate the LUT on 16 bit-basis. Precision is retained.
1319 void _LUTeval16(CMSREGISTER
const cmsUInt16Number In
[], CMSREGISTER cmsUInt16Number Out
[], CMSREGISTER
const void* D
)
1321 cmsPipeline
* lut
= (cmsPipeline
*) D
;
1323 cmsFloat32Number Storage
[2][MAX_STAGE_CHANNELS
];
1324 int Phase
= 0, NextPhase
;
1326 From16ToFloat(In
, &Storage
[Phase
][0], lut
->InputChannels
);
1328 for (mpe
= lut
->Elements
;
1332 NextPhase
= Phase
^ 1;
1333 mpe
->EvalPtr(&Storage
[Phase
][0], &Storage
[NextPhase
][0], mpe
);
1338 FromFloatTo16(&Storage
[Phase
][0], Out
, lut
->OutputChannels
);
1343 // Does evaluate the LUT on cmsFloat32Number-basis.
1345 void _LUTevalFloat(const cmsFloat32Number In
[], cmsFloat32Number Out
[], const void* D
)
1347 cmsPipeline
* lut
= (cmsPipeline
*) D
;
1349 cmsFloat32Number Storage
[2][MAX_STAGE_CHANNELS
];
1350 int Phase
= 0, NextPhase
;
1352 memmove(&Storage
[Phase
][0], In
, lut
->InputChannels
* sizeof(cmsFloat32Number
));
1354 for (mpe
= lut
->Elements
;
1358 NextPhase
= Phase
^ 1;
1359 mpe
->EvalPtr(&Storage
[Phase
][0], &Storage
[NextPhase
][0], mpe
);
1363 memmove(Out
, &Storage
[Phase
][0], lut
->OutputChannels
* sizeof(cmsFloat32Number
));
1367 // LUT Creation & Destruction
1368 cmsPipeline
* CMSEXPORT
cmsPipelineAlloc(cmsContext ContextID
, cmsUInt32Number InputChannels
, cmsUInt32Number OutputChannels
)
1370 cmsPipeline
* NewLUT
;
1372 // A value of zero in channels is allowed as placeholder
1373 if (InputChannels
>= cmsMAXCHANNELS
||
1374 OutputChannels
>= cmsMAXCHANNELS
) return NULL
;
1376 NewLUT
= (cmsPipeline
*) _cmsMallocZero(ContextID
, sizeof(cmsPipeline
));
1377 if (NewLUT
== NULL
) return NULL
;
1379 NewLUT
-> InputChannels
= InputChannels
;
1380 NewLUT
-> OutputChannels
= OutputChannels
;
1382 NewLUT
->Eval16Fn
= _LUTeval16
;
1383 NewLUT
->EvalFloatFn
= _LUTevalFloat
;
1384 NewLUT
->DupDataFn
= NULL
;
1385 NewLUT
->FreeDataFn
= NULL
;
1386 NewLUT
->Data
= NewLUT
;
1387 NewLUT
->ContextID
= ContextID
;
1389 if (!BlessLUT(NewLUT
))
1391 _cmsFree(ContextID
, NewLUT
);
1398 cmsContext CMSEXPORT
cmsGetPipelineContextID(const cmsPipeline
* lut
)
1400 _cmsAssert(lut
!= NULL
);
1401 return lut
->ContextID
;
1404 cmsUInt32Number CMSEXPORT
cmsPipelineInputChannels(const cmsPipeline
* lut
)
1406 _cmsAssert(lut
!= NULL
);
1407 return lut
->InputChannels
;
1410 cmsUInt32Number CMSEXPORT
cmsPipelineOutputChannels(const cmsPipeline
* lut
)
1412 _cmsAssert(lut
!= NULL
);
1413 return lut
->OutputChannels
;
1416 // Free a profile elements LUT
1417 void CMSEXPORT
cmsPipelineFree(cmsPipeline
* lut
)
1419 cmsStage
*mpe
, *Next
;
1421 if (lut
== NULL
) return;
1423 for (mpe
= lut
->Elements
;
1431 if (lut
->FreeDataFn
) lut
->FreeDataFn(lut
->ContextID
, lut
->Data
);
1433 _cmsFree(lut
->ContextID
, lut
);
1437 // Default to evaluate the LUT on 16 bit-basis.
1438 void CMSEXPORT
cmsPipelineEval16(const cmsUInt16Number In
[], cmsUInt16Number Out
[], const cmsPipeline
* lut
)
1440 _cmsAssert(lut
!= NULL
);
1441 lut
->Eval16Fn(In
, Out
, lut
->Data
);
1445 // Does evaluate the LUT on cmsFloat32Number-basis.
1446 void CMSEXPORT
cmsPipelineEvalFloat(const cmsFloat32Number In
[], cmsFloat32Number Out
[], const cmsPipeline
* lut
)
1448 _cmsAssert(lut
!= NULL
);
1449 lut
->EvalFloatFn(In
, Out
, lut
);
1455 cmsPipeline
* CMSEXPORT
cmsPipelineDup(const cmsPipeline
* lut
)
1457 cmsPipeline
* NewLUT
;
1458 cmsStage
*NewMPE
, *Anterior
= NULL
, *mpe
;
1459 cmsBool First
= TRUE
;
1461 if (lut
== NULL
) return NULL
;
1463 NewLUT
= cmsPipelineAlloc(lut
->ContextID
, lut
->InputChannels
, lut
->OutputChannels
);
1464 if (NewLUT
== NULL
) return NULL
;
1466 for (mpe
= lut
->Elements
;
1470 NewMPE
= cmsStageDup(mpe
);
1472 if (NewMPE
== NULL
) {
1473 cmsPipelineFree(NewLUT
);
1478 NewLUT
->Elements
= NewMPE
;
1482 if (Anterior
!= NULL
)
1483 Anterior
->Next
= NewMPE
;
1489 NewLUT
->Eval16Fn
= lut
->Eval16Fn
;
1490 NewLUT
->EvalFloatFn
= lut
->EvalFloatFn
;
1491 NewLUT
->DupDataFn
= lut
->DupDataFn
;
1492 NewLUT
->FreeDataFn
= lut
->FreeDataFn
;
1494 if (NewLUT
->DupDataFn
!= NULL
)
1495 NewLUT
->Data
= NewLUT
->DupDataFn(lut
->ContextID
, lut
->Data
);
1498 NewLUT
->SaveAs8Bits
= lut
->SaveAs8Bits
;
1500 if (!BlessLUT(NewLUT
))
1502 _cmsFree(lut
->ContextID
, NewLUT
);
1510 int CMSEXPORT
cmsPipelineInsertStage(cmsPipeline
* lut
, cmsStageLoc loc
, cmsStage
* mpe
)
1512 cmsStage
* Anterior
= NULL
, *pt
;
1514 if (lut
== NULL
|| mpe
== NULL
)
1520 mpe
->Next
= lut
->Elements
;
1521 lut
->Elements
= mpe
;
1526 if (lut
->Elements
== NULL
)
1527 lut
->Elements
= mpe
;
1530 for (pt
= lut
->Elements
;
1532 pt
= pt
-> Next
) Anterior
= pt
;
1534 Anterior
->Next
= mpe
;
1542 return BlessLUT(lut
);
1545 // Unlink an element and return the pointer to it
1546 void CMSEXPORT
cmsPipelineUnlinkStage(cmsPipeline
* lut
, cmsStageLoc loc
, cmsStage
** mpe
)
1548 cmsStage
*Anterior
, *pt
, *Last
;
1549 cmsStage
*Unlinked
= NULL
;
1552 // If empty LUT, there is nothing to remove
1553 if (lut
->Elements
== NULL
) {
1554 if (mpe
) *mpe
= NULL
;
1558 // On depending on the strategy...
1563 cmsStage
* elem
= lut
->Elements
;
1565 lut
->Elements
= elem
-> Next
;
1573 Anterior
= Last
= NULL
;
1574 for (pt
= lut
->Elements
;
1581 Unlinked
= Last
; // Next already points to NULL
1583 // Truncate the chain
1585 Anterior
->Next
= NULL
;
1587 lut
->Elements
= NULL
;
1595 cmsStageFree(Unlinked
);
1597 // May fail, but we ignore it
1602 // Concatenate two LUT into a new single one
1603 cmsBool CMSEXPORT
cmsPipelineCat(cmsPipeline
* l1
, const cmsPipeline
* l2
)
1607 // If both LUTS does not have elements, we need to inherit
1608 // the number of channels
1609 if (l1
->Elements
== NULL
&& l2
->Elements
== NULL
) {
1610 l1
->InputChannels
= l2
->InputChannels
;
1611 l1
->OutputChannels
= l2
->OutputChannels
;
1615 for (mpe
= l2
->Elements
;
1619 // We have to dup each element
1620 if (!cmsPipelineInsertStage(l1
, cmsAT_END
, cmsStageDup(mpe
)))
1624 return BlessLUT(l1
);
1628 cmsBool CMSEXPORT
cmsPipelineSetSaveAs8bitsFlag(cmsPipeline
* lut
, cmsBool On
)
1630 cmsBool Anterior
= lut
->SaveAs8Bits
;
1632 lut
->SaveAs8Bits
= On
;
1637 cmsStage
* CMSEXPORT
cmsPipelineGetPtrToFirstStage(const cmsPipeline
* lut
)
1639 return lut
->Elements
;
1642 cmsStage
* CMSEXPORT
cmsPipelineGetPtrToLastStage(const cmsPipeline
* lut
)
1644 cmsStage
*mpe
, *Anterior
= NULL
;
1646 for (mpe
= lut
->Elements
; mpe
!= NULL
; mpe
= mpe
->Next
)
1652 cmsUInt32Number CMSEXPORT
cmsPipelineStageCount(const cmsPipeline
* lut
)
1657 for (n
=0, mpe
= lut
->Elements
; mpe
!= NULL
; mpe
= mpe
->Next
)
1663 // This function may be used to set the optional evaluator and a block of private data. If private data is being used, an optional
1664 // duplicator and free functions should also be specified in order to duplicate the LUT construct. Use NULL to inhibit such functionality.
1665 void CMSEXPORT
_cmsPipelineSetOptimizationParameters(cmsPipeline
* Lut
,
1666 _cmsPipelineEval16Fn Eval16
,
1668 _cmsFreeUserDataFn FreePrivateDataFn
,
1669 _cmsDupUserDataFn DupPrivateDataFn
)
1672 Lut
->Eval16Fn
= Eval16
;
1673 Lut
->DupDataFn
= DupPrivateDataFn
;
1674 Lut
->FreeDataFn
= FreePrivateDataFn
;
1675 Lut
->Data
= PrivateData
;
1679 // ----------------------------------------------------------- Reverse interpolation
1680 // Here's how it goes. The derivative Df(x) of the function f is the linear
1681 // transformation that best approximates f near the point x. It can be represented
1682 // by a matrix A whose entries are the partial derivatives of the components of f
1683 // with respect to all the coordinates. This is know as the Jacobian
1685 // The best linear approximation to f is given by the matrix equation:
1689 // So, if x0 is a good "guess" for the zero of f, then solving for the zero of this
1690 // linear approximation will give a "better guess" for the zero of f. Thus let y=0,
1691 // and since y0=f(x0) one can solve the above equation for x. This leads to the
1692 // Newton's method formula:
1694 // xn+1 = xn - A-1 f(xn)
1696 // where xn+1 denotes the (n+1)-st guess, obtained from the n-th guess xn in the
1697 // fashion described above. Iterating this will give better and better approximations
1698 // if you have a "good enough" initial guess.
1701 #define JACOBIAN_EPSILON 0.001f
1702 #define INVERSION_MAX_ITERATIONS 30
1704 // Increment with reflexion on boundary
1706 void IncDelta(cmsFloat32Number
*Val
)
1708 if (*Val
< (1.0 - JACOBIAN_EPSILON
))
1710 *Val
+= JACOBIAN_EPSILON
;
1713 *Val
-= JACOBIAN_EPSILON
;
1719 // Euclidean distance between two vectors of n elements each one
1721 cmsFloat32Number
EuclideanDistance(cmsFloat32Number a
[], cmsFloat32Number b
[], int n
)
1723 cmsFloat32Number sum
= 0;
1726 for (i
=0; i
< n
; i
++) {
1727 cmsFloat32Number dif
= b
[i
] - a
[i
];
1735 // Evaluate a LUT in reverse direction. It only searches on 3->3 LUT. Uses Newton method
1737 // x1 <- x - [J(x)]^-1 * f(x)
1739 // lut: The LUT on where to do the search
1740 // Target: LabK, 3 values of Lab plus destination K which is fixed
1741 // Result: The obtained CMYK
1742 // Hint: Location where begin the search
1744 cmsBool CMSEXPORT
cmsPipelineEvalReverseFloat(cmsFloat32Number Target
[],
1745 cmsFloat32Number Result
[],
1746 cmsFloat32Number Hint
[],
1747 const cmsPipeline
* lut
)
1749 cmsUInt32Number i
, j
;
1750 cmsFloat64Number error
, LastError
= 1E20
;
1751 cmsFloat32Number fx
[4], x
[4], xd
[4], fxd
[4];
1755 // Only 3->3 and 4->3 are supported
1756 if (lut
->InputChannels
!= 3 && lut
->InputChannels
!= 4) return FALSE
;
1757 if (lut
->OutputChannels
!= 3) return FALSE
;
1759 // Take the hint as starting point if specified
1762 // Begin at any point, we choose 1/3 of CMY axis
1763 x
[0] = x
[1] = x
[2] = 0.3f
;
1767 // Only copy 3 channels from hint...
1768 for (j
=0; j
< 3; j
++)
1772 // If Lut is 4-dimensions, then grab target[3], which is fixed
1773 if (lut
->InputChannels
== 4) {
1776 else x
[3] = 0; // To keep lint happy
1780 for (i
= 0; i
< INVERSION_MAX_ITERATIONS
; i
++) {
1783 cmsPipelineEvalFloat(x
, fx
, lut
);
1786 error
= EuclideanDistance(fx
, Target
, 3);
1788 // If not convergent, return last safe value
1789 if (error
>= LastError
)
1792 // Keep latest values
1794 for (j
=0; j
< lut
->InputChannels
; j
++)
1797 // Found an exact match?
1801 // Obtain slope (the Jacobian)
1802 for (j
= 0; j
< 3; j
++) {
1807 xd
[3] = x
[3]; // Keep fixed channel
1811 cmsPipelineEvalFloat(xd
, fxd
, lut
);
1813 Jacobian
.v
[0].n
[j
] = ((fxd
[0] - fx
[0]) / JACOBIAN_EPSILON
);
1814 Jacobian
.v
[1].n
[j
] = ((fxd
[1] - fx
[1]) / JACOBIAN_EPSILON
);
1815 Jacobian
.v
[2].n
[j
] = ((fxd
[2] - fx
[2]) / JACOBIAN_EPSILON
);
1819 tmp2
.n
[0] = fx
[0] - Target
[0];
1820 tmp2
.n
[1] = fx
[1] - Target
[1];
1821 tmp2
.n
[2] = fx
[2] - Target
[2];
1823 if (!_cmsMAT3solve(&tmp
, &Jacobian
, &tmp2
))
1827 x
[0] -= (cmsFloat32Number
) tmp
.n
[0];
1828 x
[1] -= (cmsFloat32Number
) tmp
.n
[1];
1829 x
[2] -= (cmsFloat32Number
) tmp
.n
[2];
1831 // Some clipping....
1832 for (j
=0; j
< 3; j
++) {
1833 if (x
[j
] < 0) x
[j
] = 0;
1835 if (x
[j
] > 1.0) x
[j
] = 1.0;