thirdparty/liblcms2/src/cmscnvrt.c

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