5d5f35d3fcf8c3578d51692b0799fddbebc765af
[openjpeg.git] / thirdparty / liblcms2 / src / cmsintrp.c
1 //---------------------------------------------------------------------------------
2 //
3 //  Little Color Management System
4 //  Copyright (c) 1998-2012 Marti Maria Saguer
5 //
6 // Permission is hereby granted, free of charge, to any person obtaining
7 // a copy of this software and associated documentation files (the "Software"),
8 // to deal in the Software without restriction, including without limitation
9 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 // and/or sell copies of the Software, and to permit persons to whom the Software
11 // is furnished to do so, subject to the following conditions:
12 //
13 // The above copyright notice and this permission notice shall be included in
14 // all copies or substantial portions of the Software.
15 //
16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
18 // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 //
24 //---------------------------------------------------------------------------------
25 //
26
27 #include "lcms2_internal.h"
28
29 // 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
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
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
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.
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
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 auxiliar 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
169 void _cmsFreeInterpParams(cmsInterpParams* p)
170 {
171     if (p != NULL) _cmsFree(p ->ContextID, p);
172 }
173
174
175 // Inline fixed point interpolation
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
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
216 cmsINLINE cmsFloat32Number fclamp(cmsFloat32Number v) 
217 {
218     return v < 0.0f ? 0.0f : (v > 1.0f ? 1.0f : v);
219 }
220
221 // Floating-point version of 1D interpolation
222 static
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 }