Added debian extra dependency packages.

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>

1 files changed, 695 insertions, 0 deletions

diff --git a/debian/lcms/lcms-1.19.dfsg2/src/cmswtpnt.c b/debian/lcms/lcms-1.19.dfsg2/src/cmswtpnt.c
new file mode 100755
index 00000000..c3ec50d9
--- /dev/null
+++ b/debian/lcms/lcms-1.19.dfsg2/src/cmswtpnt.c
@@ -0,0 +1,695 @@
+//
+//  Little cms
+//  Copyright (C) 1998-2007 Marti Maria
+//
+// Permission is hereby granted, free of charge, to any person obtaining 
+// a copy of this software and associated documentation files (the "Software"), 
+// to deal in the Software without restriction, including without limitation 
+// the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+// and/or sell copies of the Software, and to permit persons to whom the Software 
+// is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in 
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO 
+// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#include "lcms.h"
+
+
+// Conversions
+
+void LCMSEXPORT cmsXYZ2xyY(LPcmsCIExyY Dest, const cmsCIEXYZ* Source)
+{
+       double ISum;
+
+       ISum = 1./(Source -> X + Source -> Y + Source -> Z);
+
+       Dest -> x = (Source -> X) * ISum;
+       Dest -> y = (Source -> Y) * ISum;
+       Dest -> Y = Source -> Y;
+}
+
+
+void LCMSEXPORT cmsxyY2XYZ(LPcmsCIEXYZ Dest, const cmsCIExyY* Source)
+{
+
+        Dest -> X = (Source -> x / Source -> y) * Source -> Y;
+        Dest -> Y = Source -> Y;
+        Dest -> Z = ((1 - Source -> x - Source -> y) / Source -> y) * Source -> Y;
+}
+
+
+// Obtains WhitePoint from Temperature
+
+LCMSBOOL LCMSEXPORT cmsWhitePointFromTemp(int TempK, LPcmsCIExyY WhitePoint)
+{
+       double x, y;
+       double T, T2, T3;
+       // double M1, M2;
+
+
+       // No optimization provided.
+
+       T = TempK;
+       T2 = T*T;            // Square
+       T3 = T2*T;           // Cube
+
+       // For correlated color temperature (T) between 4000K and 7000K:
+
+       if (T >= 4000. && T <= 7000.)
+       {
+              x = -4.6070*(1E9/T3) + 2.9678*(1E6/T2) + 0.09911*(1E3/T) + 0.244063;
+       }
+       else
+              // or for correlated color temperature (T) between 7000K and 25000K:
+
+       if (T > 7000.0 && T <= 25000.0)
+       {
+              x = -2.0064*(1E9/T3) + 1.9018*(1E6/T2) + 0.24748*(1E3/T) + 0.237040;
+       }
+       else {
+              cmsSignalError(LCMS_ERRC_ABORTED, "cmsWhitePointFromTemp: invalid temp");
+              return FALSE;
+              }
+
+       // Obtain y(x)
+
+       y = -3.000*(x*x) + 2.870*x - 0.275;
+
+       // wave factors (not used, but here for futures extensions)
+
+       // M1 = (-1.3515 - 1.7703*x + 5.9114 *y)/(0.0241 + 0.2562*x - 0.7341*y);
+       // M2 = (0.0300 - 31.4424*x + 30.0717*y)/(0.0241 + 0.2562*x - 0.7341*y);
+
+
+
+       // Fill WhitePoint struct
+
+       WhitePoint -> x = x;
+       WhitePoint -> y = y;
+       WhitePoint -> Y = 1.0;
+
+       return TRUE;
+}
+
+// Build a White point, primary chromas transfer matrix from RGB to CIE XYZ
+// This is just an approximation, I am not handling all the non-linear
+// aspects of the RGB to XYZ process, and assumming that the gamma correction
+// has transitive property in the tranformation chain.
+//
+// the alghoritm:
+//
+//            - First I build the absolute conversion matrix using
+//              primaries in XYZ. This matrix is next inverted
+//            - Then I eval the source white point across this matrix
+//              obtaining the coeficients of the transformation
+//            - Then, I apply these coeficients to the original matrix
+
+
+LCMSBOOL LCMSEXPORT cmsBuildRGB2XYZtransferMatrix(LPMAT3 r, LPcmsCIExyY WhitePt,
+                                            LPcmsCIExyYTRIPLE Primrs)
+{
+        VEC3 WhitePoint, Coef;
+        MAT3 Result, Primaries;
+        double xn, yn;
+        double xr, yr;
+        double xg, yg;
+        double xb, yb;
+
+
+        xn = WhitePt -> x;
+        yn = WhitePt -> y;
+        xr = Primrs -> Red.x;
+        yr = Primrs -> Red.y;
+        xg = Primrs -> Green.x;
+        yg = Primrs -> Green.y;
+        xb = Primrs -> Blue.x;
+        yb = Primrs -> Blue.y;
+
+
+        // Build Primaries matrix
+        VEC3init(&Primaries.v[0], xr,        xg,         xb);
+        VEC3init(&Primaries.v[1], yr,        yg,         yb);
+        VEC3init(&Primaries.v[2], (1-xr-yr), (1-xg-yg),  (1-xb-yb));
+
+
+        // Result = Primaries ^ (-1) inverse matrix
+        if (!MAT3inverse(&Primaries, &Result))
+                        return FALSE;
+
+
+        VEC3init(&WhitePoint, xn/yn, 1.0, (1.0-xn-yn)/yn);
+
+        // Across inverse primaries ...
+        MAT3eval(&Coef, &Result, &WhitePoint);
+
+        // Give us the Coefs, then I build transformation matrix
+        VEC3init(&r -> v[0], Coef.n[VX]*xr,          Coef.n[VY]*xg,          Coef.n[VZ]*xb);
+        VEC3init(&r -> v[1], Coef.n[VX]*yr,          Coef.n[VY]*yg,          Coef.n[VZ]*yb);
+        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));
+       
+
+        return TRUE;
+}
+
+
+
+// Compute chromatic adaptation matrix using Chad as cone matrix 
+
+static
+void ComputeChromaticAdaptation(LPMAT3 Conversion,
+                                LPcmsCIEXYZ SourceWhitePoint,
+                                LPcmsCIEXYZ DestWhitePoint,
+                                LPMAT3 Chad)
+
+{
+      
+        MAT3 Chad_Inv;
+        VEC3 ConeSourceXYZ, ConeSourceRGB;
+        VEC3 ConeDestXYZ, ConeDestRGB;
+        MAT3 Cone, Tmp;
+
+
+        Tmp = *Chad;
+        MAT3inverse(&Tmp, &Chad_Inv);
+
+        VEC3init(&ConeSourceXYZ, SourceWhitePoint -> X,
+                                 SourceWhitePoint -> Y,
+                                 SourceWhitePoint -> Z);
+
+        VEC3init(&ConeDestXYZ,   DestWhitePoint -> X,
+                                 DestWhitePoint -> Y,
+                                 DestWhitePoint -> Z);
+
+        MAT3eval(&ConeSourceRGB, Chad, &ConeSourceXYZ);
+        MAT3eval(&ConeDestRGB,   Chad, &ConeDestXYZ);
+
+        // Build matrix
+
+        VEC3init(&Cone.v[0], ConeDestRGB.n[0]/ConeSourceRGB.n[0],    0.0,  0.0);
+        VEC3init(&Cone.v[1], 0.0,   ConeDestRGB.n[1]/ConeSourceRGB.n[1],   0.0);
+        VEC3init(&Cone.v[2], 0.0,   0.0,   ConeDestRGB.n[2]/ConeSourceRGB.n[2]);
+
+
+        // Normalize
+        MAT3per(&Tmp, &Cone, Chad);
+        MAT3per(Conversion, &Chad_Inv, &Tmp);
+
+}
+
+
+// Returns the final chrmatic adaptation from illuminant FromIll to Illuminant ToIll
+// The cone matrix can be specified in ConeMatrix. If NULL, Bradford is assumed
+
+LCMSBOOL cmsAdaptationMatrix(LPMAT3 r, LPMAT3 ConeMatrix, LPcmsCIEXYZ FromIll, LPcmsCIEXYZ ToIll)
+{
+     MAT3 LamRigg   = {{ // Bradford matrix
+                      {{  0.8951,  0.2664, -0.1614 }},
+                      {{ -0.7502,  1.7135,  0.0367 }},
+                      {{  0.0389, -0.0685,  1.0296 }}
+                      }};
+
+
+      if (ConeMatrix == NULL)
+            ConeMatrix = &LamRigg;
+
+      ComputeChromaticAdaptation(r, FromIll, ToIll, ConeMatrix);
+      return TRUE;
+
+}
+
+// Same as anterior, but assuming D50 destination. White point is given in xyY
+
+LCMSBOOL cmsAdaptMatrixToD50(LPMAT3 r, LPcmsCIExyY SourceWhitePt)
+{
+        cmsCIEXYZ Dn;      
+        MAT3 Bradford;
+        MAT3 Tmp;
+
+        cmsxyY2XYZ(&Dn, SourceWhitePt);
+        
+        cmsAdaptationMatrix(&Bradford, NULL, &Dn, cmsD50_XYZ());
+
+        Tmp = *r;
+        MAT3per(r, &Bradford, &Tmp);
+
+        return TRUE;
+}
+
+
+// Same as anterior, but assuming D50 source. White point is given in xyY
+
+LCMSBOOL cmsAdaptMatrixFromD50(LPMAT3 r, LPcmsCIExyY DestWhitePt)
+{
+        cmsCIEXYZ Dn;       
+        MAT3 Bradford;
+        MAT3 Tmp;
+
+        cmsxyY2XYZ(&Dn, DestWhitePt);
+        
+        cmsAdaptationMatrix(&Bradford, NULL, cmsD50_XYZ(), &Dn);
+
+        Tmp = *r;
+        MAT3per(r, &Bradford, &Tmp);
+
+        return TRUE;
+}
+
+
+// Adapts a color to a given illuminant. Original color is expected to have
+// a SourceWhitePt white point. 
+
+LCMSBOOL LCMSEXPORT cmsAdaptToIlluminant(LPcmsCIEXYZ Result, 
+                                     LPcmsCIEXYZ SourceWhitePt, 
+                                     LPcmsCIEXYZ Illuminant, 
+                                     LPcmsCIEXYZ Value)
+{
+        MAT3 Bradford;
+        VEC3 In, Out;
+    
+        // BradfordLamRiggChromaticAdaptation(&Bradford, SourceWhitePt, Illuminant);
+
+        cmsAdaptationMatrix(&Bradford, NULL, SourceWhitePt, Illuminant);
+
+        VEC3init(&In, Value -> X, Value -> Y, Value -> Z);
+        MAT3eval(&Out, &Bradford, &In);
+
+        Result -> X = Out.n[0];
+        Result -> Y = Out.n[1];
+        Result -> Z = Out.n[2];
+
+        return TRUE;
+}
+
+
+
+typedef struct {
+
+    double mirek;  // temp (in microreciprocal kelvin) 
+    double ut;     // u coord of intersection w/ blackbody locus  
+    double vt;     // v coord of intersection w/ blackbody locus 
+    double tt;     // slope of ISOTEMPERATURE. line 
+
+    } ISOTEMPERATURE,FAR* LPISOTEMPERATURE;
+
+static ISOTEMPERATURE isotempdata[] = {
+//  {Mirek, Ut,       Vt,      Tt      } 
+    {0,     0.18006,  0.26352,  -0.24341},
+    {10,    0.18066,  0.26589,  -0.25479},
+    {20,    0.18133,  0.26846,  -0.26876},
+    {30,    0.18208,  0.27119,  -0.28539},
+    {40,    0.18293,  0.27407,  -0.30470},
+    {50,    0.18388,  0.27709,  -0.32675},
+    {60,    0.18494,  0.28021,  -0.35156},
+    {70,    0.18611,  0.28342,  -0.37915},
+    {80,    0.18740,  0.28668,  -0.40955},
+    {90,    0.18880,  0.28997,  -0.44278},
+    {100,   0.19032,  0.29326,  -0.47888},
+    {125,   0.19462,  0.30141,  -0.58204},
+    {150,   0.19962,  0.30921,  -0.70471},
+    {175,   0.20525,  0.31647,  -0.84901},
+    {200,   0.21142,  0.32312,  -1.0182 },
+    {225,   0.21807,  0.32909,  -1.2168 },
+    {250,   0.22511,  0.33439,  -1.4512 },
+    {275,   0.23247,  0.33904,  -1.7298 },
+    {300,   0.24010,  0.34308,  -2.0637 },
+    {325,   0.24702,  0.34655,  -2.4681 },
+    {350,   0.25591,  0.34951,  -2.9641 },
+    {375,   0.26400,  0.35200,  -3.5814 },
+    {400,   0.27218,  0.35407,  -4.3633 },
+    {425,   0.28039,  0.35577,  -5.3762 },
+    {450,   0.28863,  0.35714,  -6.7262 },
+    {475,   0.29685,  0.35823,  -8.5955 },
+    {500,   0.30505,  0.35907,  -11.324 },
+    {525,   0.31320,  0.35968,  -15.628 },
+    {550,   0.32129,  0.36011,  -23.325 },
+    {575,   0.32931,  0.36038,  -40.770 },
+    {600,   0.33724,  0.36051, -116.45  }
+};
+
+#define NISO sizeof(isotempdata)/sizeof(ISOTEMPERATURE)
+
+
+// Robertson's method
+
+static 
+double Robertson(LPcmsCIExyY v)
+{
+    int j;
+    double us,vs;
+    double uj,vj,tj,di,dj,mi,mj;
+    double Tc = -1, xs, ys;
+
+    di = mi = 0;
+    xs = v -> x;
+    ys = v -> y;
+
+    // convert (x,y) to CIE 1960 (u,v) 
+
+    us = (2*xs) / (-xs + 6*ys + 1.5);
+    vs = (3*ys) / (-xs + 6*ys + 1.5);
+
+
+    for (j=0; j < NISO; j++) {
+
+        uj = isotempdata[j].ut;
+        vj = isotempdata[j].vt;
+        tj = isotempdata[j].tt;
+        mj = isotempdata[j].mirek;
+
+        dj = ((vs - vj) - tj * (us - uj)) / sqrt(1 + tj*tj);
+
+        if ((j!=0) && (di/dj < 0.0)) {
+            Tc = 1000000.0 / (mi + (di / (di - dj)) * (mj - mi));
+            break;
+        }
+
+        di = dj;
+        mi = mj;
+    }
+
+
+    if (j == NISO) return -1;   
+    return Tc;
+}
+
+
+
+static
+LCMSBOOL InRange(LPcmsCIExyY a, LPcmsCIExyY b, double tolerance)
+{
+       double dist_x, dist_y;
+
+       dist_x = fabs(a->x - b->x);
+       dist_y = fabs(a->y - b->y);
+
+       return (tolerance >= dist_x * dist_x + dist_y * dist_y);
+
+}
+
+
+typedef struct {
+                char Name[30];
+                cmsCIExyY Val;
+
+              } WHITEPOINTS,FAR *LPWHITEPOINTS;
+
+static
+int FromD40toD150(LPWHITEPOINTS pts)
+{
+       int i, n;
+
+       n = 0;
+       for (i=40; i < 150; i ++)
+       {
+              sprintf(pts[n].Name, "D%d", i);
+              cmsWhitePointFromTemp((int) (i*100.0), &pts[n].Val);
+              n++;
+       }
+
+   return n;
+}
+
+
+// To be removed in future versions
+void _cmsIdentifyWhitePoint(char *Buffer, LPcmsCIEXYZ WhitePt)
+{
+       int i, n;
+       cmsCIExyY Val;
+       double T;
+       WHITEPOINTS SomeIlluminants[140] = {
+
+                                   {"CIE illuminant A", {0.4476, 0.4074, 1.0}},
+                                   {"CIE illuminant C", {0.3101, 0.3162, 1.0}},
+                                   {"D65 (daylight)",   {0.3127, 0.3291, 1.0}},
+                                   };
+
+              n = FromD40toD150(&SomeIlluminants[3]) + 3;
+
+              cmsXYZ2xyY(&Val, WhitePt);
+
+              Val.Y = 1.;
+              for (i=0; i < n; i++)
+              {
+
+                            if (InRange(&Val, &SomeIlluminants[i].Val, 0.000005))
+                            {
+                                strcpy(Buffer, "WhitePoint : ");
+                                strcat(Buffer, SomeIlluminants[i].Name);                                
+                                return;
+                            }
+              }
+
+              T = Robertson(&Val);
+
+              if (T > 0) 
+                sprintf(Buffer, "White point near %dK", (int) T);                                                     
+              else
+              {
+              sprintf(Buffer, "Unknown white point (X:%1.2g, Y:%1.2g, Z:%1.2g)",
+                                          WhitePt -> X, WhitePt -> Y, WhitePt -> Z);
+              
+              }
+              
+}
+
+
+// Use darker colorant to obtain black point
+
+static
+int BlackPointAsDarkerColorant(cmsHPROFILE hInput,                               
+                               int Intent,
+                               LPcmsCIEXYZ BlackPoint,
+                               DWORD dwFlags)
+{
+    WORD *Black, *White;
+    cmsHTRANSFORM xform;
+    icColorSpaceSignature Space;
+    int nChannels;
+    DWORD dwFormat; 
+    cmsHPROFILE hLab;
+    cmsCIELab  Lab;
+    cmsCIEXYZ  BlackXYZ, MediaWhite;        
+    
+    // If the profile does not support input direction, assume Black point 0    
+    if (!cmsIsIntentSupported(hInput, Intent, LCMS_USED_AS_INPUT)) {
+
+        BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
+        return 0;
+    }
+    
+
+    // Try to get black by using black colorant
+    Space = cmsGetColorSpace(hInput);
+    
+    if (!_cmsEndPointsBySpace(Space, &White, &Black, &nChannels)) {
+        
+        BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
+        return 0;
+    }
+    
+    dwFormat = CHANNELS_SH(nChannels)|BYTES_SH(2);
+
+    hLab = cmsCreateLabProfile(NULL);
+    
+    xform = cmsCreateTransform(hInput, dwFormat,
+                                hLab, TYPE_Lab_DBL, Intent, cmsFLAGS_NOTPRECALC);
+    
+    
+    cmsDoTransform(xform, Black, &Lab, 1);
+
+    // Force it to be neutral, clip to max. L* of 50
+
+    Lab.a = Lab.b = 0;
+    if (Lab.L > 50) Lab.L = 50;
+
+    cmsCloseProfile(hLab);
+    cmsDeleteTransform(xform);
+    
+    cmsLab2XYZ(NULL, &BlackXYZ, &Lab);
+    
+    if (Intent == INTENT_ABSOLUTE_COLORIMETRIC) {
+        
+        *BlackPoint = BlackXYZ; 
+    }
+    else {
+        
+        if (!(dwFlags & LCMS_BPFLAGS_D50_ADAPTED)) {
+
+            cmsTakeMediaWhitePoint(&MediaWhite, hInput);
+            cmsAdaptToIlluminant(BlackPoint, cmsD50_XYZ(), &MediaWhite, &BlackXYZ);
+        }
+        else
+            *BlackPoint = BlackXYZ;
+    }
+        
+    return 1;
+}
+
+
+// Get a black point of output CMYK profile, discounting any ink-limiting embedded 
+// in the profile. For doing that, use perceptual intent in input direction:
+// Lab (0, 0, 0) -> [Perceptual] Profile -> CMYK -> [Rel. colorimetric] Profile -> Lab
+
+static
+int BlackPointUsingPerceptualBlack(LPcmsCIEXYZ BlackPoint, 
+                                   cmsHPROFILE hProfile, 
+                                   DWORD dwFlags)
+{
+    cmsHTRANSFORM hPercLab2CMYK, hRelColCMYK2Lab;
+    cmsHPROFILE hLab;
+    cmsCIELab LabIn, LabOut;
+    WORD CMYK[MAXCHANNELS];
+    cmsCIEXYZ  BlackXYZ, MediaWhite;        
+
+
+     if (!cmsIsIntentSupported(hProfile, INTENT_PERCEPTUAL, LCMS_USED_AS_INPUT)) {
+
+        BlackPoint -> X = BlackPoint ->Y = BlackPoint -> Z = 0.0;
+        return 0;
+    }
+   
+    hLab = cmsCreateLabProfile(NULL);
+
+    hPercLab2CMYK  = cmsCreateTransform(hLab, TYPE_Lab_DBL, 
+                                        hProfile, TYPE_CMYK_16, 
+                                        INTENT_PERCEPTUAL, cmsFLAGS_NOTPRECALC);
+
+    hRelColCMYK2Lab = cmsCreateTransform(hProfile, TYPE_CMYK_16, 
+                                         hLab, TYPE_Lab_DBL, 
+                                         INTENT_RELATIVE_COLORIMETRIC, cmsFLAGS_NOTPRECALC);
+
+    LabIn.L = LabIn.a = LabIn.b = 0;
+
+    cmsDoTransform(hPercLab2CMYK, &LabIn, CMYK, 1);
+    cmsDoTransform(hRelColCMYK2Lab, CMYK, &LabOut, 1);
+
+    if (LabOut.L > 50) LabOut.L = 50;
+    LabOut.a = LabOut.b = 0;
+
+    cmsDeleteTransform(hPercLab2CMYK);
+    cmsDeleteTransform(hRelColCMYK2Lab);
+    cmsCloseProfile(hLab);
+
+    cmsLab2XYZ(NULL, &BlackXYZ, &LabOut);   
+    
+    if (!(dwFlags & LCMS_BPFLAGS_D50_ADAPTED)){
+            cmsTakeMediaWhitePoint(&MediaWhite, hProfile);
+            cmsAdaptToIlluminant(BlackPoint, cmsD50_XYZ(), &MediaWhite, &BlackXYZ);
+    }
+    else
+            *BlackPoint = BlackXYZ;
+   
+    return 1;
+
+}
+
+
+// Get Perceptual black of v4 profiles.
+static
+int GetV4PerceptualBlack(LPcmsCIEXYZ BlackPoint, cmsHPROFILE hProfile, DWORD dwFlags)
+{
+        if (dwFlags & LCMS_BPFLAGS_D50_ADAPTED) {
+
+            BlackPoint->X = PERCEPTUAL_BLACK_X;
+            BlackPoint->Y = PERCEPTUAL_BLACK_Y;
+            BlackPoint->Z = PERCEPTUAL_BLACK_Z;
+        }
+        else {
+
+            cmsCIEXYZ D50BlackPoint, MediaWhite;
+
+            cmsTakeMediaWhitePoint(&MediaWhite, hProfile);
+            D50BlackPoint.X = PERCEPTUAL_BLACK_X; 
+            D50BlackPoint.Y = PERCEPTUAL_BLACK_Y;
+            D50BlackPoint.Z = PERCEPTUAL_BLACK_Z;
+
+            // Obtain the absolute XYZ. Adapt perceptual black back from D50 to whatever media white
+            cmsAdaptToIlluminant(BlackPoint, cmsD50_XYZ(), &MediaWhite, &D50BlackPoint);
+        }
+
+
+        return 1;
+}
+
+
+// This function shouldn't exist at all -- there is such quantity of broken
+// profiles on black point tag, that we must somehow fix chromaticity to 
+// avoid huge tint when doing Black point compensation. This function does
+// just that. There is a special flag for using black point tag, but turned 
+// off by default because it is bogus on most profiles. The detection algorithm 
+// involves to turn BP to neutral and to use only L component.  
+
+int cmsDetectBlackPoint(LPcmsCIEXYZ BlackPoint, cmsHPROFILE hProfile, int Intent, DWORD dwFlags)
+{    
+
+    // v4 + perceptual & saturation intents does have its own black point, and it is 
+    // well specified enough to use it.
+
+    if ((cmsGetProfileICCversion(hProfile) >= 0x4000000) &&     
+        (Intent == INTENT_PERCEPTUAL || Intent == INTENT_SATURATION)) {
+
+       // Matrix shaper share MRC & perceptual intents
+       if (_cmsIsMatrixShaper(hProfile)) 
+           return BlackPointAsDarkerColorant(hProfile, INTENT_RELATIVE_COLORIMETRIC, BlackPoint, cmsFLAGS_NOTPRECALC);
+
+       // CLUT based - Get perceptual black point (fixed value)
+       return GetV4PerceptualBlack(BlackPoint, hProfile, dwFlags);
+    }
+
+
+#ifdef HONOR_BLACK_POINT_TAG
+
+    // v2, v4 rel/abs colorimetric
+    if (cmsIsTag(hProfile, icSigMediaBlackPointTag) && 
+                    Intent == INTENT_RELATIVE_COLORIMETRIC) {
+
+        cmsCIEXYZ BlackXYZ, UntrustedBlackPoint, TrustedBlackPoint, MediaWhite;
+        cmsCIELab Lab;
+
+             // If black point is specified, then use it, 
+        
+             cmsTakeMediaBlackPoint(&BlackXYZ, hProfile);
+             cmsTakeMediaWhitePoint(&MediaWhite, hProfile);
+
+             // Black point is absolute XYZ, so adapt to D50 to get PCS value
+             cmsAdaptToIlluminant(&UntrustedBlackPoint, &MediaWhite, cmsD50_XYZ(), &BlackXYZ);
+
+             // Force a=b=0 to get rid of any chroma
+
+             cmsXYZ2Lab(NULL, &Lab, &UntrustedBlackPoint);
+             Lab.a = Lab.b = 0;
+             if (Lab.L > 50) Lab.L = 50; // Clip to L* <= 50
+
+             cmsLab2XYZ(NULL, &TrustedBlackPoint, &Lab);
+
+             // Return BP as D50 relative or absolute XYZ (depends on flags)
+             if (!(dwFlags & LCMS_BPFLAGS_D50_ADAPTED))
+                    cmsAdaptToIlluminant(BlackPoint, cmsD50_XYZ(), &MediaWhite, &TrustedBlackPoint);
+             else
+                    *BlackPoint = TrustedBlackPoint;
+
+             return 1;
+    }
+
+#endif
+    
+    // That is about v2 profiles. 
+    
+    // If output profile, discount ink-limiting and that's all
+    if (Intent == INTENT_RELATIVE_COLORIMETRIC && 
+            (cmsGetDeviceClass(hProfile) == icSigOutputClass) &&
+            (cmsGetColorSpace(hProfile) == icSigCmykData))
+                return BlackPointUsingPerceptualBlack(BlackPoint, hProfile, dwFlags);
+
+    // Nope, compute BP using current intent.
+    return BlackPointAsDarkerColorant(hProfile, Intent, BlackPoint, dwFlags);
+
+}