1 /*
   2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   3  *
   4  * This code is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 only, as
   6  * published by the Free Software Foundation.  Oracle designates this
   7  * particular file as subject to the "Classpath" exception as provided
   8  * by Oracle in the LICENSE file that accompanied this code.
   9  *
  10  * This code is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * version 2 for more details (a copy is included in the LICENSE file that
  14  * accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License version
  17  * 2 along with this work; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  21  * or visit www.oracle.com if you need additional information or have any
  22  * questions.
  23  */
  24 
  25 // This file is available under and governed by the GNU General Public
  26 // License version 2 only, as published by the Free Software Foundation.
  27 // However, the following notice accompanied the original version of this
  28 // file:
  29 //
  30 //---------------------------------------------------------------------------------
  31 //
  32 //  Little Color Management System
  33 //  Copyright (c) 1998-2017 Marti Maria Saguer
  34 //
  35 // Permission is hereby granted, free of charge, to any person obtaining
  36 // a copy of this software and associated documentation files (the "Software"),
  37 // to deal in the Software without restriction, including without limitation
  38 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
  39 // and/or sell copies of the Software, and to permit persons to whom the Software
  40 // is furnished to do so, subject to the following conditions:
  41 //
  42 // The above copyright notice and this permission notice shall be included in
  43 // all copies or substantial portions of the Software.
  44 //
  45 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  46 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  47 // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  48 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  49 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  50 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  51 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  52 //
  53 //---------------------------------------------------------------------------------
  54 //
  55 
  56 #include "lcms2_internal.h"
  57 
  58 
  59 // Link several profiles to obtain a single LUT modelling the whole color transform. Intents, Black point
  60 // compensation and Adaptation parameters may vary across profiles. BPC and Adaptation refers to the PCS
  61 // after the profile. I.e, BPC[0] refers to connexion between profile(0) and profile(1)
  62 cmsPipeline* _cmsLinkProfiles(cmsContext     ContextID,
  63                               cmsUInt32Number nProfiles,
  64                               cmsUInt32Number Intents[],
  65                               cmsHPROFILE     hProfiles[],
  66                               cmsBool         BPC[],
  67                               cmsFloat64Number AdaptationStates[],
  68                               cmsUInt32Number dwFlags);
  69 
  70 //---------------------------------------------------------------------------------
  71 
  72 // This is the default routine for ICC-style intents. A user may decide to override it by using a plugin.
  73 // Supported intents are perceptual, relative colorimetric, saturation and ICC-absolute colorimetric
  74 static
  75 cmsPipeline* DefaultICCintents(cmsContext     ContextID,
  76                                cmsUInt32Number nProfiles,
  77                                cmsUInt32Number Intents[],
  78                                cmsHPROFILE     hProfiles[],
  79                                cmsBool         BPC[],
  80                                cmsFloat64Number AdaptationStates[],
  81                                cmsUInt32Number dwFlags);
  82 
  83 //---------------------------------------------------------------------------------
  84 
  85 // This is the entry for black-preserving K-only intents, which are non-ICC. Last profile have to be a output profile
  86 // to do the trick (no devicelinks allowed at that position)
  87 static
  88 cmsPipeline*  BlackPreservingKOnlyIntents(cmsContext     ContextID,
  89                                           cmsUInt32Number nProfiles,
  90                                           cmsUInt32Number Intents[],
  91                                           cmsHPROFILE     hProfiles[],
  92                                           cmsBool         BPC[],
  93                                           cmsFloat64Number AdaptationStates[],
  94                                           cmsUInt32Number dwFlags);
  95 
  96 //---------------------------------------------------------------------------------
  97 
  98 // This is the entry for black-plane preserving, which are non-ICC. Again, Last profile have to be a output profile
  99 // to do the trick (no devicelinks allowed at that position)
 100 static
 101 cmsPipeline*  BlackPreservingKPlaneIntents(cmsContext     ContextID,
 102                                            cmsUInt32Number nProfiles,
 103                                            cmsUInt32Number Intents[],
 104                                            cmsHPROFILE     hProfiles[],
 105                                            cmsBool         BPC[],
 106                                            cmsFloat64Number AdaptationStates[],
 107                                            cmsUInt32Number dwFlags);
 108 
 109 //---------------------------------------------------------------------------------
 110 
 111 
 112 // This is a structure holding implementations for all supported intents.
 113 typedef struct _cms_intents_list {
 114 
 115     cmsUInt32Number Intent;
 116     char            Description[256];
 117     cmsIntentFn     Link;
 118     struct _cms_intents_list*  Next;
 119 
 120 } cmsIntentsList;
 121 
 122 
 123 // Built-in intents
 124 static cmsIntentsList DefaultIntents[] = {
 125 
 126     { INTENT_PERCEPTUAL,                            "Perceptual",                                   DefaultICCintents,            &DefaultIntents[1] },
 127     { INTENT_RELATIVE_COLORIMETRIC,                 "Relative colorimetric",                        DefaultICCintents,            &DefaultIntents[2] },
 128     { INTENT_SATURATION,                            "Saturation",                                   DefaultICCintents,            &DefaultIntents[3] },
 129     { INTENT_ABSOLUTE_COLORIMETRIC,                 "Absolute colorimetric",                        DefaultICCintents,            &DefaultIntents[4] },
 130     { INTENT_PRESERVE_K_ONLY_PERCEPTUAL,            "Perceptual preserving black ink",              BlackPreservingKOnlyIntents,  &DefaultIntents[5] },
 131     { INTENT_PRESERVE_K_ONLY_RELATIVE_COLORIMETRIC, "Relative colorimetric preserving black ink",   BlackPreservingKOnlyIntents,  &DefaultIntents[6] },
 132     { INTENT_PRESERVE_K_ONLY_SATURATION,            "Saturation preserving black ink",              BlackPreservingKOnlyIntents,  &DefaultIntents[7] },
 133     { INTENT_PRESERVE_K_PLANE_PERCEPTUAL,           "Perceptual preserving black plane",            BlackPreservingKPlaneIntents, &DefaultIntents[8] },
 134     { INTENT_PRESERVE_K_PLANE_RELATIVE_COLORIMETRIC,"Relative colorimetric preserving black plane", BlackPreservingKPlaneIntents, &DefaultIntents[9] },
 135     { INTENT_PRESERVE_K_PLANE_SATURATION,           "Saturation preserving black plane",            BlackPreservingKPlaneIntents, NULL }
 136 };
 137 
 138 
 139 // A pointer to the beginning of the list
 140 _cmsIntentsPluginChunkType _cmsIntentsPluginChunk = { NULL };
 141 
 142 // Duplicates the zone of memory used by the plug-in in the new context
 143 static
 144 void DupPluginIntentsList(struct _cmsContext_struct* ctx,
 145                                                const struct _cmsContext_struct* src)
 146 {
 147    _cmsIntentsPluginChunkType newHead = { NULL };
 148    cmsIntentsList*  entry;
 149    cmsIntentsList*  Anterior = NULL;
 150    _cmsIntentsPluginChunkType* head = (_cmsIntentsPluginChunkType*) src->chunks[IntentPlugin];
 151 
 152     // Walk the list copying all nodes
 153    for (entry = head->Intents;
 154         entry != NULL;
 155         entry = entry ->Next) {
 156 
 157             cmsIntentsList *newEntry = ( cmsIntentsList *) _cmsSubAllocDup(ctx ->MemPool, entry, sizeof(cmsIntentsList));
 158 
 159             if (newEntry == NULL)
 160                 return;
 161 
 162             // We want to keep the linked list order, so this is a little bit tricky
 163             newEntry -> Next = NULL;
 164             if (Anterior)
 165                 Anterior -> Next = newEntry;
 166 
 167             Anterior = newEntry;
 168 
 169             if (newHead.Intents == NULL)
 170                 newHead.Intents = newEntry;
 171     }
 172 
 173   ctx ->chunks[IntentPlugin] = _cmsSubAllocDup(ctx->MemPool, &newHead, sizeof(_cmsIntentsPluginChunkType));
 174 }
 175 
 176 void  _cmsAllocIntentsPluginChunk(struct _cmsContext_struct* ctx,
 177                                          const struct _cmsContext_struct* src)
 178 {
 179     if (src != NULL) {
 180 
 181         // Copy all linked list
 182         DupPluginIntentsList(ctx, src);
 183     }
 184     else {
 185         static _cmsIntentsPluginChunkType IntentsPluginChunkType = { NULL };
 186         ctx ->chunks[IntentPlugin] = _cmsSubAllocDup(ctx ->MemPool, &IntentsPluginChunkType, sizeof(_cmsIntentsPluginChunkType));
 187     }
 188 }
 189 
 190 
 191 // Search the list for a suitable intent. Returns NULL if not found
 192 static
 193 cmsIntentsList* SearchIntent(cmsContext ContextID, cmsUInt32Number Intent)
 194 {
 195     _cmsIntentsPluginChunkType* ctx = ( _cmsIntentsPluginChunkType*) _cmsContextGetClientChunk(ContextID, IntentPlugin);
 196     cmsIntentsList* pt;
 197 
 198     for (pt = ctx -> Intents; pt != NULL; pt = pt -> Next)
 199         if (pt ->Intent == Intent) return pt;
 200 
 201     for (pt = DefaultIntents; pt != NULL; pt = pt -> Next)
 202         if (pt ->Intent == Intent) return pt;
 203 
 204     return NULL;
 205 }
 206 
 207 // Black point compensation. Implemented as a linear scaling in XYZ. Black points
 208 // should come relative to the white point. Fills an matrix/offset element m
 209 // which is organized as a 4x4 matrix.
 210 static
 211 void ComputeBlackPointCompensation(const cmsCIEXYZ* BlackPointIn,
 212                                    const cmsCIEXYZ* BlackPointOut,
 213                                    cmsMAT3* m, cmsVEC3* off)
 214 {
 215   cmsFloat64Number ax, ay, az, bx, by, bz, tx, ty, tz;
 216 
 217    // Now we need to compute a matrix plus an offset m and of such of
 218    // [m]*bpin + off = bpout
 219    // [m]*D50  + off = D50
 220    //
 221    // This is a linear scaling in the form ax+b, where
 222    // a = (bpout - D50) / (bpin - D50)
 223    // b = - D50* (bpout - bpin) / (bpin - D50)
 224 
 225    tx = BlackPointIn->X - cmsD50_XYZ()->X;
 226    ty = BlackPointIn->Y - cmsD50_XYZ()->Y;
 227    tz = BlackPointIn->Z - cmsD50_XYZ()->Z;
 228 
 229    ax = (BlackPointOut->X - cmsD50_XYZ()->X) / tx;
 230    ay = (BlackPointOut->Y - cmsD50_XYZ()->Y) / ty;
 231    az = (BlackPointOut->Z - cmsD50_XYZ()->Z) / tz;
 232 
 233    bx = - cmsD50_XYZ()-> X * (BlackPointOut->X - BlackPointIn->X) / tx;
 234    by = - cmsD50_XYZ()-> Y * (BlackPointOut->Y - BlackPointIn->Y) / ty;
 235    bz = - cmsD50_XYZ()-> Z * (BlackPointOut->Z - BlackPointIn->Z) / tz;
 236 
 237    _cmsVEC3init(&m ->v[0], ax, 0,  0);
 238    _cmsVEC3init(&m ->v[1], 0, ay,  0);
 239    _cmsVEC3init(&m ->v[2], 0,  0,  az);
 240    _cmsVEC3init(off, bx, by, bz);
 241 
 242 }
 243 
 244 
 245 // Approximate a blackbody illuminant based on CHAD information
 246 static
 247 cmsFloat64Number CHAD2Temp(const cmsMAT3* Chad)
 248 {
 249     // Convert D50 across inverse CHAD to get the absolute white point
 250     cmsVEC3 d, s;
 251     cmsCIEXYZ Dest;
 252     cmsCIExyY DestChromaticity;
 253     cmsFloat64Number TempK;
 254     cmsMAT3 m1, m2;
 255 
 256     m1 = *Chad;
 257     if (!_cmsMAT3inverse(&m1, &m2)) return FALSE;
 258 
 259     s.n[VX] = cmsD50_XYZ() -> X;
 260     s.n[VY] = cmsD50_XYZ() -> Y;
 261     s.n[VZ] = cmsD50_XYZ() -> Z;
 262 
 263     _cmsMAT3eval(&d, &m2, &s);
 264 
 265     Dest.X = d.n[VX];
 266     Dest.Y = d.n[VY];
 267     Dest.Z = d.n[VZ];
 268 
 269     cmsXYZ2xyY(&DestChromaticity, &Dest);
 270 
 271     if (!cmsTempFromWhitePoint(&TempK, &DestChromaticity))
 272         return -1.0;
 273 
 274     return TempK;
 275 }
 276 
 277 // Compute a CHAD based on a given temperature
 278 static
 279     void Temp2CHAD(cmsMAT3* Chad, cmsFloat64Number Temp)
 280 {
 281     cmsCIEXYZ White;
 282     cmsCIExyY ChromaticityOfWhite;
 283 
 284     cmsWhitePointFromTemp(&ChromaticityOfWhite, Temp);
 285     cmsxyY2XYZ(&White, &ChromaticityOfWhite);
 286     _cmsAdaptationMatrix(Chad, NULL, &White, cmsD50_XYZ());
 287 }
 288 
 289 // Join scalings to obtain relative input to absolute and then to relative output.
 290 // Result is stored in a 3x3 matrix
 291 static
 292 cmsBool  ComputeAbsoluteIntent(cmsFloat64Number AdaptationState,
 293                                const cmsCIEXYZ* WhitePointIn,
 294                                const cmsMAT3* ChromaticAdaptationMatrixIn,
 295                                const cmsCIEXYZ* WhitePointOut,
 296                                const cmsMAT3* ChromaticAdaptationMatrixOut,
 297                                cmsMAT3* m)
 298 {
 299     cmsMAT3 Scale, m1, m2, m3, m4;
 300 
 301     // TODO: Follow Marc Mahy's recommendation to check if CHAD is same by using M1*M2 == M2*M1. If so, do nothing.
 302     // TODO: Add support for ArgyllArts tag
 303 
 304     // Adaptation state
 305     if (AdaptationState == 1.0) {
 306 
 307         // Observer is fully adapted. Keep chromatic adaptation.
 308         // That is the standard V4 behaviour
 309         _cmsVEC3init(&m->v[0], WhitePointIn->X / WhitePointOut->X, 0, 0);
 310         _cmsVEC3init(&m->v[1], 0, WhitePointIn->Y / WhitePointOut->Y, 0);
 311         _cmsVEC3init(&m->v[2], 0, 0, WhitePointIn->Z / WhitePointOut->Z);
 312 
 313     }
 314     else  {
 315 
 316         // Incomplete adaptation. This is an advanced feature.
 317         _cmsVEC3init(&Scale.v[0], WhitePointIn->X / WhitePointOut->X, 0, 0);
 318         _cmsVEC3init(&Scale.v[1], 0,  WhitePointIn->Y / WhitePointOut->Y, 0);
 319         _cmsVEC3init(&Scale.v[2], 0, 0,  WhitePointIn->Z / WhitePointOut->Z);
 320 
 321 
 322         if (AdaptationState == 0.0) {
 323 
 324             m1 = *ChromaticAdaptationMatrixOut;
 325             _cmsMAT3per(&m2, &m1, &Scale);
 326             // m2 holds CHAD from output white to D50 times abs. col. scaling
 327 
 328             // Observer is not adapted, undo the chromatic adaptation
 329             _cmsMAT3per(m, &m2, ChromaticAdaptationMatrixOut);
 330 
 331             m3 = *ChromaticAdaptationMatrixIn;
 332             if (!_cmsMAT3inverse(&m3, &m4)) return FALSE;
 333             _cmsMAT3per(m, &m2, &m4);
 334 
 335         } else {
 336 
 337             cmsMAT3 MixedCHAD;
 338             cmsFloat64Number TempSrc, TempDest, Temp;
 339 
 340             m1 = *ChromaticAdaptationMatrixIn;
 341             if (!_cmsMAT3inverse(&m1, &m2)) return FALSE;
 342             _cmsMAT3per(&m3, &m2, &Scale);
 343             // m3 holds CHAD from input white to D50 times abs. col. scaling
 344 
 345             TempSrc  = CHAD2Temp(ChromaticAdaptationMatrixIn);
 346             TempDest = CHAD2Temp(ChromaticAdaptationMatrixOut);
 347 
 348             if (TempSrc < 0.0 || TempDest < 0.0) return FALSE; // Something went wrong
 349 
 350             if (_cmsMAT3isIdentity(&Scale) && fabs(TempSrc - TempDest) < 0.01) {
 351 
 352                 _cmsMAT3identity(m);
 353                 return TRUE;
 354             }
 355 
 356             Temp = (1.0 - AdaptationState) * TempDest + AdaptationState * TempSrc;
 357 
 358             // Get a CHAD from whatever output temperature to D50. This replaces output CHAD
 359             Temp2CHAD(&MixedCHAD, Temp);
 360 
 361             _cmsMAT3per(m, &m3, &MixedCHAD);
 362         }
 363 
 364     }
 365     return TRUE;
 366 
 367 }
 368 
 369 // Just to see if m matrix should be applied
 370 static
 371 cmsBool IsEmptyLayer(cmsMAT3* m, cmsVEC3* off)
 372 {
 373     cmsFloat64Number diff = 0;
 374     cmsMAT3 Ident;
 375     int i;
 376 
 377     if (m == NULL && off == NULL) return TRUE;  // NULL is allowed as an empty layer
 378     if (m == NULL && off != NULL) return FALSE; // This is an internal error
 379 
 380     _cmsMAT3identity(&Ident);
 381 
 382     for (i=0; i < 3*3; i++)
 383         diff += fabs(((cmsFloat64Number*)m)[i] - ((cmsFloat64Number*)&Ident)[i]);
 384 
 385     for (i=0; i < 3; i++)
 386         diff += fabs(((cmsFloat64Number*)off)[i]);
 387 
 388 
 389     return (diff < 0.002);
 390 }
 391 
 392 
 393 // Compute the conversion layer
 394 static
 395 cmsBool ComputeConversion(cmsUInt32Number i,
 396                           cmsHPROFILE hProfiles[],
 397                           cmsUInt32Number Intent,
 398                           cmsBool BPC,
 399                           cmsFloat64Number AdaptationState,
 400                           cmsMAT3* m, cmsVEC3* off)
 401 {
 402 
 403     int k;
 404 
 405     // m  and off are set to identity and this is detected latter on
 406     _cmsMAT3identity(m);
 407     _cmsVEC3init(off, 0, 0, 0);
 408 
 409     // If intent is abs. colorimetric,
 410     if (Intent == INTENT_ABSOLUTE_COLORIMETRIC) {
 411 
 412         cmsCIEXYZ WhitePointIn, WhitePointOut;
 413         cmsMAT3 ChromaticAdaptationMatrixIn, ChromaticAdaptationMatrixOut;
 414 
 415         _cmsReadMediaWhitePoint(&WhitePointIn,  hProfiles[i-1]);
 416         _cmsReadCHAD(&ChromaticAdaptationMatrixIn, hProfiles[i-1]);
 417 
 418         _cmsReadMediaWhitePoint(&WhitePointOut,  hProfiles[i]);
 419         _cmsReadCHAD(&ChromaticAdaptationMatrixOut, hProfiles[i]);
 420 
 421         if (!ComputeAbsoluteIntent(AdaptationState,
 422                                   &WhitePointIn,  &ChromaticAdaptationMatrixIn,
 423                                   &WhitePointOut, &ChromaticAdaptationMatrixOut, m)) return FALSE;
 424 
 425     }
 426     else {
 427         // Rest of intents may apply BPC.
 428 
 429         if (BPC) {
 430 
 431             cmsCIEXYZ BlackPointIn, BlackPointOut;
 432 
 433             cmsDetectBlackPoint(&BlackPointIn,  hProfiles[i-1], Intent, 0);
 434             cmsDetectDestinationBlackPoint(&BlackPointOut, hProfiles[i], Intent, 0);
 435 
 436             // If black points are equal, then do nothing
 437             if (BlackPointIn.X != BlackPointOut.X ||
 438                 BlackPointIn.Y != BlackPointOut.Y ||
 439                 BlackPointIn.Z != BlackPointOut.Z)
 440                     ComputeBlackPointCompensation(&BlackPointIn, &BlackPointOut, m, off);
 441         }
 442     }
 443 
 444     // Offset should be adjusted because the encoding. We encode XYZ normalized to 0..1.0,
 445     // to do that, we divide by MAX_ENCODEABLE_XZY. The conversion stage goes XYZ -> XYZ so
 446     // we have first to convert from encoded to XYZ and then convert back to encoded.
 447     // y = Mx + Off
 448     // x = x'c
 449     // y = M x'c + Off
 450     // y = y'c; y' = y / c
 451     // y' = (Mx'c + Off) /c = Mx' + (Off / c)
 452 
 453     for (k=0; k < 3; k++) {
 454         off ->n[k] /= MAX_ENCODEABLE_XYZ;
 455     }
 456 
 457     return TRUE;
 458 }
 459 
 460 
 461 // Add a conversion stage if needed. If a matrix/offset m is given, it applies to XYZ space
 462 static
 463 cmsBool AddConversion(cmsPipeline* Result, cmsColorSpaceSignature InPCS, cmsColorSpaceSignature OutPCS, cmsMAT3* m, cmsVEC3* off)
 464 {
 465     cmsFloat64Number* m_as_dbl = (cmsFloat64Number*) m;
 466     cmsFloat64Number* off_as_dbl = (cmsFloat64Number*) off;
 467 
 468     // Handle PCS mismatches. A specialized stage is added to the LUT in such case
 469     switch (InPCS) {
 470 
 471     case cmsSigXYZData: // Input profile operates in XYZ
 472 
 473         switch (OutPCS) {
 474 
 475         case cmsSigXYZData:  // XYZ -> XYZ
 476             if (!IsEmptyLayer(m, off) &&
 477                 !cmsPipelineInsertStage(Result, cmsAT_END, cmsStageAllocMatrix(Result ->ContextID, 3, 3, m_as_dbl, off_as_dbl)))
 478                 return FALSE;
 479             break;
 480 
 481         case cmsSigLabData:  // XYZ -> Lab
 482             if (!IsEmptyLayer(m, off) &&
 483                 !cmsPipelineInsertStage(Result, cmsAT_END, cmsStageAllocMatrix(Result ->ContextID, 3, 3, m_as_dbl, off_as_dbl)))
 484                 return FALSE;
 485             if (!cmsPipelineInsertStage(Result, cmsAT_END, _cmsStageAllocXYZ2Lab(Result ->ContextID)))
 486                 return FALSE;
 487             break;
 488 
 489         default:
 490             return FALSE;   // Colorspace mismatch
 491         }
 492         break;
 493 
 494     case cmsSigLabData: // Input profile operates in Lab
 495 
 496         switch (OutPCS) {
 497 
 498         case cmsSigXYZData:  // Lab -> XYZ
 499 
 500             if (!cmsPipelineInsertStage(Result, cmsAT_END, _cmsStageAllocLab2XYZ(Result ->ContextID)))
 501                 return FALSE;
 502             if (!IsEmptyLayer(m, off) &&
 503                 !cmsPipelineInsertStage(Result, cmsAT_END, cmsStageAllocMatrix(Result ->ContextID, 3, 3, m_as_dbl, off_as_dbl)))
 504                 return FALSE;
 505             break;
 506 
 507         case cmsSigLabData:  // Lab -> Lab
 508 
 509             if (!IsEmptyLayer(m, off)) {
 510                 if (!cmsPipelineInsertStage(Result, cmsAT_END, _cmsStageAllocLab2XYZ(Result ->ContextID)) ||
 511                     !cmsPipelineInsertStage(Result, cmsAT_END, cmsStageAllocMatrix(Result ->ContextID, 3, 3, m_as_dbl, off_as_dbl)) ||
 512                     !cmsPipelineInsertStage(Result, cmsAT_END, _cmsStageAllocXYZ2Lab(Result ->ContextID)))
 513                     return FALSE;
 514             }
 515             break;
 516 
 517         default:
 518             return FALSE;  // Mismatch
 519         }
 520         break;
 521 
 522         // On colorspaces other than PCS, check for same space
 523     default:
 524         if (InPCS != OutPCS) return FALSE;
 525         break;
 526     }
 527 
 528     return TRUE;
 529 }
 530 
 531 
 532 // Is a given space compatible with another?
 533 static
 534 cmsBool ColorSpaceIsCompatible(cmsColorSpaceSignature a, cmsColorSpaceSignature b)
 535 {
 536     // If they are same, they are compatible.
 537     if (a == b) return TRUE;
 538 
 539     // Check for MCH4 substitution of CMYK
 540     if ((a == cmsSig4colorData) && (b == cmsSigCmykData)) return TRUE;
 541     if ((a == cmsSigCmykData) && (b == cmsSig4colorData)) return TRUE;
 542 
 543     // Check for XYZ/Lab. Those spaces are interchangeable as they can be computed one from other.
 544     if ((a == cmsSigXYZData) && (b == cmsSigLabData)) return TRUE;
 545     if ((a == cmsSigLabData) && (b == cmsSigXYZData)) return TRUE;
 546 
 547     return FALSE;
 548 }
 549 
 550 
 551 // Default handler for ICC-style intents
 552 static
 553 cmsPipeline* DefaultICCintents(cmsContext       ContextID,
 554                                cmsUInt32Number  nProfiles,
 555                                cmsUInt32Number  TheIntents[],
 556                                cmsHPROFILE      hProfiles[],
 557                                cmsBool          BPC[],
 558                                cmsFloat64Number AdaptationStates[],
 559                                cmsUInt32Number  dwFlags)
 560 {
 561     cmsPipeline* Lut = NULL;
 562     cmsPipeline* Result;
 563     cmsHPROFILE hProfile;
 564     cmsMAT3 m;
 565     cmsVEC3 off;
 566     cmsColorSpaceSignature ColorSpaceIn, ColorSpaceOut = cmsSigLabData, CurrentColorSpace;
 567     cmsProfileClassSignature ClassSig;
 568     cmsUInt32Number  i, Intent;
 569 
 570     // For safety
 571     if (nProfiles == 0) return NULL;
 572 
 573     // Allocate an empty LUT for holding the result. 0 as channel count means 'undefined'
 574     Result = cmsPipelineAlloc(ContextID, 0, 0);
 575     if (Result == NULL) return NULL;
 576 
 577     CurrentColorSpace = cmsGetColorSpace(hProfiles[0]);
 578 
 579     for (i=0; i < nProfiles; i++) {
 580 
 581         cmsBool  lIsDeviceLink, lIsInput;
 582 
 583         hProfile      = hProfiles[i];
 584         ClassSig      = cmsGetDeviceClass(hProfile);
 585         lIsDeviceLink = (ClassSig == cmsSigLinkClass || ClassSig == cmsSigAbstractClass );
 586 
 587         // First profile is used as input unless devicelink or abstract
 588         if ((i == 0) && !lIsDeviceLink) {
 589             lIsInput = TRUE;
 590         }
 591         else {
 592           // Else use profile in the input direction if current space is not PCS
 593         lIsInput      = (CurrentColorSpace != cmsSigXYZData) &&
 594                         (CurrentColorSpace != cmsSigLabData);
 595         }
 596 
 597         Intent        = TheIntents[i];
 598 
 599         if (lIsInput || lIsDeviceLink) {
 600 
 601             ColorSpaceIn    = cmsGetColorSpace(hProfile);
 602             ColorSpaceOut   = cmsGetPCS(hProfile);
 603         }
 604         else {
 605 
 606             ColorSpaceIn    = cmsGetPCS(hProfile);
 607             ColorSpaceOut   = cmsGetColorSpace(hProfile);
 608         }
 609 
 610         if (!ColorSpaceIsCompatible(ColorSpaceIn, CurrentColorSpace)) {
 611 
 612             cmsSignalError(ContextID, cmsERROR_COLORSPACE_CHECK, "ColorSpace mismatch");
 613             goto Error;
 614         }
 615 
 616         // If devicelink is found, then no custom intent is allowed and we can
 617         // read the LUT to be applied. Settings don't apply here.
 618         if (lIsDeviceLink || ((ClassSig == cmsSigNamedColorClass) && (nProfiles == 1))) {
 619 
 620             // Get the involved LUT from the profile
 621             Lut = _cmsReadDevicelinkLUT(hProfile, Intent);
 622             if (Lut == NULL) goto Error;
 623 
 624             // What about abstract profiles?
 625              if (ClassSig == cmsSigAbstractClass && i > 0) {
 626                 if (!ComputeConversion(i, hProfiles, Intent, BPC[i], AdaptationStates[i], &m, &off)) goto Error;
 627              }
 628              else {
 629                 _cmsMAT3identity(&m);
 630                 _cmsVEC3init(&off, 0, 0, 0);
 631              }
 632 
 633 
 634             if (!AddConversion(Result, CurrentColorSpace, ColorSpaceIn, &m, &off)) goto Error;
 635 
 636         }
 637         else {
 638 
 639             if (lIsInput) {
 640                 // Input direction means non-pcs connection, so proceed like devicelinks
 641                 Lut = _cmsReadInputLUT(hProfile, Intent);
 642                 if (Lut == NULL) goto Error;
 643             }
 644             else {
 645 
 646                 // Output direction means PCS connection. Intent may apply here
 647                 Lut = _cmsReadOutputLUT(hProfile, Intent);
 648                 if (Lut == NULL) goto Error;
 649 
 650 
 651                 if (!ComputeConversion(i, hProfiles, Intent, BPC[i], AdaptationStates[i], &m, &off)) goto Error;
 652                 if (!AddConversion(Result, CurrentColorSpace, ColorSpaceIn, &m, &off)) goto Error;
 653 
 654             }
 655         }
 656 
 657         // Concatenate to the output LUT
 658         if (!cmsPipelineCat(Result, Lut))
 659             goto Error;
 660 
 661         cmsPipelineFree(Lut);
 662         Lut = NULL;
 663 
 664         // Update current space
 665         CurrentColorSpace = ColorSpaceOut;
 666     }
 667 
 668     // Check for non-negatives clip
 669     if (dwFlags & cmsFLAGS_NONEGATIVES) {
 670 
 671            if (ColorSpaceOut == cmsSigGrayData ||
 672                   ColorSpaceOut == cmsSigRgbData ||
 673                   ColorSpaceOut == cmsSigCmykData) {
 674 
 675                   cmsStage* clip = _cmsStageClipNegatives(Result->ContextID, cmsChannelsOf(ColorSpaceOut));
 676                   if (clip == NULL) goto Error;
 677 
 678                   if (!cmsPipelineInsertStage(Result, cmsAT_END, clip))
 679                          goto Error;
 680            }
 681 
 682     }
 683 
 684     return Result;
 685 
 686 Error:
 687 
 688     if (Lut != NULL) cmsPipelineFree(Lut);
 689     if (Result != NULL) cmsPipelineFree(Result);
 690     return NULL;
 691 
 692     cmsUNUSED_PARAMETER(dwFlags);
 693 }
 694 
 695 
 696 // Wrapper for DLL calling convention
 697 cmsPipeline*  CMSEXPORT _cmsDefaultICCintents(cmsContext     ContextID,
 698                                               cmsUInt32Number nProfiles,
 699                                               cmsUInt32Number TheIntents[],
 700                                               cmsHPROFILE     hProfiles[],
 701                                               cmsBool         BPC[],
 702                                               cmsFloat64Number AdaptationStates[],
 703                                               cmsUInt32Number dwFlags)
 704 {
 705     return DefaultICCintents(ContextID, nProfiles, TheIntents, hProfiles, BPC, AdaptationStates, dwFlags);
 706 }
 707 
 708 // Black preserving intents ---------------------------------------------------------------------------------------------
 709 
 710 // Translate black-preserving intents to ICC ones
 711 static
 712 cmsUInt32Number TranslateNonICCIntents(cmsUInt32Number Intent)
 713 {
 714     switch (Intent) {
 715         case INTENT_PRESERVE_K_ONLY_PERCEPTUAL:
 716         case INTENT_PRESERVE_K_PLANE_PERCEPTUAL:
 717             return INTENT_PERCEPTUAL;
 718 
 719         case INTENT_PRESERVE_K_ONLY_RELATIVE_COLORIMETRIC:
 720         case INTENT_PRESERVE_K_PLANE_RELATIVE_COLORIMETRIC:
 721             return INTENT_RELATIVE_COLORIMETRIC;
 722 
 723         case INTENT_PRESERVE_K_ONLY_SATURATION:
 724         case INTENT_PRESERVE_K_PLANE_SATURATION:
 725             return INTENT_SATURATION;
 726 
 727         default: return Intent;
 728     }
 729 }
 730 
 731 // Sampler for Black-only preserving CMYK->CMYK transforms
 732 
 733 typedef struct {
 734     cmsPipeline*    cmyk2cmyk;      // The original transform
 735     cmsToneCurve*   KTone;          // Black-to-black tone curve
 736 
 737 } GrayOnlyParams;
 738 
 739 
 740 // Preserve black only if that is the only ink used
 741 static
 742 int BlackPreservingGrayOnlySampler(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register void* Cargo)
 743 {
 744     GrayOnlyParams* bp = (GrayOnlyParams*) Cargo;
 745 
 746     // If going across black only, keep black only
 747     if (In[0] == 0 && In[1] == 0 && In[2] == 0) {
 748 
 749         // TAC does not apply because it is black ink!
 750         Out[0] = Out[1] = Out[2] = 0;
 751         Out[3] = cmsEvalToneCurve16(bp->KTone, In[3]);
 752         return TRUE;
 753     }
 754 
 755     // Keep normal transform for other colors
 756     bp ->cmyk2cmyk ->Eval16Fn(In, Out, bp ->cmyk2cmyk->Data);
 757     return TRUE;
 758 }
 759 
 760 // This is the entry for black-preserving K-only intents, which are non-ICC
 761 static
 762 cmsPipeline*  BlackPreservingKOnlyIntents(cmsContext     ContextID,
 763                                           cmsUInt32Number nProfiles,
 764                                           cmsUInt32Number TheIntents[],
 765                                           cmsHPROFILE     hProfiles[],
 766                                           cmsBool         BPC[],
 767                                           cmsFloat64Number AdaptationStates[],
 768                                           cmsUInt32Number dwFlags)
 769 {
 770     GrayOnlyParams  bp;
 771     cmsPipeline*    Result;
 772     cmsUInt32Number ICCIntents[256];
 773     cmsStage*         CLUT;
 774     cmsUInt32Number i, nGridPoints;
 775 
 776 
 777     // Sanity check
 778     if (nProfiles < 1 || nProfiles > 255) return NULL;
 779 
 780     // Translate black-preserving intents to ICC ones
 781     for (i=0; i < nProfiles; i++)
 782         ICCIntents[i] = TranslateNonICCIntents(TheIntents[i]);
 783 
 784     // Check for non-cmyk profiles
 785     if (cmsGetColorSpace(hProfiles[0]) != cmsSigCmykData ||
 786         cmsGetColorSpace(hProfiles[nProfiles-1]) != cmsSigCmykData)
 787            return DefaultICCintents(ContextID, nProfiles, ICCIntents, hProfiles, BPC, AdaptationStates, dwFlags);
 788 
 789     memset(&bp, 0, sizeof(bp));
 790 
 791     // Allocate an empty LUT for holding the result
 792     Result = cmsPipelineAlloc(ContextID, 4, 4);
 793     if (Result == NULL) return NULL;
 794 
 795     // Create a LUT holding normal ICC transform
 796     bp.cmyk2cmyk = DefaultICCintents(ContextID,
 797         nProfiles,
 798         ICCIntents,
 799         hProfiles,
 800         BPC,
 801         AdaptationStates,
 802         dwFlags);
 803 
 804     if (bp.cmyk2cmyk == NULL) goto Error;
 805 
 806     // Now, compute the tone curve
 807     bp.KTone = _cmsBuildKToneCurve(ContextID,
 808         4096,
 809         nProfiles,
 810         ICCIntents,
 811         hProfiles,
 812         BPC,
 813         AdaptationStates,
 814         dwFlags);
 815 
 816     if (bp.KTone == NULL) goto Error;
 817 
 818 
 819     // How many gridpoints are we going to use?
 820     nGridPoints = _cmsReasonableGridpointsByColorspace(cmsSigCmykData, dwFlags);
 821 
 822     // Create the CLUT. 16 bits
 823     CLUT = cmsStageAllocCLut16bit(ContextID, nGridPoints, 4, 4, NULL);
 824     if (CLUT == NULL) goto Error;
 825 
 826     // This is the one and only MPE in this LUT
 827     if (!cmsPipelineInsertStage(Result, cmsAT_BEGIN, CLUT))
 828         goto Error;
 829 
 830     // Sample it. We cannot afford pre/post linearization this time.
 831     if (!cmsStageSampleCLut16bit(CLUT, BlackPreservingGrayOnlySampler, (void*) &bp, 0))
 832         goto Error;
 833 
 834     // Get rid of xform and tone curve
 835     cmsPipelineFree(bp.cmyk2cmyk);
 836     cmsFreeToneCurve(bp.KTone);
 837 
 838     return Result;
 839 
 840 Error:
 841 
 842     if (bp.cmyk2cmyk != NULL) cmsPipelineFree(bp.cmyk2cmyk);
 843     if (bp.KTone != NULL)  cmsFreeToneCurve(bp.KTone);
 844     if (Result != NULL) cmsPipelineFree(Result);
 845     return NULL;
 846 
 847 }
 848 
 849 // K Plane-preserving CMYK to CMYK ------------------------------------------------------------------------------------
 850 
 851 typedef struct {
 852 
 853     cmsPipeline*     cmyk2cmyk;     // The original transform
 854     cmsHTRANSFORM    hProofOutput;  // Output CMYK to Lab (last profile)
 855     cmsHTRANSFORM    cmyk2Lab;      // The input chain
 856     cmsToneCurve*    KTone;         // Black-to-black tone curve
 857     cmsPipeline*     LabK2cmyk;     // The output profile
 858     cmsFloat64Number MaxError;
 859 
 860     cmsHTRANSFORM    hRoundTrip;
 861     cmsFloat64Number MaxTAC;
 862 
 863 
 864 } PreserveKPlaneParams;
 865 
 866 
 867 // The CLUT will be stored at 16 bits, but calculations are performed at cmsFloat32Number precision
 868 static
 869 int BlackPreservingSampler(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register void* Cargo)
 870 {
 871     int i;
 872     cmsFloat32Number Inf[4], Outf[4];
 873     cmsFloat32Number LabK[4];
 874     cmsFloat64Number SumCMY, SumCMYK, Error, Ratio;
 875     cmsCIELab ColorimetricLab, BlackPreservingLab;
 876     PreserveKPlaneParams* bp = (PreserveKPlaneParams*) Cargo;
 877 
 878     // Convert from 16 bits to floating point
 879     for (i=0; i < 4; i++)
 880         Inf[i] = (cmsFloat32Number) (In[i] / 65535.0);
 881 
 882     // Get the K across Tone curve
 883     LabK[3] = cmsEvalToneCurveFloat(bp ->KTone, Inf[3]);
 884 
 885     // If going across black only, keep black only
 886     if (In[0] == 0 && In[1] == 0 && In[2] == 0) {
 887 
 888         Out[0] = Out[1] = Out[2] = 0;
 889         Out[3] = _cmsQuickSaturateWord(LabK[3] * 65535.0);
 890         return TRUE;
 891     }
 892 
 893     // Try the original transform,
 894     cmsPipelineEvalFloat( Inf, Outf, bp ->cmyk2cmyk);
 895 
 896     // Store a copy of the floating point result into 16-bit
 897     for (i=0; i < 4; i++)
 898             Out[i] = _cmsQuickSaturateWord(Outf[i] * 65535.0);
 899 
 900     // Maybe K is already ok (mostly on K=0)
 901     if ( fabs(Outf[3] - LabK[3]) < (3.0 / 65535.0) ) {
 902         return TRUE;
 903     }
 904 
 905     // K differ, mesure and keep Lab measurement for further usage
 906     // this is done in relative colorimetric intent
 907     cmsDoTransform(bp->hProofOutput, Out, &ColorimetricLab, 1);
 908 
 909     // Is not black only and the transform doesn't keep black.
 910     // Obtain the Lab of output CMYK. After that we have Lab + K
 911     cmsDoTransform(bp ->cmyk2Lab, Outf, LabK, 1);
 912 
 913     // Obtain the corresponding CMY using reverse interpolation
 914     // (K is fixed in LabK[3])
 915     if (!cmsPipelineEvalReverseFloat(LabK, Outf, Outf, bp ->LabK2cmyk)) {
 916 
 917         // Cannot find a suitable value, so use colorimetric xform
 918         // which is already stored in Out[]
 919         return TRUE;
 920     }
 921 
 922     // Make sure to pass through K (which now is fixed)
 923     Outf[3] = LabK[3];
 924 
 925     // Apply TAC if needed
 926     SumCMY   = Outf[0]  + Outf[1] + Outf[2];
 927     SumCMYK  = SumCMY + Outf[3];
 928 
 929     if (SumCMYK > bp ->MaxTAC) {
 930 
 931         Ratio = 1 - ((SumCMYK - bp->MaxTAC) / SumCMY);
 932         if (Ratio < 0)
 933             Ratio = 0;
 934     }
 935     else
 936        Ratio = 1.0;
 937 
 938     Out[0] = _cmsQuickSaturateWord(Outf[0] * Ratio * 65535.0);     // C
 939     Out[1] = _cmsQuickSaturateWord(Outf[1] * Ratio * 65535.0);     // M
 940     Out[2] = _cmsQuickSaturateWord(Outf[2] * Ratio * 65535.0);     // Y
 941     Out[3] = _cmsQuickSaturateWord(Outf[3] * 65535.0);
 942 
 943     // Estimate the error (this goes 16 bits to Lab DBL)
 944     cmsDoTransform(bp->hProofOutput, Out, &BlackPreservingLab, 1);
 945     Error = cmsDeltaE(&ColorimetricLab, &BlackPreservingLab);
 946     if (Error > bp -> MaxError)
 947         bp->MaxError = Error;
 948 
 949     return TRUE;
 950 }
 951 
 952 // This is the entry for black-plane preserving, which are non-ICC
 953 static
 954 cmsPipeline* BlackPreservingKPlaneIntents(cmsContext     ContextID,
 955                                           cmsUInt32Number nProfiles,
 956                                           cmsUInt32Number TheIntents[],
 957                                           cmsHPROFILE     hProfiles[],
 958                                           cmsBool         BPC[],
 959                                           cmsFloat64Number AdaptationStates[],
 960                                           cmsUInt32Number dwFlags)
 961 {
 962     PreserveKPlaneParams bp;
 963     cmsPipeline*    Result = NULL;
 964     cmsUInt32Number ICCIntents[256];
 965     cmsStage*         CLUT;
 966     cmsUInt32Number i, nGridPoints;
 967     cmsHPROFILE hLab;
 968 
 969     // Sanity check
 970     if (nProfiles < 1 || nProfiles > 255) return NULL;
 971 
 972     // Translate black-preserving intents to ICC ones
 973     for (i=0; i < nProfiles; i++)
 974         ICCIntents[i] = TranslateNonICCIntents(TheIntents[i]);
 975 
 976     // Check for non-cmyk profiles
 977     if (cmsGetColorSpace(hProfiles[0]) != cmsSigCmykData ||
 978         !(cmsGetColorSpace(hProfiles[nProfiles-1]) == cmsSigCmykData ||
 979         cmsGetDeviceClass(hProfiles[nProfiles-1]) == cmsSigOutputClass))
 980            return  DefaultICCintents(ContextID, nProfiles, ICCIntents, hProfiles, BPC, AdaptationStates, dwFlags);
 981 
 982     // Allocate an empty LUT for holding the result
 983     Result = cmsPipelineAlloc(ContextID, 4, 4);
 984     if (Result == NULL) return NULL;
 985 
 986 
 987     memset(&bp, 0, sizeof(bp));
 988 
 989     // We need the input LUT of the last profile, assuming this one is responsible of
 990     // black generation. This LUT will be searched in inverse order.
 991     bp.LabK2cmyk = _cmsReadInputLUT(hProfiles[nProfiles-1], INTENT_RELATIVE_COLORIMETRIC);
 992     if (bp.LabK2cmyk == NULL) goto Cleanup;
 993 
 994     // Get total area coverage (in 0..1 domain)
 995     bp.MaxTAC = cmsDetectTAC(hProfiles[nProfiles-1]) / 100.0;
 996     if (bp.MaxTAC <= 0) goto Cleanup;
 997 
 998 
 999     // Create a LUT holding normal ICC transform
1000     bp.cmyk2cmyk = DefaultICCintents(ContextID,
1001                                          nProfiles,
1002                                          ICCIntents,
1003                                          hProfiles,
1004                                          BPC,
1005                                          AdaptationStates,
1006                                          dwFlags);
1007     if (bp.cmyk2cmyk == NULL) goto Cleanup;
1008 
1009     // Now the tone curve
1010     bp.KTone = _cmsBuildKToneCurve(ContextID, 4096, nProfiles,
1011                                    ICCIntents,
1012                                    hProfiles,
1013                                    BPC,
1014                                    AdaptationStates,
1015                                    dwFlags);
1016     if (bp.KTone == NULL) goto Cleanup;
1017 
1018     // To measure the output, Last profile to Lab
1019     hLab = cmsCreateLab4ProfileTHR(ContextID, NULL);
1020     bp.hProofOutput = cmsCreateTransformTHR(ContextID, hProfiles[nProfiles-1],
1021                                          CHANNELS_SH(4)|BYTES_SH(2), hLab, TYPE_Lab_DBL,
1022                                          INTENT_RELATIVE_COLORIMETRIC,
1023                                          cmsFLAGS_NOCACHE|cmsFLAGS_NOOPTIMIZE);
1024     if ( bp.hProofOutput == NULL) goto Cleanup;
1025 
1026     // Same as anterior, but lab in the 0..1 range
1027     bp.cmyk2Lab = cmsCreateTransformTHR(ContextID, hProfiles[nProfiles-1],
1028                                          FLOAT_SH(1)|CHANNELS_SH(4)|BYTES_SH(4), hLab,
1029                                          FLOAT_SH(1)|CHANNELS_SH(3)|BYTES_SH(4),
1030                                          INTENT_RELATIVE_COLORIMETRIC,
1031                                          cmsFLAGS_NOCACHE|cmsFLAGS_NOOPTIMIZE);
1032     if (bp.cmyk2Lab == NULL) goto Cleanup;
1033     cmsCloseProfile(hLab);
1034 
1035     // Error estimation (for debug only)
1036     bp.MaxError = 0;
1037 
1038     // How many gridpoints are we going to use?
1039     nGridPoints = _cmsReasonableGridpointsByColorspace(cmsSigCmykData, dwFlags);
1040 
1041 
1042     CLUT = cmsStageAllocCLut16bit(ContextID, nGridPoints, 4, 4, NULL);
1043     if (CLUT == NULL) goto Cleanup;
1044 
1045     if (!cmsPipelineInsertStage(Result, cmsAT_BEGIN, CLUT))
1046         goto Cleanup;
1047 
1048     cmsStageSampleCLut16bit(CLUT, BlackPreservingSampler, (void*) &bp, 0);
1049 
1050 Cleanup:
1051 
1052     if (bp.cmyk2cmyk) cmsPipelineFree(bp.cmyk2cmyk);
1053     if (bp.cmyk2Lab) cmsDeleteTransform(bp.cmyk2Lab);
1054     if (bp.hProofOutput) cmsDeleteTransform(bp.hProofOutput);
1055 
1056     if (bp.KTone) cmsFreeToneCurve(bp.KTone);
1057     if (bp.LabK2cmyk) cmsPipelineFree(bp.LabK2cmyk);
1058 
1059     return Result;
1060 }
1061 
1062 // Link routines ------------------------------------------------------------------------------------------------------
1063 
1064 // Chain several profiles into a single LUT. It just checks the parameters and then calls the handler
1065 // for the first intent in chain. The handler may be user-defined. Is up to the handler to deal with the
1066 // rest of intents in chain. A maximum of 255 profiles at time are supported, which is pretty reasonable.
1067 cmsPipeline* _cmsLinkProfiles(cmsContext     ContextID,
1068                               cmsUInt32Number nProfiles,
1069                               cmsUInt32Number TheIntents[],
1070                               cmsHPROFILE     hProfiles[],
1071                               cmsBool         BPC[],
1072                               cmsFloat64Number AdaptationStates[],
1073                               cmsUInt32Number dwFlags)
1074 {
1075     cmsUInt32Number i;
1076     cmsIntentsList* Intent;
1077 
1078     // Make sure a reasonable number of profiles is provided
1079     if (nProfiles <= 0 || nProfiles > 255) {
1080          cmsSignalError(ContextID, cmsERROR_RANGE, "Couldn't link '%d' profiles", nProfiles);
1081         return NULL;
1082     }
1083 
1084     for (i=0; i < nProfiles; i++) {
1085 
1086         // Check if black point is really needed or allowed. Note that
1087         // following Adobe's document:
1088         // BPC does not apply to devicelink profiles, nor to abs colorimetric,
1089         // and applies always on V4 perceptual and saturation.
1090 
1091         if (TheIntents[i] == INTENT_ABSOLUTE_COLORIMETRIC)
1092             BPC[i] = FALSE;
1093 
1094         if (TheIntents[i] == INTENT_PERCEPTUAL || TheIntents[i] == INTENT_SATURATION) {
1095 
1096             // Force BPC for V4 profiles in perceptual and saturation
1097             if (cmsGetEncodedICCversion(hProfiles[i]) >= 0x4000000)
1098                 BPC[i] = TRUE;
1099         }
1100     }
1101 
1102     // Search for a handler. The first intent in the chain defines the handler. That would
1103     // prevent using multiple custom intents in a multiintent chain, but the behaviour of
1104     // this case would present some issues if the custom intent tries to do things like
1105     // preserve primaries. This solution is not perfect, but works well on most cases.
1106 
1107     Intent = SearchIntent(ContextID, TheIntents[0]);
1108     if (Intent == NULL) {
1109         cmsSignalError(ContextID, cmsERROR_UNKNOWN_EXTENSION, "Unsupported intent '%d'", TheIntents[0]);
1110         return NULL;
1111     }
1112 
1113     // Call the handler
1114     return Intent ->Link(ContextID, nProfiles, TheIntents, hProfiles, BPC, AdaptationStates, dwFlags);
1115 }
1116 
1117 // -------------------------------------------------------------------------------------------------
1118 
1119 // Get information about available intents. nMax is the maximum space for the supplied "Codes"
1120 // and "Descriptions" the function returns the total number of intents, which may be greater
1121 // than nMax, although the matrices are not populated beyond this level.
1122 cmsUInt32Number CMSEXPORT cmsGetSupportedIntentsTHR(cmsContext ContextID, cmsUInt32Number nMax, cmsUInt32Number* Codes, char** Descriptions)
1123 {
1124     _cmsIntentsPluginChunkType* ctx = ( _cmsIntentsPluginChunkType*) _cmsContextGetClientChunk(ContextID, IntentPlugin);
1125     cmsIntentsList* pt;
1126     cmsUInt32Number nIntents;
1127 
1128 
1129     for (nIntents=0, pt = ctx->Intents; pt != NULL; pt = pt -> Next)
1130     {
1131         if (nIntents < nMax) {
1132             if (Codes != NULL)
1133                 Codes[nIntents] = pt ->Intent;
1134 
1135             if (Descriptions != NULL)
1136                 Descriptions[nIntents] = pt ->Description;
1137         }
1138 
1139         nIntents++;
1140     }
1141 
1142     for (nIntents=0, pt = DefaultIntents; pt != NULL; pt = pt -> Next)
1143     {
1144         if (nIntents < nMax) {
1145             if (Codes != NULL)
1146                 Codes[nIntents] = pt ->Intent;
1147 
1148             if (Descriptions != NULL)
1149                 Descriptions[nIntents] = pt ->Description;
1150         }
1151 
1152         nIntents++;
1153     }
1154     return nIntents;
1155 }
1156 
1157 cmsUInt32Number CMSEXPORT cmsGetSupportedIntents(cmsUInt32Number nMax, cmsUInt32Number* Codes, char** Descriptions)
1158 {
1159     return cmsGetSupportedIntentsTHR(NULL, nMax, Codes, Descriptions);
1160 }
1161 
1162 // The plug-in registration. User can add new intents or override default routines
1163 cmsBool  _cmsRegisterRenderingIntentPlugin(cmsContext id, cmsPluginBase* Data)
1164 {
1165     _cmsIntentsPluginChunkType* ctx = ( _cmsIntentsPluginChunkType*) _cmsContextGetClientChunk(id, IntentPlugin);
1166     cmsPluginRenderingIntent* Plugin = (cmsPluginRenderingIntent*) Data;
1167     cmsIntentsList* fl;
1168 
1169     // Do we have to reset the custom intents?
1170     if (Data == NULL) {
1171 
1172         ctx->Intents = NULL;
1173         return TRUE;
1174     }
1175 
1176     fl = (cmsIntentsList*) _cmsPluginMalloc(id, sizeof(cmsIntentsList));
1177     if (fl == NULL) return FALSE;
1178 
1179 
1180     fl ->Intent  = Plugin ->Intent;
1181     strncpy(fl ->Description, Plugin ->Description, sizeof(fl ->Description)-1);
1182     fl ->Description[sizeof(fl ->Description)-1] = 0;
1183 
1184     fl ->Link    = Plugin ->Link;
1185 
1186     fl ->Next = ctx ->Intents;
1187     ctx ->Intents = fl;
1188 
1189     return TRUE;
1190 }
1191 
--- EOF ---