rfreeimage 0.1.0

data/vendor/FreeImage/Source/OpenEXR/Half/halfExport.h

@@ -0,0 +1,27 @@
+#ifndef HALFEXPORT_H
+#define HALFEXPORT_H
+
+//
+//  Copyright (c) 2008 Lucasfilm Entertainment Company Ltd.
+//  All rights reserved.   Used under authorization.
+//  This material contains the confidential and proprietary
+//  information of Lucasfilm Entertainment Company and
+//  may not be copied in whole or in part without the express
+//  written permission of Lucasfilm Entertainment Company.
+//  This copyright notice does not imply publication.
+//
+
+#if defined(OPENEXR_DLL)
+    #if defined(HALF_EXPORTS)
+    #define HALF_EXPORT __declspec(dllexport)
+    #else
+    #define HALF_EXPORT __declspec(dllimport)
+    #endif
+    #define HALF_EXPORT_CONST
+#else
+    #define HALF_EXPORT
+    #define HALF_EXPORT_CONST const
+#endif
+
+#endif // #ifndef HALFEXPORT_H
+

data/vendor/FreeImage/Source/OpenEXR/Half/halfFunction.h

@@ -0,0 +1,179 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
+// Digital Ltd. LLC
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// *       Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// *       Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// *       Neither the name of Industrial Light & Magic nor the names of
+// its contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////
+
+// Primary authors:
+//     Florian Kainz <kainz@ilm.com>
+//     Rod Bogart <rgb@ilm.com>
+
+
+//---------------------------------------------------------------------------
+//
+//	halfFunction<T> -- a class for fast evaluation
+//			   of half --> T functions
+//
+//	The constructor for a halfFunction object,
+//
+//	    halfFunction (function,
+//			  domainMin, domainMax,
+//			  defaultValue,
+//			  posInfValue, negInfValue,
+//			  nanValue);
+//
+//	evaluates the function for all finite half values in the interval
+//	[domainMin, domainMax], and stores the results in a lookup table.
+//	For finite half values that are not in [domainMin, domainMax], the
+//	constructor stores defaultValue in the table.  For positive infinity,
+//	negative infinity and NANs, posInfValue, negInfValue and nanValue
+//	are stored in the table.
+//
+//	The tabulated function can then be evaluated quickly for arbitrary
+//	half values by calling the the halfFunction object's operator()
+//	method.
+//
+//	Example:
+//
+//	    #include <math.h>
+//	    #include <halfFunction.h>
+//
+//	    halfFunction<half> hsin (sin);
+//
+//	    halfFunction<half> hsqrt (sqrt,		// function
+//				      0, HALF_MAX,	// domain
+//				      half::qNan(),	// sqrt(x) for x < 0
+//				      half::posInf(),	// sqrt(+inf)
+//				      half::qNan(),	// sqrt(-inf)
+//				      half::qNan());	// sqrt(nan)
+//
+//	    half x = hsin (1);
+//	    half y = hsqrt (3.5);
+//
+//---------------------------------------------------------------------------
+
+#ifndef _HALF_FUNCTION_H_
+#define _HALF_FUNCTION_H_
+
+#include "half.h"
+
+#include "IlmBaseConfig.h"
+#ifndef ILMBASE_HAVE_LARGE_STACK  
+#include <string.h>     // need this for memset
+#else 
+#endif
+
+#include <float.h>
+
+
+template <class T>
+class halfFunction
+{
+  public:
+
+    //------------
+    // Constructor
+    //------------
+
+    template <class Function>
+    halfFunction (Function f,
+		  half domainMin = -HALF_MAX,
+		  half domainMax =  HALF_MAX,
+		  T defaultValue = 0,
+		  T posInfValue  = 0,
+		  T negInfValue  = 0,
+		  T nanValue     = 0);
+
+#ifndef ILMBASE_HAVE_LARGE_STACK
+    ~halfFunction () { delete [] _lut; }    
+#endif
+    
+    //-----------
+    // Evaluation
+    //-----------
+
+    T		operator () (half x) const;
+
+  private:
+
+#ifdef ILMBASE_HAVE_LARGE_STACK
+    T		_lut[1 << 16];
+#else
+    T *         _lut;
+#endif
+};
+
+
+//---------------
+// Implementation
+//---------------
+
+template <class T>
+template <class Function>
+halfFunction<T>::halfFunction (Function f,
+			       half domainMin,
+			       half domainMax,
+			       T defaultValue,
+			       T posInfValue,
+			       T negInfValue,
+			       T nanValue)
+{
+#ifndef ILMBASE_HAVE_LARGE_STACK
+    _lut = new T[1<<16];
+    memset (_lut, 0 , (1<<16) * sizeof(T));
+#endif
+    
+    for (int i = 0; i < (1 << 16); i++)
+    {
+	half x;
+	x.setBits (i);
+
+	if (x.isNan())
+	    _lut[i] = nanValue;
+	else if (x.isInfinity())
+	    _lut[i] = x.isNegative()? negInfValue: posInfValue;
+	else if (x < domainMin || x > domainMax)
+	    _lut[i] = defaultValue;
+	else
+	    _lut[i] = f (x);
+    }
+}
+
+
+template <class T>
+inline T
+halfFunction<T>::operator () (half x) const
+{
+    return _lut[x.bits()];
+}
+
+
+#endif

data/vendor/FreeImage/Source/OpenEXR/Half/halfLimits.h

