1 //---------------------------------------------------------------------------------
3 // Little Color Management System
4 // Copyright (c) 1998-2012 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"
29 // This module incorporates several interpolation routines, for 1 to 8 channels on input and
30 // up to 65535 channels on output. The user may change those by using the interpolation plug-in
32 // Interpolation routines by default
33 static cmsInterpFunction DefaultInterpolatorsFactory(cmsUInt32Number nInputChannels, cmsUInt32Number nOutputChannels, cmsUInt32Number dwFlags);
35 // This is the default factory
36 _cmsInterpPluginChunkType _cmsInterpPluginChunk = { NULL };
38 // The interpolation plug-in memory chunk allocator/dup
39 void _cmsAllocInterpPluginChunk(struct _cmsContext_struct* ctx, const struct _cmsContext_struct* src)
43 _cmsAssert(ctx != NULL);
46 from = src ->chunks[InterpPlugin];
49 static _cmsInterpPluginChunkType InterpPluginChunk = { NULL };
51 from = &InterpPluginChunk;
54 _cmsAssert(from != NULL);
55 ctx ->chunks[InterpPlugin] = _cmsSubAllocDup(ctx ->MemPool, from, sizeof(_cmsInterpPluginChunkType));
60 cmsBool _cmsRegisterInterpPlugin(cmsContext ContextID, cmsPluginBase* Data)
62 cmsPluginInterpolation* Plugin = (cmsPluginInterpolation*) Data;
63 _cmsInterpPluginChunkType* ptr = (_cmsInterpPluginChunkType*) _cmsContextGetClientChunk(ContextID, InterpPlugin);
67 ptr ->Interpolators = NULL;
71 // Set replacement functions
72 ptr ->Interpolators = Plugin ->InterpolatorsFactory;
77 // Set the interpolation method
78 cmsBool _cmsSetInterpolationRoutine(cmsContext ContextID, cmsInterpParams* p)
80 _cmsInterpPluginChunkType* ptr = (_cmsInterpPluginChunkType*) _cmsContextGetClientChunk(ContextID, InterpPlugin);
82 p ->Interpolation.Lerp16 = NULL;
84 // Invoke factory, possibly in the Plug-in
85 if (ptr ->Interpolators != NULL)
86 p ->Interpolation = ptr->Interpolators(p -> nInputs, p ->nOutputs, p ->dwFlags);
88 // If unsupported by the plug-in, go for the LittleCMS default.
89 // If happens only if an extern plug-in is being used
90 if (p ->Interpolation.Lerp16 == NULL)
91 p ->Interpolation = DefaultInterpolatorsFactory(p ->nInputs, p ->nOutputs, p ->dwFlags);
93 // Check for valid interpolator (we just check one member of the union)
94 if (p ->Interpolation.Lerp16 == NULL) {
102 // This function precalculates as many parameters as possible to speed up the interpolation.
103 cmsInterpParams* _cmsComputeInterpParamsEx(cmsContext ContextID,
104 const cmsUInt32Number nSamples[],
105 int InputChan, int OutputChan,
107 cmsUInt32Number dwFlags)
112 // Check for maximum inputs
113 if (InputChan > MAX_INPUT_DIMENSIONS) {
114 cmsSignalError(ContextID, cmsERROR_RANGE, "Too many input channels (%d channels, max=%d)", InputChan, MAX_INPUT_DIMENSIONS);
118 // Creates an empty object
119 p = (cmsInterpParams*) _cmsMallocZero(ContextID, sizeof(cmsInterpParams));
120 if (p == NULL) return NULL;
122 // Keep original parameters
123 p -> dwFlags = dwFlags;
124 p -> nInputs = InputChan;
125 p -> nOutputs = OutputChan;
127 p ->ContextID = ContextID;
129 // Fill samples per input direction and domain (which is number of nodes minus one)
130 for (i=0; i < InputChan; i++) {
132 p -> nSamples[i] = nSamples[i];
133 p -> Domain[i] = nSamples[i] - 1;
136 // Compute factors to apply to each component to index the grid array
137 p -> opta[0] = p -> nOutputs;
138 for (i=1; i < InputChan; i++)
139 p ->opta[i] = p ->opta[i-1] * nSamples[InputChan-i];
142 if (!_cmsSetInterpolationRoutine(ContextID, p)) {
143 cmsSignalError(ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported interpolation (%d->%d channels)", InputChan, OutputChan);
144 _cmsFree(ContextID, p);
153 // This one is a wrapper on the anterior, but assuming all directions have same number of nodes
154 cmsInterpParams* _cmsComputeInterpParams(cmsContext ContextID, int nSamples, int InputChan, int OutputChan, const void* Table, cmsUInt32Number dwFlags)
157 cmsUInt32Number Samples[MAX_INPUT_DIMENSIONS];
159 // Fill the auxiliar array
160 for (i=0; i < MAX_INPUT_DIMENSIONS; i++)
161 Samples[i] = nSamples;
163 // Call the extended function
164 return _cmsComputeInterpParamsEx(ContextID, Samples, InputChan, OutputChan, Table, dwFlags);
168 // Free all associated memory
169 void _cmsFreeInterpParams(cmsInterpParams* p)
171 if (p != NULL) _cmsFree(p ->ContextID, p);
175 // Inline fixed point interpolation
176 cmsINLINE cmsUInt16Number LinearInterp(cmsS15Fixed16Number a, cmsS15Fixed16Number l, cmsS15Fixed16Number h)
178 cmsUInt32Number dif = (cmsUInt32Number) (h - l) * a + 0x8000;
179 dif = (dif >> 16) + l;
180 return (cmsUInt16Number) (dif);
184 // Linear interpolation (Fixed-point optimized)
186 void LinLerp1D(register const cmsUInt16Number Value[],
187 register cmsUInt16Number Output[],
188 register const cmsInterpParams* p)
190 cmsUInt16Number y1, y0;
193 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p ->Table;
196 if (Value[0] == 0xffff) {
198 Output[0] = LutTable[p -> Domain[0]];
202 val3 = p -> Domain[0] * Value[0];
203 val3 = _cmsToFixedDomain(val3); // To fixed 15.16
205 cell0 = FIXED_TO_INT(val3); // Cell is 16 MSB bits
206 rest = FIXED_REST_TO_INT(val3); // Rest is 16 LSB bits
208 y0 = LutTable[cell0];
209 y1 = LutTable[cell0+1];
212 Output[0] = LinearInterp(rest, y0, y1);
215 // To prevent out of bounds indexing
216 cmsINLINE cmsFloat32Number fclamp(cmsFloat32Number v)
218 return v < 0.0f ? 0.0f : (v > 1.0f ? 1.0f : v);
221 // Floating-point version of 1D interpolation
223 void LinLerp1Dfloat(const cmsFloat32Number Value[],
224 cmsFloat32Number Output[],
225 const cmsInterpParams* p)
227 cmsFloat32Number y1, y0;
228 cmsFloat32Number val2, rest;
230 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p ->Table;
232 val2 = fclamp(Value[0]);
236 Output[0] = LutTable[p -> Domain[0]];
240 val2 *= p -> Domain[0];
242 cell0 = (int) floor(val2);
243 cell1 = (int) ceil(val2);
245 // Rest is 16 LSB bits
248 y0 = LutTable[cell0] ;
249 y1 = LutTable[cell1] ;
251 Output[0] = y0 + (y1 - y0) * rest;
256 // Eval gray LUT having only one input channel
258 void Eval1Input(register const cmsUInt16Number Input[],
259 register cmsUInt16Number Output[],
260 register const cmsInterpParams* p16)
262 cmsS15Fixed16Number fk;
263 cmsS15Fixed16Number k0, k1, rk, K0, K1;
265 cmsUInt32Number OutChan;
266 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
268 v = Input[0] * p16 -> Domain[0];
269 fk = _cmsToFixedDomain(v);
271 k0 = FIXED_TO_INT(fk);
272 rk = (cmsUInt16Number) FIXED_REST_TO_INT(fk);
274 k1 = k0 + (Input[0] != 0xFFFFU ? 1 : 0);
276 K0 = p16 -> opta[0] * k0;
277 K1 = p16 -> opta[0] * k1;
279 for (OutChan=0; OutChan < p16->nOutputs; OutChan++) {
281 Output[OutChan] = LinearInterp(rk, LutTable[K0+OutChan], LutTable[K1+OutChan]);
287 // Eval gray LUT having only one input channel
289 void Eval1InputFloat(const cmsFloat32Number Value[],
290 cmsFloat32Number Output[],
291 const cmsInterpParams* p)
293 cmsFloat32Number y1, y0;
294 cmsFloat32Number val2, rest;
296 cmsUInt32Number OutChan;
297 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p ->Table;
299 val2 = fclamp(Value[0]);
303 Output[0] = LutTable[p -> Domain[0]];
307 val2 *= p -> Domain[0];
309 cell0 = (int) floor(val2);
310 cell1 = (int) ceil(val2);
312 // Rest is 16 LSB bits
315 cell0 *= p -> opta[0];
316 cell1 *= p -> opta[0];
318 for (OutChan=0; OutChan < p->nOutputs; OutChan++) {
320 y0 = LutTable[cell0 + OutChan] ;
321 y1 = LutTable[cell1 + OutChan] ;
323 Output[OutChan] = y0 + (y1 - y0) * rest;
327 // Bilinear interpolation (16 bits) - cmsFloat32Number version
329 void BilinearInterpFloat(const cmsFloat32Number Input[],
330 cmsFloat32Number Output[],
331 const cmsInterpParams* p)
334 # define LERP(a,l,h) (cmsFloat32Number) ((l)+(((h)-(l))*(a)))
335 # define DENS(i,j) (LutTable[(i)+(j)+OutChan])
337 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p ->Table;
338 cmsFloat32Number px, py;
341 int TotalOut, OutChan;
342 cmsFloat32Number fx, fy,
347 TotalOut = p -> nOutputs;
348 px = fclamp(Input[0]) * p->Domain[0];
349 py = fclamp(Input[1]) * p->Domain[1];
351 x0 = (int) _cmsQuickFloor(px); fx = px - (cmsFloat32Number) x0;
352 y0 = (int) _cmsQuickFloor(py); fy = py - (cmsFloat32Number) y0;
354 X0 = p -> opta[1] * x0;
355 X1 = X0 + (Input[0] >= 1.0 ? 0 : p->opta[1]);
357 Y0 = p -> opta[0] * y0;
358 Y1 = Y0 + (Input[1] >= 1.0 ? 0 : p->opta[0]);
360 for (OutChan = 0; OutChan < TotalOut; OutChan++) {
367 dx0 = LERP(fx, d00, d10);
368 dx1 = LERP(fx, d01, d11);
370 dxy = LERP(fy, dx0, dx1);
372 Output[OutChan] = dxy;
380 // Bilinear interpolation (16 bits) - optimized version
382 void BilinearInterp16(register const cmsUInt16Number Input[],
383 register cmsUInt16Number Output[],
384 register const cmsInterpParams* p)
387 #define DENS(i,j) (LutTable[(i)+(j)+OutChan])
388 #define LERP(a,l,h) (cmsUInt16Number) (l + ROUND_FIXED_TO_INT(((h-l)*a)))
390 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p ->Table;
391 int OutChan, TotalOut;
392 cmsS15Fixed16Number fx, fy;
395 register int X0, X1, Y0, Y1;
396 int d00, d01, d10, d11,
400 TotalOut = p -> nOutputs;
402 fx = _cmsToFixedDomain((int) Input[0] * p -> Domain[0]);
403 x0 = FIXED_TO_INT(fx);
404 rx = FIXED_REST_TO_INT(fx); // Rest in 0..1.0 domain
407 fy = _cmsToFixedDomain((int) Input[1] * p -> Domain[1]);
408 y0 = FIXED_TO_INT(fy);
409 ry = FIXED_REST_TO_INT(fy);
412 X0 = p -> opta[1] * x0;
413 X1 = X0 + (Input[0] == 0xFFFFU ? 0 : p->opta[1]);
415 Y0 = p -> opta[0] * y0;
416 Y1 = Y0 + (Input[1] == 0xFFFFU ? 0 : p->opta[0]);
418 for (OutChan = 0; OutChan < TotalOut; OutChan++) {
425 dx0 = LERP(rx, d00, d10);
426 dx1 = LERP(rx, d01, d11);
428 dxy = LERP(ry, dx0, dx1);
430 Output[OutChan] = (cmsUInt16Number) dxy;
439 // Trilinear interpolation (16 bits) - cmsFloat32Number version
441 void TrilinearInterpFloat(const cmsFloat32Number Input[],
442 cmsFloat32Number Output[],
443 const cmsInterpParams* p)
446 # define LERP(a,l,h) (cmsFloat32Number) ((l)+(((h)-(l))*(a)))
447 # define DENS(i,j,k) (LutTable[(i)+(j)+(k)+OutChan])
449 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p ->Table;
450 cmsFloat32Number px, py, pz;
452 X0, Y0, Z0, X1, Y1, Z1;
453 int TotalOut, OutChan;
454 cmsFloat32Number fx, fy, fz,
455 d000, d001, d010, d011,
456 d100, d101, d110, d111,
457 dx00, dx01, dx10, dx11,
460 TotalOut = p -> nOutputs;
462 // We need some clipping here
463 px = fclamp(Input[0]) * p->Domain[0];
464 py = fclamp(Input[1]) * p->Domain[1];
465 pz = fclamp(Input[2]) * p->Domain[2];
467 x0 = (int) _cmsQuickFloor(px); fx = px - (cmsFloat32Number) x0;
468 y0 = (int) _cmsQuickFloor(py); fy = py - (cmsFloat32Number) y0;
469 z0 = (int) _cmsQuickFloor(pz); fz = pz - (cmsFloat32Number) z0;
471 X0 = p -> opta[2] * x0;
472 X1 = X0 + (Input[0] >= 1.0 ? 0 : p->opta[2]);
474 Y0 = p -> opta[1] * y0;
475 Y1 = Y0 + (Input[1] >= 1.0 ? 0 : p->opta[1]);
477 Z0 = p -> opta[0] * z0;
478 Z1 = Z0 + (Input[2] >= 1.0 ? 0 : p->opta[0]);
480 for (OutChan = 0; OutChan < TotalOut; OutChan++) {
482 d000 = DENS(X0, Y0, Z0);
483 d001 = DENS(X0, Y0, Z1);
484 d010 = DENS(X0, Y1, Z0);
485 d011 = DENS(X0, Y1, Z1);
487 d100 = DENS(X1, Y0, Z0);
488 d101 = DENS(X1, Y0, Z1);
489 d110 = DENS(X1, Y1, Z0);
490 d111 = DENS(X1, Y1, Z1);
493 dx00 = LERP(fx, d000, d100);
494 dx01 = LERP(fx, d001, d101);
495 dx10 = LERP(fx, d010, d110);
496 dx11 = LERP(fx, d011, d111);
498 dxy0 = LERP(fy, dx00, dx10);
499 dxy1 = LERP(fy, dx01, dx11);
501 dxyz = LERP(fz, dxy0, dxy1);
503 Output[OutChan] = dxyz;
511 // Trilinear interpolation (16 bits) - optimized version
513 void TrilinearInterp16(register const cmsUInt16Number Input[],
514 register cmsUInt16Number Output[],
515 register const cmsInterpParams* p)
518 #define DENS(i,j,k) (LutTable[(i)+(j)+(k)+OutChan])
519 #define LERP(a,l,h) (cmsUInt16Number) (l + ROUND_FIXED_TO_INT(((h-l)*a)))
521 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p ->Table;
522 int OutChan, TotalOut;
523 cmsS15Fixed16Number fx, fy, fz;
524 register int rx, ry, rz;
526 register int X0, X1, Y0, Y1, Z0, Z1;
527 int d000, d001, d010, d011,
528 d100, d101, d110, d111,
529 dx00, dx01, dx10, dx11,
532 TotalOut = p -> nOutputs;
534 fx = _cmsToFixedDomain((int) Input[0] * p -> Domain[0]);
535 x0 = FIXED_TO_INT(fx);
536 rx = FIXED_REST_TO_INT(fx); // Rest in 0..1.0 domain
539 fy = _cmsToFixedDomain((int) Input[1] * p -> Domain[1]);
540 y0 = FIXED_TO_INT(fy);
541 ry = FIXED_REST_TO_INT(fy);
543 fz = _cmsToFixedDomain((int) Input[2] * p -> Domain[2]);
544 z0 = FIXED_TO_INT(fz);
545 rz = FIXED_REST_TO_INT(fz);
548 X0 = p -> opta[2] * x0;
549 X1 = X0 + (Input[0] == 0xFFFFU ? 0 : p->opta[2]);
551 Y0 = p -> opta[1] * y0;
552 Y1 = Y0 + (Input[1] == 0xFFFFU ? 0 : p->opta[1]);
554 Z0 = p -> opta[0] * z0;
555 Z1 = Z0 + (Input[2] == 0xFFFFU ? 0 : p->opta[0]);
557 for (OutChan = 0; OutChan < TotalOut; OutChan++) {
559 d000 = DENS(X0, Y0, Z0);
560 d001 = DENS(X0, Y0, Z1);
561 d010 = DENS(X0, Y1, Z0);
562 d011 = DENS(X0, Y1, Z1);
564 d100 = DENS(X1, Y0, Z0);
565 d101 = DENS(X1, Y0, Z1);
566 d110 = DENS(X1, Y1, Z0);
567 d111 = DENS(X1, Y1, Z1);
570 dx00 = LERP(rx, d000, d100);
571 dx01 = LERP(rx, d001, d101);
572 dx10 = LERP(rx, d010, d110);
573 dx11 = LERP(rx, d011, d111);
575 dxy0 = LERP(ry, dx00, dx10);
576 dxy1 = LERP(ry, dx01, dx11);
578 dxyz = LERP(rz, dxy0, dxy1);
580 Output[OutChan] = (cmsUInt16Number) dxyz;
589 // Tetrahedral interpolation, using Sakamoto algorithm.
590 #define DENS(i,j,k) (LutTable[(i)+(j)+(k)+OutChan])
592 void TetrahedralInterpFloat(const cmsFloat32Number Input[],
593 cmsFloat32Number Output[],
594 const cmsInterpParams* p)
596 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
597 cmsFloat32Number px, py, pz;
599 X0, Y0, Z0, X1, Y1, Z1;
600 cmsFloat32Number rx, ry, rz;
601 cmsFloat32Number c0, c1=0, c2=0, c3=0;
602 int OutChan, TotalOut;
604 TotalOut = p -> nOutputs;
606 // We need some clipping here
607 px = fclamp(Input[0]) * p->Domain[0];
608 py = fclamp(Input[1]) * p->Domain[1];
609 pz = fclamp(Input[2]) * p->Domain[2];
611 x0 = (int) _cmsQuickFloor(px); rx = (px - (cmsFloat32Number) x0);
612 y0 = (int) _cmsQuickFloor(py); ry = (py - (cmsFloat32Number) y0);
613 z0 = (int) _cmsQuickFloor(pz); rz = (pz - (cmsFloat32Number) z0);
616 X0 = p -> opta[2] * x0;
617 X1 = X0 + (Input[0] >= 1.0 ? 0 : p->opta[2]);
619 Y0 = p -> opta[1] * y0;
620 Y1 = Y0 + (Input[1] >= 1.0 ? 0 : p->opta[1]);
622 Z0 = p -> opta[0] * z0;
623 Z1 = Z0 + (Input[2] >= 1.0 ? 0 : p->opta[0]);
625 for (OutChan=0; OutChan < TotalOut; OutChan++) {
627 // These are the 6 Tetrahedral
629 c0 = DENS(X0, Y0, Z0);
631 if (rx >= ry && ry >= rz) {
633 c1 = DENS(X1, Y0, Z0) - c0;
634 c2 = DENS(X1, Y1, Z0) - DENS(X1, Y0, Z0);
635 c3 = DENS(X1, Y1, Z1) - DENS(X1, Y1, Z0);
639 if (rx >= rz && rz >= ry) {
641 c1 = DENS(X1, Y0, Z0) - c0;
642 c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
643 c3 = DENS(X1, Y0, Z1) - DENS(X1, Y0, Z0);
647 if (rz >= rx && rx >= ry) {
649 c1 = DENS(X1, Y0, Z1) - DENS(X0, Y0, Z1);
650 c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
651 c3 = DENS(X0, Y0, Z1) - c0;
655 if (ry >= rx && rx >= rz) {
657 c1 = DENS(X1, Y1, Z0) - DENS(X0, Y1, Z0);
658 c2 = DENS(X0, Y1, Z0) - c0;
659 c3 = DENS(X1, Y1, Z1) - DENS(X1, Y1, Z0);
663 if (ry >= rz && rz >= rx) {
665 c1 = DENS(X1, Y1, Z1) - DENS(X0, Y1, Z1);
666 c2 = DENS(X0, Y1, Z0) - c0;
667 c3 = DENS(X0, Y1, Z1) - DENS(X0, Y1, Z0);
671 if (rz >= ry && ry >= rx) {
673 c1 = DENS(X1, Y1, Z1) - DENS(X0, Y1, Z1);
674 c2 = DENS(X0, Y1, Z1) - DENS(X0, Y0, Z1);
675 c3 = DENS(X0, Y0, Z1) - c0;
682 Output[OutChan] = c0 + c1 * rx + c2 * ry + c3 * rz;
693 void TetrahedralInterp16(register const cmsUInt16Number Input[],
694 register cmsUInt16Number Output[],
695 register const cmsInterpParams* p)
697 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p -> Table;
698 cmsS15Fixed16Number fx, fy, fz;
699 cmsS15Fixed16Number rx, ry, rz;
701 cmsS15Fixed16Number c0, c1, c2, c3, Rest;
702 cmsS15Fixed16Number X0, X1, Y0, Y1, Z0, Z1;
703 cmsUInt32Number TotalOut = p -> nOutputs;
705 fx = _cmsToFixedDomain((int) Input[0] * p -> Domain[0]);
706 fy = _cmsToFixedDomain((int) Input[1] * p -> Domain[1]);
707 fz = _cmsToFixedDomain((int) Input[2] * p -> Domain[2]);
709 x0 = FIXED_TO_INT(fx);
710 y0 = FIXED_TO_INT(fy);
711 z0 = FIXED_TO_INT(fz);
713 rx = FIXED_REST_TO_INT(fx);
714 ry = FIXED_REST_TO_INT(fy);
715 rz = FIXED_REST_TO_INT(fz);
717 X0 = p -> opta[2] * x0;
718 X1 = (Input[0] == 0xFFFFU ? 0 : p->opta[2]);
720 Y0 = p -> opta[1] * y0;
721 Y1 = (Input[1] == 0xFFFFU ? 0 : p->opta[1]);
723 Z0 = p -> opta[0] * z0;
724 Z1 = (Input[2] == 0xFFFFU ? 0 : p->opta[0]);
726 LutTable = &LutTable[X0+Y0+Z0];
728 // Output should be computed as x = ROUND_FIXED_TO_INT(_cmsToFixedDomain(Rest))
729 // which expands as: x = (Rest + ((Rest+0x7fff)/0xFFFF) + 0x8000)>>16
730 // This can be replaced by: t = Rest+0x8001, x = (t + (t>>16))>>16
731 // at the cost of being off by one at 7fff and 17ffe.
737 for (; TotalOut; TotalOut--) {
745 Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
746 *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
748 } else if (rz >= rx) {
751 for (; TotalOut; TotalOut--) {
759 Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
760 *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
765 for (; TotalOut; TotalOut--) {
773 Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
774 *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
781 for (; TotalOut; TotalOut--) {
789 Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
790 *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
792 } else if (ry >= rz) {
795 for (; TotalOut; TotalOut--) {
803 Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
804 *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
809 for (; TotalOut; TotalOut--) {
817 Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
818 *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
825 #define DENS(i,j,k) (LutTable[(i)+(j)+(k)+OutChan])
827 void Eval4Inputs(register const cmsUInt16Number Input[],
828 register cmsUInt16Number Output[],
829 register const cmsInterpParams* p16)
831 const cmsUInt16Number* LutTable;
832 cmsS15Fixed16Number fk;
833 cmsS15Fixed16Number k0, rk;
835 cmsS15Fixed16Number fx, fy, fz;
836 cmsS15Fixed16Number rx, ry, rz;
838 cmsS15Fixed16Number X0, X1, Y0, Y1, Z0, Z1;
840 cmsS15Fixed16Number c0, c1, c2, c3, Rest;
841 cmsUInt32Number OutChan;
842 cmsUInt16Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
845 fk = _cmsToFixedDomain((int) Input[0] * p16 -> Domain[0]);
846 fx = _cmsToFixedDomain((int) Input[1] * p16 -> Domain[1]);
847 fy = _cmsToFixedDomain((int) Input[2] * p16 -> Domain[2]);
848 fz = _cmsToFixedDomain((int) Input[3] * p16 -> Domain[3]);
850 k0 = FIXED_TO_INT(fk);
851 x0 = FIXED_TO_INT(fx);
852 y0 = FIXED_TO_INT(fy);
853 z0 = FIXED_TO_INT(fz);
855 rk = FIXED_REST_TO_INT(fk);
856 rx = FIXED_REST_TO_INT(fx);
857 ry = FIXED_REST_TO_INT(fy);
858 rz = FIXED_REST_TO_INT(fz);
860 K0 = p16 -> opta[3] * k0;
861 K1 = K0 + (Input[0] == 0xFFFFU ? 0 : p16->opta[3]);
863 X0 = p16 -> opta[2] * x0;
864 X1 = X0 + (Input[1] == 0xFFFFU ? 0 : p16->opta[2]);
866 Y0 = p16 -> opta[1] * y0;
867 Y1 = Y0 + (Input[2] == 0xFFFFU ? 0 : p16->opta[1]);
869 Z0 = p16 -> opta[0] * z0;
870 Z1 = Z0 + (Input[3] == 0xFFFFU ? 0 : p16->opta[0]);
872 LutTable = (cmsUInt16Number*) p16 -> Table;
875 for (OutChan=0; OutChan < p16 -> nOutputs; OutChan++) {
877 c0 = DENS(X0, Y0, Z0);
879 if (rx >= ry && ry >= rz) {
881 c1 = DENS(X1, Y0, Z0) - c0;
882 c2 = DENS(X1, Y1, Z0) - DENS(X1, Y0, Z0);
883 c3 = DENS(X1, Y1, Z1) - DENS(X1, Y1, Z0);
887 if (rx >= rz && rz >= ry) {
889 c1 = DENS(X1, Y0, Z0) - c0;
890 c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
891 c3 = DENS(X1, Y0, Z1) - DENS(X1, Y0, Z0);
895 if (rz >= rx && rx >= ry) {
897 c1 = DENS(X1, Y0, Z1) - DENS(X0, Y0, Z1);
898 c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
899 c3 = DENS(X0, Y0, Z1) - c0;
903 if (ry >= rx && rx >= rz) {
905 c1 = DENS(X1, Y1, Z0) - DENS(X0, Y1, Z0);
906 c2 = DENS(X0, Y1, Z0) - c0;
907 c3 = DENS(X1, Y1, Z1) - DENS(X1, Y1, Z0);
911 if (ry >= rz && rz >= rx) {
913 c1 = DENS(X1, Y1, Z1) - DENS(X0, Y1, Z1);
914 c2 = DENS(X0, Y1, Z0) - c0;
915 c3 = DENS(X0, Y1, Z1) - DENS(X0, Y1, Z0);
919 if (rz >= ry && ry >= rx) {
921 c1 = DENS(X1, Y1, Z1) - DENS(X0, Y1, Z1);
922 c2 = DENS(X0, Y1, Z1) - DENS(X0, Y0, Z1);
923 c3 = DENS(X0, Y0, Z1) - c0;
930 Rest = c1 * rx + c2 * ry + c3 * rz;
932 Tmp1[OutChan] = (cmsUInt16Number) c0 + ROUND_FIXED_TO_INT(_cmsToFixedDomain(Rest));
936 LutTable = (cmsUInt16Number*) p16 -> Table;
939 for (OutChan=0; OutChan < p16 -> nOutputs; OutChan++) {
941 c0 = DENS(X0, Y0, Z0);
943 if (rx >= ry && ry >= rz) {
945 c1 = DENS(X1, Y0, Z0) - c0;
946 c2 = DENS(X1, Y1, Z0) - DENS(X1, Y0, Z0);
947 c3 = DENS(X1, Y1, Z1) - DENS(X1, Y1, Z0);
951 if (rx >= rz && rz >= ry) {
953 c1 = DENS(X1, Y0, Z0) - c0;
954 c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
955 c3 = DENS(X1, Y0, Z1) - DENS(X1, Y0, Z0);
959 if (rz >= rx && rx >= ry) {
961 c1 = DENS(X1, Y0, Z1) - DENS(X0, Y0, Z1);
962 c2 = DENS(X1, Y1, Z1) - DENS(X1, Y0, Z1);
963 c3 = DENS(X0, Y0, Z1) - c0;
967 if (ry >= rx && rx >= rz) {
969 c1 = DENS(X1, Y1, Z0) - DENS(X0, Y1, Z0);
970 c2 = DENS(X0, Y1, Z0) - c0;
971 c3 = DENS(X1, Y1, Z1) - DENS(X1, Y1, Z0);
975 if (ry >= rz && rz >= rx) {
977 c1 = DENS(X1, Y1, Z1) - DENS(X0, Y1, Z1);
978 c2 = DENS(X0, Y1, Z0) - c0;
979 c3 = DENS(X0, Y1, Z1) - DENS(X0, Y1, Z0);
983 if (rz >= ry && ry >= rx) {
985 c1 = DENS(X1, Y1, Z1) - DENS(X0, Y1, Z1);
986 c2 = DENS(X0, Y1, Z1) - DENS(X0, Y0, Z1);
987 c3 = DENS(X0, Y0, Z1) - c0;
994 Rest = c1 * rx + c2 * ry + c3 * rz;
996 Tmp2[OutChan] = (cmsUInt16Number) c0 + ROUND_FIXED_TO_INT(_cmsToFixedDomain(Rest));
1001 for (i=0; i < p16 -> nOutputs; i++) {
1002 Output[i] = LinearInterp(rk, Tmp1[i], Tmp2[i]);
1008 // For more that 3 inputs (i.e., CMYK)
1009 // evaluate two 3-dimensional interpolations and then linearly interpolate between them.
1013 void Eval4InputsFloat(const cmsFloat32Number Input[],
1014 cmsFloat32Number Output[],
1015 const cmsInterpParams* p)
1017 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
1018 cmsFloat32Number rest;
1019 cmsFloat32Number pk;
1021 const cmsFloat32Number* T;
1023 cmsFloat32Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1026 pk = fclamp(Input[0]) * p->Domain[0];
1027 k0 = _cmsQuickFloor(pk);
1028 rest = pk - (cmsFloat32Number) k0;
1030 K0 = p -> opta[3] * k0;
1031 K1 = K0 + (Input[0] >= 1.0 ? 0 : p->opta[3]);
1034 memmove(&p1.Domain[0], &p ->Domain[1], 3*sizeof(cmsUInt32Number));
1039 TetrahedralInterpFloat(Input + 1, Tmp1, &p1);
1043 TetrahedralInterpFloat(Input + 1, Tmp2, &p1);
1045 for (i=0; i < p -> nOutputs; i++)
1047 cmsFloat32Number y0 = Tmp1[i];
1048 cmsFloat32Number y1 = Tmp2[i];
1050 Output[i] = y0 + (y1 - y0) * rest;
1056 void Eval5Inputs(register const cmsUInt16Number Input[],
1057 register cmsUInt16Number Output[],
1059 register const cmsInterpParams* p16)
1061 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
1062 cmsS15Fixed16Number fk;
1063 cmsS15Fixed16Number k0, rk;
1065 const cmsUInt16Number* T;
1067 cmsUInt16Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1071 fk = _cmsToFixedDomain((cmsS15Fixed16Number) Input[0] * p16 -> Domain[0]);
1072 k0 = FIXED_TO_INT(fk);
1073 rk = FIXED_REST_TO_INT(fk);
1075 K0 = p16 -> opta[4] * k0;
1076 K1 = p16 -> opta[4] * (k0 + (Input[0] != 0xFFFFU ? 1 : 0));
1079 memmove(&p1.Domain[0], &p16 ->Domain[1], 4*sizeof(cmsUInt32Number));
1084 Eval4Inputs(Input + 1, Tmp1, &p1);
1089 Eval4Inputs(Input + 1, Tmp2, &p1);
1091 for (i=0; i < p16 -> nOutputs; i++) {
1093 Output[i] = LinearInterp(rk, Tmp1[i], Tmp2[i]);
1100 void Eval5InputsFloat(const cmsFloat32Number Input[],
1101 cmsFloat32Number Output[],
1102 const cmsInterpParams* p)
1104 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
1105 cmsFloat32Number rest;
1106 cmsFloat32Number pk;
1108 const cmsFloat32Number* T;
1110 cmsFloat32Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1113 pk = fclamp(Input[0]) * p->Domain[0];
1114 k0 = _cmsQuickFloor(pk);
1115 rest = pk - (cmsFloat32Number) k0;
1117 K0 = p -> opta[4] * k0;
1118 K1 = K0 + (Input[0] >= 1.0 ? 0 : p->opta[4]);
1121 memmove(&p1.Domain[0], &p ->Domain[1], 4*sizeof(cmsUInt32Number));
1126 Eval4InputsFloat(Input + 1, Tmp1, &p1);
1131 Eval4InputsFloat(Input + 1, Tmp2, &p1);
1133 for (i=0; i < p -> nOutputs; i++) {
1135 cmsFloat32Number y0 = Tmp1[i];
1136 cmsFloat32Number y1 = Tmp2[i];
1138 Output[i] = y0 + (y1 - y0) * rest;
1145 void Eval6Inputs(register const cmsUInt16Number Input[],
1146 register cmsUInt16Number Output[],
1147 register const cmsInterpParams* p16)
1149 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
1150 cmsS15Fixed16Number fk;
1151 cmsS15Fixed16Number k0, rk;
1153 const cmsUInt16Number* T;
1155 cmsUInt16Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1158 fk = _cmsToFixedDomain((cmsS15Fixed16Number) Input[0] * p16 -> Domain[0]);
1159 k0 = FIXED_TO_INT(fk);
1160 rk = FIXED_REST_TO_INT(fk);
1162 K0 = p16 -> opta[5] * k0;
1163 K1 = p16 -> opta[5] * (k0 + (Input[0] != 0xFFFFU ? 1 : 0));
1166 memmove(&p1.Domain[0], &p16 ->Domain[1], 5*sizeof(cmsUInt32Number));
1171 Eval5Inputs(Input + 1, Tmp1, &p1);
1176 Eval5Inputs(Input + 1, Tmp2, &p1);
1178 for (i=0; i < p16 -> nOutputs; i++) {
1180 Output[i] = LinearInterp(rk, Tmp1[i], Tmp2[i]);
1187 void Eval6InputsFloat(const cmsFloat32Number Input[],
1188 cmsFloat32Number Output[],
1189 const cmsInterpParams* p)
1191 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
1192 cmsFloat32Number rest;
1193 cmsFloat32Number pk;
1195 const cmsFloat32Number* T;
1197 cmsFloat32Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1200 pk = fclamp(Input[0]) * p->Domain[0];
1201 k0 = _cmsQuickFloor(pk);
1202 rest = pk - (cmsFloat32Number) k0;
1204 K0 = p -> opta[5] * k0;
1205 K1 = K0 + (Input[0] >= 1.0 ? 0 : p->opta[5]);
1208 memmove(&p1.Domain[0], &p ->Domain[1], 5*sizeof(cmsUInt32Number));
1213 Eval5InputsFloat(Input + 1, Tmp1, &p1);
1218 Eval5InputsFloat(Input + 1, Tmp2, &p1);
1220 for (i=0; i < p -> nOutputs; i++) {
1222 cmsFloat32Number y0 = Tmp1[i];
1223 cmsFloat32Number y1 = Tmp2[i];
1225 Output[i] = y0 + (y1 - y0) * rest;
1231 void Eval7Inputs(register const cmsUInt16Number Input[],
1232 register cmsUInt16Number Output[],
1233 register const cmsInterpParams* p16)
1235 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
1236 cmsS15Fixed16Number fk;
1237 cmsS15Fixed16Number k0, rk;
1239 const cmsUInt16Number* T;
1241 cmsUInt16Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1245 fk = _cmsToFixedDomain((cmsS15Fixed16Number) Input[0] * p16 -> Domain[0]);
1246 k0 = FIXED_TO_INT(fk);
1247 rk = FIXED_REST_TO_INT(fk);
1249 K0 = p16 -> opta[6] * k0;
1250 K1 = p16 -> opta[6] * (k0 + (Input[0] != 0xFFFFU ? 1 : 0));
1253 memmove(&p1.Domain[0], &p16 ->Domain[1], 6*sizeof(cmsUInt32Number));
1258 Eval6Inputs(Input + 1, Tmp1, &p1);
1263 Eval6Inputs(Input + 1, Tmp2, &p1);
1265 for (i=0; i < p16 -> nOutputs; i++) {
1266 Output[i] = LinearInterp(rk, Tmp1[i], Tmp2[i]);
1272 void Eval7InputsFloat(const cmsFloat32Number Input[],
1273 cmsFloat32Number Output[],
1274 const cmsInterpParams* p)
1276 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
1277 cmsFloat32Number rest;
1278 cmsFloat32Number pk;
1280 const cmsFloat32Number* T;
1282 cmsFloat32Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1285 pk = fclamp(Input[0]) * p->Domain[0];
1286 k0 = _cmsQuickFloor(pk);
1287 rest = pk - (cmsFloat32Number) k0;
1289 K0 = p -> opta[6] * k0;
1290 K1 = K0 + (Input[0] >= 1.0 ? 0 : p->opta[6]);
1293 memmove(&p1.Domain[0], &p ->Domain[1], 6*sizeof(cmsUInt32Number));
1298 Eval6InputsFloat(Input + 1, Tmp1, &p1);
1303 Eval6InputsFloat(Input + 1, Tmp2, &p1);
1306 for (i=0; i < p -> nOutputs; i++) {
1308 cmsFloat32Number y0 = Tmp1[i];
1309 cmsFloat32Number y1 = Tmp2[i];
1311 Output[i] = y0 + (y1 - y0) * rest;
1317 void Eval8Inputs(register const cmsUInt16Number Input[],
1318 register cmsUInt16Number Output[],
1319 register const cmsInterpParams* p16)
1321 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
1322 cmsS15Fixed16Number fk;
1323 cmsS15Fixed16Number k0, rk;
1325 const cmsUInt16Number* T;
1327 cmsUInt16Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1330 fk = _cmsToFixedDomain((cmsS15Fixed16Number) Input[0] * p16 -> Domain[0]);
1331 k0 = FIXED_TO_INT(fk);
1332 rk = FIXED_REST_TO_INT(fk);
1334 K0 = p16 -> opta[7] * k0;
1335 K1 = p16 -> opta[7] * (k0 + (Input[0] != 0xFFFFU ? 1 : 0));
1338 memmove(&p1.Domain[0], &p16 ->Domain[1], 7*sizeof(cmsUInt32Number));
1343 Eval7Inputs(Input + 1, Tmp1, &p1);
1347 Eval7Inputs(Input + 1, Tmp2, &p1);
1349 for (i=0; i < p16 -> nOutputs; i++) {
1350 Output[i] = LinearInterp(rk, Tmp1[i], Tmp2[i]);
1357 void Eval8InputsFloat(const cmsFloat32Number Input[],
1358 cmsFloat32Number Output[],
1359 const cmsInterpParams* p)
1361 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
1362 cmsFloat32Number rest;
1363 cmsFloat32Number pk;
1365 const cmsFloat32Number* T;
1367 cmsFloat32Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1370 pk = fclamp(Input[0]) * p->Domain[0];
1371 k0 = _cmsQuickFloor(pk);
1372 rest = pk - (cmsFloat32Number) k0;
1374 K0 = p -> opta[7] * k0;
1375 K1 = K0 + (Input[0] >= 1.0 ? 0 : p->opta[7]);
1378 memmove(&p1.Domain[0], &p ->Domain[1], 7*sizeof(cmsUInt32Number));
1383 Eval7InputsFloat(Input + 1, Tmp1, &p1);
1388 Eval7InputsFloat(Input + 1, Tmp2, &p1);
1391 for (i=0; i < p -> nOutputs; i++) {
1393 cmsFloat32Number y0 = Tmp1[i];
1394 cmsFloat32Number y1 = Tmp2[i];
1396 Output[i] = y0 + (y1 - y0) * rest;
1400 // The default factory
1402 cmsInterpFunction DefaultInterpolatorsFactory(cmsUInt32Number nInputChannels, cmsUInt32Number nOutputChannels, cmsUInt32Number dwFlags)
1405 cmsInterpFunction Interpolation;
1406 cmsBool IsFloat = (dwFlags & CMS_LERP_FLAGS_FLOAT);
1407 cmsBool IsTrilinear = (dwFlags & CMS_LERP_FLAGS_TRILINEAR);
1409 memset(&Interpolation, 0, sizeof(Interpolation));
1412 if (nInputChannels >= 4 && nOutputChannels >= MAX_STAGE_CHANNELS)
1413 return Interpolation;
1415 switch (nInputChannels) {
1417 case 1: // Gray LUT / linear
1419 if (nOutputChannels == 1) {
1422 Interpolation.LerpFloat = LinLerp1Dfloat;
1424 Interpolation.Lerp16 = LinLerp1D;
1430 Interpolation.LerpFloat = Eval1InputFloat;
1432 Interpolation.Lerp16 = Eval1Input;
1438 Interpolation.LerpFloat = BilinearInterpFloat;
1440 Interpolation.Lerp16 = BilinearInterp16;
1443 case 3: // RGB et al
1448 Interpolation.LerpFloat = TrilinearInterpFloat;
1450 Interpolation.Lerp16 = TrilinearInterp16;
1455 Interpolation.LerpFloat = TetrahedralInterpFloat;
1458 Interpolation.Lerp16 = TetrahedralInterp16;
1466 Interpolation.LerpFloat = Eval4InputsFloat;
1468 Interpolation.Lerp16 = Eval4Inputs;
1473 Interpolation.LerpFloat = Eval5InputsFloat;
1475 Interpolation.Lerp16 = Eval5Inputs;
1480 Interpolation.LerpFloat = Eval6InputsFloat;
1482 Interpolation.Lerp16 = Eval6Inputs;
1487 Interpolation.LerpFloat = Eval7InputsFloat;
1489 Interpolation.Lerp16 = Eval7Inputs;
1494 Interpolation.LerpFloat = Eval8InputsFloat;
1496 Interpolation.Lerp16 = Eval8Inputs;
1502 Interpolation.Lerp16 = NULL;
1505 return Interpolation;