modules/lcms/src/cmswtpnt.c

   1 //
   2 //  Little cms
   3 //  Copyright (C) 1998-2007 Marti Maria
   4 //
   5 // Permission is hereby granted, free of charge, to any person obtaining
   6 // a copy of this software and associated documentation files (the "Software"),
   7 // to deal in the Software without restriction, including without limitation
   8 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9 // and/or sell copies of the Software, and to permit persons to whom the Software
  10 // is furnished to do so, subject to the following conditions:
  11 //
  12 // The above copyright notice and this permission notice shall be included in
  13 // all copies or substantial portions of the Software.
  14 //
  15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  17 // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  19 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  20 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  21 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22
  23 #include "lcms.h"
  24
  25
  26 // Conversions
  27
  28 void LCMSEXPORT cmsXYZ2xyY(LPcmsCIExyY Dest, const cmsCIEXYZ* Source)
  29 {
  30        double ISum;
  31
  32        ISum = 1./(Source -> X + Source -> Y + Source -> Z);
  33
  34        Dest -> x = (Source -> X) * ISum;
  35        Dest -> y = (Source -> Y) * ISum;
  36        Dest -> Y = Source -> Y;
  37 }
  38
  39
  40 void LCMSEXPORT cmsxyY2XYZ(LPcmsCIEXYZ Dest, const cmsCIExyY* Source)
  41 {
  42
  43         Dest -> X = (Source -> x / Source -> y) * Source -> Y;
  44         Dest -> Y = Source -> Y;
  45         Dest -> Z = ((1 - Source -> x - Source -> y) / Source -> y) * Source -> Y;
  46 }
  47
  48
  49 // Obtains WhitePoint from Temperature
  50
  51 LCMSBOOL LCMSEXPORT cmsWhitePointFromTemp(int TempK, LPcmsCIExyY WhitePoint)
  52 {
  53        double x, y;
  54        double T, T2, T3;
  55        // double M1, M2;
  56
  57
  58        // No optimization provided.
  59
  60        T = TempK;
  61        T2 = T*T;            // Square
  62        T3 = T2*T;           // Cube
  63
  64        // For correlated color temperature (T) between 4000K and 7000K:
  65
  66        if (T >= 4000. && T <= 7000.)
  67        {
  68               x = -4.6070*(1E9/T3) + 2.9678*(1E6/T2) + 0.09911*(1E3/T) + 0.244063;
  69        }
  70        else
  71               // or for correlated color temperature (T) between 7000K and 25000K:
  72
  73        if (T > 7000.0 && T <= 25000.0)
  74        {
  75               x = -2.0064*(1E9/T3) + 1.9018*(1E6/T2) + 0.24748*(1E3/T) + 0.237040;
  76        }
  77        else {
  78               cmsSignalError(LCMS_ERRC_ABORTED, "cmsWhitePointFromTemp: invalid temp");
  79               return FALSE;
  80               }
  81
  82        // Obtain y(x)
  83
  84        y = -3.000*(x*x) + 2.870*x - 0.275;
  85
  86        // wave factors (not used, but here for futures extensions)
  87
  88        // M1 = (-1.3515 - 1.7703*x + 5.9114 *y)/(0.0241 + 0.2562*x - 0.7341*y);
  89        // M2 = (0.0300 - 31.4424*x + 30.0717*y)/(0.0241 + 0.2562*x - 0.7341*y);
  90
  91
  92
  93        // Fill WhitePoint struct
  94
  95        WhitePoint -> x = x;
  96        WhitePoint -> y = y;
  97        WhitePoint -> Y = 1.0;
  98
  99        return TRUE;
 100 }
 101
 102 // Build a White point, primary chromas transfer matrix from RGB to CIE XYZ
 103 // This is just an approximation, I am not handling all the non-linear
 104 // aspects of the RGB to XYZ process, and assumming that the gamma correction
 105 // has transitive property in the tranformation chain.
 106 //
 107 // the alghoritm:
 108 //
 109 //            - First I build the absolute conversion matrix using
 110 //              primaries in XYZ. This matrix is next inverted
 111 //            - Then I eval the source white point across this matrix
 112 //              obtaining the coeficients of the transformation
 113 //            - Then, I apply these coeficients to the original matrix
 114
 115
 116 LCMSBOOL LCMSEXPORT cmsBuildRGB2XYZtransferMatrix(LPMAT3 r, LPcmsCIExyY WhitePt,
 117                                             LPcmsCIExyYTRIPLE Primrs)
 118 {
 119         VEC3 WhitePoint, Coef;
 120         MAT3 Result, Primaries;
 121         double xn, yn;
 122         double xr, yr;
 123         double xg, yg;
 124         double xb, yb;
 125
 126
 127         xn = WhitePt -> x;
 128         yn = WhitePt -> y;
 129         if (yn == 0.0)
 130            return FALSE;
 131         xr = Primrs -> Red.x;
 132         yr = Primrs -> Red.y;
 133         xg = Primrs -> Green.x;
 134         yg = Primrs -> Green.y;
 135         xb = Primrs -> Blue.x;
 136         yb = Primrs -> Blue.y;
 137
 138
 139         // Build Primaries matrix
 140         VEC3init(&Primaries.v[0], xr,        xg,         xb);
 141         VEC3init(&Primaries.v[1], yr,        yg,         yb);
 142         VEC3init(&Primaries.v[2], (1-xr-yr), (1-xg-yg),  (1-xb-yb));
 143
 144
 145         // Result = Primaries ^ (-1) inverse matrix
 146         if (MAT3inverse(&Primaries, &Result) < 0)
 147                         return FALSE;
 148
 149
 150         VEC3init(&WhitePoint, xn/yn, 1.0, (1.0-xn-yn)/yn);
 151
 152         // Across inverse primaries ...
 153         MAT3eval(&Coef, &Result, &WhitePoint);
 154
 155         // Give us the Coefs, then I build transformation matrix
 156         VEC3init(&r -> v[0], Coef.n[VX]*xr,          Coef.n[VY]*xg,          Coef.n[VZ]*xb);
 157         VEC3init(&r -> v[1], Coef.n[VX]*yr,          Coef.n[VY]*yg,          Coef.n[VZ]*yb);
 158         VEC3init(&r -> v[2], Coef.n[VX]*(1.0-xr-yr), Coef.n[VY]*(1.0-xg-yg), Coef.n[VZ]*(1.0-xb-yb));
 159
 160
 161         return TRUE;
 162 }
 163
 164
 165
 166 // Compute chromatic adaptation matrix using Chad as cone matrix
 167
 168 static
 169 void ComputeChromaticAdaptation(LPMAT3 Conversion,
 170                                 LPcmsCIEXYZ SourceWhitePoint,
 171                                 LPcmsCIEXYZ DestWhitePoint,
 172                                 LPMAT3 Chad)
 173
 174 {
 175
 176         MAT3 Chad_Inv;
 177         VEC3 ConeSourceXYZ, ConeSourceRGB;
 178         VEC3 ConeDestXYZ, ConeDestRGB;
 179         MAT3 Cone, Tmp;
 180
 181
 182         Tmp = *Chad;
 183         MAT3inverse(&Tmp, &Chad_Inv);
 184
 185         VEC3init(&ConeSourceXYZ, SourceWhitePoint -> X,
 186                                  SourceWhitePoint -> Y,
 187                                  SourceWhitePoint -> Z);
 188
 189         VEC3init(&ConeDestXYZ,   DestWhitePoint -> X,
 190                                  DestWhitePoint -> Y,
 191                                  DestWhitePoint -> Z);
 192
 193         MAT3eval(&ConeSourceRGB, Chad, &ConeSourceXYZ);
 194         MAT3eval(&ConeDestRGB,   Chad, &ConeDestXYZ);
 195
 196         // Build matrix
 197
 198         VEC3init(&Cone.v[0], ConeDestRGB.n[0]/ConeSourceRGB.n[0],    0.0,  0.0);
 199         VEC3init(&Cone.v[1], 0.0,   ConeDestRGB.n[1]/ConeSourceRGB.n[1],   0.0);
 200         VEC3init(&Cone.v[2], 0.0,   0.0,   ConeDestRGB.n[2]/ConeSourceRGB.n[2]);
 201
 202
 203         // Normalize
 204         MAT3per(&Tmp, &Cone, Chad);
 205         MAT3per(Conversion, &Chad_Inv, &Tmp);
 206
 207 }
 208
 209
 210 // Returns the final chrmatic adaptation from illuminant FromIll to Illuminant ToIll
 211 // The cone matrix can be specified in ConeMatrix. If NULL, Bradford is assumed
 212
 213 LCMSBOOL cmsAdaptationMatrix(LPMAT3 r, LPMAT3 ConeMatrix, LPcmsCIEXYZ FromIll, LPcmsCIEXYZ ToIll)
 214 {
 215      MAT3 LamRigg   = {{ // Bradford matrix
 216                       {{  0.8951,  0.2664, -0.1614 }},
 217                       {{ -0.7502,  1.7135,  0.0367 }},
 218                       {{  0.0389, -0.0685,  1.0296 }}
 219                       }};
 220
 221
 222       if (ConeMatrix == NULL)
 223             ConeMatrix = &LamRigg;
 224
 225       ComputeChromaticAdaptation(r, FromIll, ToIll, ConeMatrix);
 226       return TRUE;
 227
 228 }
 229
 230 // Same as anterior, but assuming D50 destination. White point is given in xyY
 231
 232 LCMSBOOL cmsAdaptMatrixToD50(LPMAT3 r, LPcmsCIExyY SourceWhitePt)
 233 {
 234         cmsCIEXYZ Dn;
 235         MAT3 Bradford;
 236         MAT3 Tmp;
 237
 238         cmsxyY2XYZ(&Dn, SourceWhitePt);
 239
 240         cmsAdaptationMatrix(&Bradford, NULL, &Dn, cmsD50_XYZ());
 241
 242         Tmp = *r;
 243         MAT3per(r, &Bradford, &Tmp);
 244
 245         return TRUE;
 246 }
 247
 248
 249 // Same as anterior, but assuming D50 source. White point is given in xyY
 250
 251 LCMSBOOL cmsAdaptMatrixFromD50(LPMAT3 r, LPcmsCIExyY DestWhitePt)
 252 {
 253         cmsCIEXYZ Dn;
 254         MAT3 Bradford;
 255         MAT3 Tmp;
 256
 257         cmsxyY2XYZ(&Dn, DestWhitePt);
 258
 259         cmsAdaptationMatrix(&Bradford, NULL, cmsD50_XYZ(), &Dn);
 260
 261         Tmp = *r;
 262         MAT3per(r, &Bradford, &Tmp);
 263
 264         return TRUE;
 265 }
 266
 267
 268 // Adapts a color to a given illuminant. Original color is expected to have
 269 // a SourceWhitePt white point.
 270
 271 LCMSBOOL LCMSEXPORT cmsAdaptToIlluminant(LPcmsCIEXYZ Result,
 272                                      LPcmsCIEXYZ SourceWhitePt,
 273                                      LPcmsCIEXYZ Illuminant,
 274                                      LPcmsCIEXYZ Value)
 275 {
 276         MAT3 Bradford;
 277         VEC3 In, Out;
 278
 279         // BradfordLamRiggChromaticAdaptation(&Bradford, SourceWhitePt, Illuminant);
 280
 281         cmsAdaptationMatrix(&Bradford, NULL, SourceWhitePt, Illuminant);
 282
 283         VEC3init(&In, Value -> X, Value -> Y, Value -> Z);
 284         MAT3eval(&Out, &Bradford, &In);
 285
 286         Result -> X = Out.n[0];
 287         Result -> Y = Out.n[1];
 288         Result -> Z = Out.n[2];
 289
 290         return TRUE;
 291 }
 292
 293
 294
 295 typedef struct {
 296
 297     double mirek;  // temp (in microreciprocal kelvin)
 298     double ut;     // u coord of intersection w/ blackbody locus
 299     double vt;     // v coord of intersection w/ blackbody locus
 300     double tt;     // slope of ISOTEMPERATURE. line
 301
 302     } ISOTEMPERATURE,FAR* LPISOTEMPERATURE;
 303
 304 static ISOTEMPERATURE isotempdata[] = {
 305 //  {Mirek, Ut,       Vt,      Tt      }
 306     {0,     0.18006,  0.26352,  -0.24341},
 307     {10,    0.18066,  0.26589,  -0.25479},
 308     {20,    0.18133,  0.26846,  -0.26876},
 309     {30,    0.18208,  0.27119,  -0.28539},
 310     {40,    0.18293,  0.27407,  -0.30470},
 311     {50,    0.18388,  0.27709,  -0.32675},
 312     {60,    0.18494,  0.28021,  -0.35156},
 313     {70,    0.18611,  0.28342,  -0.37915},
 314     {80,    0.18740,  0.28668,  -0.40955},
 315     {90,    0.18880,  0.28997,  -0.44278},
 316     {100,   0.19032,  0.29326,  -0.47888},
 317     {125,   0.19462,  0.30141,  -0.58204},
 318     {150,   0.19962,  0.30921,  -0.70471},
 319     {175,   0.20525,  0.31647,  -0.84901},
 320     {200,   0.21142,  0.32312,  -1.0182 },
 321     {225,   0.21807,  0.32909,  -1.2168 },
 322     {250,   0.22511,  0.33439,  -1.4512 },
 323     {275,   0.23247,  0.33904,  -1.7298 },
 324     {300,   0.24010,  0.34308,  -2.0637 },
 325     {325,   0.24702,  0.34655,  -2.4681 },
 326     {350,   0.25591,  0.34951,  -2.9641 },
 327     {375,   0.26400,  0.35200,  -3.5814 },
 328     {400,   0.27218,  0.35407,  -4.3633 },
 329     {425,   0.28039,  0.35577,  -5.3762 },
 330     {450,   0.28863,  0.35714,  -6.7262 },
 331     {475,   0.29685,  0.35823,  -8.5955 },
 332     {500,   0.30505,  0.35907,  -11.324 },
 333     {525,   0.31320,  0.35968,  -15.628 },
 334     {550,   0.32129,  0.36011,  -23.325 },
 335     {575,   0.32931,  0.36038,  -40.770 },
 336     {600,   0.33724,  0.36051, -116.45  }
 337 };
 338
 339 #define NISO sizeof(isotempdata)/sizeof(ISOTEMPERATURE)
 340
 341
 342 // Robertson's method
 343
 344 static
 345 double Robertson(LPcmsCIExyY v)
 346 {
 347     int j;
 348     double us,vs;
 349     double uj,vj,tj,di,dj,mi,mj;
 350     double Tc = -1, xs, ys;
 351
 352     di = mi = 0;
 353     xs = v -> x;
 354     ys = v -> y;
 355
 356     // convert (x,y) to CIE 1960 (u,v)
 357
 358     us = (2*xs) / (-xs + 6*ys + 1.5);
 359     vs = (3*ys) / (-xs + 6*ys + 1.5);
 360
 361
 362     for (j=0; j < NISO; j++) {
 363
 364         uj = isotempdata[j].ut;
 365         vj = isotempdata[j].vt;
 366         tj = isotempdata[j].tt;
 367         mj = isotempdata[j].mirek;
 368
 369         dj = ((vs - vj) - tj * (us - uj)) / sqrt(1 + tj*tj);
 370
 371         if ((j!=0) && (di/dj < 0.0)) {
 372             Tc = 1000000.0 / (mi + (di / (di - dj)) * (mj - mi));
 373             break;
 374         }
 375
 376         di = dj;
 377         mi = mj;
 378     }
 379
 380
 381     if (j == NISO) return -1;
 382     return Tc;
 383 }
 384
 385
 386
 387 static
 388 LCMSBOOL InRange(LPcmsCIExyY a, LPcmsCIExyY b, double tolerance)
 389 {
 390        double dist_x, dist_y;
 391
 392        dist_x = fabs(a->x - b->x);
 393        dist_y = fabs(a->y - b->y);
 394
 395        return (tolerance >= dist_x * dist_x + dist_y * dist_y);
 396
 397 }
 398
 399
 400 typedef struct {
 401                 char Name[30];
 402                 cmsCIExyY Val;
 403
 404               } WHITEPOINTS,FAR *LPWHITEPOINTS;
 405
 406 static
 407 int FromD40toD150(LPWHITEPOINTS pts)
 408 {
 409        int i, n;
 410
 411        n = 0;
 412        for (i=40; i < 150; i ++)
 413        {
 414               sprintf(pts[n].Name, "D%d", i);
 415               cmsWhitePointFromTemp((int) (i*100.0), &pts[n].Val);
 416               n++;
 417        }
 418
 419    return n;
 420 }
 421
 422
 423 // To be removed in future versions
 424 void _cmsIdentifyWhitePoint(char *Buffer, LPcmsCIEXYZ WhitePt)
 425 {
 426        int i, n;
 427        cmsCIExyY Val;
 428        double T;
 429        WHITEPOINTS SomeIlluminants[140] = {
 430
 431                                    {"CIE illuminant A", {0.4476, 0.4074, 1.0}},
 432                                    {"CIE illuminant C", {0.3101, 0.3162, 1.0}},
 433                                    {"D65 (daylight)",   {0.3127, 0.3291, 1.0}},
 434                                    };
 435
 436               n = FromD40toD150(&SomeIlluminants[3]) + 3;
 437
 438               cmsXYZ2xyY(&Val, WhitePt);
 439
 440               Val.Y = 1.;
 441               for (i=0; i < n; i++)
 442               {
 443
 444                             if (InRange(&Val, &SomeIlluminants[i].Val, 0.000005))
 445                             {
 446                                 strcpy(Buffer, "WhitePoint : ");
 447                                 strcat(Buffer, SomeIlluminants[i].Name);
 448                                 return;
 449                             }
 450               }
 451
 452               T = Robertson(&Val);
 453
 454               if (T > 0)
 455                 sprintf(Buffer, "White point near %dK", (int) T);
 456               else
 457               {
 458               sprintf(Buffer, "Unknown white point (X:%1.2g, Y:%1.2g, Z:%1.2g)",
 459                                           WhitePt -> X, WhitePt -> Y, WhitePt -> Z);
 460
 461               }
 462
 463 }
 464
 465
 466 // Use darker colorant to obtain black point
 467
 468 static
 469 int BlackPointAsDarkerColorant(cmsHPROFILE hInput,
 470                                int Intent,
 471                                LPcmsCIEXYZ BlackPoint,
 472                                DWORD dwFlags)
 473 {
 474     WORD *Black, *White;
 475     cmsHTRANSFORM xform;
 476     icColorSpaceSignature Space;
 477     int nChannels;
 478     DWORD dwFormat;
 479     cmsHPROFILE hLab;
 480     cmsCIELab  Lab;
 481     cmsCIEXYZ  BlackXYZ, MediaWhite;
 482
 483     // If the profile does not support input direction, assume Black point 0
 484     if (!cmsIsIntentSupported(hInput, Intent, LCMS_USED_AS_INPUT)) {
 485
 486         BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
 487         return 0;
 488     }
 489
 490
 491     // Try to get black by using black colorant
 492     Space = cmsGetColorSpace(hInput);
 493
 494     if (!_cmsEndPointsBySpace(Space, &White, &Black, &nChannels)) {
 495
 496         BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
 497         return 0;
 498     }
 499
 500     dwFormat = CHANNELS_SH(nChannels)|BYTES_SH(2);
 501
 502     hLab = cmsCreateLabProfile(NULL);
 503
 504     xform = cmsCreateTransform(hInput, dwFormat,
 505                                 hLab, TYPE_Lab_DBL, Intent, cmsFLAGS_NOTPRECALC);
 506
 507
 508     cmsDoTransform(xform, Black, &Lab, 1);
 509
 510     // Force it to be neutral, clip to max. L* of 50
 511
 512     Lab.a = Lab.b = 0;
 513     if (Lab.L > 50) Lab.L = 50;
 514
 515     cmsCloseProfile(hLab);
 516     cmsDeleteTransform(xform);
 517
 518     cmsLab2XYZ(NULL, &BlackXYZ, &Lab);
 519
 520     if (Intent == INTENT_ABSOLUTE_COLORIMETRIC) {
 521
 522         *BlackPoint = BlackXYZ;
 523     }
 524     else {
 525
 526         if (!(dwFlags & LCMS_BPFLAGS_D50_ADAPTED)) {
 527
 528             cmsTakeMediaWhitePoint(&MediaWhite, hInput);
 529             cmsAdaptToIlluminant(BlackPoint, cmsD50_XYZ(), &MediaWhite, &BlackXYZ);
 530         }
 531         else
 532             *BlackPoint = BlackXYZ;
 533     }
 534
 535     return 1;
 536 }
 537
 538
 539 // Get a black point of output CMYK profile, discounting any ink-limiting embedded
 540 // in the profile. For doing that, use perceptual intent in input direction:
 541 // Lab (0, 0, 0) -> [Perceptual] Profile -> CMYK -> [Rel. colorimetric] Profile -> Lab
 542
 543 static
 544 int BlackPointUsingPerceptualBlack(LPcmsCIEXYZ BlackPoint,
 545                                    cmsHPROFILE hProfile,
 546                                    DWORD dwFlags)
 547 {
 548     cmsHTRANSFORM hPercLab2CMYK, hRelColCMYK2Lab;
 549     cmsHPROFILE hLab;
 550     cmsCIELab LabIn, LabOut;
 551     WORD CMYK[MAXCHANNELS];
 552     cmsCIEXYZ  BlackXYZ, MediaWhite;
 553
 554
 555      if (!cmsIsIntentSupported(hProfile, INTENT_PERCEPTUAL, LCMS_USED_AS_INPUT)) {
 556
 557         BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
 558         return 0;
 559     }
 560
 561     hLab = cmsCreateLabProfile(NULL);
 562
 563     hPercLab2CMYK  = cmsCreateTransform(hLab, TYPE_Lab_DBL,
 564                                         hProfile, TYPE_CMYK_16,
 565                                         INTENT_PERCEPTUAL, cmsFLAGS_NOTPRECALC);
 566
 567     hRelColCMYK2Lab = cmsCreateTransform(hProfile, TYPE_CMYK_16,
 568                                          hLab, TYPE_Lab_DBL,
 569                                          INTENT_RELATIVE_COLORIMETRIC, cmsFLAGS_NOTPRECALC);
 570
 571     LabIn.L = LabIn.a = LabIn.b = 0;
 572
 573     cmsDoTransform(hPercLab2CMYK, &LabIn, CMYK, 1);
 574     cmsDoTransform(hRelColCMYK2Lab, CMYK, &LabOut, 1);
 575
 576     if (LabOut.L > 50) LabOut.L = 50;
 577     LabOut.a = LabOut.b = 0;
 578
 579     cmsDeleteTransform(hPercLab2CMYK);
 580     cmsDeleteTransform(hRelColCMYK2Lab);
 581     cmsCloseProfile(hLab);
 582
 583     cmsLab2XYZ(NULL, &BlackXYZ, &LabOut);
 584
 585     if (!(dwFlags & LCMS_BPFLAGS_D50_ADAPTED)){
 586             cmsTakeMediaWhitePoint(&MediaWhite, hProfile);
 587             cmsAdaptToIlluminant(BlackPoint, cmsD50_XYZ(), &MediaWhite, &BlackXYZ);
 588     }
 589     else
 590             *BlackPoint = BlackXYZ;
 591
 592     return 1;
 593
 594 }
 595
 596
 597 // Get Perceptual black of v4 profiles.
 598 static
 599 int GetV4PerceptualBlack(LPcmsCIEXYZ BlackPoint, cmsHPROFILE hProfile, DWORD dwFlags)
 600 {
 601         if (dwFlags & LCMS_BPFLAGS_D50_ADAPTED) {
 602
 603             BlackPoint->X = PERCEPTUAL_BLACK_X;
 604             BlackPoint->Y = PERCEPTUAL_BLACK_Y;
 605             BlackPoint->Z = PERCEPTUAL_BLACK_Z;
 606         }
 607         else {
 608
 609             cmsCIEXYZ D50BlackPoint, MediaWhite;
 610
 611             cmsTakeMediaWhitePoint(&MediaWhite, hProfile);
 612             D50BlackPoint.X = PERCEPTUAL_BLACK_X;
 613             D50BlackPoint.Y = PERCEPTUAL_BLACK_Y;
 614             D50BlackPoint.Z = PERCEPTUAL_BLACK_Z;
 615
 616             // Obtain the absolute XYZ. Adapt perceptual black back from D50 to whatever media white
 617             cmsAdaptToIlluminant(BlackPoint, cmsD50_XYZ(), &MediaWhite, &D50BlackPoint);
 618         }
 619
 620
 621         return 1;
 622 }
 623
 624
 625 // This function shouldn't exist at all -- there is such quantity of broken
 626 // profiles on black point tag, that we must somehow fix chromaticity to
 627 // avoid huge tint when doing Black point compensation. This function does
 628 // just that. There is a special flag for using black point tag, but turned
 629 // off by default because it is bogus on most profiles. The detection algorithm
 630 // involves to turn BP to neutral and to use only L component.
 631
 632 int cmsDetectBlackPoint(LPcmsCIEXYZ BlackPoint, cmsHPROFILE hProfile, int Intent, DWORD dwFlags)
 633 {
 634
 635     // v4 + perceptual & saturation intents does have its own black point, and it is
 636     // well specified enough to use it.
 637
 638     if ((cmsGetProfileICCversion(hProfile) >= 0x4000000) &&
 639         (Intent == INTENT_PERCEPTUAL || Intent == INTENT_SATURATION)) {
 640
 641        // Matrix shaper share MRC & perceptual intents
 642        if (_cmsIsMatrixShaper(hProfile))
 643            return BlackPointAsDarkerColorant(hProfile, INTENT_RELATIVE_COLORIMETRIC, BlackPoint, cmsFLAGS_NOTPRECALC);
 644
 645        // CLUT based - Get perceptual black point (fixed value)
 646        return GetV4PerceptualBlack(BlackPoint, hProfile, dwFlags);
 647     }
 648
 649
 650 #ifdef HONOR_BLACK_POINT_TAG
 651
 652     // v2, v4 rel/abs colorimetric
 653     if (cmsIsTag(hProfile, icSigMediaBlackPointTag) &&
 654                     Intent == INTENT_RELATIVE_COLORIMETRIC) {
 655
 656         cmsCIEXYZ BlackXYZ, UntrustedBlackPoint, TrustedBlackPoint, MediaWhite;
 657         cmsCIELab Lab;
 658
 659              // If black point is specified, then use it,
 660
 661              cmsTakeMediaBlackPoint(&BlackXYZ, hProfile);
 662              cmsTakeMediaWhitePoint(&MediaWhite, hProfile);
 663
 664              // Black point is absolute XYZ, so adapt to D50 to get PCS value
 665              cmsAdaptToIlluminant(&UntrustedBlackPoint, &MediaWhite, cmsD50_XYZ(), &BlackXYZ);
 666
 667              // Force a=b=0 to get rid of any chroma
 668
 669              cmsXYZ2Lab(NULL, &Lab, &UntrustedBlackPoint);
 670              Lab.a = Lab.b = 0;
 671              if (Lab.L > 50) Lab.L = 50; // Clip to L* <= 50
 672
 673              cmsLab2XYZ(NULL, &TrustedBlackPoint, &Lab);
 674
 675              // Return BP as D50 relative or absolute XYZ (depends on flags)
 676              if (!(dwFlags & LCMS_BPFLAGS_D50_ADAPTED))
 677                     cmsAdaptToIlluminant(BlackPoint, cmsD50_XYZ(), &MediaWhite, &TrustedBlackPoint);
 678              else
 679                     *BlackPoint = TrustedBlackPoint;
 680
 681              return 1;
 682     }
 683
 684 #endif
 685
 686     // That is about v2 profiles.
 687
 688     // If output profile, discount ink-limiting and that's all
 689     if (Intent == INTENT_RELATIVE_COLORIMETRIC &&
 690             (cmsGetDeviceClass(hProfile) == icSigOutputClass) &&
 691             (cmsGetColorSpace(hProfile) == icSigCmykData))
 692                 return BlackPointUsingPerceptualBlack(BlackPoint, hProfile, dwFlags);
 693
 694     // Nope, compute BP using current intent.
 695     return BlackPointAsDarkerColorant(hProfile, Intent, BlackPoint, dwFlags);
 696
 697 }