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 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 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 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) || isnan(v)) ? 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 } 1507
