Move StrideIn/StrideOut as parameters for formatters

1 files changed, 1078 insertions, 1076 deletions

diff --git a/testbed/testcms2.c b/testbed/testcms2.c
index a12a3bf..398c41f 100644
--- a/testbed/testcms2.c
+++ b/testbed/testcms2.c
@@ -37,7 +37,7 @@
 #endif
 
 // A single check. Returns 1 if success, 0 if failed
-typedef cmsInt32Number (*TestFn)(void);

+typedef cmsInt32Number (*TestFn)(void);
 
 // A parametric Tone curve test function
 typedef cmsFloat32Number (* dblfnptr)(cmsFloat32Number x, const cmsFloat64Number Params[]);
@@ -47,9 +47,9 @@ typedef cmsFloat32Number (* dblfnptr)(cmsFloat32Number x, const cmsFloat64Number
 
 static char ReasonToFailBuffer[TEXT_ERROR_BUFFER_SIZE];
 static char SubTestBuffer[TEXT_ERROR_BUFFER_SIZE];
-static cmsInt32Number TotalTests = 0, TotalFail = 0;

+static cmsInt32Number TotalTests = 0, TotalFail = 0;
 static cmsBool TrappedError;
-static cmsInt32Number SimultaneousErrors;

+static cmsInt32Number SimultaneousErrors;
 
 
 #define cmsmin(a, b) (((a) < (b)) ? (a) : (b))
@@ -58,9 +58,9 @@ static cmsInt32Number SimultaneousErrors;
 static
 void Die(const char* Reason)
 {
-    printf("\n\nArrrgggg!!: %s!\n\n", Reason);

-    fflush(stdout);

-    exit(1);

+    printf("\n\nArrrgggg!!: %s!\n\n", Reason);
+    fflush(stdout);
+    exit(1);
 }
 
 // Memory management replacement -----------------------------------------------------------------------------
@@ -74,12 +74,12 @@ static cmsUInt32Number SingleHit, MaxAllocated=0, TotalMemory=0;
 // malloc are built in a way similar to that, but I do on my own to be portable.
 typedef struct { 
     cmsUInt32Number KeepSize;
-    cmsUInt32Number Align8;

-    cmsContext WhoAllocated; // Some systems do need pointers aligned to 8-byte boundaries.

+    cmsUInt32Number Align8;
+    cmsContext WhoAllocated; // Some systems do need pointers aligned to 8-byte boundaries.
 
-} _cmsMemoryBlock;

-

-#define SIZE_OF_MEM_HEADER (sizeof(_cmsMemoryBlock))

+} _cmsMemoryBlock;
+
+#define SIZE_OF_MEM_HEADER (sizeof(_cmsMemoryBlock))
 
 // This is a fake thread descriptor used to check thread integrity. 
 // Basically it returns a different threadID each time it is called.
@@ -88,7 +88,7 @@ typedef struct {
 static
 cmsContext DbgThread(void)
 {
-    static cmsUInt32Number n = 1;

+    static cmsUInt32Number n = 1;
 
     return (cmsContext) n++;
 }
@@ -97,7 +97,7 @@ cmsContext DbgThread(void)
 static
 void* DebugMalloc(cmsContext ContextID, cmsUInt32Number size)
 {
-    _cmsMemoryBlock* blk;

+    _cmsMemoryBlock* blk;
 
     if (size <= 0) {
        Die("malloc requested with zero bytes");
@@ -111,26 +111,26 @@ void* DebugMalloc(cmsContext ContextID, cmsUInt32Number size)
     if (size > SingleHit) 
         SingleHit = size;
 
-    blk = (_cmsMemoryBlock*) malloc(size + SIZE_OF_MEM_HEADER);

+    blk = (_cmsMemoryBlock*) malloc(size + SIZE_OF_MEM_HEADER);
     if (blk == NULL) return NULL;
 
     blk ->KeepSize = size;
     blk ->WhoAllocated = ContextID;
 
-    return (void*) ((cmsUInt8Number*) blk + SIZE_OF_MEM_HEADER);

+    return (void*) ((cmsUInt8Number*) blk + SIZE_OF_MEM_HEADER);
 }
 
 // The free routine
 static
 void  DebugFree(cmsContext ContextID, void *Ptr)
 {
-    _cmsMemoryBlock* blk;

+    _cmsMemoryBlock* blk;
     
     if (Ptr == NULL) {
         Die("NULL free (which is a no-op in C, but may be an clue of something going wrong)");
     }
 
-    blk = (_cmsMemoryBlock*) (((cmsUInt8Number*) Ptr) - SIZE_OF_MEM_HEADER);

+    blk = (_cmsMemoryBlock*) (((cmsUInt8Number*) Ptr) - SIZE_OF_MEM_HEADER);
     TotalMemory -= blk ->KeepSize;
 
     if (blk ->WhoAllocated != ContextID) {
@@ -144,14 +144,14 @@ void  DebugFree(cmsContext ContextID, void *Ptr)
 static
 void * DebugRealloc(cmsContext ContextID, void* Ptr, cmsUInt32Number NewSize)
 {
-    _cmsMemoryBlock* blk;

+    _cmsMemoryBlock* blk;
     void*  NewPtr;
     cmsUInt32Number max_sz;
 
     NewPtr = DebugMalloc(ContextID, NewSize);
     if (Ptr == NULL) return NewPtr;
 
-    blk = (_cmsMemoryBlock*) (((cmsUInt8Number*) Ptr) - SIZE_OF_MEM_HEADER);

+    blk = (_cmsMemoryBlock*) (((cmsUInt8Number*) Ptr) - SIZE_OF_MEM_HEADER);
     max_sz = blk -> KeepSize > NewSize ? NewSize : blk ->KeepSize;
     memmove(NewPtr, Ptr, max_sz);
     DebugFree(ContextID, Ptr);
@@ -234,7 +234,7 @@ static
 void Check(const char* Title, TestFn Fn)
 {
     printf("Checking %s ...", Title);
-    fflush(stdout);

+    fflush(stdout);
 
     ReasonToFailBuffer[0] = 0;
     SubTestBuffer[0] = 0;
@@ -262,8 +262,8 @@ void Check(const char* Title, TestFn Fn)
                printf("\tMore than one (%d) errors were reported\n", SimultaneousErrors); 
 
         TotalFail++;
-    }   

-    fflush(stdout);

+    }   
+    fflush(stdout);
 }
 
 // Dump a tone curve, for easy diagnostic
@@ -322,38 +322,38 @@ cmsHPROFILE Create_AboveRGB(void)
 static
 cmsHPROFILE Create_Gray22(void)
 {
-    cmsHPROFILE hProfile;

-    cmsToneCurve* Curve = cmsBuildGamma(DbgThread(), 2.2);

+    cmsHPROFILE hProfile;
+    cmsToneCurve* Curve = cmsBuildGamma(DbgThread(), 2.2);
     if (Curve == NULL) return NULL;
 
     hProfile = cmsCreateGrayProfileTHR(DbgThread(), cmsD50_xyY(), Curve);
     cmsFreeToneCurve(Curve);
 
-    return hProfile;

+    return hProfile;
 }
 
 
 static
 cmsHPROFILE Create_GrayLab(void)
 {
-    cmsHPROFILE hProfile;

-    cmsToneCurve* Curve = cmsBuildGamma(DbgThread(), 1.0);

+    cmsHPROFILE hProfile;
+    cmsToneCurve* Curve = cmsBuildGamma(DbgThread(), 1.0);
     if (Curve == NULL) return NULL;
 
     hProfile = cmsCreateGrayProfileTHR(DbgThread(), cmsD50_xyY(), Curve);
     cmsFreeToneCurve(Curve);
 
-    cmsSetPCS(hProfile, cmsSigLabData);

-    return hProfile;

+    cmsSetPCS(hProfile, cmsSigLabData);
+    return hProfile;
 }
 
 // A CMYK devicelink that adds gamma 3.0 to each channel
 static
 cmsHPROFILE Create_CMYK_DeviceLink(void)
 {
-    cmsHPROFILE hProfile;

-    cmsToneCurve* Tab[4];

-    cmsToneCurve* Curve = cmsBuildGamma(DbgThread(), 3.0);

+    cmsHPROFILE hProfile;
+    cmsToneCurve* Tab[4];
+    cmsToneCurve* Curve = cmsBuildGamma(DbgThread(), 3.0);
     if (Curve == NULL) return NULL;
 
     Tab[0] = Curve;
@@ -366,7 +366,7 @@ cmsHPROFILE Create_CMYK_DeviceLink(void)
 
     cmsFreeToneCurve(Curve);
 
-    return hProfile;

+    return hProfile;
 }
 
 
@@ -374,9 +374,9 @@ cmsHPROFILE Create_CMYK_DeviceLink(void)
 // DONT USE THIS PROFILE FOR ANYTHING, IT IS USELESS BUT FOR TESTING PURPOSES.
 typedef struct {
 
-    cmsHTRANSFORM hLab2sRGB;

-    cmsHTRANSFORM sRGB2Lab;

-    cmsHTRANSFORM hIlimit;

+    cmsHTRANSFORM hLab2sRGB;
+    cmsHTRANSFORM sRGB2Lab;
+    cmsHTRANSFORM hIlimit;
 
 } FakeCMYKParams;
 
@@ -390,40 +390,40 @@ cmsFloat64Number Clip(cmsFloat64Number v)
 }
 
 static
-cmsInt32Number ForwardSampler(register const cmsUInt16Number In[], cmsUInt16Number Out[], void* Cargo)

+cmsInt32Number ForwardSampler(register const cmsUInt16Number In[], cmsUInt16Number Out[], void* Cargo)
 {
-    FakeCMYKParams* p = (FakeCMYKParams*) Cargo;

-    cmsFloat64Number rgb[3], cmyk[4];   

-    cmsFloat64Number c, m, y, k;

-

-    cmsDoTransform(p ->hLab2sRGB, In, rgb, 1);

-         

-    c = 1 - rgb[0];

+    FakeCMYKParams* p = (FakeCMYKParams*) Cargo;
+    cmsFloat64Number rgb[3], cmyk[4];   
+    cmsFloat64Number c, m, y, k;
+
+    cmsDoTransform(p ->hLab2sRGB, In, rgb, 1);
+         
+    c = 1 - rgb[0];
     m = 1 - rgb[1];
     y = 1 - rgb[2];
 
     k = (c < m ? cmsmin(c, y) : cmsmin(m, y));
    
-    // NONSENSE WARNING!: I'm doing this just because this is a test 

-    // profile that may have ink limit up to 400%. There is no UCR here

-    // so the profile is basically useless for anything but testing.

+    // NONSENSE WARNING!: I'm doing this just because this is a test 
+    // profile that may have ink limit up to 400%. There is no UCR here
+    // so the profile is basically useless for anything but testing.
 
     cmyk[0] = c;
     cmyk[1] = m;
     cmyk[2] = y;
     cmyk[3] = k;
 
-    cmsDoTransform(p ->hIlimit, cmyk, Out, 1);

+    cmsDoTransform(p ->hIlimit, cmyk, Out, 1);
 
-    return 1;

+    return 1;
 }
 
 
 static
-cmsInt32Number ReverseSampler(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register void* Cargo)

+cmsInt32Number ReverseSampler(register const cmsUInt16Number In[], register cmsUInt16Number Out[], register void* Cargo)
 {
-    FakeCMYKParams* p = (FakeCMYKParams*) Cargo;

-    cmsFloat64Number c, m, y, k, rgb[3];    

+    FakeCMYKParams* p = (FakeCMYKParams*) Cargo;
+    cmsFloat64Number c, m, y, k, rgb[3];    
 
     c = In[0] / 65535.0;
     m = In[1] / 65535.0;
@@ -448,107 +448,107 @@ cmsInt32Number ReverseSampler(register const cmsUInt16Number In[], register cmsU
             rgb[2] = Clip((1 - y) * (1 - k));       
         }   
 
-        cmsDoTransform(p ->sRGB2Lab, rgb, Out, 1);

-        return 1;

-}
-
-
-
-static
-cmsHPROFILE CreateFakeCMYK(cmsFloat64Number InkLimit, cmsBool lUseAboveRGB)

-{
-    cmsHPROFILE hICC;

-    cmsPipeline* AToB0, *BToA0;

-    cmsStage* CLUT;

-    cmsContext ContextID;

-    FakeCMYKParams p;

-    cmsHPROFILE hLab, hsRGB, hLimit;

-    cmsUInt16Number cmykfrm;

-

-

-    if (lUseAboveRGB)

-        hsRGB = Create_AboveRGB();

-    else

-       hsRGB  = cmsCreate_sRGBProfile();

-

-    hLab   = cmsCreateLab4Profile(NULL);

-    hLimit = cmsCreateInkLimitingDeviceLink(cmsSigCmykData, InkLimit);

-

-    cmykfrm = BYTES_SH(0)|CHANNELS_SH(4);

-    p.hLab2sRGB = cmsCreateTransform(hLab,  TYPE_Lab_16,  hsRGB, TYPE_RGB_DBL, INTENT_PERCEPTUAL, cmsFLAGS_NOOPTIMIZE|cmsFLAGS_NOCACHE);

-    p.sRGB2Lab  = cmsCreateTransform(hsRGB, TYPE_RGB_DBL, hLab,  TYPE_Lab_16,  INTENT_PERCEPTUAL, cmsFLAGS_NOOPTIMIZE|cmsFLAGS_NOCACHE);

-    p.hIlimit   = cmsCreateTransform(hLimit, cmykfrm, NULL, TYPE_CMYK_16, INTENT_PERCEPTUAL, cmsFLAGS_NOOPTIMIZE|cmsFLAGS_NOCACHE);

-

-    cmsCloseProfile(hLab); cmsCloseProfile(hsRGB); cmsCloseProfile(hLimit);

-

-    ContextID = DbgThread();

-    hICC = cmsCreateProfilePlaceholder(ContextID);

-    if (!hICC) return NULL;

-

-    cmsSetProfileVersion(hICC, 4.2);

-

-    cmsSetDeviceClass(hICC, cmsSigOutputClass);

-    cmsSetColorSpace(hICC,  cmsSigCmykData);

-    cmsSetPCS(hICC,         cmsSigLabData);

+        cmsDoTransform(p ->sRGB2Lab, rgb, Out, 1);
+        return 1;
+}
+
+
+
+static
+cmsHPROFILE CreateFakeCMYK(cmsFloat64Number InkLimit, cmsBool lUseAboveRGB)
+{
+    cmsHPROFILE hICC;
+    cmsPipeline* AToB0, *BToA0;
+    cmsStage* CLUT;
+    cmsContext ContextID;
+    FakeCMYKParams p;
+    cmsHPROFILE hLab, hsRGB, hLimit;
+    cmsUInt16Number cmykfrm;
+
+
+    if (lUseAboveRGB)
+        hsRGB = Create_AboveRGB();
+    else
+       hsRGB  = cmsCreate_sRGBProfile();
+
+    hLab   = cmsCreateLab4Profile(NULL);
+    hLimit = cmsCreateInkLimitingDeviceLink(cmsSigCmykData, InkLimit);
+
+    cmykfrm = BYTES_SH(0)|CHANNELS_SH(4);
+    p.hLab2sRGB = cmsCreateTransform(hLab,  TYPE_Lab_16,  hsRGB, TYPE_RGB_DBL, INTENT_PERCEPTUAL, cmsFLAGS_NOOPTIMIZE|cmsFLAGS_NOCACHE);
+    p.sRGB2Lab  = cmsCreateTransform(hsRGB, TYPE_RGB_DBL, hLab,  TYPE_Lab_16,  INTENT_PERCEPTUAL, cmsFLAGS_NOOPTIMIZE|cmsFLAGS_NOCACHE);
+    p.hIlimit   = cmsCreateTransform(hLimit, cmykfrm, NULL, TYPE_CMYK_16, INTENT_PERCEPTUAL, cmsFLAGS_NOOPTIMIZE|cmsFLAGS_NOCACHE);
+
+    cmsCloseProfile(hLab); cmsCloseProfile(hsRGB); cmsCloseProfile(hLimit);
+
+    ContextID = DbgThread();
+    hICC = cmsCreateProfilePlaceholder(ContextID);
+    if (!hICC) return NULL;
+
+    cmsSetProfileVersion(hICC, 4.2);
+
+    cmsSetDeviceClass(hICC, cmsSigOutputClass);
+    cmsSetColorSpace(hICC,  cmsSigCmykData);
+    cmsSetPCS(hICC,         cmsSigLabData);
 
     BToA0 = cmsPipelineAlloc(ContextID, 3, 4);
-    if (BToA0 == NULL) return 0;

-    CLUT = cmsStageAllocCLut16bit(ContextID, 17, 3, 4, NULL);

-    if (CLUT == NULL) return 0;

-    if (!cmsStageSampleCLut16bit(CLUT, ForwardSampler, &p, 0)) return 0;

-    

-    cmsPipelineInsertStage(BToA0, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, 3)); 

-    cmsPipelineInsertStage(BToA0, cmsAT_END, CLUT);

-    cmsPipelineInsertStage(BToA0, cmsAT_END, _cmsStageAllocIdentityCurves(ContextID, 4));

-    

+    if (BToA0 == NULL) return 0;
+    CLUT = cmsStageAllocCLut16bit(ContextID, 17, 3, 4, NULL);
+    if (CLUT == NULL) return 0;
+    if (!cmsStageSampleCLut16bit(CLUT, ForwardSampler, &p, 0)) return 0;
+    
+    cmsPipelineInsertStage(BToA0, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, 3)); 
+    cmsPipelineInsertStage(BToA0, cmsAT_END, CLUT);
+    cmsPipelineInsertStage(BToA0, cmsAT_END, _cmsStageAllocIdentityCurves(ContextID, 4));
+    
     if (!cmsWriteTag(hICC, cmsSigBToA0Tag, (void*) BToA0)) return 0;
-    cmsPipelineFree(BToA0);

-    

-    AToB0 = cmsPipelineAlloc(ContextID, 4, 3);

-    if (AToB0 == NULL) return 0;

-    CLUT = cmsStageAllocCLut16bit(ContextID, 17, 4, 3, NULL);

-    if (CLUT == NULL) return 0;

-    if (!cmsStageSampleCLut16bit(CLUT, ReverseSampler, &p, 0)) return 0;

-

-    cmsPipelineInsertStage(AToB0, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, 4)); 

-    cmsPipelineInsertStage(AToB0, cmsAT_END, CLUT);

-    cmsPipelineInsertStage(AToB0, cmsAT_END, _cmsStageAllocIdentityCurves(ContextID, 3));

-    

+    cmsPipelineFree(BToA0);
+    
+    AToB0 = cmsPipelineAlloc(ContextID, 4, 3);
+    if (AToB0 == NULL) return 0;
+    CLUT = cmsStageAllocCLut16bit(ContextID, 17, 4, 3, NULL);
+    if (CLUT == NULL) return 0;
+    if (!cmsStageSampleCLut16bit(CLUT, ReverseSampler, &p, 0)) return 0;
+
+    cmsPipelineInsertStage(AToB0, cmsAT_BEGIN, _cmsStageAllocIdentityCurves(ContextID, 4)); 
+    cmsPipelineInsertStage(AToB0, cmsAT_END, CLUT);
+    cmsPipelineInsertStage(AToB0, cmsAT_END, _cmsStageAllocIdentityCurves(ContextID, 3));
+    
     if (!cmsWriteTag(hICC, cmsSigAToB0Tag, (void*) AToB0)) return 0;
-    cmsPipelineFree(AToB0);

+    cmsPipelineFree(AToB0);
 
-    cmsDeleteTransform(p.hLab2sRGB);

-    cmsDeleteTransform(p.sRGB2Lab);

-    cmsDeleteTransform(p.hIlimit);

+    cmsDeleteTransform(p.hLab2sRGB);
+    cmsDeleteTransform(p.sRGB2Lab);
+    cmsDeleteTransform(p.hIlimit);
 
-    cmsLinkTag(hICC, cmsSigAToB1Tag, cmsSigAToB0Tag);

+    cmsLinkTag(hICC, cmsSigAToB1Tag, cmsSigAToB0Tag);
     cmsLinkTag(hICC, cmsSigAToB2Tag, cmsSigAToB0Tag);
-    cmsLinkTag(hICC, cmsSigBToA1Tag, cmsSigBToA0Tag);

+    cmsLinkTag(hICC, cmsSigBToA1Tag, cmsSigBToA0Tag);
     cmsLinkTag(hICC, cmsSigBToA2Tag, cmsSigBToA0Tag);
 
-    return hICC;    

+    return hICC;    
 }
 
 
 // Does create several profiles for latter use------------------------------------------------------------------------------------------------
 
 static
-cmsInt32Number OneVirtual(cmsHPROFILE h, const char* SubTestTxt, const char* FileName)

+cmsInt32Number OneVirtual(cmsHPROFILE h, const char* SubTestTxt, const char* FileName)
 {
-    SubTest(SubTestTxt);

-    if (h == NULL) return 0;

+    SubTest(SubTestTxt);
+    if (h == NULL) return 0;
 
-    if (!cmsSaveProfileToFile(h, FileName)) return 0;

-    cmsCloseProfile(h);

+    if (!cmsSaveProfileToFile(h, FileName)) return 0;
+    cmsCloseProfile(h);
 
-    h = cmsOpenProfileFromFile(FileName, "r");

-    if (h == NULL) return 0;

+    h = cmsOpenProfileFromFile(FileName, "r");
+    if (h == NULL) return 0;
 
-    // Do some teste....

+    // Do some teste....
 
-    cmsCloseProfile(h);

+    cmsCloseProfile(h);
 
-    return 1;

+    return 1;
 }
 
 
