Removed the libs directory containing win32 compiled versions of libpng, libtiff and liblcms. Added a thirdparty directory to include main source files of libtiff, libpng, libz and liblcms to enable support of these formats in the codec executables. CMake will try to statically build these libraries if they are not found on the system. Note that these third party libraries are not required to build libopenjpeg (which has no dependencies).

1 files changed, 351 insertions, 0 deletions

diff --git a/thirdparty/liblcms2/src/cmswtpnt.c b/thirdparty/liblcms2/src/cmswtpnt.c
new file mode 100644
index 00000000..6319984c
--- /dev/null
+++ b/thirdparty/liblcms2/src/cmswtpnt.c
@@ -0,0 +1,351 @@
+//---------------------------------------------------------------------------------
+//
+//  Little Color Management System
+//  Copyright (c) 1998-2010 Marti Maria Saguer
+//
+// Permission is hereby granted, free of charge, to any person obtaining 
+// a copy of this software and associated documentation files (the "Software"), 
+// to deal in the Software without restriction, including without limitation 
+// the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+// and/or sell copies of the Software, and to permit persons to whom the Software 
+// is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in 
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO 
+// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+//---------------------------------------------------------------------------------
+//
+
+#include "lcms2_internal.h"
+
+
+// D50 - Widely used
+const cmsCIEXYZ* CMSEXPORT cmsD50_XYZ(void)
+{
+    static cmsCIEXYZ D50XYZ = {cmsD50X, cmsD50Y, cmsD50Z};
+
+    return &D50XYZ;
+}
+
+const cmsCIExyY* CMSEXPORT cmsD50_xyY(void)
+{
+    static cmsCIExyY D50xyY;
+
+    cmsXYZ2xyY(&D50xyY, cmsD50_XYZ());
+
+    return &D50xyY;
+}
+
+// Obtains WhitePoint from Temperature
+cmsBool  CMSEXPORT cmsWhitePointFromTemp(cmsCIExyY* WhitePoint, cmsFloat64Number TempK)
+{
+       cmsFloat64Number x, y;
+       cmsFloat64Number T, T2, T3;
+       // cmsFloat64Number M1, M2;
+
+	   _cmsAssert(WhitePoint != NULL);
+
+       T = TempK;
+       T2 = T*T;            // Square
+       T3 = T2*T;           // Cube
+
+       // For correlated color temperature (T) between 4000K and 7000K:
+
+       if (T >= 4000. && T <= 7000.)
+       {
+              x = -4.6070*(1E9/T3) + 2.9678*(1E6/T2) + 0.09911*(1E3/T) + 0.244063;
+       }
+       else
+              // or for correlated color temperature (T) between 7000K and 25000K:
+
+       if (T > 7000.0 && T <= 25000.0)
+       {
+              x = -2.0064*(1E9/T3) + 1.9018*(1E6/T2) + 0.24748*(1E3/T) + 0.237040;
+       }
+       else {
+              cmsSignalError(0, cmsERROR_RANGE, "cmsWhitePointFromTemp: invalid temp");
+              return FALSE;
+              }
+
+       // Obtain y(x)
+
+       y = -3.000*(x*x) + 2.870*x - 0.275;
+
+       // wave factors (not used, but here for futures extensions)
+
+       // M1 = (-1.3515 - 1.7703*x + 5.9114 *y)/(0.0241 + 0.2562*x - 0.7341*y);
+       // M2 = (0.0300 - 31.4424*x + 30.0717*y)/(0.0241 + 0.2562*x - 0.7341*y);
+
+       WhitePoint -> x = x;
+       WhitePoint -> y = y;
+       WhitePoint -> Y = 1.0;
+
+       return TRUE;
+}
+
+
+
+typedef struct {
+
+    cmsFloat64Number mirek;  // temp (in microreciprocal kelvin) 
+    cmsFloat64Number ut;     // u coord of intersection w/ blackbody locus  
+    cmsFloat64Number vt;     // v coord of intersection w/ blackbody locus 
+    cmsFloat64Number tt;     // slope of ISOTEMPERATURE. line 
+
+    } ISOTEMPERATURE;
+
+static ISOTEMPERATURE isotempdata[] = {
+//  {Mirek, Ut,       Vt,      Tt      } 
+    {0,     0.18006,  0.26352,  -0.24341},
+    {10,    0.18066,  0.26589,  -0.25479},
+    {20,    0.18133,  0.26846,  -0.26876},
+    {30,    0.18208,  0.27119,  -0.28539},
+    {40,    0.18293,  0.27407,  -0.30470},
+    {50,    0.18388,  0.27709,  -0.32675},
+    {60,    0.18494,  0.28021,  -0.35156},
+    {70,    0.18611,  0.28342,  -0.37915},
+    {80,    0.18740,  0.28668,  -0.40955},
+    {90,    0.18880,  0.28997,  -0.44278},
+    {100,   0.19032,  0.29326,  -0.47888},
+    {125,   0.19462,  0.30141,  -0.58204},
+    {150,   0.19962,  0.30921,  -0.70471},
+    {175,   0.20525,  0.31647,  -0.84901},
+    {200,   0.21142,  0.32312,  -1.0182 },
+    {225,   0.21807,  0.32909,  -1.2168 },
+    {250,   0.22511,  0.33439,  -1.4512 },
+    {275,   0.23247,  0.33904,  -1.7298 },
+    {300,   0.24010,  0.34308,  -2.0637 },
+    {325,   0.24702,  0.34655,  -2.4681 },
+    {350,   0.25591,  0.34951,  -2.9641 },
+    {375,   0.26400,  0.35200,  -3.5814 },
+    {400,   0.27218,  0.35407,  -4.3633 },
+    {425,   0.28039,  0.35577,  -5.3762 },
+    {450,   0.28863,  0.35714,  -6.7262 },
+    {475,   0.29685,  0.35823,  -8.5955 },
+    {500,   0.30505,  0.35907,  -11.324 },
+    {525,   0.31320,  0.35968,  -15.628 },
+    {550,   0.32129,  0.36011,  -23.325 },
+    {575,   0.32931,  0.36038,  -40.770 },
+    {600,   0.33724,  0.36051,  -116.45  }
+};
+
+#define NISO sizeof(isotempdata)/sizeof(ISOTEMPERATURE)
+
+
+// Robertson's method
+cmsBool  CMSEXPORT cmsTempFromWhitePoint(cmsFloat64Number* TempK, const cmsCIExyY* WhitePoint)
+{
+	int j;
+	cmsFloat64Number us,vs;
+	cmsFloat64Number uj,vj,tj,di,dj,mi,mj;
+	cmsFloat64Number xs, ys;
+
+	_cmsAssert(WhitePoint != NULL);
+    _cmsAssert(TempK != NULL);
+
+	di = mi = 0;
+	xs = WhitePoint -> x;
+	ys = WhitePoint -> y;
+
+	// convert (x,y) to CIE 1960 (u,WhitePoint) 
+
+	us = (2*xs) / (-xs + 6*ys + 1.5);
+	vs = (3*ys) / (-xs + 6*ys + 1.5);
+
+
+	for (j=0; j < NISO; j++) {
+
+		uj = isotempdata[j].ut;
+		vj = isotempdata[j].vt;
+		tj = isotempdata[j].tt;
+		mj = isotempdata[j].mirek;
+
+		dj = ((vs - vj) - tj * (us - uj)) / sqrt(1.0 + tj * tj);
+
+		if ((j != 0) && (di/dj < 0.0)) {
+
+			// Found a match
+			*TempK = 1000000.0 / (mi + (di / (di - dj)) * (mj - mi));
+			return TRUE;
+		}
+
+		di = dj;
+		mi = mj;
+	}
+
+	// Not found
+	return FALSE;
+}
+
+
+// Compute chromatic adaptation matrix using Chad as cone matrix 
+
+static
+cmsBool ComputeChromaticAdaptation(cmsMAT3* Conversion,
+                                const cmsCIEXYZ* SourceWhitePoint,
+                                const cmsCIEXYZ* DestWhitePoint,
+                                const cmsMAT3* Chad)
+
+{
+      
+    cmsMAT3 Chad_Inv;
+    cmsVEC3 ConeSourceXYZ, ConeSourceRGB;
+    cmsVEC3 ConeDestXYZ, ConeDestRGB;
+    cmsMAT3 Cone, Tmp;
+
+
+    Tmp = *Chad;
+    if (!_cmsMAT3inverse(&Tmp, &Chad_Inv)) return FALSE;
+
+    _cmsVEC3init(&ConeSourceXYZ, SourceWhitePoint -> X,
+                             SourceWhitePoint -> Y,
+                             SourceWhitePoint -> Z);
+
+    _cmsVEC3init(&ConeDestXYZ,   DestWhitePoint -> X,
+                             DestWhitePoint -> Y,
+                             DestWhitePoint -> Z);
+
+    _cmsMAT3eval(&ConeSourceRGB, Chad, &ConeSourceXYZ);
+    _cmsMAT3eval(&ConeDestRGB,   Chad, &ConeDestXYZ);
+
+    // Build matrix
+    _cmsVEC3init(&Cone.v[0], ConeDestRGB.n[0]/ConeSourceRGB.n[0],    0.0,  0.0);
+    _cmsVEC3init(&Cone.v[1], 0.0,   ConeDestRGB.n[1]/ConeSourceRGB.n[1],   0.0);
+    _cmsVEC3init(&Cone.v[2], 0.0,   0.0,   ConeDestRGB.n[2]/ConeSourceRGB.n[2]);
+
+
+    // Normalize
+    _cmsMAT3per(&Tmp, &Cone, Chad);
+    _cmsMAT3per(Conversion, &Chad_Inv, &Tmp);
+
+	return TRUE;
+}
+
+// Returns the final chrmatic adaptation from illuminant FromIll to Illuminant ToIll
+// The cone matrix can be specified in ConeMatrix. If NULL, Bradford is assumed
+cmsBool  _cmsAdaptationMatrix(cmsMAT3* r, const cmsMAT3* ConeMatrix, const cmsCIEXYZ* FromIll, const cmsCIEXYZ* ToIll)
+{
+	cmsMAT3 LamRigg   = {{ // Bradford matrix
+		{{  0.8951,  0.2664, -0.1614 }},
+		{{ -0.7502,  1.7135,  0.0367 }},
+		{{  0.0389, -0.0685,  1.0296 }}
+	}};
+
+	if (ConeMatrix == NULL)
+		ConeMatrix = &LamRigg;
+
+	return ComputeChromaticAdaptation(r, FromIll, ToIll, ConeMatrix);	
+}
+
+// Same as anterior, but assuming D50 destination. White point is given in xyY
+static
+cmsBool _cmsAdaptMatrixToD50(cmsMAT3* r, const cmsCIExyY* SourceWhitePt)
+{
+	cmsCIEXYZ Dn;      
+	cmsMAT3 Bradford;
+	cmsMAT3 Tmp;
+
+	cmsxyY2XYZ(&Dn, SourceWhitePt);
+
+	if (!_cmsAdaptationMatrix(&Bradford, NULL, &Dn, cmsD50_XYZ())) return FALSE;
+
+	Tmp = *r;
+	_cmsMAT3per(r, &Bradford, &Tmp);
+
+	return TRUE;
+}
+
+// Build a White point, primary chromas transfer matrix from RGB to CIE XYZ
+// This is just an approximation, I am not handling all the non-linear
+// aspects of the RGB to XYZ process, and assumming that the gamma correction
+// has transitive property in the tranformation chain.
+//
+// the alghoritm:
+//
+//            - First I build the absolute conversion matrix using
+//              primaries in XYZ. This matrix is next inverted
+//            - Then I eval the source white point across this matrix
+//              obtaining the coeficients of the transformation
+//            - Then, I apply these coeficients to the original matrix
+//
+cmsBool _cmsBuildRGB2XYZtransferMatrix(cmsMAT3* r, const cmsCIExyY* WhitePt, const cmsCIExyYTRIPLE* Primrs)
+{
+	cmsVEC3 WhitePoint, Coef;
+	cmsMAT3 Result, Primaries;
+	cmsFloat64Number xn, yn;
+	cmsFloat64Number xr, yr;
+	cmsFloat64Number xg, yg;
+	cmsFloat64Number xb, yb;
+
+	xn = WhitePt -> x;
+	yn = WhitePt -> y;
+	xr = Primrs -> Red.x;
+	yr = Primrs -> Red.y;
+	xg = Primrs -> Green.x;
+	yg = Primrs -> Green.y;
+	xb = Primrs -> Blue.x;
+	yb = Primrs -> Blue.y;
+
+	// Build Primaries matrix
+	_cmsVEC3init(&Primaries.v[0], xr,        xg,         xb);
+	_cmsVEC3init(&Primaries.v[1], yr,        yg,         yb);
+	_cmsVEC3init(&Primaries.v[2], (1-xr-yr), (1-xg-yg),  (1-xb-yb));
+
+
+	// Result = Primaries ^ (-1) inverse matrix
+	if (!_cmsMAT3inverse(&Primaries, &Result))
+		return FALSE;
+
+
+	_cmsVEC3init(&WhitePoint, xn/yn, 1.0, (1.0-xn-yn)/yn);
+
+	// Across inverse primaries ...
+	_cmsMAT3eval(&Coef, &Result, &WhitePoint);
+
+	// Give us the Coefs, then I build transformation matrix
+	_cmsVEC3init(&r -> v[0], Coef.n[VX]*xr,          Coef.n[VY]*xg,          Coef.n[VZ]*xb);
+	_cmsVEC3init(&r -> v[1], Coef.n[VX]*yr,          Coef.n[VY]*yg,          Coef.n[VZ]*yb);
+	_cmsVEC3init(&r -> v[2], Coef.n[VX]*(1.0-xr-yr), Coef.n[VY]*(1.0-xg-yg), Coef.n[VZ]*(1.0-xb-yb));
+
+
+	return _cmsAdaptMatrixToD50(r, WhitePt);
+	
+}
+
+
+// Adapts a color to a given illuminant. Original color is expected to have
+// a SourceWhitePt white point. 
+cmsBool CMSEXPORT cmsAdaptToIlluminant(cmsCIEXYZ* Result, 
+							 const cmsCIEXYZ* SourceWhitePt, 
+							 const cmsCIEXYZ* Illuminant, 
+							 const cmsCIEXYZ* Value)
+{
+	cmsMAT3 Bradford;
+	cmsVEC3 In, Out;
+
+	_cmsAssert(Result != NULL);
+	_cmsAssert(SourceWhitePt != NULL);
+	_cmsAssert(Illuminant != NULL);
+	_cmsAssert(Value != NULL);
+
+	if (!_cmsAdaptationMatrix(&Bradford, NULL, SourceWhitePt, Illuminant)) return FALSE;
+
+	_cmsVEC3init(&In, Value -> X, Value -> Y, Value -> Z);
+	_cmsMAT3eval(&Out, &Bradford, &In);
+
+	Result -> X = Out.n[0];
+	Result -> Y = Out.n[1];
+	Result -> Z = Out.n[2];
+
+	return TRUE;
+}
+
+