@@ -0,0 +1,102 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
+// Digital Ltd. LLC
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// *       Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// *       Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// *       Neither the name of Industrial Light & Magic nor the names of
+// its contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+// Primary authors:
+//     Florian Kainz <kainz@ilm.com>
+//     Rod Bogart <rgb@ilm.com>
+
+
+#ifndef INCLUDED_HALF_LIMITS_H
+#define INCLUDED_HALF_LIMITS_H
+
+
+//------------------------------------------------------------------------
+//
+//	C++ standard library-style numeric_limits for class half
+//
+//------------------------------------------------------------------------
+
+#include <limits>
+#include "half.h"
+
+namespace std {
+
+template <>
+class numeric_limits <half>
+{
+  public:
+
+    static const bool is_specialized = true;
+
+    static half min () throw () {return HALF_NRM_MIN;}
+    static half max () throw () {return HALF_MAX;}
+
+    static const int digits = HALF_MANT_DIG;
+    static const int digits10 = HALF_DIG;
+    static const bool is_signed = true;
+    static const bool is_integer = false;
+    static const bool is_exact = false;
+    static const int radix = HALF_RADIX;
+    static half epsilon () throw () {return HALF_EPSILON;}
+    static half round_error () throw () {return HALF_EPSILON / 2;}
+
+    static const int min_exponent = HALF_MIN_EXP;
+    static const int min_exponent10 = HALF_MIN_10_EXP;
+    static const int max_exponent = HALF_MAX_EXP;
+    static const int max_exponent10 = HALF_MAX_10_EXP;
+
+    static const bool has_infinity = true;
+    static const bool has_quiet_NaN = true;
+    static const bool has_signaling_NaN = true;
+    static const float_denorm_style has_denorm = denorm_present;
+    static const bool has_denorm_loss = false;
+    static half infinity () throw () {return half::posInf();}
+    static half quiet_NaN () throw () {return half::qNan();}
+    static half signaling_NaN () throw () {return half::sNan();}
+    static half denorm_min () throw () {return HALF_MIN;}
+
+    static const bool is_iec559 = false;
+    static const bool is_bounded = false;
+    static const bool is_modulo = false;
+
+    static const bool traps = true;
+    static const bool tinyness_before = false;
+    static const float_round_style round_style = round_to_nearest;
+};
+
+
+} // namespace std
+
+#endif

data/vendor/FreeImage/Source/OpenEXR/Half/toFloat.cpp

@@ -0,0 +1,164 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
+// Digital Ltd. LLC
+// 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// *       Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// *       Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// *       Neither the name of Industrial Light & Magic nor the names of
+// its contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission. 
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+
+
+//---------------------------------------------------------------------------
+//
+//	toFloat
+//
+//	A program to generate the lookup table for half-to-float
+//	conversion needed by class half.
+//	The program loops over all 65536 possible half numbers,
+//	converts each of them to a float, and prints the result.
+//
+//---------------------------------------------------------------------------
+
+
+#include <iostream>
+#include <iomanip>
+
+using namespace std;
+
+//---------------------------------------------------
+// Interpret an unsigned short bit pattern as a half,
+// and convert that half to the corresponding float's
+// bit pattern.
+//---------------------------------------------------
+
+unsigned int
+halfToFloat (unsigned short y)
+{
+
+    int s = (y >> 15) & 0x00000001;
+    int e = (y >> 10) & 0x0000001f;
+    int m =  y        & 0x000003ff;
+
+    if (e == 0)
+    {
+	if (m == 0)
+	{
+	    //
+	    // Plus or minus zero
+	    //
+
+	    return s << 31;
+	}
+	else
+	{
+	    //
+	    // Denormalized number -- renormalize it
+	    //
+
+	    while (!(m & 0x00000400))
+	    {
+		m <<= 1;
+		e -=  1;
+	    }
+
+	    e += 1;
+	    m &= ~0x00000400;
+	}
+    }
+    else if (e == 31)
+    {
+	if (m == 0)
+	{
+	    //
+	    // Positive or negative infinity
+	    //
+
+	    return (s << 31) | 0x7f800000;
+	}
+	else
+	{
+	    //
+	    // Nan -- preserve sign and significand bits
+	    //
+
+	    return (s << 31) | 0x7f800000 | (m << 13);
+	}
+    }
+
+    //
+    // Normalized number
+    //
+
+    e = e + (127 - 15);
+    m = m << 13;
+
+    //
+    // Assemble s, e and m.
+    //
+
+    return (s << 31) | (e << 23) | m;
+}
+
+
+//---------------------------------------------
+// Main - prints the half-to-float lookup table
+//---------------------------------------------
+
+int
+main ()
+{
+    cout.precision (9);
+    cout.setf (ios_base::hex, ios_base::basefield);
+
+    cout << "//\n"
+	    "// This is an automatically generated file.\n"
+	    "// Do not edit.\n"
+	    "//\n\n";
+
+    cout << "{\n    ";
+
+    const int iMax = (1 << 16);
+
+    for (int i = 0; i < iMax; i++)
+    {
+	cout << "{0x" << setfill ('0') << setw (8) << halfToFloat (i) << "}, ";
+
+	if (i % 4 == 3)
+	{
+	    cout << "\n";
+
+	    if (i < iMax - 1)
+		cout << "    ";
+	}
+    }
+
+    cout << "};\n";
+    return 0;
+}