// Create an output MPE LUT from agiven profile. Version mismatches are handled here cmsPipeline* _cmsReadOutputLUT(cmsHPROFILE hProfile, int Intent) { cmsTagTypeSignature OriginalType; cmsTagSignature tag16 = PCS2Device16[Intent]; cmsTagSignature tagFloat = PCS2DeviceFloat[Intent]; cmsContext ContextID = cmsGetProfileContextID(hProfile); if (cmsIsTag(hProfile, tagFloat)) { // Float tag takes precedence // Floating point LUT are always V4, so no adjustment is required return cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat)); } // Revert to perceptual if no tag is found if (!cmsIsTag(hProfile, tag16)) { tag16 = PCS2Device16[0]; } if (cmsIsTag(hProfile, tag16)) { // Is there any LUT-Based table? // Check profile version and LUT type. Do the necessary adjustments if needed // First read the tag cmsPipeline* Lut = (cmsPipeline*) cmsReadTag(hProfile, tag16); if (Lut == NULL) return NULL; // After reading it, we have info about the original type OriginalType = _cmsGetTagTrueType(hProfile, tag16); // The profile owns the Lut, so we need to copy it Lut = cmsPipelineDup(Lut); if (Lut == NULL) return NULL; // Now it is time for a controversial stuff. I found that for 3D LUTS using // Lab used as indexer space, trilinear interpolation should be used if (cmsGetPCS(hProfile) == cmsSigLabData) ChangeInterpolationToTrilinear(Lut); // We need to adjust data only for Lab and Lut16 type if (OriginalType != cmsSigLut16Type || cmsGetPCS(hProfile) != cmsSigLabData) return Lut; // Add a matrix for conversion V4 to V2 Lab PCS cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageAllocLabV4ToV2(ContextID)); return Lut; } // Lut not found, try to create a matrix-shaper // Check if this is a grayscale profile. if (cmsGetColorSpace(hProfile) == cmsSigGrayData) { // if so, build appropiate conversion tables. // The tables are the PCS iluminant, scaled across GrayTRC return BuildGrayOutputPipeline(hProfile); } // Not gray, create a normal matrix-shaper return BuildRGBOutputMatrixShaper(hProfile); }
// Read both, profile sequence description and profile sequence id if present. Then combine both to // create qa unique structure holding both. Shame on ICC to store things in such complicated way. cmsSEQ* _cmsReadProfileSequence(cmsHPROFILE hProfile) { cmsSEQ* ProfileSeq; cmsSEQ* ProfileId; cmsSEQ* NewSeq; cmsUInt32Number i; // Take profile sequence description first ProfileSeq = (cmsSEQ*) cmsReadTag(hProfile, cmsSigProfileSequenceDescTag); // Take profile sequence ID ProfileId = (cmsSEQ*) cmsReadTag(hProfile, cmsSigProfileSequenceIdTag); if (ProfileSeq == NULL && ProfileId == NULL) return NULL; if (ProfileSeq == NULL) return cmsDupProfileSequenceDescription(ProfileId); if (ProfileId == NULL) return cmsDupProfileSequenceDescription(ProfileSeq); // We have to mix both together. For that they must agree if (ProfileSeq ->n != ProfileId ->n) return cmsDupProfileSequenceDescription(ProfileSeq); NewSeq = cmsDupProfileSequenceDescription(ProfileSeq); // Ok, proceed to the mixing if (NewSeq != NULL) { for (i=0; i < ProfileSeq ->n; i++) { memmove(&NewSeq ->seq[i].ProfileID, &ProfileId ->seq[i].ProfileID, sizeof(cmsProfileID)); NewSeq ->seq[i].Description = cmsMLUdup(ProfileId ->seq[i].Description); } } return NewSeq; }
/** * gimp_color_profile_is_linear: * @profile: a #GimpColorProfile * * This function determines is the ICC profile represented by a GimpColorProfile * is a linear RGB profile or not, some profiles that are LUTs though linear * will also return FALSE; * * Return value: %TRUE if the profile is a matrix shaping profile with linear * TRCs, %FALSE otherwise. * * Since: 2.10 **/ gboolean gimp_color_profile_is_linear (GimpColorProfile *profile) { cmsHPROFILE prof; cmsToneCurve *curve; g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (profile), FALSE); prof = profile->priv->lcms_profile; if (! cmsIsMatrixShaper (prof)) return FALSE; if (cmsIsCLUT (prof, INTENT_PERCEPTUAL, LCMS_USED_AS_INPUT)) return FALSE; if (cmsIsCLUT (prof, INTENT_PERCEPTUAL, LCMS_USED_AS_OUTPUT)) return FALSE; curve = cmsReadTag(prof, cmsSigRedTRCTag); if (curve == NULL || ! cmsIsToneCurveLinear (curve)) return FALSE; curve = cmsReadTag (prof, cmsSigGreenTRCTag); if (curve == NULL || ! cmsIsToneCurveLinear (curve)) return FALSE; curve = cmsReadTag (prof, cmsSigBlueTRCTag); if (curve == NULL || ! cmsIsToneCurveLinear (curve)) return FALSE; return TRUE; }
// Chromatic adaptation matrix. Fix some issues as well cmsBool _cmsReadCHAD(cmsMAT3* Dest, cmsHPROFILE hProfile) { cmsMAT3* Tag; _cmsAssert(Dest != NULL); Tag = (cmsMAT3*) cmsReadTag(hProfile, cmsSigChromaticAdaptationTag); if (Tag != NULL) { *Dest = *Tag; return TRUE; } // No CHAD available, default it to identity _cmsMAT3identity(Dest); // V2 display profiles should give D50 if (cmsGetEncodedICCversion(hProfile) < 0x4000000) { if (cmsGetDeviceClass(hProfile) == cmsSigDisplayClass) { cmsCIEXYZ* White = (cmsCIEXYZ*) cmsReadTag(hProfile, cmsSigMediaWhitePointTag); if (White == NULL) { _cmsMAT3identity(Dest); return TRUE; } return _cmsAdaptationMatrix(Dest, NULL, White, cmsD50_XYZ()); } } return TRUE; }
static void EmitHeader(cmsIOHANDLER* m, const char* Title, cmsHPROFILE hProfile) { time_t timer; cmsMLU *Description, *Copyright; char DescASCII[256], CopyrightASCII[256]; time(&timer); Description = (cmsMLU*) cmsReadTag(hProfile, cmsSigProfileDescriptionTag); Copyright = (cmsMLU*) cmsReadTag(hProfile, cmsSigCopyrightTag); DescASCII[0] = DescASCII[255] = 0; CopyrightASCII[0] = CopyrightASCII[255] = 0; if (Description != NULL) cmsMLUgetASCII(Description, cmsNoLanguage, cmsNoCountry, DescASCII, 255); if (Copyright != NULL) cmsMLUgetASCII(Copyright, cmsNoLanguage, cmsNoCountry, CopyrightASCII, 255); _cmsIOPrintf(m, "%%!PS-Adobe-3.0\n"); _cmsIOPrintf(m, "%%\n"); _cmsIOPrintf(m, "%% %s\n", Title); _cmsIOPrintf(m, "%% Source: %s\n", RemoveCR(DescASCII)); _cmsIOPrintf(m, "%% %s\n", RemoveCR(CopyrightASCII)); _cmsIOPrintf(m, "%% Created: %s", ctime(&timer)); // ctime appends a \n!!! _cmsIOPrintf(m, "%%\n"); _cmsIOPrintf(m, "%%%%BeginResource\n"); }
// Read and create a BRAND NEW MPE LUT from a given profile. All stuff dependent of version, etc // is adjusted here in order to create a LUT that takes care of all those details cmsPipeline* _cmsReadInputLUT(cmsHPROFILE hProfile, int Intent) { cmsTagTypeSignature OriginalType; cmsTagSignature tag16 = Device2PCS16[Intent]; cmsTagSignature tagFloat = Device2PCSFloat[Intent]; cmsContext ContextID = cmsGetProfileContextID(hProfile); if (cmsIsTag(hProfile, tagFloat)) { // Float tag takes precedence // Floating point LUT are always V4, so no adjustment is required return cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat)); } // Revert to perceptual if no tag is found if (!cmsIsTag(hProfile, tag16)) { tag16 = Device2PCS16[0]; } if (cmsIsTag(hProfile, tag16)) { // Is there any LUT-Based table? // Check profile version and LUT type. Do the necessary adjustments if needed // First read the tag cmsPipeline* Lut = (cmsPipeline*) cmsReadTag(hProfile, tag16); if (Lut == NULL) return NULL; // After reading it, we have now info about the original type OriginalType = _cmsGetTagTrueType(hProfile, tag16); // The profile owns the Lut, so we need to copy it Lut = cmsPipelineDup(Lut); // We need to adjust data only for Lab16 on output if (OriginalType != cmsSigLut16Type || cmsGetPCS(hProfile) != cmsSigLabData) return Lut; // If the input is Lab, add also a conversion at the begin if (cmsGetColorSpace(hProfile) == cmsSigLabData) cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageAllocLabV4ToV2(ContextID)); // Add a matrix for conversion V2 to V4 Lab PCS cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocLabV2ToV4(ContextID)); return Lut; } // Lut was not found, try to create a matrix-shaper // Check if this is a grayscale profile. if (cmsGetColorSpace(hProfile) == cmsSigGrayData) { // if so, build appropiate conversion tables. // The tables are the PCS iluminant, scaled across GrayTRC return BuildGrayInputMatrixPipeline(hProfile); } // Not gray, create a normal matrix-shaper return BuildRGBInputMatrixShaper(hProfile); }
QString dkCmsTakeProductInfo(cmsHPROFILE hProfile) { static char Info[4096]; cmsMLU* mlu = 0; Info[0] = '\0'; if (cmsIsTag(hProfile, cmsSigProfileDescriptionTag)) { char Desc[1024]; mlu = static_cast<cmsMLU*>( cmsReadTag(hProfile, cmsSigProfileDescriptionTag) ); cmsMLUgetASCII(mlu, "en", "US", Desc, 1024); strcat(Info, Desc); } if (cmsIsTag(hProfile, cmsSigCopyrightTag)) { char Copyright[1024]; mlu = static_cast<cmsMLU*>( cmsReadTag(hProfile, cmsSigCopyrightTag) ); cmsMLUgetASCII(mlu, "en", "US", Copyright, 1024); strcat(Info, " - "); strcat(Info, Copyright); } #define K007 static_cast<cmsTagSignature>( 0x4B303037 ) if (cmsIsTag(hProfile, K007)) { char MonCal[1024]; mlu = static_cast<cmsMLU*>( cmsReadTag(hProfile, K007) ); cmsMLUgetASCII(mlu, "en", "US", MonCal, 1024); strcat(Info, " - "); strcat(Info, MonCal); } else { /* * _cmsIdentifyWhitePoint is complex and partly redundant * with cietonguewidget, leave this part off * untill the full lcms2 implementation * cmsCIEXYZ WhitePt; char WhiteStr[1024]; dkCmsTakeMediaWhitePoint(&WhitePt, hProfile); _cmsIdentifyWhitePoint(WhiteStr, &WhitePt); strcat(Info, " - "); strcat(Info, WhiteStr); */ } #undef K007 return QString::fromLatin1(Info); }
static cmsPipeline* BuildRGBOutputMatrixShaper(cmsHPROFILE hProfile) { cmsPipeline* Lut; cmsToneCurve *Shapes[3], *InvShapes[3]; cmsMAT3 Mat, Inv; int i, j; cmsContext ContextID = cmsGetProfileContextID(hProfile); if (!ReadICCMatrixRGB2XYZ(&Mat, hProfile)) return NULL; if (!_cmsMAT3inverse(&Mat, &Inv)) return NULL; // XYZ PCS in encoded in 1.15 format, and the matrix input should come in 0..0xffff range, so // we need to adjust the input by a << 1 to obtain a 1.16 fixed and then by a factor of // (0xffff/0x10000) to put data in 0..0xffff range. Total factor is (2.0*65535.0)/65536.0; for (i=0; i < 3; i++) for (j=0; j < 3; j++) Inv.v[i].n[j] *= OutpAdj; Shapes[0] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigRedTRCTag); Shapes[1] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGreenTRCTag); Shapes[2] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigBlueTRCTag); if (!Shapes[0] || !Shapes[1] || !Shapes[2]) return NULL; InvShapes[0] = cmsReverseToneCurve(Shapes[0]); InvShapes[1] = cmsReverseToneCurve(Shapes[1]); InvShapes[2] = cmsReverseToneCurve(Shapes[2]); if (!InvShapes[0] || !InvShapes[1] || !InvShapes[2]) { return NULL; } Lut = cmsPipelineAlloc(ContextID, 3, 3); if (Lut != NULL) { // Note that it is certainly possible a single profile would have a LUT based // tag for output working in lab and a matrix-shaper for the fallback cases. // This is not allowed by the spec, but this code is tolerant to those cases if (cmsGetPCS(hProfile) == cmsSigLabData) { cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocLab2XYZ(ContextID)); } cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 3, (cmsFloat64Number*) &Inv, NULL)); cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 3, InvShapes)); } cmsFreeToneCurveTriple(InvShapes); return Lut; }
// This one includes abstract profiles as well. Matrix-shaper cannot be obtained on that device class. The // tag name here may default to AToB0 cmsPipeline* _cmsReadDevicelinkLUT(cmsHPROFILE hProfile, int Intent) { cmsPipeline* Lut; cmsTagTypeSignature OriginalType; cmsTagSignature tag16 = Device2PCS16[Intent]; cmsTagSignature tagFloat = Device2PCSFloat[Intent]; cmsContext ContextID = cmsGetProfileContextID(hProfile); if (cmsIsTag(hProfile, tagFloat)) { // Float tag takes precedence // Floating point LUT are always V4, no adjustment is required return cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat)); } tagFloat = Device2PCSFloat[0]; if (cmsIsTag(hProfile, tagFloat)) { return cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat)); } if (!cmsIsTag(hProfile, tag16)) { // Is there any LUT-Based table? tag16 = Device2PCS16[0]; if (!cmsIsTag(hProfile, tag16)) return NULL; } // Check profile version and LUT type. Do the necessary adjustments if needed // Read the tag Lut = (cmsPipeline*) cmsReadTag(hProfile, tag16); if (Lut == NULL) return NULL; // The profile owns the Lut, so we need to copy it Lut = cmsPipelineDup(Lut); // After reading it, we have info about the original type OriginalType = _cmsGetTagTrueType(hProfile, tag16); // We need to adjust data for Lab16 on output if (OriginalType != cmsSigLut16Type) return Lut; // Here it is possible to get Lab on both sides if (cmsGetPCS(hProfile) == cmsSigLabData) { cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageAllocLabV4ToV2(ContextID)); } if (cmsGetColorSpace(hProfile) == cmsSigLabData) { cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocLabV2ToV4(ContextID)); } return Lut; }
static cmsPipeline* BuildRGBOutputMatrixShaper(cmsHPROFILE hProfile) { cmsPipeline* Lut; cmsToneCurve *Shapes[3], *InvShapes[3]; cmsMAT3 Mat, Inv; int i, j; cmsContext ContextID = cmsGetProfileContextID(hProfile); if (!ReadICCMatrixRGB2XYZ(&Mat, hProfile)) return NULL; if (!_cmsMAT3inverse(&Mat, &Inv)) return NULL; // XYZ PCS in encoded in 1.15 format, and the matrix input should come in 0..0xffff range, so // we need to adjust the input by a << 1 to obtain a 1.16 fixed and then by a factor of // (0xffff/0x10000) to put data in 0..0xffff range. Total factor is (2.0*65535.0)/65536.0; for (i=0; i < 3; i++) for (j=0; j < 3; j++) Inv.v[i].n[j] *= OutpAdj; Shapes[0] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigRedTRCTag); Shapes[1] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGreenTRCTag); Shapes[2] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigBlueTRCTag); if (!Shapes[0] || !Shapes[1] || !Shapes[2]) return NULL; InvShapes[0] = cmsReverseToneCurve(Shapes[0]); InvShapes[1] = cmsReverseToneCurve(Shapes[1]); InvShapes[2] = cmsReverseToneCurve(Shapes[2]); if (!InvShapes[0] || !InvShapes[1] || !InvShapes[2]) { return NULL; } Lut = cmsPipelineAlloc(ContextID, 3, 3); if (Lut != NULL) { cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 3, (cmsFloat64Number*) &Inv, NULL)); cmsStage* mpe = cmsStageAllocToneCurves(ContextID, 3, InvShapes); if (mpe) cmsPipelineInsertStage(Lut, cmsAT_END, mpe); else { cmsPipelineFree(Lut); Lut = NULL; } } cmsFreeToneCurveTriple(InvShapes); return Lut; }
// RGB Matrix shaper static cmsPipeline* BuildRGBInputMatrixShaper(cmsHPROFILE hProfile) { cmsPipeline* Lut; cmsMAT3 Mat; cmsToneCurve *Shapes[3]; cmsContext ContextID = cmsGetProfileContextID(hProfile); int i, j; if (!ReadICCMatrixRGB2XYZ(&Mat, hProfile)) return NULL; // XYZ PCS in encoded in 1.15 format, and the matrix output comes in 0..0xffff range, so // we need to adjust the output by a factor of (0x10000/0xffff) to put data in // a 1.16 range, and then a >> 1 to obtain 1.15. The total factor is (65536.0)/(65535.0*2) for (i=0; i < 3; i++) for (j=0; j < 3; j++) Mat.v[i].n[j] *= InpAdj; Shapes[0] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigRedTRCTag); Shapes[1] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGreenTRCTag); Shapes[2] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigBlueTRCTag); if (!Shapes[0] || !Shapes[1] || !Shapes[2]) return NULL; Lut = cmsPipelineAlloc(ContextID, 3, 3); if (Lut != NULL) { if (!cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 3, Shapes)) || !cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 3, (cmsFloat64Number*) &Mat, NULL))) goto Error; // Note that it is certainly possible a single profile would have a LUT based // tag for output working in lab and a matrix-shaper for the fallback cases. // This is not allowed by the spec, but this code is tolerant to those cases if (cmsGetPCS(hProfile) == cmsSigLabData) { if (!cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageAllocXYZ2Lab(ContextID))) goto Error; } } return Lut; Error: cmsPipelineFree(Lut); return NULL; }
// Get a media white point fixing some issues found in certain old profiles cmsBool _cmsReadMediaWhitePoint(cmsCIEXYZ* Dest, cmsHPROFILE hProfile) { cmsCIEXYZ* Tag; _cmsAssert(Dest != NULL); Tag = (cmsCIEXYZ*) cmsReadTag(hProfile, cmsSigMediaWhitePointTag); // If no wp, take D50 if (Tag == NULL) { *Dest = *cmsD50_XYZ(); return TRUE; } // V2 display profiles should give D50 if (cmsGetEncodedICCversion(hProfile) < 0x4000000) { if (cmsGetDeviceClass(hProfile) == cmsSigDisplayClass) { *Dest = *cmsD50_XYZ(); return TRUE; } } // All seems ok *Dest = *Tag; return TRUE; }
/* Get the nth colorant name in the clrt tag */ char* gscms_get_clrtname(gcmmhprofile_t profile, int colorcount, gs_memory_t *memory) { cmsNAMEDCOLORLIST *lcms_names; char name[256]; char *buf; int length; lcms_names = (cmsNAMEDCOLORLIST *)cmsReadTag(profile, cmsSigColorantTableTag); if (colorcount >= cmsNamedColorCount(lcms_names)) return(NULL); if (cmsNamedColorInfo(lcms_names, colorcount, name, NULL, NULL, NULL, NULL) == 0) return NULL; length = strlen(name); buf = (char*) gs_alloc_bytes(memory, length + 1, "gscms_get_clrtname"); if (buf) strcpy(buf, name); return buf; }
// Read the AToD0 tag, adjusting the encoding of Lab or XYZ if neded static cmsPipeline* _cmsReadFloatDevicelinkTag(cmsHPROFILE hProfile, cmsTagSignature tagFloat) { cmsContext ContextID = cmsGetProfileContextID(hProfile); cmsPipeline* Lut = cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat)); cmsColorSpaceSignature PCS = cmsGetPCS(hProfile); cmsColorSpaceSignature spc = cmsGetColorSpace(hProfile); if (Lut == NULL) return NULL; if (spc == cmsSigLabData) { cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageNormalizeToLabFloat(ContextID)); } else if (spc == cmsSigXYZData) { cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageNormalizeToXyzFloat(ContextID)); } if (PCS == cmsSigLabData) { cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageNormalizeFromLabFloat(ContextID)); } else if (PCS == cmsSigXYZData) { cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageNormalizeFromXyzFloat(ContextID)); } return Lut; }
static cmsPipeline* _cmsReadFloatOutputTag(cmsHPROFILE hProfile, cmsTagSignature tagFloat) { cmsContext ContextID = cmsGetProfileContextID(hProfile); cmsPipeline* Lut = cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat)); cmsColorSpaceSignature PCS = cmsGetPCS(hProfile); cmsColorSpaceSignature dataSpace = cmsGetColorSpace(hProfile); if (Lut == NULL) return NULL; // If PCS is Lab or XYZ, the floating point tag is accepting data in the space encoding, // and since the formatter has already accomodated to 0..1.0, we should undo this change if ( PCS == cmsSigLabData) { cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageNormalizeToLabFloat(ContextID)); } else if (PCS == cmsSigXYZData) { cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageNormalizeToXyzFloat(ContextID)); } // the output can be Lab or XYZ, in which case normalisation is needed on the end of the pipeline if ( dataSpace == cmsSigLabData) { cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageNormalizeFromLabFloat(ContextID)); } else if ( dataSpace == cmsSigXYZData) { cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageNormalizeFromXyzFloat(ContextID)); } return Lut; }
static cmsPipeline* BuildGrayOutputPipeline(cmsHPROFILE hProfile) { cmsToneCurve *GrayTRC, *RevGrayTRC; cmsPipeline* Lut; cmsContext ContextID = cmsGetProfileContextID(hProfile); GrayTRC = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGrayTRCTag); if (GrayTRC == NULL) return NULL; RevGrayTRC = cmsReverseToneCurve(GrayTRC); if (RevGrayTRC == NULL) return NULL; Lut = cmsPipelineAlloc(ContextID, 3, 1); if (Lut == NULL) { cmsFreeToneCurve(RevGrayTRC); return NULL; } if (cmsGetPCS(hProfile) == cmsSigLabData) { cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 1, 3, PickLstarMatrix, NULL)); } else { cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 1, 3, PickYMatrix, NULL)); } cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 1, &RevGrayTRC)); cmsFreeToneCurve(RevGrayTRC); return Lut; }
/*static cmsPipeline* _cmsReadFloatInputTag(cmsHPROFILE hProfile, cmsTagSignature tagFloat) { cmsContext ContextID = cmsGetProfileContextID(hProfile); cmsPipeline* Lut = cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat)); cmsColorSpaceSignature spc = cmsGetColorSpace(hProfile); if (Lut == NULL) return NULL; // If PCS is Lab or XYZ, the floating point tag is accepting data in the space encoding, // and since the formatter has already accomodated to 0..1.0, we should undo this change if ( spc == cmsSigLabData) { cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageNormalizeFromLabFloat(ContextID)); } else if (spc == cmsSigXYZData) { cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageNormalizeFromXyzFloat(ContextID)); } return Lut; } */ static cmsPipeline* _cmsReadFloatInputTag(cmsHPROFILE hProfile, cmsTagSignature tagFloat) { cmsContext ContextID = cmsGetProfileContextID(hProfile); cmsPipeline* Lut = cmsPipelineDup((cmsPipeline*) cmsReadTag(hProfile, tagFloat)); cmsColorSpaceSignature spc = cmsGetColorSpace(hProfile); cmsColorSpaceSignature PCS = cmsGetPCS(hProfile); if (Lut == NULL) return NULL; // input and output of transform are in lcms 0..1 encoding. If XYZ or Lab spaces are used, // these need to be normalized into the appropriate ranges (Lab = 100,0,0, XYZ=1.0,1.0,1.0) if ( spc == cmsSigLabData) { cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageNormalizeToLabFloat(ContextID)); } else if (spc == cmsSigXYZData) { cmsPipelineInsertStage(Lut, cmsAT_BEGIN, _cmsStageNormalizeToXyzFloat(ContextID)); } if ( PCS == cmsSigLabData) { cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageNormalizeFromLabFloat(ContextID)); } else if( PCS == cmsSigXYZData) { cmsPipelineInsertStage(Lut, cmsAT_END, _cmsStageNormalizeFromXyzFloat(ContextID)); } return Lut; }
static const cmsMLU* GetInfo(cmsHPROFILE hProfile, cmsInfoType Info) { cmsTagSignature sig; switch (Info) { case cmsInfoDescription: sig = cmsSigProfileDescriptionTag; break; case cmsInfoManufacturer: sig = cmsSigDeviceMfgDescTag; break; case cmsInfoModel: sig = cmsSigDeviceModelDescTag; break; case cmsInfoCopyright: sig = cmsSigCopyrightTag; break; default: return NULL; } return (cmsMLU*) cmsReadTag(hProfile, sig); }
// Displays the colorant table static void PrintColorantTable(cmsHPROFILE hInput, cmsTagSignature Sig, const char* Title) { cmsNAMEDCOLORLIST* list; int i, n; if (cmsIsTag(hInput, Sig)) { printf("%s:\n", Title); list = cmsReadTag(hInput, Sig); if (list == NULL) { printf("(Unavailable)\n"); return; } n = cmsNamedColorCount(list); for (i=0; i < n; i++) { char Name[cmsMAX_PATH]; cmsNamedColorInfo(list, i, Name, NULL, NULL, NULL, NULL); printf("\t%s\n", Name); } printf("\n"); } }
// Create a sequence description out of an array of profiles cmsSEQ* _cmsCompileProfileSequence(cmsContext ContextID, cmsUInt32Number nProfiles, cmsHPROFILE hProfiles[]) { cmsUInt32Number i; cmsSEQ* seq = cmsAllocProfileSequenceDescription(ContextID, nProfiles); if (seq == NULL) return NULL; for (i=0; i < nProfiles; i++) { cmsPSEQDESC* ps = &seq ->seq[i]; cmsHPROFILE h = hProfiles[i]; cmsTechnologySignature* techpt; cmsGetHeaderAttributes(h, &ps ->attributes); cmsGetHeaderProfileID(h, ps ->ProfileID.ID8); ps ->deviceMfg = cmsGetHeaderManufacturer(h); ps ->deviceModel = cmsGetHeaderModel(h); techpt = (cmsTechnologySignature*) cmsReadTag(h, cmsSigTechnologyTag); if (techpt == NULL) ps ->technology = (cmsTechnologySignature) 0; else ps ->technology = *techpt; ps ->Manufacturer = GetMLUFromProfile(h, cmsSigDeviceMfgDescTag); ps ->Model = GetMLUFromProfile(h, cmsSigDeviceModelDescTag); ps ->Description = GetMLUFromProfile(h, cmsSigProfileDescriptionTag); } return seq; }
QString dkCmsTakeProductName(cmsHPROFILE hProfile) { static char Name[1024*2+4]; char Manufacturer[1024], Model[1024]; Name[0] = '\0'; Manufacturer[0] = Model[0] = '\0'; cmsMLU* mlu = 0; if (cmsIsTag(hProfile, cmsSigDeviceMfgDescTag)) { mlu = static_cast<cmsMLU*>( cmsReadTag(hProfile, cmsSigDeviceMfgDescTag) ); cmsMLUgetASCII(mlu, "en", "US", Manufacturer, 1024); } if (cmsIsTag(hProfile, cmsSigDeviceModelDescTag)) { mlu = static_cast<cmsMLU*>( cmsReadTag(hProfile, cmsSigDeviceModelDescTag) ); cmsMLUgetASCII(mlu, "en", "US", Model, 1024); } if (!Manufacturer[0] && !Model[0]) { if (cmsIsTag(hProfile, cmsSigProfileDescriptionTag)) { mlu = static_cast<cmsMLU*>( cmsReadTag(hProfile, cmsSigProfileDescriptionTag) ); cmsMLUgetASCII(mlu, "en", "US", Name, 1024); return QString::fromLatin1(Name); } else { return QString::fromLatin1("{no name}"); } } if (!Manufacturer[0] || strncmp(Model, Manufacturer, 8) == 0 || strlen(Model) > 30) { strcpy(Name, Model); } else { sprintf(Name, "%s - %s", Model, Manufacturer); } return QString::fromLatin1(Name); }
// Auxiliary, read and duplicate a MLU if found. static cmsMLU* GetMLUFromProfile(cmsHPROFILE h, cmsTagSignature sig) { cmsMLU* mlu = (cmsMLU*) cmsReadTag(h, sig); if (mlu == NULL) return NULL; return cmsMLUdup(mlu); }
/* Get the number of colorant names in the clrt tag */ int gscms_get_numberclrtnames(gcmmhprofile_t profile) { cmsNAMEDCOLORLIST *lcms_names; lcms_names = (cmsNAMEDCOLORLIST *)cmsReadTag(profile, cmsSigColorantTableTag); return cmsNamedColorCount(lcms_names); }
LCMSBOOL dkCmsTakeMediaWhitePoint(LPcmsCIEXYZ Dest, cmsHPROFILE hProfile) { LPcmsCIEXYZ tag = static_cast<LPcmsCIEXYZ>( cmsReadTag(hProfile, cmsSigMediaWhitePointTag) ); if (tag == NULL) return FALSE; *Dest = *tag; return TRUE; }
// Auxiliary, read colorants as a MAT3 structure. Used by any function that needs a matrix-shaper static cmsBool ReadICCMatrixRGB2XYZ(cmsMAT3* r, cmsHPROFILE hProfile) { cmsCIEXYZ *PtrRed, *PtrGreen, *PtrBlue; _cmsAssert(r != NULL); PtrRed = (cmsCIEXYZ *) cmsReadTag(hProfile, cmsSigRedColorantTag); PtrGreen = (cmsCIEXYZ *) cmsReadTag(hProfile, cmsSigGreenColorantTag); PtrBlue = (cmsCIEXYZ *) cmsReadTag(hProfile, cmsSigBlueColorantTag); if (PtrRed == NULL || PtrGreen == NULL || PtrBlue == NULL) return FALSE; _cmsVEC3init(&r -> v[0], PtrRed -> X, PtrGreen -> X, PtrBlue -> X); _cmsVEC3init(&r -> v[1], PtrRed -> Y, PtrGreen -> Y, PtrBlue -> Y); _cmsVEC3init(&r -> v[2], PtrRed -> Z, PtrGreen -> Z, PtrBlue -> Z); return TRUE; }
QString dkCmsTakeCopyright(cmsHPROFILE hProfile) { char buffer[1024]; const cmsMLU* const mlu = (const cmsMLU* const)cmsReadTag(hProfile, cmsSigCopyrightTag); buffer[0] = '\0'; if (mlu == NULL) return QString(); cmsMLUgetASCII(mlu, "en", "US", buffer, 1024); return QString::fromLatin1(buffer); }
// Gray input pipeline static cmsPipeline* BuildGrayInputMatrixPipeline(cmsHPROFILE hProfile) { cmsToneCurve *GrayTRC; cmsPipeline* Lut; cmsContext ContextID = cmsGetProfileContextID(hProfile); GrayTRC = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGrayTRCTag); if (GrayTRC == NULL) return NULL; Lut = cmsPipelineAlloc(ContextID, 1, 3); if (Lut == NULL) goto Error; if (cmsGetPCS(hProfile) == cmsSigLabData) { // In this case we implement the profile as an identity matrix plus 3 tone curves cmsUInt16Number Zero[2] = { 0x8080, 0x8080 }; cmsToneCurve* EmptyTab; cmsToneCurve* LabCurves[3]; EmptyTab = cmsBuildTabulatedToneCurve16(ContextID, 2, Zero); if (EmptyTab == NULL) goto Error; LabCurves[0] = GrayTRC; LabCurves[1] = EmptyTab; LabCurves[2] = EmptyTab; if (!cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 1, OneToThreeInputMatrix, NULL)) || !cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 3, LabCurves))) { cmsFreeToneCurve(EmptyTab); goto Error; } cmsFreeToneCurve(EmptyTab); } else { if (!cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 1, &GrayTRC)) || !cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 1, GrayInputMatrix, NULL))) goto Error; } return Lut; Error: cmsFreeToneCurve(GrayTRC); cmsPipelineFree(Lut); return NULL; }
static gboolean gimp_color_profile_get_rgb_matrix_colorants (GimpColorProfile *profile, GimpMatrix3 *matrix) { cmsHPROFILE lcms_profile; cmsCIEXYZ *red; cmsCIEXYZ *green; cmsCIEXYZ *blue; g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (profile), FALSE); lcms_profile = profile->priv->lcms_profile; red = cmsReadTag (lcms_profile, cmsSigRedColorantTag); green = cmsReadTag (lcms_profile, cmsSigGreenColorantTag); blue = cmsReadTag (lcms_profile, cmsSigBlueColorantTag); if (red && green && blue) { if (matrix) { matrix->coeff[0][0] = red->X; matrix->coeff[0][1] = red->Y; matrix->coeff[0][2] = red->Z; matrix->coeff[1][0] = green->X; matrix->coeff[1][1] = green->Y; matrix->coeff[1][2] = green->Z; matrix->coeff[2][0] = blue->X; matrix->coeff[2][1] = blue->Y; matrix->coeff[2][2] = blue->Z; } return TRUE; } return FALSE; }
// RGB Matrix shaper static cmsPipeline* BuildRGBInputMatrixShaper(cmsHPROFILE hProfile) { cmsPipeline* Lut; cmsMAT3 Mat; cmsToneCurve *Shapes[3]; cmsContext ContextID = cmsGetProfileContextID(hProfile); int i, j; if (!ReadICCMatrixRGB2XYZ(&Mat, hProfile)) return NULL; // XYZ PCS in encoded in 1.15 format, and the matrix output comes in 0..0xffff range, so // we need to adjust the output by a factor of (0x10000/0xffff) to put data in // a 1.16 range, and then a >> 1 to obtain 1.15. The total factor is (65536.0)/(65535.0*2) for (i=0; i < 3; i++) for (j=0; j < 3; j++) Mat.v[i].n[j] *= InpAdj; Shapes[0] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigRedTRCTag); Shapes[1] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigGreenTRCTag); Shapes[2] = (cmsToneCurve *) cmsReadTag(hProfile, cmsSigBlueTRCTag); if (!Shapes[0] || !Shapes[1] || !Shapes[2]) return NULL; Lut = cmsPipelineAlloc(ContextID, 3, 3); if (Lut != NULL) { cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocToneCurves(ContextID, 3, Shapes)); cmsPipelineInsertStage(Lut, cmsAT_END, cmsStageAllocMatrix(ContextID, 3, 3, (cmsFloat64Number*) &Mat, NULL)); } return Lut; }
/** * cd_util_extract_vcgt: **/ static gboolean cd_util_extract_vcgt (CdUtilPrivate *priv, gchar **values, GError **error) { cmsFloat32Number in; cmsHPROFILE lcms_profile; const cmsToneCurve **vcgt; guint i; guint size; /* check arguments */ if (g_strv_length (values) != 2) { g_set_error_literal (error, 1, 0, "invalid input, expect 'filename' size'"); return FALSE; } /* invalid size */ size = atoi (values[1]); if (size <= 1 || size > 1024) { g_set_error_literal (error, 1, 0, "invalid size,expected 2-1024"); return FALSE; } /* does profile have VCGT */ lcms_profile = cd_icc_get_handle (priv->icc); vcgt = cmsReadTag (lcms_profile, cmsSigVcgtTag); if (vcgt == NULL || vcgt[0] == NULL) { g_set_error_literal (error, 1, 0, "profile does not have any VCGT data"); return FALSE; } /* output data */ g_print ("idx,red,green,blue\n"); for (i = 0; i < size; i++) { in = (gdouble) i / (gdouble) (size - 1); g_print ("%u,", i); g_print ("%f,", cmsEvalToneCurveFloat(vcgt[0], in)); g_print ("%f,", cmsEvalToneCurveFloat(vcgt[1], in)); g_print ("%f\n", cmsEvalToneCurveFloat(vcgt[2], in)); } /* success */ priv->rewrite_file = FALSE; return TRUE; }