1 //---------------------------------------------------------------------------------
2 //
3 // Little Color Management System
4 // Copyright (c) 1998-2016 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 // 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
31
32 // Interpolation routines by default
33 static cmsInterpFunction DefaultInterpolatorsFactory(cmsUInt32Number nInputChannels, cmsUInt32Number nOutputChannels, cmsUInt32Number dwFlags);
34
35 // This is the default factory
36 _cmsInterpPluginChunkType _cmsInterpPluginChunk = { NULL };
37
38 // The interpolation plug-in memory chunk allocator/dup
_cmsAllocInterpPluginChunk(struct _cmsContext_struct * ctx,const struct _cmsContext_struct * src)39 void _cmsAllocInterpPluginChunk(struct _cmsContext_struct* ctx, const struct _cmsContext_struct* src)
40 {
41 void* from;
42
43 _cmsAssert(ctx != NULL);
44
45 if (src != NULL) {
46 from = src ->chunks[InterpPlugin];
47 }
48 else {
49 static _cmsInterpPluginChunkType InterpPluginChunk = { NULL };
50
51 from = &InterpPluginChunk;
52 }
53
54 _cmsAssert(from != NULL);
55 ctx ->chunks[InterpPlugin] = _cmsSubAllocDup(ctx ->MemPool, from, sizeof(_cmsInterpPluginChunkType));
56 }
57
58
59 // Main plug-in entry
_cmsRegisterInterpPlugin(cmsContext ContextID,cmsPluginBase * Data)60 cmsBool _cmsRegisterInterpPlugin(cmsContext ContextID, cmsPluginBase* Data)
61 {
62 cmsPluginInterpolation* Plugin = (cmsPluginInterpolation*) Data;
63 _cmsInterpPluginChunkType* ptr = (_cmsInterpPluginChunkType*) _cmsContextGetClientChunk(ContextID, InterpPlugin);
64
65 if (Data == NULL) {
66
67 ptr ->Interpolators = NULL;
68 return TRUE;
69 }
70
71 // Set replacement functions
72 ptr ->Interpolators = Plugin ->InterpolatorsFactory;
73 return TRUE;
74 }
75
76
77 // Set the interpolation method
_cmsSetInterpolationRoutine(cmsContext ContextID,cmsInterpParams * p)78 cmsBool _cmsSetInterpolationRoutine(cmsContext ContextID, cmsInterpParams* p)
79 {
80 _cmsInterpPluginChunkType* ptr = (_cmsInterpPluginChunkType*) _cmsContextGetClientChunk(ContextID, InterpPlugin);
81
82 p ->Interpolation.Lerp16 = NULL;
83
84 // Invoke factory, possibly in the Plug-in
85 if (ptr ->Interpolators != NULL)
86 p ->Interpolation = ptr->Interpolators(p -> nInputs, p ->nOutputs, p ->dwFlags);
87
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);
92
93 // Check for valid interpolator (we just check one member of the union)
94 if (p ->Interpolation.Lerp16 == NULL) {
95 return FALSE;
96 }
97
98 return TRUE;
99 }
100
101
102 // This function precalculates as many parameters as possible to speed up the interpolation.
_cmsComputeInterpParamsEx(cmsContext ContextID,const cmsUInt32Number nSamples[],int InputChan,int OutputChan,const void * Table,cmsUInt32Number dwFlags)103 cmsInterpParams* _cmsComputeInterpParamsEx(cmsContext ContextID,
104 const cmsUInt32Number nSamples[],
105 int InputChan, int OutputChan,
106 const void *Table,
107 cmsUInt32Number dwFlags)
108 {
109 cmsInterpParams* p;
110 int i;
111
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);
115 return NULL;
116 }
117
118 // Creates an empty object
119 p = (cmsInterpParams*) _cmsMallocZero(ContextID, sizeof(cmsInterpParams));
120 if (p == NULL) return NULL;
121
122 // Keep original parameters
123 p -> dwFlags = dwFlags;
124 p -> nInputs = InputChan;
125 p -> nOutputs = OutputChan;
126 p ->Table = Table;
127 p ->ContextID = ContextID;
128
129 // Fill samples per input direction and domain (which is number of nodes minus one)
130 for (i=0; i < InputChan; i++) {
131
132 p -> nSamples[i] = nSamples[i];
133 p -> Domain[i] = nSamples[i] - 1;
134 }
135
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];
140
141
142 if (!_cmsSetInterpolationRoutine(ContextID, p)) {
143 cmsSignalError(ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported interpolation (%d->%d channels)", InputChan, OutputChan);
144 _cmsFree(ContextID, p);
145 return NULL;
146 }
147
148 // All seems ok
149 return p;
150 }
151
152
153 // This one is a wrapper on the anterior, but assuming all directions have same number of nodes
_cmsComputeInterpParams(cmsContext ContextID,int nSamples,int InputChan,int OutputChan,const void * Table,cmsUInt32Number dwFlags)154 cmsInterpParams* _cmsComputeInterpParams(cmsContext ContextID, int nSamples, int InputChan, int OutputChan, const void* Table, cmsUInt32Number dwFlags)
155 {
156 int i;
157 cmsUInt32Number Samples[MAX_INPUT_DIMENSIONS];
158
159 // Fill the auxiliary array
160 for (i=0; i < MAX_INPUT_DIMENSIONS; i++)
161 Samples[i] = nSamples;
162
163 // Call the extended function
164 return _cmsComputeInterpParamsEx(ContextID, Samples, InputChan, OutputChan, Table, dwFlags);
165 }
166
167
168 // Free all associated memory
_cmsFreeInterpParams(cmsInterpParams * p)169 void _cmsFreeInterpParams(cmsInterpParams* p)
170 {
171 if (p != NULL) _cmsFree(p ->ContextID, p);
172 }
173
174
175 // Inline fixed point interpolation
LinearInterp(cmsS15Fixed16Number a,cmsS15Fixed16Number l,cmsS15Fixed16Number h)176 cmsINLINE cmsUInt16Number LinearInterp(cmsS15Fixed16Number a, cmsS15Fixed16Number l, cmsS15Fixed16Number h)
177 {
178 cmsUInt32Number dif = (cmsUInt32Number) (h - l) * a + 0x8000;
179 dif = (dif >> 16) + l;
180 return (cmsUInt16Number) (dif);
181 }
182
183
184 // Linear interpolation (Fixed-point optimized)
185 static
LinLerp1D(register const cmsUInt16Number Value[],register cmsUInt16Number Output[],register const cmsInterpParams * p)186 void LinLerp1D(register const cmsUInt16Number Value[],
187 register cmsUInt16Number Output[],
188 register const cmsInterpParams* p)
189 {
190 cmsUInt16Number y1, y0;
191 int cell0, rest;
192 int val3;
193 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p ->Table;
194
195 // if last value...
196 if (Value[0] == 0xffff) {
197
198 Output[0] = LutTable[p -> Domain[0]];
199 return;
200 }
201
202 val3 = p -> Domain[0] * Value[0];
203 val3 = _cmsToFixedDomain(val3); // To fixed 15.16
204
205 cell0 = FIXED_TO_INT(val3); // Cell is 16 MSB bits
206 rest = FIXED_REST_TO_INT(val3); // Rest is 16 LSB bits
207
208 y0 = LutTable[cell0];
209 y1 = LutTable[cell0+1];
210
211
212 Output[0] = LinearInterp(rest, y0, y1);
213 }
214
215 // To prevent out of bounds indexing
fclamp(cmsFloat32Number v)216 cmsINLINE cmsFloat32Number fclamp(cmsFloat32Number v)
217 {
218 return ((v < 0.0f) || isnan(v)) ? 0.0f : (v > 1.0f ? 1.0f : v);
219 }
220
221 // Floating-point version of 1D interpolation
222 static
LinLerp1Dfloat(const cmsFloat32Number Value[],cmsFloat32Number Output[],const cmsInterpParams * p)223 void LinLerp1Dfloat(const cmsFloat32Number Value[],
224 cmsFloat32Number Output[],
225 const cmsInterpParams* p)
226 {
227 cmsFloat32Number y1, y0;
228 cmsFloat32Number val2, rest;
229 int cell0, cell1;
230 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p ->Table;
231
232 val2 = fclamp(Value[0]);
233
234 // if last value...
235 if (val2 == 1.0) {
236 Output[0] = LutTable[p -> Domain[0]];
237 return;
238 }
239
240 val2 *= p -> Domain[0];
241
242 cell0 = (int) floor(val2);
243 cell1 = (int) ceil(val2);
244
245 // Rest is 16 LSB bits
246 rest = val2 - cell0;
247
248 y0 = LutTable[cell0] ;
249 y1 = LutTable[cell1] ;
250
251 Output[0] = y0 + (y1 - y0) * rest;
252 }
253
254
255
256 // Eval gray LUT having only one input channel
257 static
Eval1Input(register const cmsUInt16Number Input[],register cmsUInt16Number Output[],register const cmsInterpParams * p16)258 void Eval1Input(register const cmsUInt16Number Input[],
259 register cmsUInt16Number Output[],
260 register const cmsInterpParams* p16)
261 {
262 cmsS15Fixed16Number fk;
263 cmsS15Fixed16Number k0, k1, rk, K0, K1;
264 int v;
265 cmsUInt32Number OutChan;
266 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
267
268 v = Input[0] * p16 -> Domain[0];
269 fk = _cmsToFixedDomain(v);
270
271 k0 = FIXED_TO_INT(fk);
272 rk = (cmsUInt16Number) FIXED_REST_TO_INT(fk);
273
274 k1 = k0 + (Input[0] != 0xFFFFU ? 1 : 0);
275
276 K0 = p16 -> opta[0] * k0;
277 K1 = p16 -> opta[0] * k1;
278
279 for (OutChan=0; OutChan < p16->nOutputs; OutChan++) {
280
281 Output[OutChan] = LinearInterp(rk, LutTable[K0+OutChan], LutTable[K1+OutChan]);
282 }
283 }
284
285
286
287 // Eval gray LUT having only one input channel
288 static
Eval1InputFloat(const cmsFloat32Number Value[],cmsFloat32Number Output[],const cmsInterpParams * p)289 void Eval1InputFloat(const cmsFloat32Number Value[],
290 cmsFloat32Number Output[],
291 const cmsInterpParams* p)
292 {
293 cmsFloat32Number y1, y0;
294 cmsFloat32Number val2, rest;
295 int cell0, cell1;
296 cmsUInt32Number OutChan;
297 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p ->Table;
298
299 val2 = fclamp(Value[0]);
300
301 // if last value...
302 if (val2 == 1.0) {
303 Output[0] = LutTable[p -> Domain[0]];
304 return;
305 }
306
307 val2 *= p -> Domain[0];
308
309 cell0 = (int) floor(val2);
310 cell1 = (int) ceil(val2);
311
312 // Rest is 16 LSB bits
313 rest = val2 - cell0;
314
315 cell0 *= p -> opta[0];
316 cell1 *= p -> opta[0];
317
318 for (OutChan=0; OutChan < p->nOutputs; OutChan++) {
319
320 y0 = LutTable[cell0 + OutChan] ;
321 y1 = LutTable[cell1 + OutChan] ;
322
323 Output[OutChan] = y0 + (y1 - y0) * rest;
324 }
325 }
326
327 // Bilinear interpolation (16 bits) - cmsFloat32Number version
328 static
BilinearInterpFloat(const cmsFloat32Number Input[],cmsFloat32Number Output[],const cmsInterpParams * p)329 void BilinearInterpFloat(const cmsFloat32Number Input[],
330 cmsFloat32Number Output[],
331 const cmsInterpParams* p)
332
333 {
334 # define LERP(a,l,h) (cmsFloat32Number) ((l)+(((h)-(l))*(a)))
335 # define DENS(i,j) (LutTable[(i)+(j)+OutChan])
336
337 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p ->Table;
338 cmsFloat32Number px, py;
339 int x0, y0,
340 X0, Y0, X1, Y1;
341 int TotalOut, OutChan;
342 cmsFloat32Number fx, fy,
343 d00, d01, d10, d11,
344 dx0, dx1,
345 dxy;
346
347 TotalOut = p -> nOutputs;
348 px = fclamp(Input[0]) * p->Domain[0];
349 py = fclamp(Input[1]) * p->Domain[1];
350
351 x0 = (int) _cmsQuickFloor(px); fx = px - (cmsFloat32Number) x0;
352 y0 = (int) _cmsQuickFloor(py); fy = py - (cmsFloat32Number) y0;
353
354 X0 = p -> opta[1] * x0;
355 X1 = X0 + (Input[0] >= 1.0 ? 0 : p->opta[1]);
356
357 Y0 = p -> opta[0] * y0;
358 Y1 = Y0 + (Input[1] >= 1.0 ? 0 : p->opta[0]);
359
360 for (OutChan = 0; OutChan < TotalOut; OutChan++) {
361
362 d00 = DENS(X0, Y0);
363 d01 = DENS(X0, Y1);
364 d10 = DENS(X1, Y0);
365 d11 = DENS(X1, Y1);
366
367 dx0 = LERP(fx, d00, d10);
368 dx1 = LERP(fx, d01, d11);
369
370 dxy = LERP(fy, dx0, dx1);
371
372 Output[OutChan] = dxy;
373 }
374
375
376 # undef LERP
377 # undef DENS
378 }
379
380 // Bilinear interpolation (16 bits) - optimized version
381 static
BilinearInterp16(register const cmsUInt16Number Input[],register cmsUInt16Number Output[],register const cmsInterpParams * p)382 void BilinearInterp16(register const cmsUInt16Number Input[],
383 register cmsUInt16Number Output[],
384 register const cmsInterpParams* p)
385
386 {
387 #define DENS(i,j) (LutTable[(i)+(j)+OutChan])
388 #define LERP(a,l,h) (cmsUInt16Number) (l + ROUND_FIXED_TO_INT(((h-l)*a)))
389
390 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p ->Table;
391 int OutChan, TotalOut;
392 cmsS15Fixed16Number fx, fy;
393 register int rx, ry;
394 int x0, y0;
395 register int X0, X1, Y0, Y1;
396 int d00, d01, d10, d11,
397 dx0, dx1,
398 dxy;
399
400 TotalOut = p -> nOutputs;
401
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
405
406
407 fy = _cmsToFixedDomain((int) Input[1] * p -> Domain[1]);
408 y0 = FIXED_TO_INT(fy);
409 ry = FIXED_REST_TO_INT(fy);
410
411
412 X0 = p -> opta[1] * x0;
413 X1 = X0 + (Input[0] == 0xFFFFU ? 0 : p->opta[1]);
414
415 Y0 = p -> opta[0] * y0;
416 Y1 = Y0 + (Input[1] == 0xFFFFU ? 0 : p->opta[0]);
417
418 for (OutChan = 0; OutChan < TotalOut; OutChan++) {
419
420 d00 = DENS(X0, Y0);
421 d01 = DENS(X0, Y1);
422 d10 = DENS(X1, Y0);
423 d11 = DENS(X1, Y1);
424
425 dx0 = LERP(rx, d00, d10);
426 dx1 = LERP(rx, d01, d11);
427
428 dxy = LERP(ry, dx0, dx1);
429
430 Output[OutChan] = (cmsUInt16Number) dxy;
431 }
432
433
434 # undef LERP
435 # undef DENS
436 }
437
438
439 // Trilinear interpolation (16 bits) - cmsFloat32Number version
440 static
TrilinearInterpFloat(const cmsFloat32Number Input[],cmsFloat32Number Output[],const cmsInterpParams * p)441 void TrilinearInterpFloat(const cmsFloat32Number Input[],
442 cmsFloat32Number Output[],
443 const cmsInterpParams* p)
444
445 {
446 # define LERP(a,l,h) (cmsFloat32Number) ((l)+(((h)-(l))*(a)))
447 # define DENS(i,j,k) (LutTable[(i)+(j)+(k)+OutChan])
448
449 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p ->Table;
450 cmsFloat32Number px, py, pz;
451 int x0, y0, z0,
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,
458 dxy0, dxy1, dxyz;
459
460 TotalOut = p -> nOutputs;
461
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];
466
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;
470
471 X0 = p -> opta[2] * x0;
472 X1 = X0 + (Input[0] >= 1.0 ? 0 : p->opta[2]);
473
474 Y0 = p -> opta[1] * y0;
475 Y1 = Y0 + (Input[1] >= 1.0 ? 0 : p->opta[1]);
476
477 Z0 = p -> opta[0] * z0;
478 Z1 = Z0 + (Input[2] >= 1.0 ? 0 : p->opta[0]);
479
480 for (OutChan = 0; OutChan < TotalOut; OutChan++) {
481
482 d000 = DENS(X0, Y0, Z0);
483 d001 = DENS(X0, Y0, Z1);
484 d010 = DENS(X0, Y1, Z0);
485 d011 = DENS(X0, Y1, Z1);
486
487 d100 = DENS(X1, Y0, Z0);
488 d101 = DENS(X1, Y0, Z1);
489 d110 = DENS(X1, Y1, Z0);
490 d111 = DENS(X1, Y1, Z1);
491
492
493 dx00 = LERP(fx, d000, d100);
494 dx01 = LERP(fx, d001, d101);
495 dx10 = LERP(fx, d010, d110);
496 dx11 = LERP(fx, d011, d111);
497
498 dxy0 = LERP(fy, dx00, dx10);
499 dxy1 = LERP(fy, dx01, dx11);
500
501 dxyz = LERP(fz, dxy0, dxy1);
502
503 Output[OutChan] = dxyz;
504 }
505
506
507 # undef LERP
508 # undef DENS
509 }
510
511 // Trilinear interpolation (16 bits) - optimized version
512 static
TrilinearInterp16(register const cmsUInt16Number Input[],register cmsUInt16Number Output[],register const cmsInterpParams * p)513 void TrilinearInterp16(register const cmsUInt16Number Input[],
514 register cmsUInt16Number Output[],
515 register const cmsInterpParams* p)
516
517 {
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)))
520
521 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p ->Table;
522 int OutChan, TotalOut;
523 cmsS15Fixed16Number fx, fy, fz;
524 register int rx, ry, rz;
525 int x0, y0, z0;
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,
530 dxy0, dxy1, dxyz;
531
532 TotalOut = p -> nOutputs;
533
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
537
538
539 fy = _cmsToFixedDomain((int) Input[1] * p -> Domain[1]);
540 y0 = FIXED_TO_INT(fy);
541 ry = FIXED_REST_TO_INT(fy);
542
543 fz = _cmsToFixedDomain((int) Input[2] * p -> Domain[2]);
544 z0 = FIXED_TO_INT(fz);
545 rz = FIXED_REST_TO_INT(fz);
546
547
548 X0 = p -> opta[2] * x0;
549 X1 = X0 + (Input[0] == 0xFFFFU ? 0 : p->opta[2]);
550
551 Y0 = p -> opta[1] * y0;
552 Y1 = Y0 + (Input[1] == 0xFFFFU ? 0 : p->opta[1]);
553
554 Z0 = p -> opta[0] * z0;
555 Z1 = Z0 + (Input[2] == 0xFFFFU ? 0 : p->opta[0]);
556
557 for (OutChan = 0; OutChan < TotalOut; OutChan++) {
558
559 d000 = DENS(X0, Y0, Z0);
560 d001 = DENS(X0, Y0, Z1);
561 d010 = DENS(X0, Y1, Z0);
562 d011 = DENS(X0, Y1, Z1);
563
564 d100 = DENS(X1, Y0, Z0);
565 d101 = DENS(X1, Y0, Z1);
566 d110 = DENS(X1, Y1, Z0);
567 d111 = DENS(X1, Y1, Z1);
568
569
570 dx00 = LERP(rx, d000, d100);
571 dx01 = LERP(rx, d001, d101);
572 dx10 = LERP(rx, d010, d110);
573 dx11 = LERP(rx, d011, d111);
574
575 dxy0 = LERP(ry, dx00, dx10);
576 dxy1 = LERP(ry, dx01, dx11);
577
578 dxyz = LERP(rz, dxy0, dxy1);
579
580 Output[OutChan] = (cmsUInt16Number) dxyz;
581 }
582
583
584 # undef LERP
585 # undef DENS
586 }
587
588
589 // Tetrahedral interpolation, using Sakamoto algorithm.
590 #define DENS(i,j,k) (LutTable[(i)+(j)+(k)+OutChan])
591 static
TetrahedralInterpFloat(const cmsFloat32Number Input[],cmsFloat32Number Output[],const cmsInterpParams * p)592 void TetrahedralInterpFloat(const cmsFloat32Number Input[],
593 cmsFloat32Number Output[],
594 const cmsInterpParams* p)
595 {
596 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
597 cmsFloat32Number px, py, pz;
598 int x0, y0, z0,
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;
603
604 TotalOut = p -> nOutputs;
605
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];
610
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);
614
615
616 X0 = p -> opta[2] * x0;
617 X1 = X0 + (Input[0] >= 1.0 ? 0 : p->opta[2]);
618
619 Y0 = p -> opta[1] * y0;
620 Y1 = Y0 + (Input[1] >= 1.0 ? 0 : p->opta[1]);
621
622 Z0 = p -> opta[0] * z0;
623 Z1 = Z0 + (Input[2] >= 1.0 ? 0 : p->opta[0]);
624
625 for (OutChan=0; OutChan < TotalOut; OutChan++) {
626
627 // These are the 6 Tetrahedral
628
629 c0 = DENS(X0, Y0, Z0);
630
631 if (rx >= ry && ry >= rz) {
632
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);
636
637 }
638 else
639 if (rx >= rz && rz >= ry) {
640
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);
644
645 }
646 else
647 if (rz >= rx && rx >= ry) {
648
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;
652
653 }
654 else
655 if (ry >= rx && rx >= rz) {
656
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);
660
661 }
662 else
663 if (ry >= rz && rz >= rx) {
664
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);
668
669 }
670 else
671 if (rz >= ry && ry >= rx) {
672
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;
676
677 }
678 else {
679 c1 = c2 = c3 = 0;
680 }
681
682 Output[OutChan] = c0 + c1 * rx + c2 * ry + c3 * rz;
683 }
684
685 }
686
687 #undef DENS
688
689
690
691
692 static
TetrahedralInterp16(register const cmsUInt16Number Input[],register cmsUInt16Number Output[],register const cmsInterpParams * p)693 void TetrahedralInterp16(register const cmsUInt16Number Input[],
694 register cmsUInt16Number Output[],
695 register const cmsInterpParams* p)
696 {
697 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p -> Table;
698 cmsS15Fixed16Number fx, fy, fz;
699 cmsS15Fixed16Number rx, ry, rz;
700 int x0, y0, z0;
701 cmsS15Fixed16Number c0, c1, c2, c3, Rest;
702 cmsS15Fixed16Number X0, X1, Y0, Y1, Z0, Z1;
703 cmsUInt32Number TotalOut = p -> nOutputs;
704
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]);
708
709 x0 = FIXED_TO_INT(fx);
710 y0 = FIXED_TO_INT(fy);
711 z0 = FIXED_TO_INT(fz);
712
713 rx = FIXED_REST_TO_INT(fx);
714 ry = FIXED_REST_TO_INT(fy);
715 rz = FIXED_REST_TO_INT(fz);
716
717 X0 = p -> opta[2] * x0;
718 X1 = (Input[0] == 0xFFFFU ? 0 : p->opta[2]);
719
720 Y0 = p -> opta[1] * y0;
721 Y1 = (Input[1] == 0xFFFFU ? 0 : p->opta[1]);
722
723 Z0 = p -> opta[0] * z0;
724 Z1 = (Input[2] == 0xFFFFU ? 0 : p->opta[0]);
725
726 LutTable = &LutTable[X0+Y0+Z0];
727
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.
732
733 if (rx >= ry) {
734 if (ry >= rz) {
735 Y1 += X1;
736 Z1 += Y1;
737 for (; TotalOut; TotalOut--) {
738 c1 = LutTable[X1];
739 c2 = LutTable[Y1];
740 c3 = LutTable[Z1];
741 c0 = *LutTable++;
742 c3 -= c2;
743 c2 -= c1;
744 c1 -= c0;
745 Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
746 *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
747 }
748 } else if (rz >= rx) {
749 X1 += Z1;
750 Y1 += X1;
751 for (; TotalOut; TotalOut--) {
752 c1 = LutTable[X1];
753 c2 = LutTable[Y1];
754 c3 = LutTable[Z1];
755 c0 = *LutTable++;
756 c2 -= c1;
757 c1 -= c3;
758 c3 -= c0;
759 Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
760 *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
761 }
762 } else {
763 Z1 += X1;
764 Y1 += Z1;
765 for (; TotalOut; TotalOut--) {
766 c1 = LutTable[X1];
767 c2 = LutTable[Y1];
768 c3 = LutTable[Z1];
769 c0 = *LutTable++;
770 c2 -= c3;
771 c3 -= c1;
772 c1 -= c0;
773 Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
774 *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
775 }
776 }
777 } else {
778 if (rx >= rz) {
779 X1 += Y1;
780 Z1 += X1;
781 for (; TotalOut; TotalOut--) {
782 c1 = LutTable[X1];
783 c2 = LutTable[Y1];
784 c3 = LutTable[Z1];
785 c0 = *LutTable++;
786 c3 -= c1;
787 c1 -= c2;
788 c2 -= c0;
789 Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
790 *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
791 }
792 } else if (ry >= rz) {
793 Z1 += Y1;
794 X1 += Z1;
795 for (; TotalOut; TotalOut--) {
796 c1 = LutTable[X1];
797 c2 = LutTable[Y1];
798 c3 = LutTable[Z1];
799 c0 = *LutTable++;
800 c1 -= c3;
801 c3 -= c2;
802 c2 -= c0;
803 Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
804 *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
805 }
806 } else {
807 Y1 += Z1;
808 X1 += Y1;
809 for (; TotalOut; TotalOut--) {
810 c1 = LutTable[X1];
811 c2 = LutTable[Y1];
812 c3 = LutTable[Z1];
813 c0 = *LutTable++;
814 c1 -= c2;
815 c2 -= c3;
816 c3 -= c0;
817 Rest = c1 * rx + c2 * ry + c3 * rz + 0x8001;
818 *Output++ = (cmsUInt16Number) c0 + ((Rest + (Rest>>16))>>16);
819 }
820 }
821 }
822 }
823
824
825 #define DENS(i,j,k) (LutTable[(i)+(j)+(k)+OutChan])
826 static
Eval4Inputs(register const cmsUInt16Number Input[],register cmsUInt16Number Output[],register const cmsInterpParams * p16)827 void Eval4Inputs(register const cmsUInt16Number Input[],
828 register cmsUInt16Number Output[],
829 register const cmsInterpParams* p16)
830 {
831 const cmsUInt16Number* LutTable;
832 cmsS15Fixed16Number fk;
833 cmsS15Fixed16Number k0, rk;
834 int K0, K1;
835 cmsS15Fixed16Number fx, fy, fz;
836 cmsS15Fixed16Number rx, ry, rz;
837 int x0, y0, z0;
838 cmsS15Fixed16Number X0, X1, Y0, Y1, Z0, Z1;
839 cmsUInt32Number i;
840 cmsS15Fixed16Number c0, c1, c2, c3, Rest;
841 cmsUInt32Number OutChan;
842 cmsUInt16Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
843
844
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]);
849
850 k0 = FIXED_TO_INT(fk);
851 x0 = FIXED_TO_INT(fx);
852 y0 = FIXED_TO_INT(fy);
853 z0 = FIXED_TO_INT(fz);
854
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);
859
860 K0 = p16 -> opta[3] * k0;
861 K1 = K0 + (Input[0] == 0xFFFFU ? 0 : p16->opta[3]);
862
863 X0 = p16 -> opta[2] * x0;
864 X1 = X0 + (Input[1] == 0xFFFFU ? 0 : p16->opta[2]);
865
866 Y0 = p16 -> opta[1] * y0;
867 Y1 = Y0 + (Input[2] == 0xFFFFU ? 0 : p16->opta[1]);
868
869 Z0 = p16 -> opta[0] * z0;
870 Z1 = Z0 + (Input[3] == 0xFFFFU ? 0 : p16->opta[0]);
871
872 LutTable = (cmsUInt16Number*) p16 -> Table;
873 LutTable += K0;
874
875 for (OutChan=0; OutChan < p16 -> nOutputs; OutChan++) {
876
877 c0 = DENS(X0, Y0, Z0);
878
879 if (rx >= ry && ry >= rz) {
880
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);
884
885 }
886 else
887 if (rx >= rz && rz >= ry) {
888
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);
892
893 }
894 else
895 if (rz >= rx && rx >= ry) {
896
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;
900
901 }
902 else
903 if (ry >= rx && rx >= rz) {
904
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);
908
909 }
910 else
911 if (ry >= rz && rz >= rx) {
912
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);
916
917 }
918 else
919 if (rz >= ry && ry >= rx) {
920
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;
924
925 }
926 else {
927 c1 = c2 = c3 = 0;
928 }
929
930 Rest = c1 * rx + c2 * ry + c3 * rz;
931
932 Tmp1[OutChan] = (cmsUInt16Number) ( c0 + ROUND_FIXED_TO_INT(_cmsToFixedDomain(Rest)));
933 }
934
935
936 LutTable = (cmsUInt16Number*) p16 -> Table;
937 LutTable += K1;
938
939 for (OutChan=0; OutChan < p16 -> nOutputs; OutChan++) {
940
941 c0 = DENS(X0, Y0, Z0);
942
943 if (rx >= ry && ry >= rz) {
944
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);
948
949 }
950 else
951 if (rx >= rz && rz >= ry) {
952
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);
956
957 }
958 else
959 if (rz >= rx && rx >= ry) {
960
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;
964
965 }
966 else
967 if (ry >= rx && rx >= rz) {
968
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);
972
973 }
974 else
975 if (ry >= rz && rz >= rx) {
976
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);
980
981 }
982 else
983 if (rz >= ry && ry >= rx) {
984
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;
988
989 }
990 else {
991 c1 = c2 = c3 = 0;
992 }
993
994 Rest = c1 * rx + c2 * ry + c3 * rz;
995
996 Tmp2[OutChan] = (cmsUInt16Number) (c0 + ROUND_FIXED_TO_INT(_cmsToFixedDomain(Rest)));
997 }
998
999
1000
1001 for (i=0; i < p16 -> nOutputs; i++) {
1002 Output[i] = LinearInterp(rk, Tmp1[i], Tmp2[i]);
1003 }
1004 }
1005 #undef DENS
1006
1007
1008 // For more that 3 inputs (i.e., CMYK)
1009 // evaluate two 3-dimensional interpolations and then linearly interpolate between them.
1010
1011
1012 static
Eval4InputsFloat(const cmsFloat32Number Input[],cmsFloat32Number Output[],const cmsInterpParams * p)1013 void Eval4InputsFloat(const cmsFloat32Number Input[],
1014 cmsFloat32Number Output[],
1015 const cmsInterpParams* p)
1016 {
1017 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
1018 cmsFloat32Number rest;
1019 cmsFloat32Number pk;
1020 int k0, K0, K1;
1021 const cmsFloat32Number* T;
1022 cmsUInt32Number i;
1023 cmsFloat32Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1024 cmsInterpParams p1;
1025
1026 pk = fclamp(Input[0]) * p->Domain[0];
1027 k0 = _cmsQuickFloor(pk);
1028 rest = pk - (cmsFloat32Number) k0;
1029
1030 K0 = p -> opta[3] * k0;
1031 K1 = K0 + (Input[0] >= 1.0 ? 0 : p->opta[3]);
1032
1033 p1 = *p;
1034 memmove(&p1.Domain[0], &p ->Domain[1], 3*sizeof(cmsUInt32Number));
1035
1036 T = LutTable + K0;
1037 p1.Table = T;
1038
1039 TetrahedralInterpFloat(Input + 1, Tmp1, &p1);
1040
1041 T = LutTable + K1;
1042 p1.Table = T;
1043 TetrahedralInterpFloat(Input + 1, Tmp2, &p1);
1044
1045 for (i=0; i < p -> nOutputs; i++)
1046 {
1047 cmsFloat32Number y0 = Tmp1[i];
1048 cmsFloat32Number y1 = Tmp2[i];
1049
1050 Output[i] = y0 + (y1 - y0) * rest;
1051 }
1052 }
1053
1054
1055 static
Eval5Inputs(register const cmsUInt16Number Input[],register cmsUInt16Number Output[],register const cmsInterpParams * p16)1056 void Eval5Inputs(register const cmsUInt16Number Input[],
1057 register cmsUInt16Number Output[],
1058
1059 register const cmsInterpParams* p16)
1060 {
1061 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
1062 cmsS15Fixed16Number fk;
1063 cmsS15Fixed16Number k0, rk;
1064 int K0, K1;
1065 const cmsUInt16Number* T;
1066 cmsUInt32Number i;
1067 cmsUInt16Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1068 cmsInterpParams p1;
1069
1070
1071 fk = _cmsToFixedDomain((cmsS15Fixed16Number) Input[0] * p16 -> Domain[0]);
1072 k0 = FIXED_TO_INT(fk);
1073 rk = FIXED_REST_TO_INT(fk);
1074
1075 K0 = p16 -> opta[4] * k0;
1076 K1 = p16 -> opta[4] * (k0 + (Input[0] != 0xFFFFU ? 1 : 0));
1077
1078 p1 = *p16;
1079 memmove(&p1.Domain[0], &p16 ->Domain[1], 4*sizeof(cmsUInt32Number));
1080
1081 T = LutTable + K0;
1082 p1.Table = T;
1083
1084 Eval4Inputs(Input + 1, Tmp1, &p1);
1085
1086 T = LutTable + K1;
1087 p1.Table = T;
1088
1089 Eval4Inputs(Input + 1, Tmp2, &p1);
1090
1091 for (i=0; i < p16 -> nOutputs; i++) {
1092
1093 Output[i] = LinearInterp(rk, Tmp1[i], Tmp2[i]);
1094 }
1095
1096 }
1097
1098
1099 static
Eval5InputsFloat(const cmsFloat32Number Input[],cmsFloat32Number Output[],const cmsInterpParams * p)1100 void Eval5InputsFloat(const cmsFloat32Number Input[],
1101 cmsFloat32Number Output[],
1102 const cmsInterpParams* p)
1103 {
1104 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
1105 cmsFloat32Number rest;
1106 cmsFloat32Number pk;
1107 int k0, K0, K1;
1108 const cmsFloat32Number* T;
1109 cmsUInt32Number i;
1110 cmsFloat32Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1111 cmsInterpParams p1;
1112
1113 pk = fclamp(Input[0]) * p->Domain[0];
1114 k0 = _cmsQuickFloor(pk);
1115 rest = pk - (cmsFloat32Number) k0;
1116
1117 K0 = p -> opta[4] * k0;
1118 K1 = K0 + (Input[0] >= 1.0 ? 0 : p->opta[4]);
1119
1120 p1 = *p;
1121 memmove(&p1.Domain[0], &p ->Domain[1], 4*sizeof(cmsUInt32Number));
1122
1123 T = LutTable + K0;
1124 p1.Table = T;
1125
1126 Eval4InputsFloat(Input + 1, Tmp1, &p1);
1127
1128 T = LutTable + K1;
1129 p1.Table = T;
1130
1131 Eval4InputsFloat(Input + 1, Tmp2, &p1);
1132
1133 for (i=0; i < p -> nOutputs; i++) {
1134
1135 cmsFloat32Number y0 = Tmp1[i];
1136 cmsFloat32Number y1 = Tmp2[i];
1137
1138 Output[i] = y0 + (y1 - y0) * rest;
1139 }
1140 }
1141
1142
1143
1144 static
Eval6Inputs(register const cmsUInt16Number Input[],register cmsUInt16Number Output[],register const cmsInterpParams * p16)1145 void Eval6Inputs(register const cmsUInt16Number Input[],
1146 register cmsUInt16Number Output[],
1147 register const cmsInterpParams* p16)
1148 {
1149 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
1150 cmsS15Fixed16Number fk;
1151 cmsS15Fixed16Number k0, rk;
1152 int K0, K1;
1153 const cmsUInt16Number* T;
1154 cmsUInt32Number i;
1155 cmsUInt16Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1156 cmsInterpParams p1;
1157
1158 fk = _cmsToFixedDomain((cmsS15Fixed16Number) Input[0] * p16 -> Domain[0]);
1159 k0 = FIXED_TO_INT(fk);
1160 rk = FIXED_REST_TO_INT(fk);
1161
1162 K0 = p16 -> opta[5] * k0;
1163 K1 = p16 -> opta[5] * (k0 + (Input[0] != 0xFFFFU ? 1 : 0));
1164
1165 p1 = *p16;
1166 memmove(&p1.Domain[0], &p16 ->Domain[1], 5*sizeof(cmsUInt32Number));
1167
1168 T = LutTable + K0;
1169 p1.Table = T;
1170
1171 Eval5Inputs(Input + 1, Tmp1, &p1);
1172
1173 T = LutTable + K1;
1174 p1.Table = T;
1175
1176 Eval5Inputs(Input + 1, Tmp2, &p1);
1177
1178 for (i=0; i < p16 -> nOutputs; i++) {
1179
1180 Output[i] = LinearInterp(rk, Tmp1[i], Tmp2[i]);
1181 }
1182
1183 }
1184
1185
1186 static
Eval6InputsFloat(const cmsFloat32Number Input[],cmsFloat32Number Output[],const cmsInterpParams * p)1187 void Eval6InputsFloat(const cmsFloat32Number Input[],
1188 cmsFloat32Number Output[],
1189 const cmsInterpParams* p)
1190 {
1191 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
1192 cmsFloat32Number rest;
1193 cmsFloat32Number pk;
1194 int k0, K0, K1;
1195 const cmsFloat32Number* T;
1196 cmsUInt32Number i;
1197 cmsFloat32Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1198 cmsInterpParams p1;
1199
1200 pk = fclamp(Input[0]) * p->Domain[0];
1201 k0 = _cmsQuickFloor(pk);
1202 rest = pk - (cmsFloat32Number) k0;
1203
1204 K0 = p -> opta[5] * k0;
1205 K1 = K0 + (Input[0] >= 1.0 ? 0 : p->opta[5]);
1206
1207 p1 = *p;
1208 memmove(&p1.Domain[0], &p ->Domain[1], 5*sizeof(cmsUInt32Number));
1209
1210 T = LutTable + K0;
1211 p1.Table = T;
1212
1213 Eval5InputsFloat(Input + 1, Tmp1, &p1);
1214
1215 T = LutTable + K1;
1216 p1.Table = T;
1217
1218 Eval5InputsFloat(Input + 1, Tmp2, &p1);
1219
1220 for (i=0; i < p -> nOutputs; i++) {
1221
1222 cmsFloat32Number y0 = Tmp1[i];
1223 cmsFloat32Number y1 = Tmp2[i];
1224
1225 Output[i] = y0 + (y1 - y0) * rest;
1226 }
1227 }
1228
1229
1230 static
Eval7Inputs(register const cmsUInt16Number Input[],register cmsUInt16Number Output[],register const cmsInterpParams * p16)1231 void Eval7Inputs(register const cmsUInt16Number Input[],
1232 register cmsUInt16Number Output[],
1233 register const cmsInterpParams* p16)
1234 {
1235 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
1236 cmsS15Fixed16Number fk;
1237 cmsS15Fixed16Number k0, rk;
1238 int K0, K1;
1239 const cmsUInt16Number* T;
1240 cmsUInt32Number i;
1241 cmsUInt16Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1242 cmsInterpParams p1;
1243
1244
1245 fk = _cmsToFixedDomain((cmsS15Fixed16Number) Input[0] * p16 -> Domain[0]);
1246 k0 = FIXED_TO_INT(fk);
1247 rk = FIXED_REST_TO_INT(fk);
1248
1249 K0 = p16 -> opta[6] * k0;
1250 K1 = p16 -> opta[6] * (k0 + (Input[0] != 0xFFFFU ? 1 : 0));
1251
1252 p1 = *p16;
1253 memmove(&p1.Domain[0], &p16 ->Domain[1], 6*sizeof(cmsUInt32Number));
1254
1255 T = LutTable + K0;
1256 p1.Table = T;
1257
1258 Eval6Inputs(Input + 1, Tmp1, &p1);
1259
1260 T = LutTable + K1;
1261 p1.Table = T;
1262
1263 Eval6Inputs(Input + 1, Tmp2, &p1);
1264
1265 for (i=0; i < p16 -> nOutputs; i++) {
1266 Output[i] = LinearInterp(rk, Tmp1[i], Tmp2[i]);
1267 }
1268 }
1269
1270
1271 static
Eval7InputsFloat(const cmsFloat32Number Input[],cmsFloat32Number Output[],const cmsInterpParams * p)1272 void Eval7InputsFloat(const cmsFloat32Number Input[],
1273 cmsFloat32Number Output[],
1274 const cmsInterpParams* p)
1275 {
1276 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
1277 cmsFloat32Number rest;
1278 cmsFloat32Number pk;
1279 int k0, K0, K1;
1280 const cmsFloat32Number* T;
1281 cmsUInt32Number i;
1282 cmsFloat32Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1283 cmsInterpParams p1;
1284
1285 pk = fclamp(Input[0]) * p->Domain[0];
1286 k0 = _cmsQuickFloor(pk);
1287 rest = pk - (cmsFloat32Number) k0;
1288
1289 K0 = p -> opta[6] * k0;
1290 K1 = K0 + (Input[0] >= 1.0 ? 0 : p->opta[6]);
1291
1292 p1 = *p;
1293 memmove(&p1.Domain[0], &p ->Domain[1], 6*sizeof(cmsUInt32Number));
1294
1295 T = LutTable + K0;
1296 p1.Table = T;
1297
1298 Eval6InputsFloat(Input + 1, Tmp1, &p1);
1299
1300 T = LutTable + K1;
1301 p1.Table = T;
1302
1303 Eval6InputsFloat(Input + 1, Tmp2, &p1);
1304
1305
1306 for (i=0; i < p -> nOutputs; i++) {
1307
1308 cmsFloat32Number y0 = Tmp1[i];
1309 cmsFloat32Number y1 = Tmp2[i];
1310
1311 Output[i] = y0 + (y1 - y0) * rest;
1312
1313 }
1314 }
1315
1316 static
Eval8Inputs(register const cmsUInt16Number Input[],register cmsUInt16Number Output[],register const cmsInterpParams * p16)1317 void Eval8Inputs(register const cmsUInt16Number Input[],
1318 register cmsUInt16Number Output[],
1319 register const cmsInterpParams* p16)
1320 {
1321 const cmsUInt16Number* LutTable = (cmsUInt16Number*) p16 -> Table;
1322 cmsS15Fixed16Number fk;
1323 cmsS15Fixed16Number k0, rk;
1324 int K0, K1;
1325 const cmsUInt16Number* T;
1326 cmsUInt32Number i;
1327 cmsUInt16Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1328 cmsInterpParams p1;
1329
1330 fk = _cmsToFixedDomain((cmsS15Fixed16Number) Input[0] * p16 -> Domain[0]);
1331 k0 = FIXED_TO_INT(fk);
1332 rk = FIXED_REST_TO_INT(fk);
1333
1334 K0 = p16 -> opta[7] * k0;
1335 K1 = p16 -> opta[7] * (k0 + (Input[0] != 0xFFFFU ? 1 : 0));
1336
1337 p1 = *p16;
1338 memmove(&p1.Domain[0], &p16 ->Domain[1], 7*sizeof(cmsUInt32Number));
1339
1340 T = LutTable + K0;
1341 p1.Table = T;
1342
1343 Eval7Inputs(Input + 1, Tmp1, &p1);
1344
1345 T = LutTable + K1;
1346 p1.Table = T;
1347 Eval7Inputs(Input + 1, Tmp2, &p1);
1348
1349 for (i=0; i < p16 -> nOutputs; i++) {
1350 Output[i] = LinearInterp(rk, Tmp1[i], Tmp2[i]);
1351 }
1352 }
1353
1354
1355
1356 static
Eval8InputsFloat(const cmsFloat32Number Input[],cmsFloat32Number Output[],const cmsInterpParams * p)1357 void Eval8InputsFloat(const cmsFloat32Number Input[],
1358 cmsFloat32Number Output[],
1359 const cmsInterpParams* p)
1360 {
1361 const cmsFloat32Number* LutTable = (cmsFloat32Number*) p -> Table;
1362 cmsFloat32Number rest;
1363 cmsFloat32Number pk;
1364 int k0, K0, K1;
1365 const cmsFloat32Number* T;
1366 cmsUInt32Number i;
1367 cmsFloat32Number Tmp1[MAX_STAGE_CHANNELS], Tmp2[MAX_STAGE_CHANNELS];
1368 cmsInterpParams p1;
1369
1370 pk = fclamp(Input[0]) * p->Domain[0];
1371 k0 = _cmsQuickFloor(pk);
1372 rest = pk - (cmsFloat32Number) k0;
1373
1374 K0 = p -> opta[7] * k0;
1375 K1 = K0 + (Input[0] >= 1.0 ? 0 : p->opta[7]);
1376
1377 p1 = *p;
1378 memmove(&p1.Domain[0], &p ->Domain[1], 7*sizeof(cmsUInt32Number));
1379
1380 T = LutTable + K0;
1381 p1.Table = T;
1382
1383 Eval7InputsFloat(Input + 1, Tmp1, &p1);
1384
1385 T = LutTable + K1;
1386 p1.Table = T;
1387
1388 Eval7InputsFloat(Input + 1, Tmp2, &p1);
1389
1390
1391 for (i=0; i < p -> nOutputs; i++) {
1392
1393 cmsFloat32Number y0 = Tmp1[i];
1394 cmsFloat32Number y1 = Tmp2[i];
1395
1396 Output[i] = y0 + (y1 - y0) * rest;
1397 }
1398 }
1399
1400 // The default factory
1401 static
DefaultInterpolatorsFactory(cmsUInt32Number nInputChannels,cmsUInt32Number nOutputChannels,cmsUInt32Number dwFlags)1402 cmsInterpFunction DefaultInterpolatorsFactory(cmsUInt32Number nInputChannels, cmsUInt32Number nOutputChannels, cmsUInt32Number dwFlags)
1403 {
1404
1405 cmsInterpFunction Interpolation;
1406 cmsBool IsFloat = (dwFlags & CMS_LERP_FLAGS_FLOAT);
1407 cmsBool IsTrilinear = (dwFlags & CMS_LERP_FLAGS_TRILINEAR);
1408
1409 memset(&Interpolation, 0, sizeof(Interpolation));
1410
1411 // Safety check
1412 if (nInputChannels >= 4 && nOutputChannels >= MAX_STAGE_CHANNELS)
1413 return Interpolation;
1414
1415 switch (nInputChannels) {
1416
1417 case 1: // Gray LUT / linear
1418
1419 if (nOutputChannels == 1) {
1420
1421 if (IsFloat)
1422 Interpolation.LerpFloat = LinLerp1Dfloat;
1423 else
1424 Interpolation.Lerp16 = LinLerp1D;
1425
1426 }
1427 else {
1428
1429 if (IsFloat)
1430 Interpolation.LerpFloat = Eval1InputFloat;
1431 else
1432 Interpolation.Lerp16 = Eval1Input;
1433 }
1434 break;
1435
1436 case 2: // Duotone
1437 if (IsFloat)
1438 Interpolation.LerpFloat = BilinearInterpFloat;
1439 else
1440 Interpolation.Lerp16 = BilinearInterp16;
1441 break;
1442
1443 case 3: // RGB et al
1444
1445 if (IsTrilinear) {
1446
1447 if (IsFloat)
1448 Interpolation.LerpFloat = TrilinearInterpFloat;
1449 else
1450 Interpolation.Lerp16 = TrilinearInterp16;
1451 }
1452 else {
1453
1454 if (IsFloat)
1455 Interpolation.LerpFloat = TetrahedralInterpFloat;
1456 else {
1457
1458 Interpolation.Lerp16 = TetrahedralInterp16;
1459 }
1460 }
1461 break;
1462
1463 case 4: // CMYK lut
1464
1465 if (IsFloat)
1466 Interpolation.LerpFloat = Eval4InputsFloat;
1467 else
1468 Interpolation.Lerp16 = Eval4Inputs;
1469 break;
1470
1471 case 5: // 5 Inks
1472 if (IsFloat)
1473 Interpolation.LerpFloat = Eval5InputsFloat;
1474 else
1475 Interpolation.Lerp16 = Eval5Inputs;
1476 break;
1477
1478 case 6: // 6 Inks
1479 if (IsFloat)
1480 Interpolation.LerpFloat = Eval6InputsFloat;
1481 else
1482 Interpolation.Lerp16 = Eval6Inputs;
1483 break;
1484
1485 case 7: // 7 inks
1486 if (IsFloat)
1487 Interpolation.LerpFloat = Eval7InputsFloat;
1488 else
1489 Interpolation.Lerp16 = Eval7Inputs;
1490 break;
1491
1492 case 8: // 8 inks
1493 if (IsFloat)
1494 Interpolation.LerpFloat = Eval8InputsFloat;
1495 else
1496 Interpolation.Lerp16 = Eval8Inputs;
1497 break;
1498
1499 break;
1500
1501 default:
1502 Interpolation.Lerp16 = NULL;
1503 }
1504
1505 return Interpolation;
1506 }
1507