@@ -556,7 +556,7 @@ cmsInt32Number OneVirtual(cmsHPROFILE h, const char* SubTestTxt, const char* Fil
 // This test checks the ability of lcms2 to save its built-ins as valid profiles. 
 // It does not check the functionality of such profiles
 static
-cmsInt32Number CreateTestProfiles(void)

+cmsInt32Number CreateTestProfiles(void)
 {
     cmsHPROFILE h;
 
@@ -570,17 +570,17 @@ cmsInt32Number CreateTestProfiles(void)
 
     // ----
     
-    h = Create_Gray22();

+    h = Create_Gray22();
     if (!OneVirtual(h, "Gray profile", "graylcms2.icc")) return 0;
 
     // ----
 
-    h = Create_GrayLab();

-    if (!OneVirtual(h, "Gray Lab profile", "glablcms2.icc")) return 0;

-    

-    // ----

-

-    h = Create_CMYK_DeviceLink();

+    h = Create_GrayLab();
+    if (!OneVirtual(h, "Gray Lab profile", "glablcms2.icc")) return 0;
+    
+    // ----
+
+    h = Create_CMYK_DeviceLink();
     if (!OneVirtual(h, "Linearization profile", "linlcms2.icc")) return 0;
 
     // -------
@@ -613,10 +613,10 @@ cmsInt32Number CreateTestProfiles(void)
     h = cmsCreateBCHSWabstractProfileTHR(DbgThread(), 17, 0, 0, 0, 0, 5000, 6000);
     if (!OneVirtual(h, "BCHS profile", "bchslcms2.icc")) return 0;
 
-    // ---

+    // ---
 
-    h = CreateFakeCMYK(300, FALSE);

-    if (!OneVirtual(h, "Fake CMYK profile", "lcms2cmyk.icc")) return 0;

+    h = CreateFakeCMYK(300, FALSE);
+    if (!OneVirtual(h, "Fake CMYK profile", "lcms2cmyk.icc")) return 0;
 
     return 1;
 }
@@ -624,7 +624,7 @@ cmsInt32Number CreateTestProfiles(void)
 static
 void RemoveTestProfiles(void)
 {
-    remove("sRGBlcms2.icc");

+    remove("sRGBlcms2.icc");
     remove("aRGBlcms2.icc");
     remove("graylcms2.icc");
     remove("linlcms2.icc");
@@ -634,15 +634,15 @@ void RemoveTestProfiles(void)
     remove("xyzlcms2.icc");
     remove("nullcms2.icc");
     remove("bchslcms2.icc");
-    remove("lcms2cmyk.icc");

-    remove("glablcms2.icc");

+    remove("lcms2cmyk.icc");
+    remove("glablcms2.icc");
 }
 
 // -------------------------------------------------------------------------------------------------
 
 // Check the size of basic types. If this test fails, nothing is going to work anyway
 static
-cmsInt32Number CheckBaseTypes(void)

+cmsInt32Number CheckBaseTypes(void)
 {
     if (sizeof(cmsUInt8Number) != 1) return 0;
     if (sizeof(cmsInt8Number) != 1) return 0;
@@ -654,10 +654,10 @@ cmsInt32Number CheckBaseTypes(void)
     if (sizeof(cmsInt64Number) != 8) return 0;
     if (sizeof(cmsFloat32Number) != 4) return 0;
     if (sizeof(cmsFloat64Number) != 8) return 0;
-    if (sizeof(cmsSignature) != 4) return 0;

-    if (sizeof(cmsU8Fixed8Number) != 2) return 0;

-    if (sizeof(cmsS15Fixed16Number) != 4) return 0;

-    if (sizeof(cmsU16Fixed16Number) != 4) return 0;

+    if (sizeof(cmsSignature) != 4) return 0;
+    if (sizeof(cmsU8Fixed8Number) != 2) return 0;
+    if (sizeof(cmsS15Fixed16Number) != 4) return 0;
+    if (sizeof(cmsU16Fixed16Number) != 4) return 0;
     
     return 1;
 }
@@ -667,9 +667,9 @@ cmsInt32Number CheckBaseTypes(void)
 
 // Are we little or big endian?  From Harbison&Steele.  
 static
-cmsInt32Number CheckEndianess(void)

+cmsInt32Number CheckEndianess(void)
 {
-    cmsInt32Number BigEndian, IsOk;   

+    cmsInt32Number BigEndian, IsOk;   
     union {
         long l;
         char c[sizeof (long)];
@@ -695,7 +695,7 @@ cmsInt32Number CheckEndianess(void)
 
 // Check quick floor
 static
-cmsInt32Number CheckQuickFloor(void)

+cmsInt32Number CheckQuickFloor(void)
 {
     if ((_cmsQuickFloor(1.234) != 1) ||
         (_cmsQuickFloor(32767.234) != 32767) ||
@@ -713,7 +713,7 @@ cmsInt32Number CheckQuickFloor(void)
 
 // Quick floor restricted to word
 static
-cmsInt32Number CheckQuickFloorWord(void)

+cmsInt32Number CheckQuickFloorWord(void)
 {
     cmsUInt32Number i;
 
@@ -789,7 +789,7 @@ cmsBool  IsGoodWord(const char *title, cmsUInt16Number in, cmsUInt16Number out)
 // Fixed point ----------------------------------------------------------------------------------------------
 
 static
-cmsInt32Number TestSingleFixed15_16(cmsFloat64Number d)

+cmsInt32Number TestSingleFixed15_16(cmsFloat64Number d)
 {
     cmsS15Fixed16Number f = _cmsDoubleTo15Fixed16(d);
     cmsFloat64Number RoundTrip = _cms15Fixed16toDouble(f);
@@ -799,7 +799,7 @@ cmsInt32Number TestSingleFixed15_16(cmsFloat64Number d)
 }
 
 static
-cmsInt32Number CheckFixedPoint15_16(void)

+cmsInt32Number CheckFixedPoint15_16(void)
 {
     if (!TestSingleFixed15_16(1.0)) return 0;
     if (!TestSingleFixed15_16(2.0)) return 0;
@@ -816,7 +816,7 @@ cmsInt32Number CheckFixedPoint15_16(void)
 }
 
 static
-cmsInt32Number TestSingleFixed8_8(cmsFloat64Number d)

+cmsInt32Number TestSingleFixed8_8(cmsFloat64Number d)
 {
     cmsS15Fixed16Number f = _cmsDoubleTo8Fixed8(d);
     cmsFloat64Number RoundTrip = _cms8Fixed8toDouble((cmsUInt16Number) f);
@@ -826,7 +826,7 @@ cmsInt32Number TestSingleFixed8_8(cmsFloat64Number d)
 }
 
 static
-cmsInt32Number CheckFixedPoint8_8(void)

+cmsInt32Number CheckFixedPoint8_8(void)
 {
     if (!TestSingleFixed8_8(1.0)) return 0;
     if (!TestSingleFixed8_8(2.0)) return 0;
@@ -847,9 +847,9 @@ cmsInt32Number CheckFixedPoint8_8(void)
 // I test tables of 2, 4, 6, and 18 points, that will be exact.
 
 static
-void BuildTable(cmsInt32Number n, cmsUInt16Number Tab[], cmsBool  Descending)

+void BuildTable(cmsInt32Number n, cmsUInt16Number Tab[], cmsBool  Descending)
 {
-    cmsInt32Number i;

+    cmsInt32Number i;
 
     for (i=0; i < n; i++) {
         cmsFloat64Number v = (cmsFloat64Number) ((cmsFloat64Number) 65535.0 * i ) / (n-1);
@@ -865,7 +865,7 @@ void BuildTable(cmsInt32Number n, cmsUInt16Number Tab[], cmsBool  Descending)
 // max_err = max allowed error 
 
 static
-cmsInt32Number Check1D(cmsInt32Number nNodesToCheck, cmsBool  Down, cmsInt32Number max_err)

+cmsInt32Number Check1D(cmsInt32Number nNodesToCheck, cmsBool  Down, cmsInt32Number max_err)
 {
     cmsUInt32Number i;
     cmsUInt16Number in, out;
@@ -905,65 +905,65 @@ cmsInt32Number Check1D(cmsInt32Number nNodesToCheck, cmsBool  Down, cmsInt32Numb
 
 
 static
-cmsInt32Number Check1DLERP2(void)

+cmsInt32Number Check1DLERP2(void)
 {
     return Check1D(2, FALSE, 0);
 }
 
 
 static
-cmsInt32Number Check1DLERP3(void)

+cmsInt32Number Check1DLERP3(void)
 {
     return Check1D(3, FALSE, 1);    
 }
 
 
 static
-cmsInt32Number Check1DLERP4(void)

+cmsInt32Number Check1DLERP4(void)
 {
     return Check1D(4, FALSE, 0);
 }
 
 static
-cmsInt32Number Check1DLERP6(void)

+cmsInt32Number Check1DLERP6(void)
 {
     return Check1D(6, FALSE, 0);
 }
 
 static
-cmsInt32Number Check1DLERP18(void)

+cmsInt32Number Check1DLERP18(void)
 {
     return Check1D(18, FALSE, 0);
 }
 
 
 static
-cmsInt32Number Check1DLERP2Down(void)

+cmsInt32Number Check1DLERP2Down(void)
 {
     return Check1D(2, TRUE, 0);
 }
 
 
 static
-cmsInt32Number Check1DLERP3Down(void)

+cmsInt32Number Check1DLERP3Down(void)
 {
     return Check1D(3, TRUE, 1);
 }
 
 static
-cmsInt32Number Check1DLERP6Down(void)

+cmsInt32Number Check1DLERP6Down(void)
 {
     return Check1D(6, TRUE, 0);
 }
 
 static
-cmsInt32Number Check1DLERP18Down(void)

+cmsInt32Number Check1DLERP18Down(void)
 {
     return Check1D(18, TRUE, 0);
 }
 
 static
-cmsInt32Number ExhaustiveCheck1DLERP(void)

+cmsInt32Number ExhaustiveCheck1DLERP(void)
 {
     cmsUInt32Number j;
     
@@ -980,7 +980,7 @@ cmsInt32Number ExhaustiveCheck1DLERP(void)
 }
 
 static
-cmsInt32Number ExhaustiveCheck1DLERPDown(void)

+cmsInt32Number ExhaustiveCheck1DLERPDown(void)
 {
     cmsUInt32Number j;
     
@@ -1002,10 +1002,10 @@ cmsInt32Number ExhaustiveCheck1DLERPDown(void)
 // 3D interpolation -------------------------------------------------------------------------------------------------
 
 static
-cmsInt32Number Check3DinterpolationFloatTetrahedral(void)

+cmsInt32Number Check3DinterpolationFloatTetrahedral(void)
 {
     cmsInterpParams* p;
-    cmsInt32Number i;

+    cmsInt32Number i;
     cmsFloat32Number In[3], Out[3];
     cmsFloat32Number FloatTable[] = { //R     G    B
 
@@ -1048,10 +1048,10 @@ Error:
 }
 
 static
-cmsInt32Number Check3DinterpolationFloatTrilinear(void)

+cmsInt32Number Check3DinterpolationFloatTrilinear(void)
 {
     cmsInterpParams* p;
-    cmsInt32Number i;

+    cmsInt32Number i;
     cmsFloat32Number In[3], Out[3];
     cmsFloat32Number FloatTable[] = { //R     G    B
 
@@ -1094,10 +1094,10 @@ Error:
 }
 
 static
-cmsInt32Number Check3DinterpolationTetrahedral16(void)

+cmsInt32Number Check3DinterpolationTetrahedral16(void)
 {
     cmsInterpParams* p;
-    cmsInt32Number i;

+    cmsInt32Number i;
     cmsUInt16Number In[3], Out[3];
     cmsUInt16Number Table[] = { 
 
@@ -1119,7 +1119,7 @@ cmsInt32Number Check3DinterpolationTetrahedral16(void)
     MaxErr = 0.0;
      for (i=0; i < 0xffff; i++) {
 
-       In[0] = In[1] = In[2] = (cmsUInt16Number) i;

+       In[0] = In[1] = In[2] = (cmsUInt16Number) i;
 
         p ->Interpolation.Lerp16(In, Out, p);
 
@@ -1138,10 +1138,10 @@ Error:
 }
 
 static
-cmsInt32Number Check3DinterpolationTrilinear16(void)

+cmsInt32Number Check3DinterpolationTrilinear16(void)
 {
     cmsInterpParams* p;
-    cmsInt32Number i;

+    cmsInt32Number i;
     cmsUInt16Number In[3], Out[3];
     cmsUInt16Number Table[] = { 
 
@@ -1163,7 +1163,7 @@ cmsInt32Number Check3DinterpolationTrilinear16(void)
     MaxErr = 0.0;
      for (i=0; i < 0xffff; i++) {
 
-       In[0] = In[1] = In[2] = (cmsUInt16Number) i;

+       In[0] = In[1] = In[2] = (cmsUInt16Number) i;
 
         p ->Interpolation.Lerp16(In, Out, p);
 
@@ -1183,10 +1183,10 @@ Error:
 
 
 static
-cmsInt32Number ExaustiveCheck3DinterpolationFloatTetrahedral(void)

+cmsInt32Number ExaustiveCheck3DinterpolationFloatTetrahedral(void)
 {
     cmsInterpParams* p;
-    cmsInt32Number r, g, b;

+    cmsInt32Number r, g, b;
     cmsFloat32Number In[3], Out[3];
     cmsFloat32Number FloatTable[] = { //R     G    B
 
@@ -1234,10 +1234,10 @@ Error:
 }
 
 static
-cmsInt32Number ExaustiveCheck3DinterpolationFloatTrilinear(void)

+cmsInt32Number ExaustiveCheck3DinterpolationFloatTrilinear(void)
 {
     cmsInterpParams* p;
-    cmsInt32Number r, g, b;

+    cmsInt32Number r, g, b;
     cmsFloat32Number In[3], Out[3];
     cmsFloat32Number FloatTable[] = { //R     G    B
 
@@ -1258,22 +1258,22 @@ cmsInt32Number ExaustiveCheck3DinterpolationFloatTrilinear(void)
     p = _cmsComputeInterpParams(DbgThread(), 2, 3, 3, FloatTable, CMS_LERP_FLAGS_FLOAT|CMS_LERP_FLAGS_TRILINEAR);
 
     MaxErr = 0.0;
-    for (r=0; r < 0xff; r++) 

-        for (g=0; g < 0xff; g++) 

-            for (b=0; b < 0xff; b++) 

-            {

-

-                In[0] = (cmsFloat32Number) r / 255.0F;

-                In[1] = (cmsFloat32Number) g / 255.0F;

-                In[2] = (cmsFloat32Number) b / 255.0F;

-

-

-                p ->Interpolation.LerpFloat(In, Out, p);

-

-                if (!IsGoodFixed15_16("Channel 1", Out[0], In[0])) goto Error;

-                if (!IsGoodFixed15_16("Channel 2", Out[1], (cmsFloat32Number) In[1] / 2.F)) goto Error;

-                if (!IsGoodFixed15_16("Channel 3", Out[2], (cmsFloat32Number) In[2] / 4.F)) goto Error;

-            }

+    for (r=0; r < 0xff; r++) 
+        for (g=0; g < 0xff; g++) 
+            for (b=0; b < 0xff; b++) 
+            {
+
+                In[0] = (cmsFloat32Number) r / 255.0F;
+                In[1] = (cmsFloat32Number) g / 255.0F;
+                In[2] = (cmsFloat32Number) b / 255.0F;
+
+
+                p ->Interpolation.LerpFloat(In, Out, p);
+
+                if (!IsGoodFixed15_16("Channel 1", Out[0], In[0])) goto Error;
+                if (!IsGoodFixed15_16("Channel 2", Out[1], (cmsFloat32Number) In[1] / 2.F)) goto Error;
+                if (!IsGoodFixed15_16("Channel 3", Out[2], (cmsFloat32Number) In[2] / 4.F)) goto Error;
+            }
 
     if (MaxErr > 0) printf("|Err|<%lf ", MaxErr);
     _cmsFreeInterpParams(p);
@@ -1286,10 +1286,10 @@ Error:
 }
 
 static
-cmsInt32Number ExhaustiveCheck3DinterpolationTetrahedral16(void)

+cmsInt32Number ExhaustiveCheck3DinterpolationTetrahedral16(void)
 {
     cmsInterpParams* p;
-    cmsInt32Number r, g, b;

+    cmsInt32Number r, g, b;
     cmsUInt16Number In[3], Out[3];
     cmsUInt16Number Table[] = { 
 
@@ -1312,9 +1312,9 @@ cmsInt32Number ExhaustiveCheck3DinterpolationTetrahedral16(void)
         for (g=0; g < 0xff; g++) 
             for (b=0; b < 0xff; b++) 
         {
-            In[0] = (cmsUInt16Number) r ;

-            In[1] = (cmsUInt16Number) g ;

-            In[2] = (cmsUInt16Number) b ;

+            In[0] = (cmsUInt16Number) r ;
+            In[1] = (cmsUInt16Number) g ;
+            In[2] = (cmsUInt16Number) b ;
 
 
         p ->Interpolation.Lerp16(In, Out, p);
@@ -1333,10 +1333,10 @@ Error:
 }
 
 static
-cmsInt32Number ExhaustiveCheck3DinterpolationTrilinear16(void)

+cmsInt32Number ExhaustiveCheck3DinterpolationTrilinear16(void)
 {
     cmsInterpParams* p;
-    cmsInt32Number r, g, b;

+    cmsInt32Number r, g, b;
     cmsUInt16Number In[3], Out[3];
     cmsUInt16Number Table[] = { 
 
@@ -1359,9 +1359,9 @@ cmsInt32Number ExhaustiveCheck3DinterpolationTrilinear16(void)
         for (g=0; g < 0xff; g++) 
             for (b=0; b < 0xff; b++) 
         {
-            In[0] = r ;
-            In[1] = g ;
-            In[2] = b ;
+            In[0] = (cmsUInt16Number) r ;
+            In[1] = (cmsUInt16Number)g ;
+            In[2] = (cmsUInt16Number)b ;
 
 
         p ->Interpolation.Lerp16(In, Out, p);
@@ -1382,13 +1382,13 @@ Error:
 
 // Check reverse interpolation on LUTS. This is right now exclusively used by K preservation algorithm
 static
-cmsInt32Number CheckReverseInterpolation3x3(void)

+cmsInt32Number CheckReverseInterpolation3x3(void)
 {
  cmsPipeline* Lut;
  cmsStage* clut;
  cmsFloat32Number Target[3], Result[3], Hint[3];
  cmsFloat32Number err, max;
- cmsInt32Number i;

+ cmsInt32Number i;
  cmsUInt16Number Table[] = { 
 
         0,    0,   0,                 // 0 0 0  
@@ -1416,65 +1416,65 @@ cmsInt32Number CheckReverseInterpolation3x3(void)
    cmsPipelineEvalReverseFloat(Target, Result, NULL, Lut);
    if (Result[0] != 0 || Result[1] != 0 || Result[2] != 0){
 
-       Fail("Reverse interpolation didn't find zero");

-       return 0;

+       Fail("Reverse interpolation didn't find zero");
+       return 0;
    }
 
    // Transverse identity
    max = 0;
    for (i=0; i <= 100; i++) {
 
-       cmsFloat32Number in = i / 100.0F;

+       cmsFloat32Number in = i / 100.0F;
 
-       Target[0] = in; Target[1] = 0; Target[2] = 0; 

-       cmsPipelineEvalReverseFloat(Target, Result, Hint, Lut);

+       Target[0] = in; Target[1] = 0; Target[2] = 0; 
+       cmsPipelineEvalReverseFloat(Target, Result, Hint, Lut);
 
-       err = fabsf(in - Result[0]);

-       if (err > max) max = err;

+       err = fabsf(in - Result[0]);
+       if (err > max) max = err;
 
-       memcpy(Hint, Result, sizeof(Hint));

+       memcpy(Hint, Result, sizeof(Hint));
    }
 
     cmsPipelineFree(Lut);
-    return (max <= FLOAT_PRECISSION);

+    return (max <= FLOAT_PRECISSION);
 }
 
 
 static
-cmsInt32Number CheckReverseInterpolation4x3(void)

+cmsInt32Number CheckReverseInterpolation4x3(void)
 {
  cmsPipeline* Lut;
  cmsStage* clut;
  cmsFloat32Number Target[4], Result[4], Hint[4];
  cmsFloat32Number err, max;
- cmsInt32Number i;

+ cmsInt32Number i;
 
  // 4 -> 3, output gets 3 first channels copied
  cmsUInt16Number Table[] = { 
 
         0,         0,         0,          //  0 0 0 0   = ( 0, 0, 0)
         0,         0,         0,          //  0 0 0 1   = ( 0, 0, 0)
-                                        

+                                        
         0,         0,         0xffff,     //  0 0 1 0   = ( 0, 0, 1)
-        0,         0,         0xffff,     //  0 0 1 1   = ( 0, 0, 1)

-                                            

+        0,         0,         0xffff,     //  0 0 1 1   = ( 0, 0, 1)
+                                            
         0,         0xffff,    0,          //  0 1 0 0   = ( 0, 1, 0)
         0,         0xffff,    0,          //  0 1 0 1   = ( 0, 1, 0)
-                                            

+                                            
         0,         0xffff,    0xffff,     //  0 1 1 0    = ( 0, 1, 1)
         0,         0xffff,    0xffff,     //  0 1 1 1    = ( 0, 1, 1)
 
         0xffff,    0,         0,          //  1 0 0 0    = ( 1, 0, 0)
         0xffff,    0,         0,          //  1 0 0 1    = ( 1, 0, 0)
-                                            

+                                            
         0xffff,    0,         0xffff,     //  1 0 1 0    = ( 1, 0, 1)
-        0xffff,    0,         0xffff,     //  1 0 1 1    = ( 1, 0, 1)

-                                            

+        0xffff,    0,         0xffff,     //  1 0 1 1    = ( 1, 0, 1)
+                                            
         0xffff,    0xffff,    0,          //  1 1 0 0    = ( 1, 1, 0)
-        0xffff,    0xffff,    0,          //  1 1 0 1    = ( 1, 1, 0)

-                                            

+        0xffff,    0xffff,    0,          //  1 1 0 1    = ( 1, 1, 0)
+                                            
         0xffff,    0xffff,    0xffff,     //  1 1 1 0    = ( 1, 1, 1)
-        0xffff,    0xffff,    0xffff,     //  1 1 1 1    = ( 1, 1, 1)

+        0xffff,    0xffff,    0xffff,     //  1 1 1 1    = ( 1, 1, 1)
     };
 
    
@@ -1487,16 +1487,16 @@ cmsInt32Number CheckReverseInterpolation4x3(void)
    SubTest("4->3 feasibility");
    for (i=0; i <= 100; i++) {
 
-       Target[0] = i / 100.0F;

-       Target[1] = Target[0];

-       Target[2] = 0;

-       Target[3] = 12;

+       Target[0] = i / 100.0F;
+       Target[1] = Target[0];
+       Target[2] = 0;
+       Target[3] = 12;
 
-       cmsPipelineEvalFloat(Target, Result, Lut);

+       cmsPipelineEvalFloat(Target, Result, Lut);
 
-       if (!IsGoodFixed15_16("0", Target[0], Result[0])) return 0;

+       if (!IsGoodFixed15_16("0", Target[0], Result[0])) return 0;
        if (!IsGoodFixed15_16("1", Target[1], Result[1])) return 0;
-       if (!IsGoodFixed15_16("2", Target[2], Result[2])) return 0;

+       if (!IsGoodFixed15_16("2", Target[2], Result[2])) return 0;
    }
 
    SubTest("4->3 zero");
@@ -1514,27 +1514,27 @@ cmsInt32Number CheckReverseInterpolation4x3(void)
 
    if (Result[0] != 0 || Result[1] != 0 || Result[2] != 0 || Result[3] != 0){
 
-       Fail("Reverse interpolation didn't find zero");

-       return 0;

+       Fail("Reverse interpolation didn't find zero");
+       return 0;
    }
 
    SubTest("4->3 find CMY");
    max = 0;
    for (i=0; i <= 100; i++) {
 
-       cmsFloat32Number in = i / 100.0F;

+       cmsFloat32Number in = i / 100.0F;
 
-       Target[0] = in; Target[1] = 0; Target[2] = 0; 

-       cmsPipelineEvalReverseFloat(Target, Result, Hint, Lut);

+       Target[0] = in; Target[1] = 0; Target[2] = 0; 
+       cmsPipelineEvalReverseFloat(Target, Result, Hint, Lut);
 
-       err = fabsf(in - Result[0]);

-       if (err > max) max = err;

+       err = fabsf(in - Result[0]);
+       if (err > max) max = err;
 
-       memcpy(Hint, Result, sizeof(Hint));

+       memcpy(Hint, Result, sizeof(Hint));
    }
 
     cmsPipelineFree(Lut);
-    return (max <= FLOAT_PRECISSION);

+    return (max <= FLOAT_PRECISSION);
 }
 
 
@@ -1542,9 +1542,9 @@ cmsInt32Number CheckReverseInterpolation4x3(void)
 
 // Lab to LCh and back should be performed at 1E-12 accuracy at least
 static
-cmsInt32Number CheckLab2LCh(void)

+cmsInt32Number CheckLab2LCh(void)
 {
-    cmsInt32Number l, a, b;

+    cmsInt32Number l, a, b;
     cmsFloat64Number dist, Max = 0;
     cmsCIELab Lab, Lab2;
     cmsCIELCh LCh;
@@ -1573,9 +1573,9 @@ cmsInt32Number CheckLab2LCh(void)
 
 // Lab to LCh and back should be performed at 1E-12 accuracy at least
 static
-cmsInt32Number CheckLab2XYZ(void)

+cmsInt32Number CheckLab2XYZ(void)
 {
-    cmsInt32Number l, a, b;

+    cmsInt32Number l, a, b;
     cmsFloat64Number dist, Max = 0;
     cmsCIELab Lab, Lab2;
     cmsCIEXYZ XYZ;
@@ -1605,13 +1605,13 @@ cmsInt32Number CheckLab2XYZ(void)
 
 // Lab to xyY and back should be performed at 1E-12 accuracy at least
 static
-cmsInt32Number CheckLab2xyY(void)

+cmsInt32Number CheckLab2xyY(void)
 {
-    cmsInt32Number l, a, b;

+    cmsInt32Number l, a, b;
     cmsFloat64Number dist, Max = 0;
     cmsCIELab Lab, Lab2;
     cmsCIEXYZ XYZ;
-    cmsCIExyY xyY;

+    cmsCIExyY xyY;
 
     for (l=0; l <= 100; l += 10) {
 
@@ -1624,8 +1624,8 @@ cmsInt32Number CheckLab2xyY(void)
                 Lab.b = b;
 
                 cmsLab2XYZ(NULL, &XYZ, &Lab);
-                cmsXYZ2xyY(&xyY, &XYZ);

-                cmsxyY2XYZ(&XYZ, &xyY);

+                cmsXYZ2xyY(&xyY, &XYZ);
+                cmsxyY2XYZ(&XYZ, &xyY);
                 cmsXYZ2Lab(NULL, &Lab2, &XYZ);
 
                 dist = cmsDeltaE(&Lab, &Lab2);
@@ -1640,9 +1640,9 @@ cmsInt32Number CheckLab2xyY(void)
 
 
 static
-cmsInt32Number CheckLabV2encoding(void)

+cmsInt32Number CheckLabV2encoding(void)
 {
-    cmsInt32Number n2, i, j;

+    cmsInt32Number n2, i, j;
     cmsUInt16Number Inw[3], aw[3];
     cmsCIELab Lab;
 
@@ -1650,7 +1650,7 @@ cmsInt32Number CheckLabV2encoding(void)
     
     for (j=0; j < 65535; j++) {
 
-        Inw[0] = Inw[1] = Inw[2] = j;
+        Inw[0] = Inw[1] = Inw[2] = (cmsUInt16Number) j;
 
         cmsLabEncoded2FloatV2(&Lab, Inw);
         cmsFloat2LabEncodedV2(aw, &Lab);
@@ -1668,9 +1668,9 @@ cmsInt32Number CheckLabV2encoding(void)
 }
 
 static
-cmsInt32Number CheckLabV4encoding(void)

+cmsInt32Number CheckLabV4encoding(void)
 {
-    cmsInt32Number n2, i, j;

+    cmsInt32Number n2, i, j;
     cmsUInt16Number Inw[3], aw[3];
     cmsCIELab Lab;
 
@@ -1678,7 +1678,7 @@ cmsInt32Number CheckLabV4encoding(void)
     
     for (j=0; j < 65535; j++) {
 
-        Inw[0] = Inw[1] = Inw[2] = j;
+        Inw[0] = Inw[1] = Inw[2] = (cmsUInt16Number) j;
 
         cmsLabEncoded2Float(&Lab, Inw);
         cmsFloat2LabEncoded(aw, &Lab);
@@ -1699,9 +1699,9 @@ cmsInt32Number CheckLabV4encoding(void)
 // BlackBody -----------------------------------------------------------------------------------------------------
 
 static
-cmsInt32Number CheckTemp2CHRM(void)

+cmsInt32Number CheckTemp2CHRM(void)
 {
-    cmsInt32Number j;

+    cmsInt32Number j;
     cmsFloat64Number d, v, Max = 0;
     cmsCIExyY White;
     
@@ -1723,25 +1723,25 @@ cmsInt32Number CheckTemp2CHRM(void)
 // Tone curves -----------------------------------------------------------------------------------------------------
 
 static
-cmsInt32Number CheckGammaEstimation(cmsToneCurve* c, cmsFloat64Number g)

+cmsInt32Number CheckGammaEstimation(cmsToneCurve* c, cmsFloat64Number g)
 {
-    cmsFloat64Number est = cmsEstimateGamma(c, 0.001);

+    cmsFloat64Number est = cmsEstimateGamma(c, 0.001);
 
-    SubTest("Gamma estimation");

-    if (fabs(est - g) > 0.001) return 0;

-    return 1;

+    SubTest("Gamma estimation");
+    if (fabs(est - g) > 0.001) return 0;
+    return 1;
 }
 
 static
-cmsInt32Number CheckGammaCreation16(void)

+cmsInt32Number CheckGammaCreation16(void)
 {
     cmsToneCurve* LinGamma = cmsBuildGamma(DbgThread(), 1.0);
-    cmsInt32Number i;

+    cmsInt32Number i;
     cmsUInt16Number in, out;
 
     for (i=0; i < 0xffff; i++) {
 
-        in = i;
+        in = (cmsUInt16Number) i;
         out = cmsEvalToneCurve16(LinGamma, in);
         if (in != out) {
             Fail("(lin gamma): Must be %x, But is %x : ", in, out);
@@ -1750,7 +1750,7 @@ cmsInt32Number CheckGammaCreation16(void)
         }
     }       
 
-    if (!CheckGammaEstimation(LinGamma, 1.0)) return 0;

+    if (!CheckGammaEstimation(LinGamma, 1.0)) return 0;
 
     cmsFreeToneCurve(LinGamma);
     return 1;
@@ -1758,10 +1758,10 @@ cmsInt32Number CheckGammaCreation16(void)
 }
 
 static
-cmsInt32Number CheckGammaCreationFlt(void)

+cmsInt32Number CheckGammaCreationFlt(void)
 {
     cmsToneCurve* LinGamma = cmsBuildGamma(DbgThread(), 1.0);
-    cmsInt32Number i;

+    cmsInt32Number i;
     cmsFloat32Number in, out;
 
     for (i=0; i < 0xffff; i++) {
@@ -1775,7 +1775,7 @@ cmsInt32Number CheckGammaCreationFlt(void)
         }
     }       
 
-    if (!CheckGammaEstimation(LinGamma, 1.0)) return 0;

+    if (!CheckGammaEstimation(LinGamma, 1.0)) return 0;
     cmsFreeToneCurve(LinGamma);
     return 1;
 }
@@ -1783,10 +1783,10 @@ cmsInt32Number CheckGammaCreationFlt(void)
 // Curve curves using a single power function
 // Error is given in 0..ffff counts
 static
-cmsInt32Number CheckGammaFloat(cmsInt32Number nPoints, cmsFloat64Number g)

+cmsInt32Number CheckGammaFloat(cmsFloat64Number g)
 {
     cmsToneCurve* Curve = cmsBuildGamma(DbgThread(), g);
-    cmsInt32Number i;

+    cmsInt32Number i;
     cmsFloat32Number in, out;
     cmsFloat64Number val, Err;
 
@@ -1795,7 +1795,7 @@ cmsInt32Number CheckGammaFloat(cmsInt32Number nPoints, cmsFloat64Number g)
 
         in = (cmsFloat32Number) (i / 65535.0);
         out = cmsEvalToneCurveFloat(Curve, in);
-        val = pow((cmsFloat64Number) in, g);

+        val = pow((cmsFloat64Number) in, g);
 
         Err = fabs( val - out);
         if (Err > MaxErr) MaxErr = Err;     
@@ -1803,43 +1803,43 @@ cmsInt32Number CheckGammaFloat(cmsInt32Number nPoints, cmsFloat64Number g)
 
     if (MaxErr > 0) printf("|Err|<%lf ", MaxErr * 65535.0);
 
-    if (!CheckGammaEstimation(Curve, g)) return 0;

+    if (!CheckGammaEstimation(Curve, g)) return 0;
 
     cmsFreeToneCurve(Curve);
     return 1;
 }
 
-static cmsInt32Number CheckGamma18(void) 

+static cmsInt32Number CheckGamma18(void) 
 {
-    return CheckGammaFloat(256, 1.8);
+    return CheckGammaFloat(1.8);
 }
 
-static cmsInt32Number CheckGamma22(void) 

+static cmsInt32Number CheckGamma22(void) 
 {
-    return CheckGammaFloat(256, 2.2);
+    return CheckGammaFloat(2.2);
 }
 
-static cmsInt32Number CheckGamma30(void) 

+static cmsInt32Number CheckGamma30(void) 
 {
-    return CheckGammaFloat(256, 3.0);
+    return CheckGammaFloat(3.0);
 }
 
 
 // Check table-based gamma functions
 static
-cmsInt32Number CheckGammaFloatTable(cmsFloat64Number g)

+cmsInt32Number CheckGammaFloatTable(cmsFloat64Number g)
 {
-    cmsFloat32Number Values[1025];

+    cmsFloat32Number Values[1025];
     cmsToneCurve* Curve; 
-    cmsInt32Number i;

+    cmsInt32Number i;
     cmsFloat32Number in, out;
     cmsFloat64Number val, Err;
 
-    for (i=0; i <= 1024; i++) {

+    for (i=0; i <= 1024; i++) {
 
         in = (cmsFloat32Number) (i / 1024.0);
-        Values[i] = powf(in, (float) g);

-    }

+        Values[i] = powf(in, (float) g);
+    }
 
     Curve = cmsBuildTabulatedToneCurveFloat(DbgThread(), 1025, Values);
 
@@ -1856,43 +1856,43 @@ cmsInt32Number CheckGammaFloatTable(cmsFloat64Number g)
 
     if (MaxErr > 0) printf("|Err|<%lf ", MaxErr * 65535.0);
 
-    if (!CheckGammaEstimation(Curve, g)) return 0;

+    if (!CheckGammaEstimation(Curve, g)) return 0;
 
     cmsFreeToneCurve(Curve);
     return 1;
 }
 
 
-static cmsInt32Number CheckGamma18Table(void) 

+static cmsInt32Number CheckGamma18Table(void) 
 {
     return CheckGammaFloatTable(1.8);
 }
 
-static cmsInt32Number CheckGamma22Table(void) 

+static cmsInt32Number CheckGamma22Table(void) 
 {
     return CheckGammaFloatTable(2.2);
 }
 
-static cmsInt32Number CheckGamma30Table(void) 

+static cmsInt32Number CheckGamma30Table(void) 
 {
     return CheckGammaFloatTable(3.0);
 }
 
 // Create a curve from a table (which is a pure gamma function) and check it against the pow function.
 static
-cmsInt32Number CheckGammaWordTable(cmsFloat64Number g)

+cmsInt32Number CheckGammaWordTable(cmsFloat64Number g)
 {
-    cmsUInt16Number Values[1025];

+    cmsUInt16Number Values[1025];
     cmsToneCurve* Curve; 
-    cmsInt32Number i;

+    cmsInt32Number i;
     cmsFloat32Number in, out;
     cmsFloat64Number val, Err;
 
-    for (i=0; i <= 1024; i++) {

+    for (i=0; i <= 1024; i++) {
 
         in = (cmsFloat32Number) (i / 1024.0);
-        Values[i] = (cmsUInt16Number) floor(powf(in, g) * 65535.0 + 0.5);

-    }

+        Values[i] = (cmsUInt16Number) floor(powf(in, g) * 65535.0 + 0.5);
+    }
 
     Curve = cmsBuildTabulatedToneCurve16(DbgThread(), 1025, Values);
 
@@ -1909,23 +1909,23 @@ cmsInt32Number CheckGammaWordTable(cmsFloat64Number g)
 
     if (MaxErr > 0) printf("|Err|<%lf ", MaxErr * 65535.0);
 
-    if (!CheckGammaEstimation(Curve, g)) return 0;

+    if (!CheckGammaEstimation(Curve, g)) return 0;
 
     cmsFreeToneCurve(Curve);
     return 1;
 }
 
-static cmsInt32Number CheckGamma18TableWord(void) 

+static cmsInt32Number CheckGamma18TableWord(void) 
 {
     return CheckGammaWordTable(1.8);
 }
 
-static cmsInt32Number CheckGamma22TableWord(void) 

+static cmsInt32Number CheckGamma22TableWord(void) 
 {
     return CheckGammaWordTable(2.2);
 }
 
-static cmsInt32Number CheckGamma30TableWord(void) 

+static cmsInt32Number CheckGamma30TableWord(void) 
 {
     return CheckGammaWordTable(3.0);
 }
@@ -1934,7 +1934,7 @@ static cmsInt32Number CheckGamma30TableWord(void)
 // Curve joining test. Joining two high-gamma of 3.0 curves should
 // give something like linear
 static
-cmsInt32Number CheckJointCurves(void)

+cmsInt32Number CheckJointCurves(void)
 {
     cmsToneCurve *Forward, *Reverse, *Result;
     cmsBool  rc;
@@ -1958,19 +1958,19 @@ cmsInt32Number CheckJointCurves(void)
 
 // Create a gamma curve by cheating the table
 static
-cmsToneCurve* GammaTableLinear(cmsInt32Number nEntries, cmsBool Dir)

+cmsToneCurve* GammaTableLinear(cmsInt32Number nEntries, cmsBool Dir)
 {
-    cmsInt32Number i;

+    cmsInt32Number i;
     cmsToneCurve* g = cmsBuildTabulatedToneCurve16(DbgThread(), nEntries, NULL);
 
     for (i=0; i < nEntries; i++) {
 
-        cmsInt32Number v = _cmsQuantizeVal(i, nEntries);

+        cmsInt32Number v = _cmsQuantizeVal(i, nEntries);
 
         if (Dir)
-            g->Table16[i] = v;
+            g->Table16[i] = (cmsUInt16Number) v;
         else
-            g->Table16[i] = 0xFFFF - v;
+            g->Table16[i] = (cmsUInt16Number) (0xFFFF - v);
     }
 
     return g;
@@ -1978,10 +1978,10 @@ cmsToneCurve* GammaTableLinear(cmsInt32Number nEntries, cmsBool Dir)
 
 
 static
-cmsInt32Number CheckJointCurvesDescending(void)

+cmsInt32Number CheckJointCurvesDescending(void)
 {
     cmsToneCurve *Forward, *Reverse, *Result;
-    cmsInt32Number i, rc;

+    cmsInt32Number i, rc;
 
      Forward = cmsBuildGamma(DbgThread(), 2.2); 
 
@@ -2006,9 +2006,9 @@ cmsInt32Number CheckJointCurvesDescending(void)
 
 
 static
-cmsInt32Number CheckFToneCurvePoint(cmsToneCurve* c, cmsInt32Number Point, cmsInt32Number Value)

+cmsInt32Number CheckFToneCurvePoint(cmsToneCurve* c, cmsUInt16Number Point, cmsInt32Number Value)
 {
-    cmsInt32Number Result;

+    cmsInt32Number Result;
 
     Result = cmsEvalToneCurve16(c, Point);
     
@@ -2016,7 +2016,7 @@ cmsInt32Number CheckFToneCurvePoint(cmsToneCurve* c, cmsInt32Number Point, cmsIn
 }
 
 static
-cmsInt32Number CheckReverseDegenerated(void)

+cmsInt32Number CheckReverseDegenerated(void)
 {
     cmsToneCurve* p, *g;
     cmsUInt16Number Tab[16];
@@ -2081,7 +2081,7 @@ cmsToneCurve* CombineGammaFloat(cmsToneCurve* g1, cmsToneCurve* g2)
 {
     cmsUInt16Number Tab[256];
     cmsFloat32Number f;
-    cmsInt32Number i;

+    cmsInt32Number i;
 
     for (i=0; i < 256; i++) {
 
@@ -2100,7 +2100,7 @@ cmsToneCurve* CombineGamma16(cmsToneCurve* g1, cmsToneCurve* g2)
 {
     cmsUInt16Number Tab[256];
 
-    cmsInt32Number i;

+    cmsInt32Number i;
 
     for (i=0; i < 256; i++) {
 
@@ -2114,7 +2114,7 @@ cmsToneCurve* CombineGamma16(cmsToneCurve* g1, cmsToneCurve* g2)
 }
 
 static
-cmsInt32Number CheckJointFloatCurves_sRGB(void)

+cmsInt32Number CheckJointFloatCurves_sRGB(void)
 {
     cmsToneCurve *Forward, *Reverse, *Result;
     cmsBool  rc;
@@ -2131,7 +2131,7 @@ cmsInt32Number CheckJointFloatCurves_sRGB(void)
 }
 
 static
-cmsInt32Number CheckJoint16Curves_sRGB(void)

+cmsInt32Number CheckJoint16Curves_sRGB(void)
 {
     cmsToneCurve *Forward, *Reverse, *Result;
     cmsBool  rc;
@@ -2150,11 +2150,11 @@ cmsInt32Number CheckJoint16Curves_sRGB(void)
 // sigmoidal curve f(x) = (1-x^g) ^(1/g)
 
 static
-cmsInt32Number CheckJointCurvesSShaped(void)

+cmsInt32Number CheckJointCurvesSShaped(void)
 {
-    cmsFloat64Number p = 3.2;

+    cmsFloat64Number p = 3.2;
     cmsToneCurve *Forward, *Reverse, *Result;
-    cmsInt32Number rc;

+    cmsInt32Number rc;
 
     Forward = cmsBuildParametricToneCurve(DbgThread(), 108, &p);    
     Reverse = cmsReverseToneCurve(Forward);
@@ -2308,9 +2308,9 @@ cmsFloat32Number sigmoidal(cmsFloat32Number x, const cmsFloat64Number Params[])
 
 
 static
-cmsBool CheckSingleParametric(const char* Name, dblfnptr fn, cmsInt32Number Type, const cmsFloat64Number Params[])

+cmsBool CheckSingleParametric(const char* Name, dblfnptr fn, cmsInt32Number Type, const cmsFloat64Number Params[])
 {
-    cmsInt32Number i;

+    cmsInt32Number i;
     cmsToneCurve* tc;
     cmsToneCurve* tc_1;
     char InverseText[256];
@@ -2349,7 +2349,7 @@ Error:
 
 // Check against some known values
 static
-cmsInt32Number CheckParametricToneCurves(void)

+cmsInt32Number CheckParametricToneCurves(void)
 {
     cmsFloat64Number Params[10];
 
@@ -2449,11 +2449,11 @@ cmsInt32Number CheckParametricToneCurves(void)
 // LUT checks ------------------------------------------------------------------------------
 
 static
-cmsInt32Number CheckLUTcreation(void)

+cmsInt32Number CheckLUTcreation(void)
 {
     cmsPipeline* lut;
     cmsPipeline* lut2;
-    cmsInt32Number n1, n2;

+    cmsInt32Number n1, n2;
     
     lut = cmsPipelineAlloc(DbgThread(), 1, 1);
     n1 = cmsPipelineStageCount(lut);
@@ -2530,7 +2530,11 @@ static
 void Add3GammaCurves(cmsPipeline* lut, cmsFloat64Number Curve)
 {
     cmsToneCurve* id = cmsBuildGamma(DbgThread(), Curve);
-    cmsToneCurve* id3[3] = { id, id, id };
+    cmsToneCurve* id3[3];
+
+    id3[0] = id;
+    id3[1] = id;
+    id3[2] = id;
 
     cmsPipelineInsertStage(lut, cmsAT_END, cmsStageAllocToneCurves(DbgThread(), 3, id3));
     
@@ -2539,23 +2543,23 @@ void Add3GammaCurves(cmsPipeline* lut, cmsFloat64Number Curve)
 
 
 static
-cmsInt32Number CheckFloatLUT(cmsPipeline* lut)

+cmsInt32Number CheckFloatLUT(cmsPipeline* lut)
 {
-    cmsInt32Number n1, i, j;

+    cmsInt32Number n1, i, j;
     cmsFloat32Number Inf[3], Outf[3];
 
     n1=0;
 
     for (j=0; j < 65535; j++) {
 
-        cmsInt32Number af[3];

+        cmsInt32Number af[3];
 
         Inf[0] = Inf[1] = Inf[2] = (cmsFloat32Number) j / 65535.0F;
         cmsPipelineEvalFloat(Inf, Outf, lut);
 
-        af[0] = (cmsInt32Number) floor(Outf[0]*65535.0 + 0.5);

-        af[1] = (cmsInt32Number) floor(Outf[1]*65535.0 + 0.5);

-        af[2] = (cmsInt32Number) floor(Outf[2]*65535.0 + 0.5);

+        af[0] = (cmsInt32Number) floor(Outf[0]*65535.0 + 0.5);
+        af[1] = (cmsInt32Number) floor(Outf[1]*65535.0 + 0.5);
+        af[2] = (cmsInt32Number) floor(Outf[2]*65535.0 + 0.5);
 
         for (i=0; i < 3; i++) {
 
@@ -2571,18 +2575,18 @@ cmsInt32Number CheckFloatLUT(cmsPipeline* lut)
 
 
 static
-cmsInt32Number Check16LUT(cmsPipeline* lut)

+cmsInt32Number Check16LUT(cmsPipeline* lut)
 {
-    cmsInt32Number n2, i, j;

+    cmsInt32Number n2, i, j;
     cmsUInt16Number Inw[3], Outw[3];
 
     n2=0;
     
     for (j=0; j < 65535; j++) {
 
-        cmsInt32Number aw[3];

+        cmsInt32Number aw[3];
 
-        Inw[0] = Inw[1] = Inw[2] = j;
+        Inw[0] = Inw[1] = Inw[2] = (cmsUInt16Number) j;
         cmsPipelineEval16(Inw, Outw, lut);
         aw[0] = Outw[0];
         aw[1] = Outw[1];
@@ -2603,10 +2607,10 @@ cmsInt32Number Check16LUT(cmsPipeline* lut)
 
 // Check any LUT that is linear
 static
-cmsInt32Number CheckStagesLUT(cmsPipeline* lut, cmsInt32Number ExpectedStages)

+cmsInt32Number CheckStagesLUT(cmsPipeline* lut, cmsInt32Number ExpectedStages)
 {
     
-    cmsInt32Number nInpChans, nOutpChans, nStages;

+    cmsInt32Number nInpChans, nOutpChans, nStages;
 
     nInpChans  = cmsPipelineInputChannels(lut);
     nOutpChans = cmsPipelineOutputChannels(lut);
@@ -2617,9 +2621,9 @@ cmsInt32Number CheckStagesLUT(cmsPipeline* lut, cmsInt32Number ExpectedStages)
 
 
 static
-cmsInt32Number CheckFullLUT(cmsPipeline* lut, cmsInt32Number ExpectedStages)

+cmsInt32Number CheckFullLUT(cmsPipeline* lut, cmsInt32Number ExpectedStages)
 {
-    cmsInt32Number rc = CheckStagesLUT(lut, ExpectedStages) && Check16LUT(lut) && CheckFloatLUT(lut);

+    cmsInt32Number rc = CheckStagesLUT(lut, ExpectedStages) && Check16LUT(lut) && CheckFloatLUT(lut);
 
     cmsPipelineFree(lut);
     return rc;
@@ -2627,7 +2631,7 @@ cmsInt32Number CheckFullLUT(cmsPipeline* lut, cmsInt32Number ExpectedStages)
 
 
 static
-cmsInt32Number Check1StageLUT(void)

+cmsInt32Number Check1StageLUT(void)
 {
     cmsPipeline* lut = cmsPipelineAlloc(DbgThread(), 3, 3);
 
@@ -2638,7 +2642,7 @@ cmsInt32Number Check1StageLUT(void)
 
 
 static
-cmsInt32Number Check2StageLUT(void)

+cmsInt32Number Check2StageLUT(void)
 {
     cmsPipeline* lut = cmsPipelineAlloc(DbgThread(), 3, 3);
 
@@ -2649,7 +2653,7 @@ cmsInt32Number Check2StageLUT(void)
 }
 
 static
-cmsInt32Number Check2Stage16LUT(void)

+cmsInt32Number Check2Stage16LUT(void)
 {
     cmsPipeline* lut = cmsPipelineAlloc(DbgThread(), 3, 3);
 
@@ -2662,7 +2666,7 @@ cmsInt32Number Check2Stage16LUT(void)
 
 
 static
-cmsInt32Number Check3StageLUT(void)

+cmsInt32Number Check3StageLUT(void)
 {
     cmsPipeline* lut = cmsPipelineAlloc(DbgThread(), 3, 3);
 
@@ -2674,7 +2678,7 @@ cmsInt32Number Check3StageLUT(void)
 }
 
 static
-cmsInt32Number Check3Stage16LUT(void)

+cmsInt32Number Check3Stage16LUT(void)
 {
     cmsPipeline* lut = cmsPipelineAlloc(DbgThread(), 3, 3);
 
@@ -2688,7 +2692,7 @@ cmsInt32Number Check3Stage16LUT(void)
 
 
 static
-cmsInt32Number Check4StageLUT(void)

+cmsInt32Number Check4StageLUT(void)
 {
     cmsPipeline* lut = cmsPipelineAlloc(DbgThread(), 3, 3);
 
@@ -2701,7 +2705,7 @@ cmsInt32Number Check4StageLUT(void)
 }
 
 static
-cmsInt32Number Check4Stage16LUT(void)

+cmsInt32Number Check4Stage16LUT(void)
 {
     cmsPipeline* lut = cmsPipelineAlloc(DbgThread(), 3, 3);
 
@@ -2714,7 +2718,7 @@ cmsInt32Number Check4Stage16LUT(void)
 }
 
 static
-cmsInt32Number Check5StageLUT(void)

+cmsInt32Number Check5StageLUT(void)
 {
     cmsPipeline* lut = cmsPipelineAlloc(DbgThread(), 3, 3);
 
@@ -2729,7 +2733,7 @@ cmsInt32Number Check5StageLUT(void)
 
 
 static
-cmsInt32Number Check5Stage16LUT(void)

+cmsInt32Number Check5Stage16LUT(void)
 {
     cmsPipeline* lut = cmsPipelineAlloc(DbgThread(), 3, 3);
 
@@ -2743,7 +2747,7 @@ cmsInt32Number Check5Stage16LUT(void)
 }
 
 static
-cmsInt32Number Check6StageLUT(void)

+cmsInt32Number Check6StageLUT(void)
 {
     cmsPipeline* lut = cmsPipelineAlloc(DbgThread(), 3, 3);
 
@@ -2758,7 +2762,7 @@ cmsInt32Number Check6StageLUT(void)
 }
 
 static
-cmsInt32Number Check6Stage16LUT(void)

+cmsInt32Number Check6Stage16LUT(void)
 {
     cmsPipeline* lut = cmsPipelineAlloc(DbgThread(), 3, 3);
 
@@ -2774,10 +2778,10 @@ cmsInt32Number Check6Stage16LUT(void)
 
 
 static
-cmsInt32Number CheckLab2LabLUT(void)

+cmsInt32Number CheckLab2LabLUT(void)
 {
     cmsPipeline* lut = cmsPipelineAlloc(DbgThread(), 3, 3);
-    cmsInt32Number rc;

+    cmsInt32Number rc;
 
     cmsPipelineInsertStage(lut, cmsAT_END, _cmsStageAllocLab2XYZ(DbgThread()));
     cmsPipelineInsertStage(lut, cmsAT_END, _cmsStageAllocXYZ2Lab(DbgThread()));
@@ -2791,10 +2795,10 @@ cmsInt32Number CheckLab2LabLUT(void)
 
 
 static
-cmsInt32Number CheckXYZ2XYZLUT(void)

+cmsInt32Number CheckXYZ2XYZLUT(void)
 {
     cmsPipeline* lut = cmsPipelineAlloc(DbgThread(), 3, 3);
-    cmsInt32Number rc;

+    cmsInt32Number rc;
 
     cmsPipelineInsertStage(lut, cmsAT_END, _cmsStageAllocXYZ2Lab(DbgThread()));
     cmsPipelineInsertStage(lut, cmsAT_END, _cmsStageAllocLab2XYZ(DbgThread()));
@@ -2809,10 +2813,10 @@ cmsInt32Number CheckXYZ2XYZLUT(void)
 
 
 static
-cmsInt32Number CheckLab2LabMatLUT(void)

+cmsInt32Number CheckLab2LabMatLUT(void)
 {
     cmsPipeline* lut = cmsPipelineAlloc(DbgThread(), 3, 3);
-    cmsInt32Number rc;

+    cmsInt32Number rc;
 
     cmsPipelineInsertStage(lut, cmsAT_END, _cmsStageAllocLab2XYZ(DbgThread()));
     AddIdentityMatrix(lut);
@@ -2826,11 +2830,11 @@ cmsInt32Number CheckLab2LabMatLUT(void)
 }
 
 static
-cmsInt32Number CheckNamedColorLUT(void)

+cmsInt32Number CheckNamedColorLUT(void)
 {
     cmsPipeline* lut = cmsPipelineAlloc(DbgThread(), 3, 3);
     cmsNAMEDCOLORLIST* nc;
-    cmsInt32Number i,j, rc = 1, n2;

+    cmsInt32Number i,j, rc = 1, n2;
     cmsUInt16Number PCS[3];
     cmsUInt16Number Colorant[MAXCHANNELS];
     char Name[255];
@@ -2842,8 +2846,8 @@ cmsInt32Number CheckNamedColorLUT(void)
 
     for (i=0; i < 256; i++) {
 
-        PCS[0] = PCS[1] = PCS[2] = i;
-        Colorant[0] = Colorant[1] = Colorant[2] = Colorant[3] = i;
+        PCS[0] = PCS[1] = PCS[2] = (cmsUInt16Number) i;
+        Colorant[0] = Colorant[1] = Colorant[2] = Colorant[3] = (cmsUInt16Number) i;
 
         sprintf(Name, "#%d", i);
         if (!cmsAppendNamedColor(nc, Name, PCS, Colorant)) { rc = 0; break; }
@@ -2858,7 +2862,7 @@ cmsInt32Number CheckNamedColorLUT(void)
 
     for (j=0; j < 256; j++) {
 
-        Inw[0] = j;
+        Inw[0] = (cmsUInt16Number) j;
 
         cmsPipelineEval16(Inw, Outw, lut);
         for (i=0; i < 3; i++) {
@@ -2881,12 +2885,12 @@ cmsInt32Number CheckNamedColorLUT(void)
 // A lightweight test of multilocalized unicode structures. 
 
 static
-cmsInt32Number CheckMLU(void)

+cmsInt32Number CheckMLU(void)
 {
     cmsMLU* mlu, *mlu2, *mlu3;
     char Buffer[256], Buffer2[256];
-    cmsInt32Number rc = 1;

-    cmsInt32Number i;

+    cmsInt32Number rc = 1;
+    cmsInt32Number i;
     cmsHPROFILE h= NULL;
 
     // Allocate a MLU structure, no preferred size
@@ -2930,8 +2934,8 @@ cmsInt32Number CheckMLU(void)
 
         char Lang[3];
         
-        Lang[0] = i % 255;
-        Lang[1] = i / 255;
+        Lang[0] = (char) (i % 255);
+        Lang[1] = (char) (i / 255);
         Lang[2] = 0;
 
         sprintf(Buffer, "String #%i", i);
@@ -2949,8 +2953,8 @@ cmsInt32Number CheckMLU(void)
 
         char Lang[3];
         
-        Lang[0] = i % 255;
-        Lang[1] = i / 255;
+        Lang[0] = (char)(i % 255);
+        Lang[1] = (char)(i / 255);
         Lang[2] = 0;
 
         cmsMLUgetASCII(mlu2, Lang, Lang, Buffer2, 256);
@@ -2983,8 +2987,8 @@ cmsInt32Number CheckMLU(void)
 
         char Lang[3];
         
-        Lang[0] = i % 255;
-        Lang[1] = i / 255;
+        Lang[0] = (char) (i % 255);
+        Lang[1] = (char) (i / 255);
         Lang[2] = 0;
 
         cmsMLUgetASCII(mlu3, Lang, Lang, Buffer2, 256);
@@ -3006,10 +3010,10 @@ Error:
 
 // A lightweight test of named color structures.
 static
-cmsInt32Number CheckNamedColorList(void)

+cmsInt32Number CheckNamedColorList(void)
 {
     cmsNAMEDCOLORLIST* nc = NULL, *nc2;
-    cmsInt32Number i, j, rc=1;

+    cmsInt32Number i, j, rc=1;
     char Name[255];
     cmsUInt16Number PCS[3];
     cmsUInt16Number Colorant[MAXCHANNELS];
@@ -3024,8 +3028,8 @@ cmsInt32Number CheckNamedColorList(void)
     for (i=0; i < 4096; i++) {
 
 
-        PCS[0] = PCS[1] = PCS[2] = i;
-        Colorant[0] = Colorant[1] = Colorant[2] = Colorant[3] = 4096 - i;
+        PCS[0] = PCS[1] = PCS[2] = (cmsUInt16Number) i;
+        Colorant[0] = Colorant[1] = Colorant[2] = Colorant[3] = (cmsUInt16Number) (4096 - i);
 
         sprintf(Name, "#%d", i);
         if (!cmsAppendNamedColor(nc, Name, PCS, Colorant)) { rc = 0; break; }
@@ -3033,8 +3037,8 @@ cmsInt32Number CheckNamedColorList(void)
 
     for (i=0; i < 4096; i++) {
 
-        CheckPCS[0] = CheckPCS[1] = CheckPCS[2] = i;
-        CheckColorant[0] = CheckColorant[1] = CheckColorant[2] = CheckColorant[3] = 4096 - i;
+        CheckPCS[0] = CheckPCS[1] = CheckPCS[2] = (cmsUInt16Number) i;
+        CheckColorant[0] = CheckColorant[1] = CheckColorant[2] = CheckColorant[3] = (cmsUInt16Number) (4096 - i);
 
         sprintf(CheckName, "#%d", i);
         if (!cmsNamedColorInfo(nc, i, Name, NULL, NULL, PCS, Colorant)) { rc = 0; goto Error; }
@@ -3069,8 +3073,8 @@ cmsInt32Number CheckNamedColorList(void)
 
     for (i=0; i < 4096; i++) {
 
-        CheckPCS[0] = CheckPCS[1] = CheckPCS[2] = i;
-        CheckColorant[0] = CheckColorant[1] = CheckColorant[2] = CheckColorant[3] = 4096 - i;
+        CheckPCS[0] = CheckPCS[1] = CheckPCS[2] = (cmsUInt16Number) i;
+        CheckColorant[0] = CheckColorant[1] = CheckColorant[2] = CheckColorant[3] = (cmsUInt16Number) (4096 - i);
 
         sprintf(CheckName, "#%d", i);
         if (!cmsNamedColorInfo(nc2, i, Name, NULL, NULL, PCS, Colorant)) { rc = 0; goto Error; }
@@ -3107,9 +3111,9 @@ static
 void CheckSingleFormatter16(cmsUInt32Number Type, const char* Text)
 {
     cmsUInt16Number Values[MAXCHANNELS];
-    char Buffer[1024];
+    cmsUInt8Number Buffer[1024];
     cmsFormatter f, b;
-    cmsInt32Number i, j, nChannels, bytes;

+    cmsInt32Number i, j, nChannels, bytes;
     _cmsTRANSFORM info;
 
     // Already failed?
@@ -3117,7 +3121,6 @@ void CheckSingleFormatter16(cmsUInt32Number Type, const char* Text)
 
     memset(&info, 0, sizeof(info));
     info.OutputFormat = info.InputFormat = Type;
-    info.StrideIn = info.StrideOut = 1;
 
     // Go forth and back
     f = _cmsGetFormatter(Type,  cmsFormatterInput, 0);
@@ -3139,15 +3142,15 @@ void CheckSingleFormatter16(cmsUInt32Number Type, const char* Text)
     for (j=0; j < 5; j++) {
 
         for (i=0; i < nChannels; i++) { 
-            Values[i] = (i+j);
+            Values[i] = (cmsUInt16Number) (i+j);
             // For 8-bit
             if (bytes == 1) 
                 Values[i] <<= 8;
         }
 
-    b.Fmt16(&info, Values, Buffer);
+    b.Fmt16(&info, Values, Buffer, 1);
     memset(Values, 0, sizeof(Values));
-    f.Fmt16(&info, Values, Buffer);
+    f.Fmt16(&info, Values, Buffer, 1);
 
     for (i=0; i < nChannels; i++) {
         if (bytes == 1) 
@@ -3160,14 +3163,14 @@ void CheckSingleFormatter16(cmsUInt32Number Type, const char* Text)
 
             // Useful for debug
             for (i=0; i < nChannels; i++) { 
-                Values[i] = (i+j);
+                Values[i] = (cmsUInt16Number) (i+j);
                 // For 8-bit
                 if (bytes == 1) 
                     Values[i] <<= 8;
             }
 
-            b.Fmt16(&info, Values, Buffer);
-            f.Fmt16(&info, Values, Buffer);
+            b.Fmt16(&info, Values, Buffer, 1);
+            f.Fmt16(&info, Values, Buffer, 1);
             return;
         }
     }
@@ -3181,7 +3184,7 @@ void CheckSingleFormatter16(cmsUInt32Number Type, const char* Text)
 
 // Check all formatters
 static
-cmsInt32Number CheckFormatters16(void)

+cmsInt32Number CheckFormatters16(void)
 {
     FormatterFailed = FALSE;
 
@@ -3339,9 +3342,9 @@ static
 void CheckSingleFormatterFloat(cmsUInt32Number Type, const char* Text)
 {
     cmsFloat32Number Values[MAXCHANNELS];
-    char Buffer[1024];
+    cmsUInt8Number Buffer[1024];
     cmsFormatter f, b;
-    cmsInt32Number i, j, nChannels;

+    cmsInt32Number i, j, nChannels;
     _cmsTRANSFORM info;
 
     // Already failed?
@@ -3349,7 +3352,6 @@ void CheckSingleFormatterFloat(cmsUInt32Number Type, const char* Text)
 
     memset(&info, 0, sizeof(info));
     info.OutputFormat = info.InputFormat = Type;
-    info.StrideIn = info.StrideOut = 1;
 
     // Go forth and back
     f = _cmsGetFormatter(Type,  cmsFormatterInput, CMS_PACK_FLAGS_FLOAT);
@@ -3373,9 +3375,9 @@ void CheckSingleFormatterFloat(cmsUInt32Number Type, const char* Text)
             Values[i] = (cmsFloat32Number) (i+j);
         }
 
-        b.FmtFloat(&info, Values, Buffer);
+        b.FmtFloat(&info, Values, Buffer, 1);
         memset(Values, 0, sizeof(Values));
-        f.FmtFloat(&info, Values, Buffer);
+        f.FmtFloat(&info, Values, Buffer, 1);
 
         for (i=0; i < nChannels; i++) {
 
@@ -3391,8 +3393,8 @@ void CheckSingleFormatterFloat(cmsUInt32Number Type, const char* Text)
                     Values[i] = (cmsFloat32Number) (i+j);
                 }
 
-                b.FmtFloat(&info, Values, Buffer);
-                f.FmtFloat(&info, Values, Buffer);
+                b.FmtFloat(&info, Values, Buffer, 1);
+                f.FmtFloat(&info, Values, Buffer, 1);
                 return;
             }
         }
@@ -3402,7 +3404,7 @@ void CheckSingleFormatterFloat(cmsUInt32Number Type, const char* Text)
 #define C(a) CheckSingleFormatterFloat(a, #a)
 
 static
-cmsInt32Number CheckFormattersFloat(void)

+cmsInt32Number CheckFormattersFloat(void)
 {
     FormatterFailed = FALSE;
 
@@ -3426,7 +3428,7 @@ cmsInt32Number CheckFormattersFloat(void)
 // Write tag testbed ----------------------------------------------------------------------------------------
 
 static
-cmsInt32Number CheckXYZ(cmsInt32Number Pass, cmsHPROFILE hProfile, cmsTagSignature tag)

+cmsInt32Number CheckXYZ(cmsInt32Number Pass, cmsHPROFILE hProfile, cmsTagSignature tag)
 {
     cmsCIEXYZ XYZ, *Pt;
 
@@ -3452,10 +3454,10 @@ cmsInt32Number CheckXYZ(cmsInt32Number Pass, cmsHPROFILE hProfile, cmsTagSignatu
 
 
 static
-cmsInt32Number CheckGamma(cmsInt32Number Pass, cmsHPROFILE hProfile, cmsTagSignature tag)

+cmsInt32Number CheckGamma(cmsInt32Number Pass, cmsHPROFILE hProfile, cmsTagSignature tag)
 {
     cmsToneCurve *g, *Pt;
-    cmsInt32Number rc;

+    cmsInt32Number rc;
 
     switch (Pass) {
 
@@ -3477,10 +3479,10 @@ cmsInt32Number CheckGamma(cmsInt32Number Pass, cmsHPROFILE hProfile, cmsTagSigna
 }
 
 static
-cmsInt32Number CheckText(cmsInt32Number Pass, cmsHPROFILE hProfile, cmsTagSignature tag)

+cmsInt32Number CheckText(cmsInt32Number Pass, cmsHPROFILE hProfile, cmsTagSignature tag)
 {
     cmsMLU *m, *Pt;
-    cmsInt32Number rc;

+    cmsInt32Number rc;
     char Buffer[256];
 
     
@@ -3505,11 +3507,11 @@ cmsInt32Number CheckText(cmsInt32Number Pass, cmsHPROFILE hProfile, cmsTagSignat
 }
 
 static
-cmsInt32Number CheckData(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)

+cmsInt32Number CheckData(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)
 {
     cmsICCData *Pt;
-    cmsICCData d = { 1, 0, { '?' }};

-    cmsInt32Number rc;

+    cmsICCData d = { 1, 0, { '?' }};
+    cmsInt32Number rc;
 
     
     switch (Pass) {
@@ -3530,7 +3532,7 @@ cmsInt32Number CheckData(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSigna
 
 
 static
-cmsInt32Number CheckSignature(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)

+cmsInt32Number CheckSignature(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)
 {
     cmsTagSignature *Pt, Holder;
     
@@ -3552,7 +3554,7 @@ cmsInt32Number CheckSignature(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTag
 
 
 static
-cmsInt32Number CheckDateTime(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)

+cmsInt32Number CheckDateTime(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)
 {
     struct tm *Pt, Holder;
 
@@ -3587,10 +3589,10 @@ cmsInt32Number CheckDateTime(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagS
 
 
 static
-cmsInt32Number CheckNamedColor(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag, cmsInt32Number max_check, cmsBool  colorant_check)

+cmsInt32Number CheckNamedColor(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag, cmsInt32Number max_check, cmsBool  colorant_check)
 {
     cmsNAMEDCOLORLIST* nc;
-    cmsInt32Number i, j, rc;

+    cmsInt32Number i, j, rc;
     char Name[255];
     cmsUInt16Number PCS[3];
     cmsUInt16Number Colorant[MAXCHANNELS];
@@ -3607,8 +3609,8 @@ cmsInt32Number CheckNamedColor(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTa
 
         for (i=0; i < max_check; i++) {
 
-            PCS[0] = PCS[1] = PCS[2] = i;
-            Colorant[0] = Colorant[1] = Colorant[2] = Colorant[3] = max_check - i;
+            PCS[0] = PCS[1] = PCS[2] = (cmsUInt16Number) i;
+            Colorant[0] = Colorant[1] = Colorant[2] = Colorant[3] = (cmsUInt16Number) (max_check - i);
 
             sprintf(Name, "#%d", i);
             if (!cmsAppendNamedColor(nc, Name, PCS, Colorant)) { Fail("Couldn't append named color"); return 0; }
@@ -3625,8 +3627,8 @@ cmsInt32Number CheckNamedColor(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTa
 
         for (i=0; i < max_check; i++) {
 
-            CheckPCS[0] = CheckPCS[1] = CheckPCS[2] = i;
-            CheckColorant[0] = CheckColorant[1] = CheckColorant[2] = CheckColorant[3] = max_check - i;
+            CheckPCS[0] = CheckPCS[1] = CheckPCS[2] = (cmsUInt16Number) i;
+            CheckColorant[0] = CheckColorant[1] = CheckColorant[2] = CheckColorant[3] = (cmsUInt16Number) (max_check - i);
 
             sprintf(CheckName, "#%d", i);
             if (!cmsNamedColorInfo(nc, i, Name, NULL, NULL, PCS, Colorant)) { Fail("Invalid string"); return 0; }
@@ -3655,10 +3657,10 @@ cmsInt32Number CheckNamedColor(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTa
 
 
 static
-cmsInt32Number CheckLUT(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)

+cmsInt32Number CheckLUT(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)
 {
     cmsPipeline* Lut, *Pt;
-    cmsInt32Number rc;

+    cmsInt32Number rc;
 
 
     switch (Pass) {
@@ -3690,11 +3692,11 @@ cmsInt32Number CheckLUT(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignat
 }
 
 static
-cmsInt32Number CheckCHAD(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)

+cmsInt32Number CheckCHAD(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)
 {
     cmsFloat64Number *Pt;
     cmsFloat64Number CHAD[] = { 0, .1, .2, .3, .4, .5, .6, .7, .8 };
-    cmsInt32Number i;

+    cmsInt32Number i;
 
     switch (Pass) {
 
@@ -3718,7 +3720,7 @@ cmsInt32Number CheckCHAD(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSigna
 }
 
 static
-cmsInt32Number CheckChromaticity(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)

+cmsInt32Number CheckChromaticity(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)
 {
     cmsCIExyYTRIPLE *Pt, c = { {0, .1, 1 }, { .3, .4, 1 }, { .6, .7, 1 }};
 
@@ -3747,15 +3749,15 @@ cmsInt32Number CheckChromaticity(cmsInt32Number Pass,  cmsHPROFILE hProfile, cms
 
 
 static
-cmsInt32Number CheckColorantOrder(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)

+cmsInt32Number CheckColorantOrder(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)
 {
     cmsUInt8Number *Pt, c[MAXCHANNELS];
-    cmsInt32Number i;

+    cmsInt32Number i;
 
     switch (Pass) {
 
         case 1:         
-            for (i=0; i < MAXCHANNELS; i++) c[i] = MAXCHANNELS - i - 1;
+            for (i=0; i < MAXCHANNELS; i++) c[i] = (cmsUInt8Number) (MAXCHANNELS - i - 1);
             return cmsWriteTag(hProfile, tag, c);
             
 
@@ -3774,7 +3776,7 @@ cmsInt32Number CheckColorantOrder(cmsInt32Number Pass,  cmsHPROFILE hProfile, cm
 }
 
 static
-cmsInt32Number CheckMeasurement(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)

+cmsInt32Number CheckMeasurement(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)
 {
     cmsICCMeasurementConditions *Pt, m;
 
@@ -3812,10 +3814,10 @@ cmsInt32Number CheckMeasurement(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsT
 
 
 static
-cmsInt32Number CheckUcrBg(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)

+cmsInt32Number CheckUcrBg(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)
 {
     cmsUcrBg *Pt, m;
-    cmsInt32Number rc;

+    cmsInt32Number rc;
     char Buffer[256];
 
     switch (Pass) {
@@ -3847,11 +3849,11 @@ cmsInt32Number CheckUcrBg(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSign
 
 
 static
-cmsInt32Number CheckCRDinfo(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)

+cmsInt32Number CheckCRDinfo(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)
 {
     cmsMLU *mlu;
     char Buffer[256];
-    cmsInt32Number rc;

+    cmsInt32Number rc;
 
     switch (Pass) {
 
@@ -3933,11 +3935,11 @@ cmsToneCurve *CreateSegmentedCurve(void)
 
 
 static
-cmsInt32Number CheckMPE(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)

+cmsInt32Number CheckMPE(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)
 {
     cmsPipeline* Lut, *Pt;
     cmsToneCurve* G[3];
-    cmsInt32Number rc;

+    cmsInt32Number rc;
 
     switch (Pass) {
 
@@ -3969,10 +3971,10 @@ cmsInt32Number CheckMPE(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignat
 
 
 static
-cmsInt32Number CheckScreening(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)

+cmsInt32Number CheckScreening(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTagSignature tag)
 {
     cmsScreening *Pt, sc;
-    cmsInt32Number rc;

+    cmsInt32Number rc;
     
     switch (Pass) {
 
@@ -4006,7 +4008,7 @@ cmsInt32Number CheckScreening(cmsInt32Number Pass,  cmsHPROFILE hProfile, cmsTag
 
 
 static
-cmsBool CheckOneStr(cmsMLU* mlu, cmsInt32Number n)

+cmsBool CheckOneStr(cmsMLU* mlu, cmsInt32Number n)
 {
     char Buffer[256], Buffer2[256];
 
@@ -4034,10 +4036,10 @@ void SetOneStr(cmsMLU** mlu, wchar_t* s1, wchar_t* s2)
 
 
 static
-cmsInt32Number CheckProfileSequenceTag(cmsInt32Number Pass,  cmsHPROFILE hProfile)

+cmsInt32Number CheckProfileSequenceTag(cmsInt32Number Pass,  cmsHPROFILE hProfile)
 {
     cmsSEQ* s;
-    cmsInt32Number i;

+    cmsInt32Number i;
 
     switch (Pass) {
 
@@ -4122,10 +4124,10 @@ cmsInt32Number CheckProfileSequenceTag(cmsInt32Number Pass,  cmsHPROFILE hProfil
 
 
 static
-cmsInt32Number CheckProfileSequenceIDTag(cmsInt32Number Pass,  cmsHPROFILE hProfile)

+cmsInt32Number CheckProfileSequenceIDTag(cmsInt32Number Pass,  cmsHPROFILE hProfile)
 {
     cmsSEQ* s;
-    cmsInt32Number i;

+    cmsInt32Number i;
 
     switch (Pass) {
 
@@ -4172,7 +4174,7 @@ cmsInt32Number CheckProfileSequenceIDTag(cmsInt32Number Pass,  cmsHPROFILE hProf
 
 
 static
-cmsInt32Number CheckICCViewingConditions(cmsInt32Number Pass,  cmsHPROFILE hProfile)

+cmsInt32Number CheckICCViewingConditions(cmsInt32Number Pass,  cmsHPROFILE hProfile)
 {
     cmsICCViewingConditions* v;
     cmsICCViewingConditions  s;
@@ -4214,42 +4216,42 @@ cmsInt32Number CheckICCViewingConditions(cmsInt32Number Pass,  cmsHPROFILE hProf
 
 
 static
-cmsInt32Number CheckVCGT(cmsInt32Number Pass,  cmsHPROFILE hProfile)

+cmsInt32Number CheckVCGT(cmsInt32Number Pass,  cmsHPROFILE hProfile)
 {
-    cmsToneCurve* Curves[3];

-    cmsToneCurve** PtrCurve;

-    

-     switch (Pass) {

+    cmsToneCurve* Curves[3];
+    cmsToneCurve** PtrCurve;
+    
+     switch (Pass) {
 
         case 1:     
-            Curves[0] = cmsBuildGamma(DbgThread(), 1.1);

+            Curves[0] = cmsBuildGamma(DbgThread(), 1.1);
             Curves[1] = cmsBuildGamma(DbgThread(), 2.2);
-            Curves[2] = cmsBuildGamma(DbgThread(), 3.4);

+            Curves[2] = cmsBuildGamma(DbgThread(), 3.4);
 
-            if (!cmsWriteTag(hProfile, cmsSigVcgtTag, Curves)) return 0;    

+            if (!cmsWriteTag(hProfile, cmsSigVcgtTag, Curves)) return 0;    
 
-            cmsFreeToneCurveTriple(Curves);

+            cmsFreeToneCurveTriple(Curves);
             return 1;
 
 
-        case 2:

+        case 2:
 
-             PtrCurve = cmsReadTag(hProfile, cmsSigVcgtTag);

-             if (PtrCurve == NULL) return 0;

-             if (!IsGoodVal("VCGT R", cmsEstimateGamma(PtrCurve[0], 0.01), 1.1, 0.001)) return 0;

+             PtrCurve = cmsReadTag(hProfile, cmsSigVcgtTag);
+             if (PtrCurve == NULL) return 0;
+             if (!IsGoodVal("VCGT R", cmsEstimateGamma(PtrCurve[0], 0.01), 1.1, 0.001)) return 0;
              if (!IsGoodVal("VCGT G", cmsEstimateGamma(PtrCurve[1], 0.01), 2.2, 0.001)) return 0;
-             if (!IsGoodVal("VCGT B", cmsEstimateGamma(PtrCurve[2], 0.01), 3.4, 0.001)) return 0;

-             return 1;

+             if (!IsGoodVal("VCGT B", cmsEstimateGamma(PtrCurve[2], 0.01), 3.4, 0.001)) return 0;
+             return 1;
 
-        default:;

-    }

+        default:;
+    }
 
-    return 0;

+    return 0;
 }
 
 
 static
-cmsInt32Number CheckRAWtags(cmsInt32Number Pass,  cmsHPROFILE hProfile)

+cmsInt32Number CheckRAWtags(cmsInt32Number Pass,  cmsHPROFILE hProfile)
 {
     char Buffer[7];
 
@@ -4272,10 +4274,10 @@ cmsInt32Number CheckRAWtags(cmsInt32Number Pass,  cmsHPROFILE hProfile)
 
 // This is a very big test that checks every single tag
 static
-cmsInt32Number CheckProfileCreation(void)

+cmsInt32Number CheckProfileCreation(void)
 {
     cmsHPROFILE h;
-    cmsInt32Number Pass;

+    cmsInt32Number Pass;
 
     h = cmsCreateProfilePlaceholder(DbgThread());
     if (h == NULL) return 0;
@@ -4402,8 +4404,8 @@ cmsInt32Number CheckProfileCreation(void)
         if (!CheckICCViewingConditions(Pass, h)) return 0;
 
 
-        SubTest("VCGT tags");

-        if (!CheckVCGT(Pass, h)) return 0;

+        SubTest("VCGT tags");
+        if (!CheckVCGT(Pass, h)) return 0;
 
         SubTest("RAW tags");
         if (!CheckRAWtags(Pass, h)) return 0;
@@ -4445,7 +4447,7 @@ void ErrorReportingFunction(cmsContext ContextID, cmsUInt32Number ErrorCode, con
 
 
 static
-cmsInt32Number CheckBadProfiles(void)

+cmsInt32Number CheckBadProfiles(void)
 {
     cmsHPROFILE h;
 
@@ -4511,17 +4513,17 @@ cmsInt32Number CheckBadProfiles(void)
 
 
 static
-cmsInt32Number CheckErrReportingOnBadProfiles(void)

+cmsInt32Number CheckErrReportingOnBadProfiles(void)
 {
-    cmsInt32Number rc;

+    cmsInt32Number rc;
 
-    cmsSetLogErrorHandler(ErrorReportingFunction);

-    rc = CheckBadProfiles();

-    cmsSetLogErrorHandler(FatalErrorQuit);

+    cmsSetLogErrorHandler(ErrorReportingFunction);
+    rc = CheckBadProfiles();
+    cmsSetLogErrorHandler(FatalErrorQuit);
 
-    // Reset the error state

-    TrappedError = FALSE;

-    return rc;

+    // Reset the error state
+    TrappedError = FALSE;
+    return rc;
 }
 
 
@@ -4531,9 +4533,9 @@ cmsInt32Number CheckErrReportingOnBadProfiles(void)
 
 // Check a linear xform
 static
-cmsInt32Number Check8linearXFORM(cmsHTRANSFORM xform, cmsInt32Number nChan)

+cmsInt32Number Check8linearXFORM(cmsHTRANSFORM xform, cmsInt32Number nChan)
 {
-    cmsInt32Number n2, i, j;

+    cmsInt32Number n2, i, j;
     cmsUInt8Number Inw[MAXCHANNELS], Outw[MAXCHANNELS];
 
     n2=0;
@@ -4545,7 +4547,7 @@ cmsInt32Number Check8linearXFORM(cmsHTRANSFORM xform, cmsInt32Number nChan)
         
         for (i=0; i < nChan; i++) {
 
-           cmsInt32Number dif = abs(Outw[i] - j);

+           cmsInt32Number dif = abs(Outw[i] - j);
            if (dif > n2) n2 = dif;
 
         }
@@ -4562,9 +4564,9 @@ cmsInt32Number Check8linearXFORM(cmsHTRANSFORM xform, cmsInt32Number nChan)
 }
 
 static
-cmsInt32Number Compare8bitXFORM(cmsHTRANSFORM xform1, cmsHTRANSFORM xform2, cmsInt32Number nChan)

+cmsInt32Number Compare8bitXFORM(cmsHTRANSFORM xform1, cmsHTRANSFORM xform2, cmsInt32Number nChan)
 {
-    cmsInt32Number n2, i, j;

+    cmsInt32Number n2, i, j;
     cmsUInt8Number Inw[MAXCHANNELS], Outw1[MAXCHANNELS], Outw2[MAXCHANNELS];;
 
     n2=0;
@@ -4577,7 +4579,7 @@ cmsInt32Number Compare8bitXFORM(cmsHTRANSFORM xform1, cmsHTRANSFORM xform2, cmsI
 
         for (i=0; i < nChan; i++) {
 
-           cmsInt32Number dif = abs(Outw2[i] - Outw1[i]);

+           cmsInt32Number dif = abs(Outw2[i] - Outw1[i]);
            if (dif > n2) n2 = dif;
 
         }
@@ -4597,21 +4599,21 @@ cmsInt32Number Compare8bitXFORM(cmsHTRANSFORM xform1, cmsHTRANSFORM xform2, cmsI
 
 // Check a linear xform
 static
-cmsInt32Number Check16linearXFORM(cmsHTRANSFORM xform, cmsInt32Number nChan)

+cmsInt32Number Check16linearXFORM(cmsHTRANSFORM xform, cmsInt32Number nChan)
 {
-    cmsInt32Number n2, i, j;

+    cmsInt32Number n2, i, j;
     cmsUInt16Number Inw[MAXCHANNELS], Outw[MAXCHANNELS];
 
     n2=0;    
     for (j=0; j < 0xFFFF; j++) {
 
-        for (i=0; i < nChan; i++) Inw[i] = j;
+        for (i=0; i < nChan; i++) Inw[i] = (cmsUInt16Number) j;
 
         cmsDoTransform(xform, Inw, Outw, 1);
         
         for (i=0; i < nChan; i++) {
 
-           cmsInt32Number dif = abs(Outw[i] - j);

+           cmsInt32Number dif = abs(Outw[i] - j);
            if (dif > n2) n2 = dif;
 
         }
@@ -4629,23 +4631,23 @@ cmsInt32Number Check16linearXFORM(cmsHTRANSFORM xform, cmsInt32Number nChan)
 }
 
 static
-cmsInt32Number Compare16bitXFORM(cmsHTRANSFORM xform1, cmsHTRANSFORM xform2, cmsInt32Number nChan)

+cmsInt32Number Compare16bitXFORM(cmsHTRANSFORM xform1, cmsHTRANSFORM xform2, cmsInt32Number nChan)
 {
-    cmsInt32Number n2, i, j;

+    cmsInt32Number n2, i, j;
     cmsUInt16Number Inw[MAXCHANNELS], Outw1[MAXCHANNELS], Outw2[MAXCHANNELS];;
 
     n2=0;
     
     for (j=0; j < 0xFFFF; j++) {
         
-        for (i=0; i < nChan; i++) Inw[i] = j;
+        for (i=0; i < nChan; i++) Inw[i] = (cmsUInt16Number) j;
 
         cmsDoTransform(xform1, Inw, Outw1, 1);
         cmsDoTransform(xform2, Inw, Outw2, 1);
 
         for (i=0; i < nChan; i++) {
 
-           cmsInt32Number dif = abs(Outw2[i] - Outw1[i]);

+           cmsInt32Number dif = abs(Outw2[i] - Outw1[i]);
            if (dif > n2) n2 = dif;
 
         }
@@ -4665,9 +4667,9 @@ cmsInt32Number Compare16bitXFORM(cmsHTRANSFORM xform1, cmsHTRANSFORM xform2, cms
 
 // Check a linear xform
 static
-cmsInt32Number CheckFloatlinearXFORM(cmsHTRANSFORM xform, cmsInt32Number nChan)

+cmsInt32Number CheckFloatlinearXFORM(cmsHTRANSFORM xform, cmsInt32Number nChan)
 {
-    cmsInt32Number n2, i, j;

+    cmsInt32Number n2, i, j;
     cmsFloat32Number In[MAXCHANNELS], Out[MAXCHANNELS];
 
     n2=0;
@@ -4692,9 +4694,9 @@ cmsInt32Number CheckFloatlinearXFORM(cmsHTRANSFORM xform, cmsInt32Number nChan)
 
 // Check a linear xform
 static
-cmsInt32Number CompareFloatXFORM(cmsHTRANSFORM xform1, cmsHTRANSFORM xform2, cmsInt32Number nChan)

+cmsInt32Number CompareFloatXFORM(cmsHTRANSFORM xform1, cmsHTRANSFORM xform2, cmsInt32Number nChan)
 {
-    cmsInt32Number n2, i, j;

+    cmsInt32Number n2, i, j;
     cmsFloat32Number In[MAXCHANNELS], Out1[MAXCHANNELS], Out2[MAXCHANNELS];
 
     n2=0;
@@ -4722,13 +4724,13 @@ cmsInt32Number CompareFloatXFORM(cmsHTRANSFORM xform1, cmsHTRANSFORM xform2, cms
 // Curves only transforms ----------------------------------------------------------------------------------------
 
 static
-cmsInt32Number CheckCurvesOnlyTransforms(void)

+cmsInt32Number CheckCurvesOnlyTransforms(void)
 {
 
     cmsHTRANSFORM xform1, xform2;
     cmsHPROFILE h1, h2, h3;
     cmsToneCurve* c1, *c2, *c3;
-    cmsInt32Number rc = 1;

+    cmsInt32Number rc = 1;
 
 
     c1 = cmsBuildGamma(DbgThread(), 2.2);
@@ -4800,7 +4802,7 @@ Error:
 static cmsFloat64Number MaxDE;
 
 static
-cmsInt32Number CheckOneLab(cmsHTRANSFORM xform, cmsFloat64Number L, cmsFloat64Number a, cmsFloat64Number b)

+cmsInt32Number CheckOneLab(cmsHTRANSFORM xform, cmsFloat64Number L, cmsFloat64Number a, cmsFloat64Number b)
 {
     cmsCIELab In, Out;
     cmsFloat64Number dE;
@@ -4823,9 +4825,9 @@ cmsInt32Number CheckOneLab(cmsHTRANSFORM xform, cmsFloat64Number L, cmsFloat64Nu
 
 // Check several Lab, slicing at non-exact values. Precision should be 16 bits. 50x50x50 checks aprox.
 static
-cmsInt32Number CheckSeveralLab(cmsHTRANSFORM xform)

+cmsInt32Number CheckSeveralLab(cmsHTRANSFORM xform)
 {
-    cmsInt32Number L, a, b;

+    cmsInt32Number L, a, b;
 
     MaxDE = 0;
     for (L=0; L < 65536; L += 1311) {
@@ -4847,10 +4849,10 @@ cmsInt32Number CheckSeveralLab(cmsHTRANSFORM xform)
 
 
 static
-cmsInt32Number OneTrivialLab(cmsHPROFILE hLab1, cmsHPROFILE hLab2, const char* txt)

+cmsInt32Number OneTrivialLab(cmsHPROFILE hLab1, cmsHPROFILE hLab2, const char* txt)
 {   
     cmsHTRANSFORM xform;
-    cmsInt32Number rc;

+    cmsInt32Number rc;
 
     SubTest(txt);
     xform = cmsCreateTransformTHR(DbgThread(), hLab1, TYPE_Lab_DBL, hLab2, TYPE_Lab_DBL, INTENT_RELATIVE_COLORIMETRIC, 0);
@@ -4863,7 +4865,7 @@ cmsInt32Number OneTrivialLab(cmsHPROFILE hLab1, cmsHPROFILE hLab2, const char* t
 
 
 static
-cmsInt32Number CheckFloatLabTransforms(void)

+cmsInt32Number CheckFloatLabTransforms(void)
 {
     return OneTrivialLab(cmsCreateLab4ProfileTHR(DbgThread(), NULL), cmsCreateLab4ProfileTHR(DbgThread(), NULL),  "Lab4/Lab4") &&
            OneTrivialLab(cmsCreateLab2ProfileTHR(DbgThread(), NULL), cmsCreateLab2ProfileTHR(DbgThread(), NULL),  "Lab2/Lab2") &&
@@ -4873,7 +4875,7 @@ cmsInt32Number CheckFloatLabTransforms(void)
 
 
 static
-cmsInt32Number CheckEncodedLabTransforms(void)

+cmsInt32Number CheckEncodedLabTransforms(void)
 {
     cmsHTRANSFORM xform;
     cmsUInt16Number In[3];
@@ -4951,11 +4953,11 @@ cmsInt32Number CheckEncodedLabTransforms(void)
 }
 
 static
-cmsInt32Number CheckStoredIdentities(void)

+cmsInt32Number CheckStoredIdentities(void)
 {
     cmsHPROFILE hLab, hLink, h4, h2;
     cmsHTRANSFORM xform;
-    cmsInt32Number rc = 1;

+    cmsInt32Number rc = 1;
 
     hLab  = cmsCreateLab4ProfileTHR(DbgThread(), NULL);
     xform = cmsCreateTransformTHR(DbgThread(), hLab, TYPE_Lab_8, hLab, TYPE_Lab_8, 0, 0);
@@ -5024,11 +5026,11 @@ Error:
 
 // Check a simple xform from a matrix profile to itself. Test floating point accuracy.
 static
-cmsInt32Number CheckMatrixShaperXFORMFloat(void)

+cmsInt32Number CheckMatrixShaperXFORMFloat(void)
 {
     cmsHPROFILE hAbove, hSRGB;
     cmsHTRANSFORM xform;
-    cmsInt32Number rc1, rc2;

+    cmsInt32Number rc1, rc2;
 
     hAbove = Create_AboveRGB();
     xform = cmsCreateTransformTHR(DbgThread(), hAbove, TYPE_RGB_FLT, hAbove, TYPE_RGB_FLT,  INTENT_RELATIVE_COLORIMETRIC, 0);
@@ -5048,11 +5050,11 @@ cmsInt32Number CheckMatrixShaperXFORMFloat(void)
 
 // Check a simple xform from a matrix profile to itself. Test 16 bits accuracy.
 static
-cmsInt32Number CheckMatrixShaperXFORM16(void)

+cmsInt32Number CheckMatrixShaperXFORM16(void)
 {   
     cmsHPROFILE hAbove, hSRGB;
     cmsHTRANSFORM xform;
-    cmsInt32Number rc1, rc2;

+    cmsInt32Number rc1, rc2;
 
     hAbove = Create_AboveRGB();
     xform = cmsCreateTransformTHR(DbgThread(), hAbove, TYPE_RGB_16, hAbove, TYPE_RGB_16,  INTENT_RELATIVE_COLORIMETRIC, 0);
@@ -5073,11 +5075,11 @@ cmsInt32Number CheckMatrixShaperXFORM16(void)
 
 // Check a simple xform from a matrix profile to itself. Test 8 bits accuracy.
 static
-cmsInt32Number CheckMatrixShaperXFORM8(void)

+cmsInt32Number CheckMatrixShaperXFORM8(void)
 {   
     cmsHPROFILE hAbove, hSRGB;
     cmsHTRANSFORM xform;
-    cmsInt32Number rc1, rc2;

+    cmsInt32Number rc1, rc2;
 
     hAbove = Create_AboveRGB();
     xform = cmsCreateTransformTHR(DbgThread(), hAbove, TYPE_RGB_8, hAbove, TYPE_RGB_8,  INTENT_RELATIVE_COLORIMETRIC, 0);
@@ -5108,7 +5110,7 @@ cmsInt32Number CheckMatrixShaperXFORM8(void)
 
 // Check known values going from sRGB to XYZ
 static
-cmsInt32Number CheckOneRGB_f(cmsHTRANSFORM xform, cmsInt32Number R, cmsInt32Number G, cmsInt32Number B, cmsFloat64Number X, cmsFloat64Number Y, cmsFloat64Number Z, cmsFloat64Number err)

+cmsInt32Number CheckOneRGB_f(cmsHTRANSFORM xform, cmsInt32Number R, cmsInt32Number G, cmsInt32Number B, cmsFloat64Number X, cmsFloat64Number Y, cmsFloat64Number Z, cmsFloat64Number err)
 {
     cmsFloat32Number RGB[3];
     cmsFloat64Number Out[3];
@@ -5126,11 +5128,11 @@ cmsInt32Number CheckOneRGB_f(cmsHTRANSFORM xform, cmsInt32Number R, cmsInt32Numb
 
 
 static
-cmsInt32Number Chack_sRGB_Float(void)

+cmsInt32Number Chack_sRGB_Float(void)
 {
     cmsHPROFILE hsRGB, hXYZ, hLab;
     cmsHTRANSFORM xform1, xform2;
-    cmsInt32Number rc;

+    cmsInt32Number rc;
 
 
     hsRGB = cmsCreate_sRGBProfileTHR(DbgThread());
@@ -5167,77 +5169,77 @@ cmsInt32Number Chack_sRGB_Float(void)
 }
 
 
-// ---------------------------------------------------

-

-static

-cmsBool GetProfileRGBPrimaries(cmsHPROFILE hProfile,

-                                cmsCIEXYZTRIPLE *result,

-                                cmsUInt32Number intent)

-{

-    cmsHPROFILE hXYZ;

-    cmsHTRANSFORM hTransform;

-    cmsFloat64Number rgb[3][3] = {{1., 0., 0.},

-    {0., 1., 0.},

-    {0., 0., 1.}};

-

-    hXYZ = cmsCreateXYZProfile();

-    if (hXYZ == NULL) return FALSE;

-

-    hTransform = cmsCreateTransform(hProfile, TYPE_RGB_DBL, hXYZ, TYPE_XYZ_DBL,

-        intent, cmsFLAGS_NOCACHE | cmsFLAGS_NOOPTIMIZE);

-    cmsCloseProfile(hXYZ);

-    if (hTransform == NULL) return FALSE;

-

-    cmsDoTransform(hTransform, rgb, result, 3);

-    cmsDeleteTransform(hTransform);

-    return TRUE;

-}

-

-

-static

-int CheckRGBPrimaries(void)

-{

-    cmsHPROFILE hsRGB;

-    cmsCIEXYZTRIPLE tripXYZ;

-    cmsCIExyYTRIPLE tripxyY;

-    cmsBool result;

-

-    hsRGB = cmsCreate_sRGBProfileTHR(DbgThread());

-    if (!hsRGB) return 0;

-

-    result = GetProfileRGBPrimaries(hsRGB, &tripXYZ,

-        INTENT_ABSOLUTE_COLORIMETRIC);

-

-    cmsCloseProfile(hsRGB);

-    if (!result) return 0;

-

-    cmsXYZ2xyY(&tripxyY.Red, &tripXYZ.Red);

-    cmsXYZ2xyY(&tripxyY.Green, &tripXYZ.Green);

-    cmsXYZ2xyY(&tripxyY.Blue, &tripXYZ.Blue);

-

-    /* valus were taken from

-    http://en.wikipedia.org/wiki/RGB_color_spaces#Specifications */

-

-    if (!IsGoodFixed15_16("xRed", tripxyY.Red.x, 0.64) ||

-        !IsGoodFixed15_16("yRed", tripxyY.Red.y, 0.33) ||

-        !IsGoodFixed15_16("xGreen", tripxyY.Green.x, 0.30) || 

-        !IsGoodFixed15_16("yGreen", tripxyY.Green.y, 0.60) ||

-        !IsGoodFixed15_16("xBlue", tripxyY.Blue.x, 0.15) || 

-        !IsGoodFixed15_16("yBlue", tripxyY.Blue.y, 0.06)) {

-            Fail("One or more primaries are wrong.");

-            return FALSE;

-    }

-

-    return TRUE;

-}

-

-

+// ---------------------------------------------------
+
+static
+cmsBool GetProfileRGBPrimaries(cmsHPROFILE hProfile,
+                                cmsCIEXYZTRIPLE *result,
+                                cmsUInt32Number intent)
+{
+    cmsHPROFILE hXYZ;
+    cmsHTRANSFORM hTransform;
+    cmsFloat64Number rgb[3][3] = {{1., 0., 0.},
+    {0., 1., 0.},
+    {0., 0., 1.}};
+
+    hXYZ = cmsCreateXYZProfile();
+    if (hXYZ == NULL) return FALSE;
+
+    hTransform = cmsCreateTransform(hProfile, TYPE_RGB_DBL, hXYZ, TYPE_XYZ_DBL,
+        intent, cmsFLAGS_NOCACHE | cmsFLAGS_NOOPTIMIZE);
+    cmsCloseProfile(hXYZ);
+    if (hTransform == NULL) return FALSE;
+
+    cmsDoTransform(hTransform, rgb, result, 3);
+    cmsDeleteTransform(hTransform);
+    return TRUE;
+}
+
+
+static
+int CheckRGBPrimaries(void)
+{
+    cmsHPROFILE hsRGB;
+    cmsCIEXYZTRIPLE tripXYZ;
+    cmsCIExyYTRIPLE tripxyY;
+    cmsBool result;
+
+    hsRGB = cmsCreate_sRGBProfileTHR(DbgThread());
+    if (!hsRGB) return 0;
+
+    result = GetProfileRGBPrimaries(hsRGB, &tripXYZ,
+        INTENT_ABSOLUTE_COLORIMETRIC);
+
+    cmsCloseProfile(hsRGB);
+    if (!result) return 0;
+
+    cmsXYZ2xyY(&tripxyY.Red, &tripXYZ.Red);
+    cmsXYZ2xyY(&tripxyY.Green, &tripXYZ.Green);
+    cmsXYZ2xyY(&tripxyY.Blue, &tripXYZ.Blue);
+
+    /* valus were taken from
+    http://en.wikipedia.org/wiki/RGB_color_spaces#Specifications */
+
+    if (!IsGoodFixed15_16("xRed", tripxyY.Red.x, 0.64) ||
+        !IsGoodFixed15_16("yRed", tripxyY.Red.y, 0.33) ||
+        !IsGoodFixed15_16("xGreen", tripxyY.Green.x, 0.30) || 
+        !IsGoodFixed15_16("yGreen", tripxyY.Green.y, 0.60) ||
+        !IsGoodFixed15_16("xBlue", tripxyY.Blue.x, 0.15) || 
+        !IsGoodFixed15_16("yBlue", tripxyY.Blue.y, 0.06)) {
+            Fail("One or more primaries are wrong.");
+            return FALSE;
+    }
+
+    return TRUE;
+}
+
+
 // -----------------------------------------------------------------------------------------------------------------
 
 // This function will check CMYK -> CMYK transforms. It uses FOGRA29 and SWOP ICC profiles
 
 static
-cmsInt32Number CheckCMYK(cmsInt32Number Intent, const char *Profile1, const char* Profile2)

+cmsInt32Number CheckCMYK(cmsInt32Number Intent, const char *Profile1, const char* Profile2)
 {
     cmsHPROFILE hSWOP  = cmsOpenProfileFromFileTHR(DbgThread(), Profile1, "r");
     cmsHPROFILE hFOGRA = cmsOpenProfileFromFileTHR(DbgThread(), Profile2, "r");
@@ -5246,7 +5248,7 @@ cmsInt32Number CheckCMYK(cmsInt32Number Intent, const char *Profile1, const char
     cmsCIELab Lab1, Lab2;
     cmsHPROFILE hLab;
     cmsFloat64Number DeltaL, Max;
-    cmsInt32Number i;

+    cmsInt32Number i;
 
     hLab = cmsCreateLab4ProfileTHR(DbgThread(), NULL);
 
@@ -5309,14 +5311,14 @@ cmsInt32Number CheckCMYK(cmsInt32Number Intent, const char *Profile1, const char
 }
 
 static
-cmsInt32Number CheckCMYKRoundtrip(void)

+cmsInt32Number CheckCMYKRoundtrip(void)
 {
     return CheckCMYK(INTENT_RELATIVE_COLORIMETRIC, "USWebCoatedSWOP.icc", "USWebCoatedSWOP.icc");
 }
 
 
 static
-cmsInt32Number CheckCMYKPerceptual(void)

+cmsInt32Number CheckCMYKPerceptual(void)
 {
     return CheckCMYK(INTENT_PERCEPTUAL, "USWebCoatedSWOP.icc", "UncoatedFOGRA29.icc");
 }
@@ -5324,7 +5326,7 @@ cmsInt32Number CheckCMYKPerceptual(void)
 
 
 static
-cmsInt32Number CheckCMYKRelCol(void)

+cmsInt32Number CheckCMYKRelCol(void)
 {
     return CheckCMYK(INTENT_RELATIVE_COLORIMETRIC, "USWebCoatedSWOP.icc", "UncoatedFOGRA29.icc");
 }
@@ -5332,7 +5334,7 @@ cmsInt32Number CheckCMYKRelCol(void)
 
 
 static
-cmsInt32Number CheckKOnlyBlackPreserving(void)

+cmsInt32Number CheckKOnlyBlackPreserving(void)
 {
     cmsHPROFILE hSWOP  = cmsOpenProfileFromFileTHR(DbgThread(), "USWebCoatedSWOP.icc", "r");
     cmsHPROFILE hFOGRA = cmsOpenProfileFromFileTHR(DbgThread(), "UncoatedFOGRA29.icc", "r");
@@ -5341,7 +5343,7 @@ cmsInt32Number CheckKOnlyBlackPreserving(void)
     cmsCIELab Lab1, Lab2;
     cmsHPROFILE hLab;
     cmsFloat64Number DeltaL, Max;
-    cmsInt32Number i;

+    cmsInt32Number i;
 
     hLab = cmsCreateLab4ProfileTHR(DbgThread(), NULL);
 
@@ -5358,16 +5360,16 @@ cmsInt32Number CheckKOnlyBlackPreserving(void)
         CMYK1[2] = 0;
         CMYK1[3] = (cmsFloat32Number) i;
 
-        // SWOP CMYK to Lab1

+        // SWOP CMYK to Lab1
         cmsDoTransform(swop_lab, CMYK1, &Lab1, 1);
 
-        // SWOP To FOGRA using black preservation

+        // SWOP To FOGRA using black preservation
         cmsDoTransform(xform, CMYK1, CMYK2, 1);
 
-        // Obtained FOGRA CMYK to Lab2

+        // Obtained FOGRA CMYK to Lab2
         cmsDoTransform(fogra_lab, CMYK2, &Lab2, 1);
 
-        // We care only on L*

+        // We care only on L*
         DeltaL = fabs(Lab1.L - Lab2.L);
 
         if (DeltaL > Max) Max = DeltaL;
@@ -5376,11 +5378,11 @@ cmsInt32Number CheckKOnlyBlackPreserving(void)
 
     cmsDeleteTransform(xform);
 
-    // dL should be below 3.0

+    // dL should be below 3.0
     if (Max > 3.0) return 0;
 
 
-    // Same, but FOGRA to SWOP

+    // Same, but FOGRA to SWOP
     xform = cmsCreateTransformTHR(DbgThread(), hFOGRA, TYPE_CMYK_FLT, hSWOP, TYPE_CMYK_FLT, INTENT_PRESERVE_K_ONLY_PERCEPTUAL, 0);
 
     Max = 0;
@@ -5413,7 +5415,7 @@ cmsInt32Number CheckKOnlyBlackPreserving(void)
 }
 
 static
-cmsInt32Number CheckKPlaneBlackPreserving(void)

+cmsInt32Number CheckKPlaneBlackPreserving(void)
 {
     cmsHPROFILE hSWOP  = cmsOpenProfileFromFileTHR(DbgThread(), "USWebCoatedSWOP.icc", "r");
     cmsHPROFILE hFOGRA = cmsOpenProfileFromFileTHR(DbgThread(), "UncoatedFOGRA29.icc", "r");
@@ -5422,7 +5424,7 @@ cmsInt32Number CheckKPlaneBlackPreserving(void)
     cmsCIELab Lab1, Lab2;
     cmsHPROFILE hLab;
     cmsFloat64Number DeltaE, Max;
-    cmsInt32Number i;

+    cmsInt32Number i;
 
     hLab = cmsCreateLab4ProfileTHR(DbgThread(), NULL);
 
@@ -5488,11 +5490,11 @@ cmsInt32Number CheckKPlaneBlackPreserving(void)
 
 
 static
-cmsInt32Number CheckProofingXFORMFloat(void)

+cmsInt32Number CheckProofingXFORMFloat(void)
 {
     cmsHPROFILE hAbove;
     cmsHTRANSFORM xform;
-    cmsInt32Number rc;

+    cmsInt32Number rc;
 
     hAbove = Create_AboveRGB();
     xform =  cmsCreateProofingTransformTHR(DbgThread(), hAbove, TYPE_RGB_FLT, hAbove, TYPE_RGB_FLT, hAbove, 
@@ -5504,11 +5506,11 @@ cmsInt32Number CheckProofingXFORMFloat(void)
 }
 
 static
-cmsInt32Number CheckProofingXFORM16(void)

+cmsInt32Number CheckProofingXFORM16(void)
 {
     cmsHPROFILE hAbove;
     cmsHTRANSFORM xform;
-    cmsInt32Number rc;

+    cmsInt32Number rc;
 
     hAbove = Create_AboveRGB();
     xform =  cmsCreateProofingTransformTHR(DbgThread(), hAbove, TYPE_RGB_16, hAbove, TYPE_RGB_16, hAbove, 
@@ -5521,11 +5523,11 @@ cmsInt32Number CheckProofingXFORM16(void)
 
 
 static
-cmsInt32Number CheckGamutCheck(void)

+cmsInt32Number CheckGamutCheck(void)
 {
         cmsHPROFILE hSRGB, hAbove;
         cmsHTRANSFORM xform;
-        cmsInt32Number rc;

+        cmsInt32Number rc;
         cmsUInt16Number Alarm[3] = { 0xDEAD, 0xBABE, 0xFACE };
 
         // Set alarm codes to fancy values so we could check the out of gamut condition
@@ -5574,7 +5576,7 @@ cmsInt32Number CheckGamutCheck(void)
 // -------------------------------------------------------------------------------------------------------------------
 
 static
-cmsInt32Number CheckBlackPoint(void)

+cmsInt32Number CheckBlackPoint(void)
 {
     cmsHPROFILE hProfile;
     cmsCIEXYZ Black;
@@ -5610,37 +5612,37 @@ cmsInt32Number CheckBlackPoint(void)
 
 
 static
-cmsInt32Number CheckOneTAC(cmsFloat64Number InkLimit)

+cmsInt32Number CheckOneTAC(cmsFloat64Number InkLimit)
 {
-    cmsHPROFILE h;

-    cmsFloat64Number d;

+    cmsHPROFILE h;
+    cmsFloat64Number d;
 
-    h =CreateFakeCMYK(InkLimit, TRUE);

-    cmsSaveProfileToFile(h, "lcmstac.icc");

-    cmsCloseProfile(h);

+    h =CreateFakeCMYK(InkLimit, TRUE);
+    cmsSaveProfileToFile(h, "lcmstac.icc");
+    cmsCloseProfile(h);
 
-    h = cmsOpenProfileFromFile("lcmstac.icc", "r");

-    d = cmsDetectTAC(h);

-    cmsCloseProfile(h);

+    h = cmsOpenProfileFromFile("lcmstac.icc", "r");
+    d = cmsDetectTAC(h);
+    cmsCloseProfile(h);
 
-    remove("lcmstac.icc");

+    remove("lcmstac.icc");
 
-    if (fabs(d - InkLimit) > 5) return 0;

+    if (fabs(d - InkLimit) > 5) return 0;
 
-    return 1;

+    return 1;
 }
 
 
 static
-cmsInt32Number CheckTAC(void)

+cmsInt32Number CheckTAC(void)
 {
-    if (!CheckOneTAC(180)) return 0;

+    if (!CheckOneTAC(180)) return 0;
     if (!CheckOneTAC(220)) return 0;
-    if (!CheckOneTAC(286)) return 0;

-    if (!CheckOneTAC(310)) return 0;

-    if (!CheckOneTAC(330)) return 0;

+    if (!CheckOneTAC(286)) return 0;
+    if (!CheckOneTAC(310)) return 0;
+    if (!CheckOneTAC(330)) return 0;
 
-    return 1;

+    return 1;
 }
 
 // -------------------------------------------------------------------------------------------------------
@@ -5649,10 +5651,10 @@ cmsInt32Number CheckTAC(void)
 #define NPOINTS_IT8 10  // (17*17*17*17)
 
 static
-cmsInt32Number CheckCGATS(void)

+cmsInt32Number CheckCGATS(void)
 {
     cmsHANDLE  it8;
-    cmsInt32Number i;

+    cmsInt32Number i;
     
 
     it8 = cmsIT8Alloc(DbgThread());
@@ -5794,7 +5796,7 @@ void GenerateCRD(const char* cOutProf, const char* FileName)
 }
 
 static 
-cmsInt32Number CheckPostScript(void)

+cmsInt32Number CheckPostScript(void)
 {
     GenerateCSA("sRGB_Color_Space_Profile.icm", "sRGB_CSA.ps");
     GenerateCSA("aRGBlcms2.icc", "aRGB_CSA.ps");
@@ -5815,133 +5817,133 @@ cmsInt32Number CheckPostScript(void)
 
 
 static
-cmsInt32Number CheckGray(cmsHTRANSFORM xform, cmsUInt8Number g, double L)

+cmsInt32Number CheckGray(cmsHTRANSFORM xform, cmsUInt8Number g, double L)
 {
-    cmsCIELab Lab;

+    cmsCIELab Lab;
 
-    cmsDoTransform(xform, &g, &Lab, 1);

+    cmsDoTransform(xform, &g, &Lab, 1);
 
-    if (!IsGoodVal("a axis on gray", 0, Lab.a, 0.001)) return 0;

+    if (!IsGoodVal("a axis on gray", 0, Lab.a, 0.001)) return 0;
     if (!IsGoodVal("b axis on gray", 0, Lab.b, 0.001)) return 0;
 
-    return IsGoodVal("Gray value", L, Lab.L, 0.01);

+    return IsGoodVal("Gray value", L, Lab.L, 0.01);
 }
 
 static
-cmsInt32Number CheckInputGray(void)

+cmsInt32Number CheckInputGray(void)
 {
-    cmsHPROFILE hGray = Create_Gray22();

-    cmsHPROFILE hLab  = cmsCreateLab4Profile(NULL);

+    cmsHPROFILE hGray = Create_Gray22();
+    cmsHPROFILE hLab  = cmsCreateLab4Profile(NULL);
     cmsHTRANSFORM xform;
 
-    if (hGray == NULL || hLab == NULL) return 0;

+    if (hGray == NULL || hLab == NULL) return 0;
 
-    xform = cmsCreateTransform(hGray, TYPE_GRAY_8, hLab, TYPE_Lab_DBL, INTENT_RELATIVE_COLORIMETRIC, 0); 

+    xform = cmsCreateTransform(hGray, TYPE_GRAY_8, hLab, TYPE_Lab_DBL, INTENT_RELATIVE_COLORIMETRIC, 0); 
     cmsCloseProfile(hGray); cmsCloseProfile(hLab);
 
     if (!CheckGray(xform, 0, 0)) return 0;
     if (!CheckGray(xform, 125, 52.768)) return 0;
     if (!CheckGray(xform, 200, 81.069)) return 0;
-    if (!CheckGray(xform, 255, 100.0)) return 0;

+    if (!CheckGray(xform, 255, 100.0)) return 0;
 
-    cmsDeleteTransform(xform);

-    return 1;

+    cmsDeleteTransform(xform);
+    return 1;
 }
 
 static
-cmsInt32Number CheckLabInputGray(void)

+cmsInt32Number CheckLabInputGray(void)
 {
-    cmsHPROFILE hGray = Create_GrayLab();

-    cmsHPROFILE hLab  = cmsCreateLab4Profile(NULL);

+    cmsHPROFILE hGray = Create_GrayLab();
+    cmsHPROFILE hLab  = cmsCreateLab4Profile(NULL);
     cmsHTRANSFORM xform;
 
-    if (hGray == NULL || hLab == NULL) return 0;

+    if (hGray == NULL || hLab == NULL) return 0;
 
-    xform = cmsCreateTransform(hGray, TYPE_GRAY_8, hLab, TYPE_Lab_DBL, INTENT_RELATIVE_COLORIMETRIC, 0);

+    xform = cmsCreateTransform(hGray, TYPE_GRAY_8, hLab, TYPE_Lab_DBL, INTENT_RELATIVE_COLORIMETRIC, 0);
     cmsCloseProfile(hGray); cmsCloseProfile(hLab);
 
     if (!CheckGray(xform, 0, 0)) return 0;
     if (!CheckGray(xform, 125, 49.019)) return 0;
     if (!CheckGray(xform, 200, 78.431)) return 0;
-    if (!CheckGray(xform, 255, 100.0)) return 0;

-
-    cmsDeleteTransform(xform);

-    return 1;

-}
-
-
-static

-cmsInt32Number CheckOutGray(cmsHTRANSFORM xform, double L, cmsUInt8Number g)

-{

-    cmsCIELab Lab;

-    cmsUInt8Number g_out;

-

-    Lab.L = L;

-    Lab.a = 0;

-    Lab.b = 0;

-

-    cmsDoTransform(xform, &Lab, &g_out, 1);

-
-    return IsGoodVal("Gray value", g, (double) g_out, 0.01);

-}

-
-static
-cmsInt32Number CheckOutputGray(void)

-{

-    cmsHPROFILE hGray = Create_Gray22();

-    cmsHPROFILE hLab  = cmsCreateLab4Profile(NULL);

-    cmsHTRANSFORM xform;

-

-    if (hGray == NULL || hLab == NULL) return 0;

-

-    xform = cmsCreateTransform( hLab, TYPE_Lab_DBL, hGray, TYPE_GRAY_8, INTENT_RELATIVE_COLORIMETRIC, 0); 

-    cmsCloseProfile(hGray); cmsCloseProfile(hLab);

-

-    if (!CheckOutGray(xform, 0, 0)) return 0;

-    if (!CheckOutGray(xform, 100, 255)) return 0;

-    

-    if (!CheckOutGray(xform, 20, 52)) return 0;

-    if (!CheckOutGray(xform, 50, 118)) return 0;

-    

-

-    cmsDeleteTransform(xform);

-    return 1;

-}

-

-

-static

-cmsInt32Number CheckLabOutputGray(void)

-{

-    cmsHPROFILE hGray = Create_GrayLab();

-    cmsHPROFILE hLab  = cmsCreateLab4Profile(NULL);

-    cmsHTRANSFORM xform;

-    cmsInt32Number i;

-

-    if (hGray == NULL || hLab == NULL) return 0;

-

-    xform = cmsCreateTransform( hLab, TYPE_Lab_DBL, hGray, TYPE_GRAY_8, INTENT_RELATIVE_COLORIMETRIC, 0);

-    cmsCloseProfile(hGray); cmsCloseProfile(hLab);

-

-    if (!CheckOutGray(xform, 0, 0)) return 0;

-    if (!CheckOutGray(xform, 100, 255)) return 0;

-

-    for (i=0; i < 100; i++) {

-

-        cmsUInt8Number g;

-

-        g = (cmsUInt8Number) floor(i * 255.0 / 100.0 + 0.5);

-

-        if (!CheckOutGray(xform, i, g)) return 0;

-    }

-    

-

-    cmsDeleteTransform(xform);

-    return 1;

-}

-

-

-static

-cmsInt32Number CheckV4gamma(void)

+    if (!CheckGray(xform, 255, 100.0)) return 0;
+
+    cmsDeleteTransform(xform);
+    return 1;
+}
+
+
+static
+cmsInt32Number CheckOutGray(cmsHTRANSFORM xform, double L, cmsUInt8Number g)
+{
+    cmsCIELab Lab;
+    cmsUInt8Number g_out;
+
+    Lab.L = L;
+    Lab.a = 0;
+    Lab.b = 0;
+
+    cmsDoTransform(xform, &Lab, &g_out, 1);
+
+    return IsGoodVal("Gray value", g, (double) g_out, 0.01);
+}
+
+static
+cmsInt32Number CheckOutputGray(void)
+{
+    cmsHPROFILE hGray = Create_Gray22();
+    cmsHPROFILE hLab  = cmsCreateLab4Profile(NULL);
+    cmsHTRANSFORM xform;
+
+    if (hGray == NULL || hLab == NULL) return 0;
+
+    xform = cmsCreateTransform( hLab, TYPE_Lab_DBL, hGray, TYPE_GRAY_8, INTENT_RELATIVE_COLORIMETRIC, 0); 
+    cmsCloseProfile(hGray); cmsCloseProfile(hLab);
+
+    if (!CheckOutGray(xform, 0, 0)) return 0;
+    if (!CheckOutGray(xform, 100, 255)) return 0;
+    
+    if (!CheckOutGray(xform, 20, 52)) return 0;
+    if (!CheckOutGray(xform, 50, 118)) return 0;
+    
+
+    cmsDeleteTransform(xform);
+    return 1;
+}
+
+
+static
+cmsInt32Number CheckLabOutputGray(void)
+{
+    cmsHPROFILE hGray = Create_GrayLab();
+    cmsHPROFILE hLab  = cmsCreateLab4Profile(NULL);
+    cmsHTRANSFORM xform;
+    cmsInt32Number i;
+
+    if (hGray == NULL || hLab == NULL) return 0;
+
+    xform = cmsCreateTransform( hLab, TYPE_Lab_DBL, hGray, TYPE_GRAY_8, INTENT_RELATIVE_COLORIMETRIC, 0);
+    cmsCloseProfile(hGray); cmsCloseProfile(hLab);
+
+    if (!CheckOutGray(xform, 0, 0)) return 0;
+    if (!CheckOutGray(xform, 100, 255)) return 0;
+
+    for (i=0; i < 100; i++) {
+
+        cmsUInt8Number g;
+
+        g = (cmsUInt8Number) floor(i * 255.0 / 100.0 + 0.5);
+
+        if (!CheckOutGray(xform, i, g)) return 0;
+    }
+    
+
+    cmsDeleteTransform(xform);
+    return 1;
+}
+
+
+static
+cmsInt32Number CheckV4gamma(void)
 {
     cmsHPROFILE h;
     cmsUInt16Number Lin[] = {0, 0xffff};
@@ -5961,195 +5963,195 @@ cmsInt32Number CheckV4gamma(void)
     return 1;
 }
 
-// cmsBool cmsGBDdumpVRML(cmsHANDLE hGBD, const char* fname);

-
-// Gamut descriptor routines

-static

-cmsInt32Number CheckGBD(void)

-{

-    cmsCIELab Lab;

-    cmsHANDLE  h;

-    cmsInt32Number L, a, b;

-    cmsUInt32Number r1, g1, b1;

-    cmsHPROFILE hLab, hsRGB;

-    cmsHTRANSFORM xform;

-
-    h = cmsGBDAlloc(DbgThread());

-    if (h == NULL) return 0;

-
-    // Fill all Lab gamut as valid

-    SubTest("Filling RAW gamut");

-
-    for (L=0; L <= 100; L += 10)

-        for (a = -128; a <= 128; a += 5)

-            for (b = -128; b <= 128; b += 5) {

-
-                Lab.L = L;

-                Lab.a = a;

-                Lab.b = b;

-                if (!cmsGDBAddPoint(h, &Lab)) return 0;

-            }

-
-    // Complete boundaries

-    SubTest("computing Lab gamut");

-    if (!cmsGDBCompute(h, 0)) return 0;

-
-
-    // All points should be inside gamut

-    SubTest("checking Lab gamut");

-    for (L=10; L <= 90; L += 25)

-        for (a = -120; a <= 120; a += 25)

-            for (b = -120; b <= 120; b += 25) {

-
-                Lab.L = L;

-                Lab.a = a;

-                Lab.b = b;

-                if (!cmsGDBCheckPoint(h, &Lab)) {

-                    return 0;

-                }

-            }

-    cmsGBDFree(h);

-

-

-    // Now for sRGB

-    SubTest("checking sRGB gamut");

-    h = cmsGBDAlloc(DbgThread());

-    hsRGB = cmsCreate_sRGBProfile();

-    hLab  = cmsCreateLab4Profile(NULL);

-

-    xform = cmsCreateTransform(hsRGB, TYPE_RGB_8, hLab, TYPE_Lab_DBL, INTENT_RELATIVE_COLORIMETRIC, cmsFLAGS_NOCACHE);

-    cmsCloseProfile(hsRGB); cmsCloseProfile(hLab);

-

-

-    for (r1=0; r1 < 256; r1 += 5) {

-        for (g1=0; g1 < 256; g1 += 5)

-            for (b1=0; b1 < 256; b1 += 5) {

-

-                

-                cmsUInt8Number rgb[3];  

-

-                rgb[0] = r1;

-                rgb[1] = g1; 

-                rgb[2] = b1;

-

-                cmsDoTransform(xform, rgb, &Lab, 1);

-

-                // if (fabs(Lab.b) < 20 && Lab.a > 0) continue;

-

-                if (!cmsGDBAddPoint(h, &Lab)) {

-                    cmsGBDFree(h);

-                    return 0;

-                }

-                

-

-            }

+// cmsBool cmsGBDdumpVRML(cmsHANDLE hGBD, const char* fname);
+
+// Gamut descriptor routines
+static
+cmsInt32Number CheckGBD(void)
+{
+    cmsCIELab Lab;
+    cmsHANDLE  h;
+    cmsInt32Number L, a, b;
+    cmsUInt32Number r1, g1, b1;
+    cmsHPROFILE hLab, hsRGB;
+    cmsHTRANSFORM xform;
+
+    h = cmsGBDAlloc(DbgThread());
+    if (h == NULL) return 0;
+
+    // Fill all Lab gamut as valid
+    SubTest("Filling RAW gamut");
+
+    for (L=0; L <= 100; L += 10)
+        for (a = -128; a <= 128; a += 5)
+            for (b = -128; b <= 128; b += 5) {
+
+                Lab.L = L;
+                Lab.a = a;
+                Lab.b = b;
+                if (!cmsGDBAddPoint(h, &Lab)) return 0;
+            }
+
+    // Complete boundaries
+    SubTest("computing Lab gamut");
+    if (!cmsGDBCompute(h, 0)) return 0;
+
+
+    // All points should be inside gamut
+    SubTest("checking Lab gamut");
+    for (L=10; L <= 90; L += 25)
+        for (a = -120; a <= 120; a += 25)
+            for (b = -120; b <= 120; b += 25) {
+
+                Lab.L = L;
+                Lab.a = a;
+                Lab.b = b;
+                if (!cmsGDBCheckPoint(h, &Lab)) {
+                    return 0;
+                }
+            }
+    cmsGBDFree(h);
+
+
+    // Now for sRGB
+    SubTest("checking sRGB gamut");
+    h = cmsGBDAlloc(DbgThread());
+    hsRGB = cmsCreate_sRGBProfile();
+    hLab  = cmsCreateLab4Profile(NULL);
+
+    xform = cmsCreateTransform(hsRGB, TYPE_RGB_8, hLab, TYPE_Lab_DBL, INTENT_RELATIVE_COLORIMETRIC, cmsFLAGS_NOCACHE);
+    cmsCloseProfile(hsRGB); cmsCloseProfile(hLab);
+
+
+    for (r1=0; r1 < 256; r1 += 5) {
+        for (g1=0; g1 < 256; g1 += 5)
+            for (b1=0; b1 < 256; b1 += 5) {
+
+                
+                cmsUInt8Number rgb[3];  
+
+                rgb[0] = (cmsUInt8Number) r1;
+                rgb[1] = (cmsUInt8Number) g1; 
+                rgb[2] = (cmsUInt8Number) b1;
+
+                cmsDoTransform(xform, rgb, &Lab, 1);
+
+                // if (fabs(Lab.b) < 20 && Lab.a > 0) continue;
+
+                if (!cmsGDBAddPoint(h, &Lab)) {
+                    cmsGBDFree(h);
+                    return 0;
+                }
+                
+
+            }
     }
-    

-

-    if (!cmsGDBCompute(h, 0)) return 0;

-    // cmsGBDdumpVRML(h, "c:\\colormaps\\lab.wrl");

-

-    for (r1=10; r1 < 200; r1 += 10) {

-        for (g1=10; g1 < 200; g1 += 10)

-            for (b1=10; b1 < 200; b1 += 10) {

-

-                

-                cmsUInt8Number rgb[3];  

-

-                rgb[0] = r1;

-                rgb[1] = g1; 

-                rgb[2] = b1;

-

-                cmsDoTransform(xform, rgb, &Lab, 1);

-                if (!cmsGDBCheckPoint(h, &Lab)) {

-

-                    cmsDeleteTransform(xform);

-                    cmsGBDFree(h);

-                    return 0;

-                }

-            }

+    
+
+    if (!cmsGDBCompute(h, 0)) return 0;
+    // cmsGBDdumpVRML(h, "c:\\colormaps\\lab.wrl");
+
+    for (r1=10; r1 < 200; r1 += 10) {
+        for (g1=10; g1 < 200; g1 += 10)
+            for (b1=10; b1 < 200; b1 += 10) {
+
+                
+                cmsUInt8Number rgb[3];  
+
+                rgb[0] = (cmsUInt8Number) r1;
+                rgb[1] = (cmsUInt8Number) g1; 
+                rgb[2] = (cmsUInt8Number) b1;
+
+                cmsDoTransform(xform, rgb, &Lab, 1);
+                if (!cmsGDBCheckPoint(h, &Lab)) {
+
+                    cmsDeleteTransform(xform);
+                    cmsGBDFree(h);
+                    return 0;
+                }
+            }
     }
 
 
-    cmsDeleteTransform(xform);

-    cmsGBDFree(h);

-

-    SubTest("checking LCh chroma ring");

-    h = cmsGBDAlloc(DbgThread());

+    cmsDeleteTransform(xform);
+    cmsGBDFree(h);
+
+    SubTest("checking LCh chroma ring");
+    h = cmsGBDAlloc(DbgThread());
 
     
-    for (r1=0; r1 < 360; r1++) {

-

-        cmsCIELCh LCh;

-

-        LCh.L = 70;

-        LCh.C = 60;

-        LCh.h = r1;

-

-        cmsLCh2Lab(&Lab, &LCh);

-        if (!cmsGDBAddPoint(h, &Lab)) {

-                    cmsGBDFree(h);

-                    return 0;

-                }

-    }

-    

-

-    if (!cmsGDBCompute(h, 0)) return 0;

-

-    cmsGBDFree(h);

-
-    return 1;

-}
-

-

-// --------------------------------------------------------------------------------------------------

-// P E R F O R M A N C E   C H E C K S

-// --------------------------------------------------------------------------------------------------

+    for (r1=0; r1 < 360; r1++) {
+
+        cmsCIELCh LCh;
+
+        LCh.L = 70;
+        LCh.C = 60;
+        LCh.h = r1;
+
+        cmsLCh2Lab(&Lab, &LCh);
+        if (!cmsGDBAddPoint(h, &Lab)) {
+                    cmsGBDFree(h);
+                    return 0;
+                }
+    }
+    
+
+    if (!cmsGDBCompute(h, 0)) return 0;
+
+    cmsGBDFree(h);
+
+    return 1;
+}
+
+
+// --------------------------------------------------------------------------------------------------
+// P E R F O R M A N C E   C H E C K S
+// --------------------------------------------------------------------------------------------------
 
 
 typedef struct {cmsUInt8Number r, g, b, a;}   Scanline_rgb1;
-typedef struct {cmsUInt16Number r, g, b, a;}  Scanline_rgb2;

+typedef struct {cmsUInt16Number r, g, b, a;}  Scanline_rgb2;
 typedef struct {cmsUInt8Number r, g, b;}      Scanline_rgb8;
-typedef struct {cmsUInt16Number r, g, b;}     Scanline_rgb0;

-

-

-static 

-void TitlePerformance(const char* Txt)

-{

-    printf("%-45s: ", Txt); fflush(stdout);

-}

+typedef struct {cmsUInt16Number r, g, b;}     Scanline_rgb0;
 
-static

-void PrintPerformance(cmsUInt32Number Bytes, cmsUInt32Number SizeOfPixel, cmsFloat64Number diff)

-{

-    cmsFloat64Number seconds  = (cmsFloat64Number) diff / CLOCKS_PER_SEC;

-    cmsFloat64Number mpix_sec = Bytes / (1024.0*1024.0*seconds*SizeOfPixel);

-

-    printf("%g MPixel/sec.\n", mpix_sec);

-    fflush(stdout);

-}

 
+static 
+void TitlePerformance(const char* Txt)
+{
+    printf("%-45s: ", Txt); fflush(stdout);
+}
 
 static
-void SpeedTest16bits(const char * Title, cmsHPROFILE hlcmsProfileIn, cmsHPROFILE hlcmsProfileOut, cmsInt32Number Intent)

+void PrintPerformance(cmsUInt32Number Bytes, cmsUInt32Number SizeOfPixel, cmsFloat64Number diff)
 {
+    cmsFloat64Number seconds  = (cmsFloat64Number) diff / CLOCKS_PER_SEC;
+    cmsFloat64Number mpix_sec = Bytes / (1024.0*1024.0*seconds*SizeOfPixel);
+
+    printf("%g MPixel/sec.\n", mpix_sec);
+    fflush(stdout);
+}
 
-    cmsInt32Number r, g, b, j;

+
+static
+void SpeedTest16bits(const char * Title, cmsHPROFILE hlcmsProfileIn, cmsHPROFILE hlcmsProfileOut, cmsInt32Number Intent)
+{
+
+    cmsInt32Number r, g, b, j;
     clock_t atime;
-    cmsFloat64Number diff;

+    cmsFloat64Number diff;
     cmsHTRANSFORM hlcmsxform;
     Scanline_rgb0 *In;
     cmsUInt32Number Mb;
 
-    if (hlcmsProfileIn == NULL || hlcmsProfileOut == NULL) 

-        Die("Unable to open profiles");

-

-    hlcmsxform  = cmsCreateTransformTHR(DbgThread(), hlcmsProfileIn, TYPE_RGB_16, 

-                               hlcmsProfileOut, TYPE_RGB_16, Intent, cmsFLAGS_NOCACHE);

-    cmsCloseProfile(hlcmsProfileIn);

-    cmsCloseProfile(hlcmsProfileOut);

+    if (hlcmsProfileIn == NULL || hlcmsProfileOut == NULL) 
+        Die("Unable to open profiles");
 
-    Mb = 256*256*256*sizeof(Scanline_rgb0);

+    hlcmsxform  = cmsCreateTransformTHR(DbgThread(), hlcmsProfileIn, TYPE_RGB_16, 
+                               hlcmsProfileOut, TYPE_RGB_16, Intent, cmsFLAGS_NOCACHE);
+    cmsCloseProfile(hlcmsProfileIn);
+    cmsCloseProfile(hlcmsProfileOut);
+
+    Mb = 256*256*256*sizeof(Scanline_rgb0);
     In = (Scanline_rgb0*) malloc(Mb);
 
     j = 0;
@@ -6165,7 +6167,7 @@ void SpeedTest16bits(const char * Title, cmsHPROFILE hlcmsProfileIn, cmsHPROFILE
     }
 
 
-    TitlePerformance(Title);

+    TitlePerformance(Title);
 
     atime = clock();
 
@@ -6173,30 +6175,30 @@ void SpeedTest16bits(const char * Title, cmsHPROFILE hlcmsProfileIn, cmsHPROFILE
 
     diff = clock() - atime;
     free(In);
-        

-    PrintPerformance(Mb, sizeof(Scanline_rgb0), diff);

+        
+    PrintPerformance(Mb, sizeof(Scanline_rgb0), diff);
     cmsDeleteTransform(hlcmsxform);
-    

+    
 }
 
 
 static
 void SpeedTest16bitsCMYK(const char * Title, cmsHPROFILE hlcmsProfileIn, cmsHPROFILE hlcmsProfileOut)
 {
-    cmsInt32Number r, g, b, j;

+    cmsInt32Number r, g, b, j;
     clock_t atime;
-    cmsFloat64Number diff;

+    cmsFloat64Number diff;
     cmsHTRANSFORM hlcmsxform;
     Scanline_rgb2 *In;
     cmsUInt32Number Mb;
-     

-    if (hlcmsProfileOut == NULL || hlcmsProfileOut == NULL) 

-        Die("Unable to open profiles");

+     
+    if (hlcmsProfileOut == NULL || hlcmsProfileOut == NULL) 
+        Die("Unable to open profiles");
 
-    hlcmsxform  = cmsCreateTransformTHR(DbgThread(), hlcmsProfileIn, TYPE_CMYK_16, 

-                hlcmsProfileOut, TYPE_CMYK_16, INTENT_PERCEPTUAL,  cmsFLAGS_NOCACHE);

-    cmsCloseProfile(hlcmsProfileIn);

-    cmsCloseProfile(hlcmsProfileOut);

+    hlcmsxform  = cmsCreateTransformTHR(DbgThread(), hlcmsProfileIn, TYPE_CMYK_16, 
+                hlcmsProfileOut, TYPE_CMYK_16, INTENT_PERCEPTUAL,  cmsFLAGS_NOCACHE);
+    cmsCloseProfile(hlcmsProfileIn);
+    cmsCloseProfile(hlcmsProfileOut);
 
     Mb = 256*256*256*sizeof(Scanline_rgb2);
 
@@ -6216,40 +6218,40 @@ void SpeedTest16bitsCMYK(const char * Title, cmsHPROFILE hlcmsProfileIn, cmsHPRO
     }
 
 
-    TitlePerformance(Title);

+    TitlePerformance(Title);
 
     atime = clock();
 
     cmsDoTransform(hlcmsxform, In, In, 256*256*256);
 
     diff = clock() - atime;
-

+
     free(In);
     
-    PrintPerformance(Mb, sizeof(Scanline_rgb2), diff);

+    PrintPerformance(Mb, sizeof(Scanline_rgb2), diff);
 
     cmsDeleteTransform(hlcmsxform);
- 

+ 
 }
 
 
 static
-void SpeedTest8bits(const char * Title, cmsHPROFILE hlcmsProfileIn, cmsHPROFILE hlcmsProfileOut, cmsInt32Number Intent)

+void SpeedTest8bits(const char * Title, cmsHPROFILE hlcmsProfileIn, cmsHPROFILE hlcmsProfileOut, cmsInt32Number Intent)
 {
-    cmsInt32Number r, g, b, j;

+    cmsInt32Number r, g, b, j;
     clock_t atime;
-    cmsFloat64Number diff;

+    cmsFloat64Number diff;
     cmsHTRANSFORM hlcmsxform;
     Scanline_rgb8 *In;
     cmsUInt32Number Mb;
    
-    if (hlcmsProfileIn == NULL || hlcmsProfileOut == NULL) 

-        Die("Unable to open profiles");

-

-    hlcmsxform  = cmsCreateTransformTHR(DbgThread(), hlcmsProfileIn, TYPE_RGB_8, 

-                            hlcmsProfileOut, TYPE_RGB_8, Intent, cmsFLAGS_NOCACHE);

-    cmsCloseProfile(hlcmsProfileIn);

-    cmsCloseProfile(hlcmsProfileOut);

+    if (hlcmsProfileIn == NULL || hlcmsProfileOut == NULL) 
+        Die("Unable to open profiles");
+
+    hlcmsxform  = cmsCreateTransformTHR(DbgThread(), hlcmsProfileIn, TYPE_RGB_8, 
+                            hlcmsProfileOut, TYPE_RGB_8, Intent, cmsFLAGS_NOCACHE);
+    cmsCloseProfile(hlcmsProfileIn);
+    cmsCloseProfile(hlcmsProfileOut);
 
     Mb = 256*256*256*sizeof(Scanline_rgb8);
 
@@ -6267,40 +6269,40 @@ void SpeedTest8bits(const char * Title, cmsHPROFILE hlcmsProfileIn, cmsHPROFILE
         j++;
     }
 
-    TitlePerformance(Title);

+    TitlePerformance(Title);
 
     atime = clock();
 
     cmsDoTransform(hlcmsxform, In, In, 256*256*256);
 
     diff = clock() - atime;
-

+
     free(In);
     
-    PrintPerformance(Mb, sizeof(Scanline_rgb8), diff);

+    PrintPerformance(Mb, sizeof(Scanline_rgb8), diff);
     
     cmsDeleteTransform(hlcmsxform);
-

+
 }
 
 
 static
 void SpeedTest8bitsCMYK(const char * Title, cmsHPROFILE hlcmsProfileIn, cmsHPROFILE hlcmsProfileOut)
 {
-    cmsInt32Number r, g, b, j;

+    cmsInt32Number r, g, b, j;
     clock_t atime;
-    cmsFloat64Number diff;

+    cmsFloat64Number diff;
     cmsHTRANSFORM hlcmsxform;
     Scanline_rgb2 *In;
     cmsUInt32Number Mb;
-    

-    if (hlcmsProfileIn == NULL || hlcmsProfileOut == NULL) 

-        Die("Unable to open profiles");

-

-    hlcmsxform  = cmsCreateTransformTHR(DbgThread(), hlcmsProfileIn, TYPE_CMYK_8, 

-                        hlcmsProfileOut, TYPE_CMYK_8, INTENT_PERCEPTUAL, cmsFLAGS_NOCACHE);

-    cmsCloseProfile(hlcmsProfileIn);

-    cmsCloseProfile(hlcmsProfileOut);

+    
+    if (hlcmsProfileIn == NULL || hlcmsProfileOut == NULL) 
+        Die("Unable to open profiles");
+
+    hlcmsxform  = cmsCreateTransformTHR(DbgThread(), hlcmsProfileIn, TYPE_CMYK_8, 
+                        hlcmsProfileOut, TYPE_CMYK_8, INTENT_PERCEPTUAL, cmsFLAGS_NOCACHE);
+    cmsCloseProfile(hlcmsProfileIn);
+    cmsCloseProfile(hlcmsProfileOut);
 
     Mb = 256*256*256*sizeof(Scanline_rgb2);
 
@@ -6319,68 +6321,68 @@ void SpeedTest8bitsCMYK(const char * Title, cmsHPROFILE hlcmsProfileIn, cmsHPROF
         j++;
     }
 
-    TitlePerformance(Title);

+    TitlePerformance(Title);
 
     atime = clock();
 
     cmsDoTransform(hlcmsxform, In, In, 256*256*256);
 
     diff = clock() - atime;
-

+
     free(In);
     
-    PrintPerformance(Mb, sizeof(Scanline_rgb2), diff);

-

+    PrintPerformance(Mb, sizeof(Scanline_rgb2), diff);
+
 
     cmsDeleteTransform(hlcmsxform);
-

-}

-

-

-static

-void SpeedTest8bitsGray(const char * Title, cmsHPROFILE hlcmsProfileIn, cmsHPROFILE hlcmsProfileOut, cmsInt32Number Intent)

-{

-    cmsInt32Number r, g, b, j;

-    clock_t atime;

-    cmsFloat64Number diff;

-    cmsHTRANSFORM hlcmsxform;

-    cmsUInt8Number *In;

-    cmsUInt32Number Mb;

-   

-   

-    if (hlcmsProfileIn == NULL || hlcmsProfileOut == NULL) 

-        Die("Unable to open profiles");

-

-    hlcmsxform  = cmsCreateTransformTHR(DbgThread(), hlcmsProfileIn, 

-                        TYPE_GRAY_8, hlcmsProfileOut, TYPE_GRAY_8, Intent, cmsFLAGS_NOCACHE);

+
+}
+
+
+static
+void SpeedTest8bitsGray(const char * Title, cmsHPROFILE hlcmsProfileIn, cmsHPROFILE hlcmsProfileOut, cmsInt32Number Intent)
+{
+    cmsInt32Number r, g, b, j;
+    clock_t atime;
+    cmsFloat64Number diff;
+    cmsHTRANSFORM hlcmsxform;
+    cmsUInt8Number *In;
+    cmsUInt32Number Mb;
+   
+   
+    if (hlcmsProfileIn == NULL || hlcmsProfileOut == NULL) 
+        Die("Unable to open profiles");
+
+    hlcmsxform  = cmsCreateTransformTHR(DbgThread(), hlcmsProfileIn, 
+                        TYPE_GRAY_8, hlcmsProfileOut, TYPE_GRAY_8, Intent, cmsFLAGS_NOCACHE);
     cmsCloseProfile(hlcmsProfileIn);
     cmsCloseProfile(hlcmsProfileOut);
-    Mb = 256*256*256;

-
-    In = (cmsUInt8Number*) malloc(Mb);

-

-    j = 0;

-    for (r=0; r < 256; r++)

-        for (g=0; g < 256; g++)

-            for (b=0; b < 256; b++) {

-

-        In[j] = (cmsUInt8Number) r;

-        

-        j++;

-    }

-

-    TitlePerformance(Title);

-

-    atime = clock();

-

-    cmsDoTransform(hlcmsxform, In, In, 256*256*256);

-

-    diff = clock() - atime;

-    free(In);

-        

-    PrintPerformance(Mb, sizeof(cmsUInt8Number), diff);

-    cmsDeleteTransform(hlcmsxform);

-}

+    Mb = 256*256*256;
+
+    In = (cmsUInt8Number*) malloc(Mb);
+
+    j = 0;
+    for (r=0; r < 256; r++)
+        for (g=0; g < 256; g++)
+            for (b=0; b < 256; b++) {
+
+        In[j] = (cmsUInt8Number) r;
+        
+        j++;
+    }
+
+    TitlePerformance(Title);
+
+    atime = clock();
+
+    cmsDoTransform(hlcmsxform, In, In, 256*256*256);
+
+    diff = clock() - atime;
+    free(In);
+        
+    PrintPerformance(Mb, sizeof(cmsUInt8Number), diff);
+    cmsDeleteTransform(hlcmsxform);
+}
 
 
 static
@@ -6403,79 +6405,79 @@ static
 void SpeedTest(void)
 {
 
-    printf("\n\nP E R F O R M A N C E   T E S T S\n");

-    printf(    "=================================\n\n");

-    fflush(stdout);

-

+    printf("\n\nP E R F O R M A N C E   T E S T S\n");
+    printf(    "=================================\n\n");
+    fflush(stdout);
+
     SpeedTest16bits("16 bits on CLUT profiles", 
-        cmsOpenProfileFromFile("sRGB_Color_Space_Profile.icm", "r"),

-        cmsOpenProfileFromFile("sRGBSpac.icm", "r"), INTENT_PERCEPTUAL);

+        cmsOpenProfileFromFile("sRGB_Color_Space_Profile.icm", "r"),
+        cmsOpenProfileFromFile("sRGBSpac.icm", "r"), INTENT_PERCEPTUAL);
 
     SpeedTest8bits("8 bits on CLUT profiles", 
-        cmsOpenProfileFromFile("sRGB_Color_Space_Profile.icm", "r"),

-        cmsOpenProfileFromFile("sRGBSpac.icm", "r"),

-        INTENT_PERCEPTUAL);

+        cmsOpenProfileFromFile("sRGB_Color_Space_Profile.icm", "r"),
+        cmsOpenProfileFromFile("sRGBSpac.icm", "r"),
+        INTENT_PERCEPTUAL);
     
     SpeedTest8bits("8 bits on Matrix-Shaper profiles", 
-        cmsOpenProfileFromFile("sRGB_Color_Space_Profile.icm", "r"), 

-        cmsOpenProfileFromFile("aRGBlcms2.icc", "r"),

-        INTENT_PERCEPTUAL);

+        cmsOpenProfileFromFile("sRGB_Color_Space_Profile.icm", "r"), 
+        cmsOpenProfileFromFile("aRGBlcms2.icc", "r"),
+        INTENT_PERCEPTUAL);
 
     SpeedTest8bits("8 bits on SAME Matrix-Shaper profiles",
-        cmsOpenProfileFromFile("sRGB_Color_Space_Profile.icm", "r"),

-        cmsOpenProfileFromFile("sRGB_Color_Space_Profile.icm", "r"),

-        INTENT_PERCEPTUAL);

-

-    SpeedTest8bits("8 bits on Matrix-Shaper profiles (AbsCol)", 

-       cmsOpenProfileFromFile("sRGB_Color_Space_Profile.icm", "r"),

-       cmsOpenProfileFromFile("aRGBlcms2.icc", "r"),

-        INTENT_ABSOLUTE_COLORIMETRIC);  

-

-    SpeedTest16bits("16 bits on Matrix-Shaper profiles", 

-       cmsOpenProfileFromFile("sRGB_Color_Space_Profile.icm", "r"),

-        cmsOpenProfileFromFile("aRGBlcms2.icc", "r"),

-        INTENT_PERCEPTUAL);

-

-    SpeedTest16bits("16 bits on SAME Matrix-Shaper profiles", 

-        cmsOpenProfileFromFile("aRGBlcms2.icc", "r"),

-        cmsOpenProfileFromFile("aRGBlcms2.icc", "r"),

-        INTENT_PERCEPTUAL);

-

-    SpeedTest16bits("16 bits on Matrix-Shaper profiles (AbsCol)", 

-       cmsOpenProfileFromFile("sRGB_Color_Space_Profile.icm", "r"),

-       cmsOpenProfileFromFile("aRGBlcms2.icc", "r"),

-        INTENT_ABSOLUTE_COLORIMETRIC);

+        cmsOpenProfileFromFile("sRGB_Color_Space_Profile.icm", "r"),
+        cmsOpenProfileFromFile("sRGB_Color_Space_Profile.icm", "r"),
+        INTENT_PERCEPTUAL);
+
+    SpeedTest8bits("8 bits on Matrix-Shaper profiles (AbsCol)", 
+       cmsOpenProfileFromFile("sRGB_Color_Space_Profile.icm", "r"),
+       cmsOpenProfileFromFile("aRGBlcms2.icc", "r"),
+        INTENT_ABSOLUTE_COLORIMETRIC);  
+
+    SpeedTest16bits("16 bits on Matrix-Shaper profiles", 
+       cmsOpenProfileFromFile("sRGB_Color_Space_Profile.icm", "r"),
+        cmsOpenProfileFromFile("aRGBlcms2.icc", "r"),
+        INTENT_PERCEPTUAL);
+
+    SpeedTest16bits("16 bits on SAME Matrix-Shaper profiles", 
+        cmsOpenProfileFromFile("aRGBlcms2.icc", "r"),
+        cmsOpenProfileFromFile("aRGBlcms2.icc", "r"),
+        INTENT_PERCEPTUAL);
+
+    SpeedTest16bits("16 bits on Matrix-Shaper profiles (AbsCol)", 
+       cmsOpenProfileFromFile("sRGB_Color_Space_Profile.icm", "r"),
+       cmsOpenProfileFromFile("aRGBlcms2.icc", "r"),
+        INTENT_ABSOLUTE_COLORIMETRIC);
 
     SpeedTest8bits("8 bits on curves", 
         CreateCurves(), 
         CreateCurves(),
-        INTENT_PERCEPTUAL);

+        INTENT_PERCEPTUAL);
 
     SpeedTest16bits("16 bits on curves", 
         CreateCurves(), 
-        CreateCurves(),

-        INTENT_PERCEPTUAL);

+        CreateCurves(),
+        INTENT_PERCEPTUAL);
 
     SpeedTest8bitsCMYK("8 bits on CMYK profiles", 
-        cmsOpenProfileFromFile("USWebCoatedSWOP.icc", "r"),

-        cmsOpenProfileFromFile("UncoatedFOGRA29.icc", "r"));

+        cmsOpenProfileFromFile("USWebCoatedSWOP.icc", "r"),
+        cmsOpenProfileFromFile("UncoatedFOGRA29.icc", "r"));
 
     SpeedTest16bitsCMYK("16 bits on CMYK profiles", 
-        cmsOpenProfileFromFile("USWebCoatedSWOP.icc", "r"),

-        cmsOpenProfileFromFile("UncoatedFOGRA29.icc", "r"));

+        cmsOpenProfileFromFile("USWebCoatedSWOP.icc", "r"),
+        cmsOpenProfileFromFile("UncoatedFOGRA29.icc", "r"));
+
+    SpeedTest8bitsGray("8 bits on gray-to-gray",
+        cmsOpenProfileFromFile("graylcms2.icc", "r"), 
+        cmsOpenProfileFromFile("glablcms2.icc", "r"), INTENT_RELATIVE_COLORIMETRIC);
 
-    SpeedTest8bitsGray("8 bits on gray-to-gray",

-        cmsOpenProfileFromFile("graylcms2.icc", "r"), 

-        cmsOpenProfileFromFile("glablcms2.icc", "r"), INTENT_RELATIVE_COLORIMETRIC);

-

-    SpeedTest8bitsGray("8 bits on SAME gray-to-gray",

-        cmsOpenProfileFromFile("graylcms2.icc", "r"), 

-        cmsOpenProfileFromFile("graylcms2.icc", "r"), INTENT_PERCEPTUAL);

+    SpeedTest8bitsGray("8 bits on SAME gray-to-gray",
+        cmsOpenProfileFromFile("graylcms2.icc", "r"), 
+        cmsOpenProfileFromFile("graylcms2.icc", "r"), INTENT_PERCEPTUAL);
 }
 
 
-// -----------------------------------------------------------------------------------------------------

-

+// -----------------------------------------------------------------------------------------------------
+
 
 // Print the supported intents
 static
@@ -6508,7 +6510,7 @@ static char ZOORawWrite[cmsMAX_PATH]  = "c:\\colormaps\\rawwrite\\";
 static
 void ReadAllTags(cmsHPROFILE h)
 {
-    cmsInt32Number i, n;

+    cmsInt32Number i, n;
     cmsTagSignature sig;
 
     n = cmsGetTagCount(h);
@@ -6524,9 +6526,9 @@ void ReadAllTags(cmsHPROFILE h)
 static
 void ReadAllRAWTags(cmsHPROFILE h)
 {
-    cmsInt32Number i, n;

+    cmsInt32Number i, n;
     cmsTagSignature sig;
-    cmsInt32Number len;

+    cmsInt32Number len;
 
     n = cmsGetTagCount(h);
     for (i=0; i < n; i++) {
@@ -6541,7 +6543,7 @@ static
 void PrintInfo(cmsHPROFILE h, cmsInfoType Info)
 {
     wchar_t* text;
-    cmsInt32Number len;

+    cmsInt32Number len;
     cmsContext id = DbgThread();
 
     len = cmsGetProfileInfo(h, Info, "en", "US", NULL, 0);
@@ -6614,13 +6616,13 @@ void ReadAllLUTS(cmsHPROFILE h)
     cmsDetectBlackPoint(&Black, h, INTENT_RELATIVE_COLORIMETRIC, 0);
     cmsDetectBlackPoint(&Black, h, INTENT_SATURATION, 0);
     cmsDetectBlackPoint(&Black, h, INTENT_ABSOLUTE_COLORIMETRIC, 0);
-    cmsDetectTAC(h);

+    cmsDetectTAC(h);
 }
 
 // Check one specimen in the ZOO
 
 static
-cmsInt32Number CheckSingleSpecimen(const char* Profile)

+cmsInt32Number CheckSingleSpecimen(const char* Profile)
 {
     char BuffSrc[256];
     char BuffDst[256];
@@ -6652,7 +6654,7 @@ cmsInt32Number CheckSingleSpecimen(const char* Profile)
 }
 
 static
-cmsInt32Number CheckRAWSpecimen(const char* Profile)

+cmsInt32Number CheckRAWSpecimen(const char* Profile)
 {
     char BuffSrc[256];
     char BuffDst[256];
@@ -6685,35 +6687,35 @@ void CheckProfileZOO(void)
     struct _finddata_t c_file;
     long hFile;
 
-    cmsSetLogErrorHandler(NULL);

+    cmsSetLogErrorHandler(NULL);
 
-    if ( (hFile = _findfirst("c:\\colormaps\\*.*", &c_file)) == -1L )

+    if ( (hFile = _findfirst("c:\\colormaps\\*.*", &c_file)) == -1L )
         printf("No files in current directory");
     else
     {
         do
         {
-

+
             printf("%s\n", c_file.name);
             if (strcmp(c_file.name, ".") != 0 &&
                 strcmp(c_file.name, "..") != 0) {
 
-                    CheckSingleSpecimen( c_file.name);

-                    CheckRAWSpecimen( c_file.name);

+                    CheckSingleSpecimen( c_file.name);
+                    CheckRAWSpecimen( c_file.name);
 
-                    if (TotalMemory > 0)

-                        printf("Ok, but %s are left!\n", MemStr(TotalMemory));

-                    else

-                        printf("Ok.\n");

+                    if (TotalMemory > 0)
+                        printf("Ok, but %s are left!\n", MemStr(TotalMemory));
+                    else
+                        printf("Ok.\n");
 
             }
 
         } while ( _findnext(hFile, &c_file) == 0 );
-

+
         _findclose(hFile);
     }
 
-    cmsSetLogErrorHandler(FatalErrorQuit);

+    cmsSetLogErrorHandler(FatalErrorQuit);
 }
 
 #endif
@@ -6722,8 +6724,8 @@ void CheckProfileZOO(void)
 
 int main(int argc, char* argv[])
 {
-    cmsInt32Number Exhaustive = 0;

-    cmsInt32Number DoSpeedTests = 1;

+    cmsInt32Number Exhaustive = 0;
+    cmsInt32Number DoSpeedTests = 1;
 
 
 #ifdef _MSC_VER
@@ -6738,14 +6740,14 @@ int main(int argc, char* argv[])
         printf("Running exhaustive tests (will take a while...)\n\n");
     }
 
-    

+    
     printf("Installing debug memory plug-in ... ");
     cmsPlugin(&DebugMemHandler);
     printf("done.\n");
 
     printf("Installing error logger ... ");
-    cmsSetLogErrorHandler(FatalErrorQuit);

-    printf("done.\n");

+    cmsSetLogErrorHandler(FatalErrorQuit);
+    printf("done.\n");
 
 #ifdef _CMS_IS_WINDOWS     
     // CheckProfileZOO();
@@ -6753,9 +6755,9 @@ int main(int argc, char* argv[])
 
     PrintSupportedIntents();
 
-    CheckRGBPrimaries();

-

-    // Create utility profiles

+    CheckRGBPrimaries();
+
+    // Create utility profiles
     Check("Creation of test profiles", CreateTestProfiles);    
 
     Check("Base types", CheckBaseTypes);
@@ -6799,17 +6801,17 @@ int main(int argc, char* argv[])
     Check("Reverse interpolation 3 -> 3", CheckReverseInterpolation3x3);
     Check("Reverse interpolation 4 -> 3", CheckReverseInterpolation4x3);
   
-    // Encoding of colorspaces

+    // Encoding of colorspaces
     Check("Lab to LCh and back (float only) ", CheckLab2LCh);
     Check("Lab to XYZ and back (float only) ", CheckLab2XYZ);
-    Check("Lab to xyY and back (float only) ", CheckLab2xyY);

+    Check("Lab to xyY and back (float only) ", CheckLab2xyY);
     Check("Lab V2 encoding", CheckLabV2encoding);
     Check("Lab V4 encoding", CheckLabV4encoding);
 
-    // BlackBody

+    // BlackBody
     Check("Blackbody radiator", CheckTemp2CHRM);
     
-    // Tone curves

+    // Tone curves
     Check("Linear gamma curves (16 bits)", CheckGammaCreation16);
     Check("Linear gamma curves (float)", CheckGammaCreationFlt);
 
@@ -6821,7 +6823,7 @@ int main(int argc, char* argv[])
     Check("Curve 2.2 (table)", CheckGamma22Table);
     Check("Curve 3.0 (table)", CheckGamma30Table);
 
-    Check("Curve 1.8 (word table)", CheckGamma18TableWord);

+    Check("Curve 1.8 (word table)", CheckGamma18TableWord);
     Check("Curve 2.2 (word table)", CheckGamma22TableWord);
     Check("Curve 3.0 (word table)", CheckGamma30TableWord);
 
@@ -6834,7 +6836,7 @@ int main(int argc, char* argv[])
     Check("Join curves sRGB (16 bits)", CheckJoint16Curves_sRGB);
     Check("Join curves sigmoidal", CheckJointCurvesSShaped);
         
-    // LUT basics

+    // LUT basics
     Check("LUT creation & dup", CheckLUTcreation);
     Check("1 Stage LUT ", Check1StageLUT);
     Check("2 Stage LUT ", Check2StageLUT);
@@ -6859,14 +6861,14 @@ int main(int argc, char* argv[])
     // MLU    
     Check("Multilocalized Unicode", CheckMLU);
     
-    // Named color

-    Check("Named color lists", CheckNamedColorList);

+    // Named color
+    Check("Named color lists", CheckNamedColorList);
     
-    // Profile I/O (this one is huge!)

+    // Profile I/O (this one is huge!)
     Check("Profile creation", CheckProfileCreation);
 
-    

-    // Error reporting

+    
+    // Error reporting
     Check("Error reporting on bad profiles", CheckErrReportingOnBadProfiles);
     
     // Transforms
@@ -6880,13 +6882,13 @@ int main(int argc, char* argv[])
     Check("Matrix-shaper transform (8 bits)",  CheckMatrixShaperXFORM8);
 
 
-    Check("Primaries of sRGB", CheckRGBPrimaries);

-    // Known values

+    Check("Primaries of sRGB", CheckRGBPrimaries);
+    // Known values
     Check("Known values across matrix-shaper", Chack_sRGB_Float);
     Check("Gray input profile", CheckInputGray);
-    Check("Gray Lab input profile", CheckLabInputGray);

-    Check("Gray output profile", CheckOutputGray);

-    Check("Gray Lab output profile", CheckLabOutputGray);

+    Check("Gray Lab input profile", CheckLabInputGray);
+    Check("Gray output profile", CheckOutputGray);
+    Check("Gray Lab output profile", CheckLabOutputGray);
 
     Check("Matrix-shaper proofing transform (float)",   CheckProofingXFORMFloat);
     Check("Matrix-shaper proofing transform (16 bits)",  CheckProofingXFORM16);
@@ -6912,15 +6914,15 @@ int main(int argc, char* argv[])
     Check("Segment maxima GBD", CheckGBD);
 
 
-    if (DoSpeedTests)

-        SpeedTest();

-    

+    if (DoSpeedTests)
+        SpeedTest();
+    
     DebugMemPrintTotals();
 
-    cmsUnregisterPlugins();

+    cmsUnregisterPlugins();
 
     // Cleanup
-    RemoveTestProfiles();

+    RemoveTestProfiles();
     
     return TotalFail;
 }