1 //--------------------------------------------------------------------------------- 2 // 3 // Little Color Management System 4 // Copyright (c) 1998-2014 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 // Virtual (built-in) profiles 30 // ----------------------------------------------------------------------------------- 31 32 static 33 cmsBool SetTextTags(cmsHPROFILE hProfile, const wchar_t* Description) 34 { 35 cmsMLU *DescriptionMLU, *CopyrightMLU; 36 cmsBool rc = FALSE; 37 cmsContext ContextID = cmsGetProfileContextID(hProfile); 38 39 DescriptionMLU = cmsMLUalloc(ContextID, 1); 40 CopyrightMLU = cmsMLUalloc(ContextID, 1); 41 42 if (DescriptionMLU == NULL || CopyrightMLU == NULL) goto Error; 43 44 if (!cmsMLUsetWide(DescriptionMLU, "en", "US", Description)) goto Error; 45 if (!cmsMLUsetWide(CopyrightMLU, "en", "US", L"No copyright, use freely")) goto Error; 46 47 if (!cmsWriteTag(hProfile, cmsSigProfileDescriptionTag, DescriptionMLU)) goto Error; 48 if (!cmsWriteTag(hProfile, cmsSigCopyrightTag, CopyrightMLU)) goto Error; 49 50 rc = TRUE; 51 52 Error: 53 54 if (DescriptionMLU) 55 cmsMLUfree(DescriptionMLU); 56 if (CopyrightMLU) 57 cmsMLUfree(CopyrightMLU); 58 return rc; 59 } 60 61 62 static 63 cmsBool SetSeqDescTag(cmsHPROFILE hProfile, const char* Model) 64 { 65 cmsBool rc = FALSE; 66 cmsContext ContextID = cmsGetProfileContextID(hProfile); 67 cmsSEQ* Seq = cmsAllocProfileSequenceDescription(ContextID, 1); 68 69 if (Seq == NULL) return FALSE; 70 71 Seq->seq[0].deviceMfg = (cmsSignature) 0; 72 Seq->seq[0].deviceModel = (cmsSignature) 0; 73 74 #ifdef CMS_DONT_USE_INT64 75 Seq->seq[0].attributes[0] = 0; 76 Seq->seq[0].attributes[1] = 0; 77 #else 78 Seq->seq[0].attributes = 0; 79 #endif 80 81 Seq->seq[0].technology = (cmsTechnologySignature) 0; 82 83 cmsMLUsetASCII( Seq->seq[0].Manufacturer, cmsNoLanguage, cmsNoCountry, "Little CMS"); 84 cmsMLUsetASCII( Seq->seq[0].Model, cmsNoLanguage, cmsNoCountry, Model); 85 86 if (!_cmsWriteProfileSequence(hProfile, Seq)) goto Error; 87 88 rc = TRUE; 89 90 Error: 91 if (Seq) 92 cmsFreeProfileSequenceDescription(Seq); 93 94 return rc; 95 } 96 97 98 99 // This function creates a profile based on White point, primaries and 100 // transfer functions. 101 cmsHPROFILE CMSEXPORT cmsCreateRGBProfileTHR(cmsContext ContextID, 102 const cmsCIExyY* WhitePoint, 103 const cmsCIExyYTRIPLE* Primaries, 104 cmsToneCurve* const TransferFunction[3]) 105 { 106 cmsHPROFILE hICC; 107 cmsMAT3 MColorants; 108 cmsCIEXYZTRIPLE Colorants; 109 cmsCIExyY MaxWhite; 110 cmsMAT3 CHAD; 111 cmsCIEXYZ WhitePointXYZ; 112 113 hICC = cmsCreateProfilePlaceholder(ContextID); 114 if (!hICC) // can't allocate 115 return NULL; 116 117 cmsSetProfileVersion(hICC, 4.3); 118 119 cmsSetDeviceClass(hICC, cmsSigDisplayClass); 120 cmsSetColorSpace(hICC, cmsSigRgbData); 121 cmsSetPCS(hICC, cmsSigXYZData); 122 123 cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL); 124 125 126 // Implement profile using following tags: 127 // 128 // 1 cmsSigProfileDescriptionTag 129 // 2 cmsSigMediaWhitePointTag 130 // 3 cmsSigRedColorantTag 131 // 4 cmsSigGreenColorantTag 132 // 5 cmsSigBlueColorantTag 133 // 6 cmsSigRedTRCTag 134 // 7 cmsSigGreenTRCTag 135 // 8 cmsSigBlueTRCTag 136 // 9 Chromatic adaptation Tag 137 // This conforms a standard RGB DisplayProfile as says ICC, and then I add (As per addendum II) 138 // 10 cmsSigChromaticityTag 139 140 141 if (!SetTextTags(hICC, L"RGB built-in")) goto Error; 142 143 if (WhitePoint) { 144 145 if (!cmsWriteTag(hICC, cmsSigMediaWhitePointTag, cmsD50_XYZ())) goto Error; 146 147 cmsxyY2XYZ(&WhitePointXYZ, WhitePoint); 148 _cmsAdaptationMatrix(&CHAD, NULL, &WhitePointXYZ, cmsD50_XYZ()); 149 150 // This is a V4 tag, but many CMM does read and understand it no matter which version 151 if (!cmsWriteTag(hICC, cmsSigChromaticAdaptationTag, (void*) &CHAD)) goto Error; 152 } 153 154 if (WhitePoint && Primaries) { 155 156 MaxWhite.x = WhitePoint -> x; 157 MaxWhite.y = WhitePoint -> y; 158 MaxWhite.Y = 1.0; 159 160 if (!_cmsBuildRGB2XYZtransferMatrix(&MColorants, &MaxWhite, Primaries)) goto Error; 161 162 Colorants.Red.X = MColorants.v[0].n[0]; 163 Colorants.Red.Y = MColorants.v[1].n[0]; 164 Colorants.Red.Z = MColorants.v[2].n[0]; 165 166 Colorants.Green.X = MColorants.v[0].n[1]; 167 Colorants.Green.Y = MColorants.v[1].n[1]; 168 Colorants.Green.Z = MColorants.v[2].n[1]; 169 170 Colorants.Blue.X = MColorants.v[0].n[2]; 171 Colorants.Blue.Y = MColorants.v[1].n[2]; 172 Colorants.Blue.Z = MColorants.v[2].n[2]; 173 174 if (!cmsWriteTag(hICC, cmsSigRedColorantTag, (void*) &Colorants.Red)) goto Error; 175 if (!cmsWriteTag(hICC, cmsSigBlueColorantTag, (void*) &Colorants.Blue)) goto Error; 176 if (!cmsWriteTag(hICC, cmsSigGreenColorantTag, (void*) &Colorants.Green)) goto Error; 177 } 178 179 180 if (TransferFunction) { 181 182 // Tries to minimize space. Thanks to Richard Hughes for this nice idea 183 if (!cmsWriteTag(hICC, cmsSigRedTRCTag, (void*) TransferFunction[0])) goto Error; 184 185 if (TransferFunction[1] == TransferFunction[0]) { 186 187 if (!cmsLinkTag (hICC, cmsSigGreenTRCTag, cmsSigRedTRCTag)) goto Error; 188 189 } else { 190 191 if (!cmsWriteTag(hICC, cmsSigGreenTRCTag, (void*) TransferFunction[1])) goto Error; 192 } 193 194 if (TransferFunction[2] == TransferFunction[0]) { 195 196 if (!cmsLinkTag (hICC, cmsSigBlueTRCTag, cmsSigRedTRCTag)) goto Error; 197 198 } else { 199 200 if (!cmsWriteTag(hICC, cmsSigBlueTRCTag, (void*) TransferFunction[2])) goto Error; 201 } 202 } 203 204 if (Primaries) { 205 if (!cmsWriteTag(hICC, cmsSigChromaticityTag, (void*) Primaries)) goto Error; 206 } 207 208 209 return hICC; 210 211 Error: 212 if (hICC) 213 cmsCloseProfile(hICC); 214 return NULL; 215 } 216 217 cmsHPROFILE CMSEXPORT cmsCreateRGBProfile(const cmsCIExyY* WhitePoint, 218 const cmsCIExyYTRIPLE* Primaries, 219 cmsToneCurve* const TransferFunction[3]) 220 { 221 return cmsCreateRGBProfileTHR(NULL, WhitePoint, Primaries, TransferFunction); 222 } 223 224 225 226 // This function creates a profile based on White point and transfer function. 227 cmsHPROFILE CMSEXPORT cmsCreateGrayProfileTHR(cmsContext ContextID, 228 const cmsCIExyY* WhitePoint, 229 const cmsToneCurve* TransferFunction) 230 { 231 cmsHPROFILE hICC; 232 cmsCIEXYZ tmp; 233 234 hICC = cmsCreateProfilePlaceholder(ContextID); 235 if (!hICC) // can't allocate 236 return NULL; 237 238 cmsSetProfileVersion(hICC, 4.3); 239 240 cmsSetDeviceClass(hICC, cmsSigDisplayClass); 241 cmsSetColorSpace(hICC, cmsSigGrayData); 242 cmsSetPCS(hICC, cmsSigXYZData); 243 cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL); 244 245 246 // Implement profile using following tags: 247 // 248 // 1 cmsSigProfileDescriptionTag 249 // 2 cmsSigMediaWhitePointTag 250 // 3 cmsSigGrayTRCTag 251 252 // This conforms a standard Gray DisplayProfile 253 254 // Fill-in the tags 255 256 if (!SetTextTags(hICC, L"gray built-in")) goto Error; 257 258 259 if (WhitePoint) { 260 261 cmsxyY2XYZ(&tmp, WhitePoint); 262 if (!cmsWriteTag(hICC, cmsSigMediaWhitePointTag, (void*) &tmp)) goto Error; 263 } 264 265 if (TransferFunction) { 266 267 if (!cmsWriteTag(hICC, cmsSigGrayTRCTag, (void*) TransferFunction)) goto Error; 268 } 269 270 return hICC; 271 272 Error: 273 if (hICC) 274 cmsCloseProfile(hICC); 275 return NULL; 276 } 277 278 279 280 cmsHPROFILE CMSEXPORT cmsCreateGrayProfile(const cmsCIExyY* WhitePoint, 281 const cmsToneCurve* TransferFunction) 282 { 283 return cmsCreateGrayProfileTHR(NULL, WhitePoint, TransferFunction); 284 } 285 286 // This is a devicelink operating in the target colorspace with as many transfer functions as components 287 288 cmsHPROFILE CMSEXPORT cmsCreateLinearizationDeviceLinkTHR(cmsContext ContextID, 289 cmsColorSpaceSignature ColorSpace, 290 cmsToneCurve* const TransferFunctions[]) 291 { 292 cmsHPROFILE hICC; 293 cmsPipeline* Pipeline; 294 int nChannels; 295 296 hICC = cmsCreateProfilePlaceholder(ContextID); 297 if (!hICC) 298 return NULL; 299 300 cmsSetProfileVersion(hICC, 4.3); 301 302 cmsSetDeviceClass(hICC, cmsSigLinkClass); 303 cmsSetColorSpace(hICC, ColorSpace); 304 cmsSetPCS(hICC, ColorSpace); 305 306 cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL); 307 308 // Set up channels 309 nChannels = cmsChannelsOf(ColorSpace); 310 311 // Creates a Pipeline with prelinearization step only 312 Pipeline = cmsPipelineAlloc(ContextID, nChannels, nChannels); 313 if (Pipeline == NULL) goto Error; 314 315 316 // Copy tables to Pipeline 317 if (!cmsPipelineInsertStage(Pipeline, cmsAT_BEGIN, cmsStageAllocToneCurves(ContextID, nChannels, TransferFunctions))) 318 goto Error; 319 320 // Create tags 321 if (!SetTextTags(hICC, L"Linearization built-in")) goto Error; 322 if (!cmsWriteTag(hICC, cmsSigAToB0Tag, (void*) Pipeline)) goto Error; 323 if (!SetSeqDescTag(hICC, "Linearization built-in")) goto Error; 324 325 // Pipeline is already on virtual profile 326 cmsPipelineFree(Pipeline); 327 328 // Ok, done 329 return hICC; 330 331 Error: 332 cmsPipelineFree(Pipeline); 333 if (hICC) 334 cmsCloseProfile(hICC); 335 336 337 return NULL; 338 } 339 340 cmsHPROFILE CMSEXPORT cmsCreateLinearizationDeviceLink(cmsColorSpaceSignature ColorSpace, 341 cmsToneCurve* const TransferFunctions[]) 342 { 343 return cmsCreateLinearizationDeviceLinkTHR(NULL, ColorSpace, TransferFunctions); 344 } 345 346 // Ink-limiting algorithm 347 // 348 // Sum = C + M + Y + K 349 // If Sum > InkLimit 350 // Ratio= 1 - (Sum - InkLimit) / (C + M + Y) 351 // if Ratio <0 352 // Ratio=0 353 // endif 354 // Else 355 // Ratio=1 356 // endif 357 // 358 // C = Ratio * C 359 // M = Ratio * M 360 // Y = Ratio * Y 361 // K: Does not change 362 363 static 364 int InkLimitingSampler(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register void* Cargo) 365 { 366 cmsFloat64Number InkLimit = *(cmsFloat64Number *) Cargo; 367 cmsFloat64Number SumCMY, SumCMYK, Ratio; 368 369 InkLimit = (InkLimit * 655.35); 370 371 SumCMY = In[0] + In[1] + In[2]; 372 SumCMYK = SumCMY + In[3]; 373 374 if (SumCMYK > InkLimit) { 375 376 Ratio = 1 - ((SumCMYK - InkLimit) / SumCMY); 377 if (Ratio < 0) 378 Ratio = 0; 379 } 380 else Ratio = 1; 381 382 Out[0] = _cmsQuickSaturateWord(In[0] * Ratio); // C 383 Out[1] = _cmsQuickSaturateWord(In[1] * Ratio); // M 384 Out[2] = _cmsQuickSaturateWord(In[2] * Ratio); // Y 385 386 Out[3] = In[3]; // K (untouched) 387 388 return TRUE; 389 } 390 391 // This is a devicelink operating in CMYK for ink-limiting 392 393 cmsHPROFILE CMSEXPORT cmsCreateInkLimitingDeviceLinkTHR(cmsContext ContextID, 394 cmsColorSpaceSignature ColorSpace, 395 cmsFloat64Number Limit) 396 { 397 cmsHPROFILE hICC; 398 cmsPipeline* LUT; 399 cmsStage* CLUT; 400 int nChannels; 401 402 if (ColorSpace != cmsSigCmykData) { 403 cmsSignalError(ContextID, cmsERROR_COLORSPACE_CHECK, "InkLimiting: Only CMYK currently supported"); 404 return NULL; 405 } 406 407 if (Limit < 0.0 || Limit > 400) { 408 409 cmsSignalError(ContextID, cmsERROR_RANGE, "InkLimiting: Limit should be between 0..400"); 410 if (Limit < 0) Limit = 0; 411 if (Limit > 400) Limit = 400; 412 413 } 414 415 hICC = cmsCreateProfilePlaceholder(ContextID); 416 if (!hICC) // can't allocate 417 return NULL; 418 419 cmsSetProfileVersion(hICC, 4.3); 420 421 cmsSetDeviceClass(hICC, cmsSigLinkClass); 422 cmsSetColorSpace(hICC, ColorSpace); 423 cmsSetPCS(hICC, ColorSpace); 424 425 cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL); 426 427 428 // Creates a Pipeline with 3D grid only 429 LUT = cmsPipelineAlloc(ContextID, 4, 4); 430 if (LUT == NULL) goto Error; 431 432 433 nChannels = cmsChannelsOf(ColorSpace); 434 435 CLUT = cmsStageAllocCLut16bit(ContextID, 17, nChannels, nChannels, NULL); 436 if (CLUT == NULL) goto Error; 437 438 if (!cmsStageSampleCLut16bit(CLUT, InkLimitingSampler, (void*) &Limit, 0)) goto Error; 439 440 if (!cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, nChannels)) || 441 !cmsPipelineInsertStage(LUT, cmsAT_END, CLUT) || 442 !cmsPipelineInsertStage(LUT, cmsAT_END, _cmsStageAllocIdentityCurves(ContextID, nChannels))) 443 goto Error; 444 445 // Create tags 446 if (!SetTextTags(hICC, L"ink-limiting built-in")) goto Error; 447 448 if (!cmsWriteTag(hICC, cmsSigAToB0Tag, (void*) LUT)) goto Error; 449 if (!SetSeqDescTag(hICC, "ink-limiting built-in")) goto Error; 450 451 // cmsPipeline is already on virtual profile 452 cmsPipelineFree(LUT); 453 454 // Ok, done 455 return hICC; 456 457 Error: 458 if (LUT != NULL) 459 cmsPipelineFree(LUT); 460 461 if (hICC != NULL) 462 cmsCloseProfile(hICC); 463 464 return NULL; 465 } 466 467 cmsHPROFILE CMSEXPORT cmsCreateInkLimitingDeviceLink(cmsColorSpaceSignature ColorSpace, cmsFloat64Number Limit) 468 { 469 return cmsCreateInkLimitingDeviceLinkTHR(NULL, ColorSpace, Limit); 470 } 471 472 473 // Creates a fake Lab identity. 474 cmsHPROFILE CMSEXPORT cmsCreateLab2ProfileTHR(cmsContext ContextID, const cmsCIExyY* WhitePoint) 475 { 476 cmsHPROFILE hProfile; 477 cmsPipeline* LUT = NULL; 478 479 hProfile = cmsCreateRGBProfileTHR(ContextID, WhitePoint == NULL ? cmsD50_xyY() : WhitePoint, NULL, NULL); 480 if (hProfile == NULL) return NULL; 481 482 cmsSetProfileVersion(hProfile, 2.1); 483 484 cmsSetDeviceClass(hProfile, cmsSigAbstractClass); 485 cmsSetColorSpace(hProfile, cmsSigLabData); 486 cmsSetPCS(hProfile, cmsSigLabData); 487 488 if (!SetTextTags(hProfile, L"Lab identity built-in")) return NULL; 489 490 // An identity LUT is all we need 491 LUT = cmsPipelineAlloc(ContextID, 3, 3); 492 if (LUT == NULL) goto Error; 493 494 if (!cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCLut(ContextID, 3))) 495 goto Error; 496 497 if (!cmsWriteTag(hProfile, cmsSigAToB0Tag, LUT)) goto Error; 498 cmsPipelineFree(LUT); 499 500 return hProfile; 501 502 Error: 503 504 if (LUT != NULL) 505 cmsPipelineFree(LUT); 506 507 if (hProfile != NULL) 508 cmsCloseProfile(hProfile); 509 510 return NULL; 511 } 512 513 514 cmsHPROFILE CMSEXPORT cmsCreateLab2Profile(const cmsCIExyY* WhitePoint) 515 { 516 return cmsCreateLab2ProfileTHR(NULL, WhitePoint); 517 } 518 519 520 // Creates a fake Lab V4 identity. 521 cmsHPROFILE CMSEXPORT cmsCreateLab4ProfileTHR(cmsContext ContextID, const cmsCIExyY* WhitePoint) 522 { 523 cmsHPROFILE hProfile; 524 cmsPipeline* LUT = NULL; 525 526 hProfile = cmsCreateRGBProfileTHR(ContextID, WhitePoint == NULL ? cmsD50_xyY() : WhitePoint, NULL, NULL); 527 if (hProfile == NULL) return NULL; 528 529 cmsSetProfileVersion(hProfile, 4.3); 530 531 cmsSetDeviceClass(hProfile, cmsSigAbstractClass); 532 cmsSetColorSpace(hProfile, cmsSigLabData); 533 cmsSetPCS(hProfile, cmsSigLabData); 534 535 if (!SetTextTags(hProfile, L"Lab identity built-in")) goto Error; 536 537 // An empty LUTs is all we need 538 LUT = cmsPipelineAlloc(ContextID, 3, 3); 539 if (LUT == NULL) goto Error; 540 541 if (!cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, 3))) 542 goto Error; 543 544 if (!cmsWriteTag(hProfile, cmsSigAToB0Tag, LUT)) goto Error; 545 cmsPipelineFree(LUT); 546 547 return hProfile; 548 549 Error: 550 551 if (LUT != NULL) 552 cmsPipelineFree(LUT); 553 554 if (hProfile != NULL) 555 cmsCloseProfile(hProfile); 556 557 return NULL; 558 } 559 560 cmsHPROFILE CMSEXPORT cmsCreateLab4Profile(const cmsCIExyY* WhitePoint) 561 { 562 return cmsCreateLab4ProfileTHR(NULL, WhitePoint); 563 } 564 565 566 // Creates a fake XYZ identity 567 cmsHPROFILE CMSEXPORT cmsCreateXYZProfileTHR(cmsContext ContextID) 568 { 569 cmsHPROFILE hProfile; 570 cmsPipeline* LUT = NULL; 571 572 hProfile = cmsCreateRGBProfileTHR(ContextID, cmsD50_xyY(), NULL, NULL); 573 if (hProfile == NULL) return NULL; 574 575 cmsSetProfileVersion(hProfile, 4.3); 576 577 cmsSetDeviceClass(hProfile, cmsSigAbstractClass); 578 cmsSetColorSpace(hProfile, cmsSigXYZData); 579 cmsSetPCS(hProfile, cmsSigXYZData); 580 581 if (!SetTextTags(hProfile, L"XYZ identity built-in")) goto Error; 582 583 // An identity LUT is all we need 584 LUT = cmsPipelineAlloc(ContextID, 3, 3); 585 if (LUT == NULL) goto Error; 586 587 if (!cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, 3))) 588 goto Error; 589 590 if (!cmsWriteTag(hProfile, cmsSigAToB0Tag, LUT)) goto Error; 591 cmsPipelineFree(LUT); 592 593 return hProfile; 594 595 Error: 596 597 if (LUT != NULL) 598 cmsPipelineFree(LUT); 599 600 if (hProfile != NULL) 601 cmsCloseProfile(hProfile); 602 603 return NULL; 604 } 605 606 607 cmsHPROFILE CMSEXPORT cmsCreateXYZProfile(void) 608 { 609 return cmsCreateXYZProfileTHR(NULL); 610 } 611 612 613 //sRGB Curves are defined by: 614 // 615 //If R'sRGB,G'sRGB, B'sRGB < 0.04045 616 // 617 // R = R'sRGB / 12.92 618 // G = G'sRGB / 12.92 619 // B = B'sRGB / 12.92 620 // 621 // 622 //else if R'sRGB,G'sRGB, B'sRGB >= 0.04045 623 // 624 // R = ((R'sRGB + 0.055) / 1.055)^2.4 625 // G = ((G'sRGB + 0.055) / 1.055)^2.4 626 // B = ((B'sRGB + 0.055) / 1.055)^2.4 627 628 static 629 cmsToneCurve* Build_sRGBGamma(cmsContext ContextID) 630 { 631 cmsFloat64Number Parameters[5]; 632 633 Parameters[0] = 2.4; 634 Parameters[1] = 1. / 1.055; 635 Parameters[2] = 0.055 / 1.055; 636 Parameters[3] = 1. / 12.92; 637 Parameters[4] = 0.04045; 638 639 return cmsBuildParametricToneCurve(ContextID, 4, Parameters); 640 } 641 642 // Create the ICC virtual profile for sRGB space 643 cmsHPROFILE CMSEXPORT cmsCreate_sRGBProfileTHR(cmsContext ContextID) 644 { 645 cmsCIExyY D65; 646 cmsCIExyYTRIPLE Rec709Primaries = { 647 {0.6400, 0.3300, 1.0}, 648 {0.3000, 0.6000, 1.0}, 649 {0.1500, 0.0600, 1.0} 650 }; 651 cmsToneCurve* Gamma22[3]; 652 cmsHPROFILE hsRGB; 653 654 cmsWhitePointFromTemp(&D65, 6504); 655 Gamma22[0] = Gamma22[1] = Gamma22[2] = Build_sRGBGamma(ContextID); 656 if (Gamma22[0] == NULL) return NULL; 657 658 hsRGB = cmsCreateRGBProfileTHR(ContextID, &D65, &Rec709Primaries, Gamma22); 659 cmsFreeToneCurve(Gamma22[0]); 660 if (hsRGB == NULL) return NULL; 661 662 if (!SetTextTags(hsRGB, L"sRGB built-in")) { 663 cmsCloseProfile(hsRGB); 664 return NULL; 665 } 666 667 return hsRGB; 668 } 669 670 cmsHPROFILE CMSEXPORT cmsCreate_sRGBProfile(void) 671 { 672 return cmsCreate_sRGBProfileTHR(NULL); 673 } 674 675 676 677 typedef struct { 678 cmsFloat64Number Brightness; 679 cmsFloat64Number Contrast; 680 cmsFloat64Number Hue; 681 cmsFloat64Number Saturation; 682 cmsCIEXYZ WPsrc, WPdest; 683 684 } BCHSWADJUSTS, *LPBCHSWADJUSTS; 685 686 687 static 688 int bchswSampler(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register void* Cargo) 689 { 690 cmsCIELab LabIn, LabOut; 691 cmsCIELCh LChIn, LChOut; 692 cmsCIEXYZ XYZ; 693 LPBCHSWADJUSTS bchsw = (LPBCHSWADJUSTS) Cargo; 694 695 696 cmsLabEncoded2Float(&LabIn, In); 697 698 699 cmsLab2LCh(&LChIn, &LabIn); 700 701 // Do some adjusts on LCh 702 703 LChOut.L = LChIn.L * bchsw ->Contrast + bchsw ->Brightness; 704 LChOut.C = LChIn.C + bchsw -> Saturation; 705 LChOut.h = LChIn.h + bchsw -> Hue; 706 707 708 cmsLCh2Lab(&LabOut, &LChOut); 709 710 // Move white point in Lab 711 712 cmsLab2XYZ(&bchsw ->WPsrc, &XYZ, &LabOut); 713 cmsXYZ2Lab(&bchsw ->WPdest, &LabOut, &XYZ); 714 715 // Back to encoded 716 717 cmsFloat2LabEncoded(Out, &LabOut); 718 719 return TRUE; 720 } 721 722 723 // Creates an abstract profile operating in Lab space for Brightness, 724 // contrast, Saturation and white point displacement 725 726 cmsHPROFILE CMSEXPORT cmsCreateBCHSWabstractProfileTHR(cmsContext ContextID, 727 int nLUTPoints, 728 cmsFloat64Number Bright, 729 cmsFloat64Number Contrast, 730 cmsFloat64Number Hue, 731 cmsFloat64Number Saturation, 732 int TempSrc, 733 int TempDest) 734 { 735 cmsHPROFILE hICC; 736 cmsPipeline* Pipeline; 737 BCHSWADJUSTS bchsw; 738 cmsCIExyY WhitePnt; 739 cmsStage* CLUT; 740 cmsUInt32Number Dimensions[MAX_INPUT_DIMENSIONS]; 741 int i; 742 743 bchsw.Brightness = Bright; 744 bchsw.Contrast = Contrast; 745 bchsw.Hue = Hue; 746 bchsw.Saturation = Saturation; 747 748 cmsWhitePointFromTemp(&WhitePnt, TempSrc ); 749 cmsxyY2XYZ(&bchsw.WPsrc, &WhitePnt); 750 751 cmsWhitePointFromTemp(&WhitePnt, TempDest); 752 cmsxyY2XYZ(&bchsw.WPdest, &WhitePnt); 753 754 hICC = cmsCreateProfilePlaceholder(ContextID); 755 if (!hICC) // can't allocate 756 return NULL; 757 758 759 cmsSetDeviceClass(hICC, cmsSigAbstractClass); 760 cmsSetColorSpace(hICC, cmsSigLabData); 761 cmsSetPCS(hICC, cmsSigLabData); 762 763 cmsSetHeaderRenderingIntent(hICC, INTENT_PERCEPTUAL); 764 765 // Creates a Pipeline with 3D grid only 766 Pipeline = cmsPipelineAlloc(ContextID, 3, 3); 767 if (Pipeline == NULL) { 768 cmsCloseProfile(hICC); 769 return NULL; 770 } 771 772 for (i=0; i < MAX_INPUT_DIMENSIONS; i++) Dimensions[i] = nLUTPoints; 773 CLUT = cmsStageAllocCLut16bitGranular(ContextID, Dimensions, 3, 3, NULL); 774 if (CLUT == NULL) return NULL; 775 776 777 if (!cmsStageSampleCLut16bit(CLUT, bchswSampler, (void*) &bchsw, 0)) { 778 779 // Shouldn't reach here 780 goto Error; 781 } 782 783 if (!cmsPipelineInsertStage(Pipeline, cmsAT_END, CLUT)) { 784 goto Error; 785 } 786 787 // Create tags 788 if (!SetTextTags(hICC, L"BCHS built-in")) return NULL; 789 790 cmsWriteTag(hICC, cmsSigMediaWhitePointTag, (void*) cmsD50_XYZ()); 791 792 cmsWriteTag(hICC, cmsSigAToB0Tag, (void*) Pipeline); 793 794 // Pipeline is already on virtual profile 795 cmsPipelineFree(Pipeline); 796 797 // Ok, done 798 return hICC; 799 800 Error: 801 cmsPipelineFree(Pipeline); 802 cmsCloseProfile(hICC); 803 return NULL; 804 } 805 806 807 CMSAPI cmsHPROFILE CMSEXPORT cmsCreateBCHSWabstractProfile(int nLUTPoints, 808 cmsFloat64Number Bright, 809 cmsFloat64Number Contrast, 810 cmsFloat64Number Hue, 811 cmsFloat64Number Saturation, 812 int TempSrc, 813 int TempDest) 814 { 815 return cmsCreateBCHSWabstractProfileTHR(NULL, nLUTPoints, Bright, Contrast, Hue, Saturation, TempSrc, TempDest); 816 } 817 818 819 // Creates a fake NULL profile. This profile return 1 channel as always 0. 820 // Is useful only for gamut checking tricks 821 cmsHPROFILE CMSEXPORT cmsCreateNULLProfileTHR(cmsContext ContextID) 822 { 823 cmsHPROFILE hProfile; 824 cmsPipeline* LUT = NULL; 825 cmsStage* PostLin; 826 cmsToneCurve* EmptyTab; 827 cmsUInt16Number Zero[2] = { 0, 0 }; 828 829 hProfile = cmsCreateProfilePlaceholder(ContextID); 830 if (!hProfile) // can't allocate 831 return NULL; 832 833 cmsSetProfileVersion(hProfile, 4.3); 834 835 if (!SetTextTags(hProfile, L"NULL profile built-in")) goto Error; 836 837 838 839 cmsSetDeviceClass(hProfile, cmsSigOutputClass); 840 cmsSetColorSpace(hProfile, cmsSigGrayData); 841 cmsSetPCS(hProfile, cmsSigLabData); 842 843 // An empty LUTs is all we need 844 LUT = cmsPipelineAlloc(ContextID, 1, 1); 845 if (LUT == NULL) goto Error; 846 847 EmptyTab = cmsBuildTabulatedToneCurve16(ContextID, 2, Zero); 848 PostLin = cmsStageAllocToneCurves(ContextID, 1, &EmptyTab); 849 cmsFreeToneCurve(EmptyTab); 850 851 if (!cmsPipelineInsertStage(LUT, cmsAT_END, PostLin)) 852 goto Error; 853 854 if (!cmsWriteTag(hProfile, cmsSigBToA0Tag, (void*) LUT)) goto Error; 855 if (!cmsWriteTag(hProfile, cmsSigMediaWhitePointTag, cmsD50_XYZ())) goto Error; 856 857 cmsPipelineFree(LUT); 858 return hProfile; 859 860 Error: 861 862 if (LUT != NULL) 863 cmsPipelineFree(LUT); 864 865 if (hProfile != NULL) 866 cmsCloseProfile(hProfile); 867 868 return NULL; 869 } 870 871 cmsHPROFILE CMSEXPORT cmsCreateNULLProfile(void) 872 { 873 return cmsCreateNULLProfileTHR(NULL); 874 } 875 876 877 static 878 int IsPCS(cmsColorSpaceSignature ColorSpace) 879 { 880 return (ColorSpace == cmsSigXYZData || 881 ColorSpace == cmsSigLabData); 882 } 883 884 885 static 886 void FixColorSpaces(cmsHPROFILE hProfile, 887 cmsColorSpaceSignature ColorSpace, 888 cmsColorSpaceSignature PCS, 889 cmsUInt32Number dwFlags) 890 { 891 if (dwFlags & cmsFLAGS_GUESSDEVICECLASS) { 892 893 if (IsPCS(ColorSpace) && IsPCS(PCS)) { 894 895 cmsSetDeviceClass(hProfile, cmsSigAbstractClass); 896 cmsSetColorSpace(hProfile, ColorSpace); 897 cmsSetPCS(hProfile, PCS); 898 return; 899 } 900 901 if (IsPCS(ColorSpace) && !IsPCS(PCS)) { 902 903 cmsSetDeviceClass(hProfile, cmsSigOutputClass); 904 cmsSetPCS(hProfile, ColorSpace); 905 cmsSetColorSpace(hProfile, PCS); 906 return; 907 } 908 909 if (IsPCS(PCS) && !IsPCS(ColorSpace)) { 910 911 cmsSetDeviceClass(hProfile, cmsSigInputClass); 912 cmsSetColorSpace(hProfile, ColorSpace); 913 cmsSetPCS(hProfile, PCS); 914 return; 915 } 916 } 917 918 cmsSetDeviceClass(hProfile, cmsSigLinkClass); 919 cmsSetColorSpace(hProfile, ColorSpace); 920 cmsSetPCS(hProfile, PCS); 921 } 922 923 924 925 // This function creates a named color profile dumping all the contents of transform to a single profile 926 // In this way, LittleCMS may be used to "group" several named color databases into a single profile. 927 // It has, however, several minor limitations. PCS is always Lab, which is not very critic since this 928 // is the normal PCS for named color profiles. 929 static 930 cmsHPROFILE CreateNamedColorDevicelink(cmsHTRANSFORM xform) 931 { 932 _cmsTRANSFORM* v = (_cmsTRANSFORM*) xform; 933 cmsHPROFILE hICC = NULL; 934 int i, nColors; 935 cmsNAMEDCOLORLIST *nc2 = NULL, *Original = NULL; 936 937 // Create an empty placeholder 938 hICC = cmsCreateProfilePlaceholder(v->ContextID); 939 if (hICC == NULL) return NULL; 940 941 // Critical information 942 cmsSetDeviceClass(hICC, cmsSigNamedColorClass); 943 cmsSetColorSpace(hICC, v ->ExitColorSpace); 944 cmsSetPCS(hICC, cmsSigLabData); 945 946 // Tag profile with information 947 if (!SetTextTags(hICC, L"Named color devicelink")) goto Error; 948 949 Original = cmsGetNamedColorList(xform); 950 if (Original == NULL) goto Error; 951 952 nColors = cmsNamedColorCount(Original); 953 nc2 = cmsDupNamedColorList(Original); 954 if (nc2 == NULL) goto Error; 955 956 // Colorant count now depends on the output space 957 nc2 ->ColorantCount = cmsPipelineOutputChannels(v ->Lut); 958 959 // Make sure we have proper formatters 960 cmsChangeBuffersFormat(xform, TYPE_NAMED_COLOR_INDEX, 961 FLOAT_SH(0) | COLORSPACE_SH(_cmsLCMScolorSpace(v ->ExitColorSpace)) 962 | BYTES_SH(2) | CHANNELS_SH(cmsChannelsOf(v ->ExitColorSpace))); 963 964 // Apply the transfor to colorants. 965 for (i=0; i < nColors; i++) { 966 cmsDoTransform(xform, &i, nc2 ->List[i].DeviceColorant, 1); 967 } 968 969 if (!cmsWriteTag(hICC, cmsSigNamedColor2Tag, (void*) nc2)) goto Error; 970 cmsFreeNamedColorList(nc2); 971 972 return hICC; 973 974 Error: 975 if (hICC != NULL) cmsCloseProfile(hICC); 976 return NULL; 977 } 978 979 980 // This structure holds information about which MPU can be stored on a profile based on the version 981 982 typedef struct { 983 cmsBool IsV4; // Is a V4 tag? 984 cmsTagSignature RequiredTag; // Set to 0 for both types 985 cmsTagTypeSignature LutType; // The LUT type 986 int nTypes; // Number of types (up to 5) 987 cmsStageSignature MpeTypes[5]; // 5 is the maximum number 988 989 } cmsAllowedLUT; 990 991 static const cmsAllowedLUT AllowedLUTTypes[] = { 992 993 { FALSE, 0, cmsSigLut16Type, 4, { cmsSigMatrixElemType, cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType}}, 994 { FALSE, 0, cmsSigLut16Type, 3, { cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType}}, 995 { FALSE, 0, cmsSigLut16Type, 2, { cmsSigCurveSetElemType, cmsSigCLutElemType}}, 996 { TRUE , 0, cmsSigLutAtoBType, 1, { cmsSigCurveSetElemType }}, 997 { TRUE , cmsSigAToB0Tag, cmsSigLutAtoBType, 3, { cmsSigCurveSetElemType, cmsSigMatrixElemType, cmsSigCurveSetElemType } }, 998 { TRUE , cmsSigAToB0Tag, cmsSigLutAtoBType, 3, { cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType } }, 999 { TRUE , cmsSigAToB0Tag, cmsSigLutAtoBType, 5, { cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType, cmsSigMatrixElemType, cmsSigCurveSetElemType }}, 1000 { TRUE , cmsSigBToA0Tag, cmsSigLutBtoAType, 1, { cmsSigCurveSetElemType }}, 1001 { TRUE , cmsSigBToA0Tag, cmsSigLutBtoAType, 3, { cmsSigCurveSetElemType, cmsSigMatrixElemType, cmsSigCurveSetElemType }}, 1002 { TRUE , cmsSigBToA0Tag, cmsSigLutBtoAType, 3, { cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType }}, 1003 { TRUE , cmsSigBToA0Tag, cmsSigLutBtoAType, 5, { cmsSigCurveSetElemType, cmsSigMatrixElemType, cmsSigCurveSetElemType, cmsSigCLutElemType, cmsSigCurveSetElemType }} 1004 }; 1005 1006 #define SIZE_OF_ALLOWED_LUT (sizeof(AllowedLUTTypes)/sizeof(cmsAllowedLUT)) 1007 1008 // Check a single entry 1009 static 1010 cmsBool CheckOne(const cmsAllowedLUT* Tab, const cmsPipeline* Lut) 1011 { 1012 cmsStage* mpe; 1013 int n; 1014 1015 for (n=0, mpe = Lut ->Elements; mpe != NULL; mpe = mpe ->Next, n++) { 1016 1017 if (n > Tab ->nTypes) return FALSE; 1018 if (cmsStageType(mpe) != Tab ->MpeTypes[n]) return FALSE; 1019 } 1020 1021 return (n == Tab ->nTypes); 1022 } 1023 1024 1025 static 1026 const cmsAllowedLUT* FindCombination(const cmsPipeline* Lut, cmsBool IsV4, cmsTagSignature DestinationTag) 1027 { 1028 cmsUInt32Number n; 1029 1030 for (n=0; n < SIZE_OF_ALLOWED_LUT; n++) { 1031 1032 const cmsAllowedLUT* Tab = AllowedLUTTypes + n; 1033 1034 if (IsV4 ^ Tab -> IsV4) continue; 1035 if ((Tab ->RequiredTag != 0) && (Tab ->RequiredTag != DestinationTag)) continue; 1036 1037 if (CheckOne(Tab, Lut)) return Tab; 1038 } 1039 1040 return NULL; 1041 } 1042 1043 1044 // Does convert a transform into a device link profile 1045 cmsHPROFILE CMSEXPORT cmsTransform2DeviceLink(cmsHTRANSFORM hTransform, cmsFloat64Number Version, cmsUInt32Number dwFlags) 1046 { 1047 cmsHPROFILE hProfile = NULL; 1048 cmsUInt32Number FrmIn, FrmOut, ChansIn, ChansOut; 1049 cmsUInt32Number ColorSpaceBitsIn, ColorSpaceBitsOut; 1050 _cmsTRANSFORM* xform = (_cmsTRANSFORM*) hTransform; 1051 cmsPipeline* LUT = NULL; 1052 cmsStage* mpe; 1053 cmsContext ContextID = cmsGetTransformContextID(hTransform); 1054 const cmsAllowedLUT* AllowedLUT; 1055 cmsTagSignature DestinationTag; 1056 cmsProfileClassSignature deviceClass; 1057 1058 _cmsAssert(hTransform != NULL); 1059 1060 // Get the first mpe to check for named color 1061 mpe = cmsPipelineGetPtrToFirstStage(xform ->Lut); 1062 1063 // Check if is a named color transform 1064 if (mpe != NULL) { 1065 1066 if (cmsStageType(mpe) == cmsSigNamedColorElemType) { 1067 return CreateNamedColorDevicelink(hTransform); 1068 } 1069 } 1070 1071 // First thing to do is to get a copy of the transformation 1072 LUT = cmsPipelineDup(xform ->Lut); 1073 if (LUT == NULL) return NULL; 1074 1075 // Time to fix the Lab2/Lab4 issue. 1076 if ((xform ->EntryColorSpace == cmsSigLabData) && (Version < 4.0)) { 1077 1078 if (!cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocLabV2ToV4curves(ContextID))) 1079 goto Error; 1080 } 1081 1082 // On the output side too 1083 if ((xform ->ExitColorSpace) == cmsSigLabData && (Version < 4.0)) { 1084 1085 if (!cmsPipelineInsertStage(LUT, cmsAT_END, _cmsStageAllocLabV4ToV2(ContextID))) 1086 goto Error; 1087 } 1088 1089 1090 hProfile = cmsCreateProfilePlaceholder(ContextID); 1091 if (!hProfile) goto Error; // can't allocate 1092 1093 cmsSetProfileVersion(hProfile, Version); 1094 1095 FixColorSpaces(hProfile, xform -> EntryColorSpace, xform -> ExitColorSpace, dwFlags); 1096 1097 // Optimize the LUT and precalculate a devicelink 1098 1099 ChansIn = cmsChannelsOf(xform -> EntryColorSpace); 1100 ChansOut = cmsChannelsOf(xform -> ExitColorSpace); 1101 1102 ColorSpaceBitsIn = _cmsLCMScolorSpace(xform -> EntryColorSpace); 1103 ColorSpaceBitsOut = _cmsLCMScolorSpace(xform -> ExitColorSpace); 1104 1105 FrmIn = COLORSPACE_SH(ColorSpaceBitsIn) | CHANNELS_SH(ChansIn)|BYTES_SH(2); 1106 FrmOut = COLORSPACE_SH(ColorSpaceBitsOut) | CHANNELS_SH(ChansOut)|BYTES_SH(2); 1107 1108 deviceClass = cmsGetDeviceClass(hProfile); 1109 1110 if (deviceClass == cmsSigOutputClass) 1111 DestinationTag = cmsSigBToA0Tag; 1112 else 1113 DestinationTag = cmsSigAToB0Tag; 1114 1115 // Check if the profile/version can store the result 1116 if (dwFlags & cmsFLAGS_FORCE_CLUT) 1117 AllowedLUT = NULL; 1118 else 1119 AllowedLUT = FindCombination(LUT, Version >= 4.0, DestinationTag); 1120 1121 if (AllowedLUT == NULL) { 1122 1123 // Try to optimize 1124 _cmsOptimizePipeline(ContextID, &LUT, xform ->RenderingIntent, &FrmIn, &FrmOut, &dwFlags); 1125 AllowedLUT = FindCombination(LUT, Version >= 4.0, DestinationTag); 1126 1127 } 1128 1129 // If no way, then force CLUT that for sure can be written 1130 if (AllowedLUT == NULL) { 1131 1132 dwFlags |= cmsFLAGS_FORCE_CLUT; 1133 _cmsOptimizePipeline(ContextID, &LUT, xform ->RenderingIntent, &FrmIn, &FrmOut, &dwFlags); 1134 1135 // Put identity curves if needed 1136 if (cmsPipelineGetPtrToFirstStage(LUT) ->Type != cmsSigCurveSetElemType) 1137 if (!cmsPipelineInsertStage(LUT, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, ChansIn))) 1138 goto Error; 1139 1140 if (cmsPipelineGetPtrToLastStage(LUT) ->Type != cmsSigCurveSetElemType) 1141 if (!cmsPipelineInsertStage(LUT, cmsAT_END, _cmsStageAllocIdentityCurves(ContextID, ChansOut))) 1142 goto Error; 1143 1144 AllowedLUT = FindCombination(LUT, Version >= 4.0, DestinationTag); 1145 } 1146 1147 // Somethings is wrong... 1148 if (AllowedLUT == NULL) { 1149 goto Error; 1150 } 1151 1152 1153 if (dwFlags & cmsFLAGS_8BITS_DEVICELINK) 1154 cmsPipelineSetSaveAs8bitsFlag(LUT, TRUE); 1155 1156 // Tag profile with information 1157 if (!SetTextTags(hProfile, L"devicelink")) goto Error; 1158 1159 // Store result 1160 if (!cmsWriteTag(hProfile, DestinationTag, LUT)) goto Error; 1161 1162 1163 if (xform -> InputColorant != NULL) { 1164 if (!cmsWriteTag(hProfile, cmsSigColorantTableTag, xform->InputColorant)) goto Error; 1165 } 1166 1167 if (xform -> OutputColorant != NULL) { 1168 if (!cmsWriteTag(hProfile, cmsSigColorantTableOutTag, xform->OutputColorant)) goto Error; 1169 } 1170 1171 if ((deviceClass == cmsSigLinkClass) && (xform ->Sequence != NULL)) { 1172 if (!_cmsWriteProfileSequence(hProfile, xform ->Sequence)) goto Error; 1173 } 1174 1175 // Set the white point 1176 if (deviceClass == cmsSigInputClass) { 1177 if (!cmsWriteTag(hProfile, cmsSigMediaWhitePointTag, &xform ->EntryWhitePoint)) goto Error; 1178 } 1179 else { 1180 if (!cmsWriteTag(hProfile, cmsSigMediaWhitePointTag, &xform ->ExitWhitePoint)) goto Error; 1181 } 1182 1183 1184 // Per 7.2.15 in spec 4.3 1185 cmsSetHeaderRenderingIntent(hProfile, xform ->RenderingIntent); 1186 1187 cmsPipelineFree(LUT); 1188 return hProfile; 1189 1190 Error: 1191 if (LUT != NULL) cmsPipelineFree(LUT); 1192 cmsCloseProfile(hProfile); 1193 return NULL; 1194 } 1195
