--- /dev/null
+///////////////////////////////////////////////////////////////////////////
+//
+// 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>
+
+//---------------------------------------------------------------------------
+//
+// half -- a 16-bit floating point number class:
+//
+// Type half can represent positive and negative numbers, whose
+// magnitude is between roughly 6.1e-5 and 6.5e+4, with a relative
+// error of 9.8e-4; numbers smaller than 6.1e-5 can be represented
+// with an absolute error of 6.0e-8. All integers from -2048 to
+// +2048 can be represented exactly.
+//
+// Type half behaves (almost) like the built-in C++ floating point
+// types. In arithmetic expressions, half, float and double can be
+// mixed freely. Here are a few examples:
+//
+// half a (3.5);
+// float b (a + sqrt (a));
+// a += b;
+// b += a;
+// b = a + 7;
+//
+// Conversions from half to float are lossless; all half numbers
+// are exactly representable as floats.
+//
+// Conversions from float to half may not preserve the float's
+// value exactly. If a float is not representable as a half, the
+// float value is rounded to the nearest representable half. If
+// a float value is exactly in the middle between the two closest
+// representable half values, then the float value is rounded to
+// the half with the greater magnitude.
+//
+// Overflows during float-to-half conversions cause arithmetic
+// exceptions. An overflow occurs when the float value to be
+// converted is too large to be represented as a half, or if the
+// float value is an infinity or a NAN.
+//
+// The implementation of type half makes the following assumptions
+// about the implementation of the built-in C++ types:
+//
+// float is an IEEE 754 single-precision number
+// sizeof (float) == 4
+// sizeof (unsigned int) == sizeof (float)
+// alignof (unsigned int) == alignof (float)
+// sizeof (unsigned short) == 2
+//
+//---------------------------------------------------------------------------
+
+#ifndef _HALF_H_
+#define _HALF_H_
+
+#include <iostream>
+
+class half
+{
+ public:
+
+ //-------------
+ // Constructors
+ //-------------
+
+ half (); // no initialization
+ half (float f);
+
+
+ //--------------------
+ // Conversion to float
+ //--------------------
+
+ operator float () const;
+
+
+ //------------
+ // Unary minus
+ //------------
+
+ half operator - () const;
+
+
+ //-----------
+ // Assignment
+ //-----------
+
+ half & operator = (half h);
+ half & operator = (float f);
+
+ half & operator += (half h);
+ half & operator += (float f);
+
+ half & operator -= (half h);
+ half & operator -= (float f);
+
+ half & operator *= (half h);
+ half & operator *= (float f);
+
+ half & operator /= (half h);
+ half & operator /= (float f);
+
+
+ //---------------------------------------------------------
+ // Round to n-bit precision (n should be between 0 and 10).
+ // After rounding, the significand's 10-n least significant
+ // bits will be zero.
+ //---------------------------------------------------------
+
+ half round (unsigned int n) const;
+
+
+ //--------------------------------------------------------------------
+ // Classification:
+ //
+ // h.isFinite() returns true if h is a normalized number,
+ // a denormalized number or zero
+ //
+ // h.isNormalized() returns true if h is a normalized number
+ //
+ // h.isDenormalized() returns true if h is a denormalized number
+ //
+ // h.isZero() returns true if h is zero
+ //
+ // h.isNan() returns true if h is a NAN
+ //
+ // h.isInfinity() returns true if h is a positive
+ // or a negative infinity
+ //
+ // h.isNegative() returns true if the sign bit of h
+ // is set (negative)
+ //--------------------------------------------------------------------
+
+ bool isFinite () const;
+ bool isNormalized () const;
+ bool isDenormalized () const;
+ bool isZero () const;
+ bool isNan () const;
+ bool isInfinity () const;
+ bool isNegative () const;
+
+
+ //--------------------------------------------
+ // Special values
+ //
+ // posInf() returns +infinity
+ //
+ // negInf() returns +infinity
+ //
+ // qNan() returns a NAN with the bit
+ // pattern 0111111111111111
+ //
+ // sNan() returns a NAN with the bit
+ // pattern 0111110111111111
+ //--------------------------------------------
+
+ static half posInf ();
+ static half negInf ();
+ static half qNan ();
+ static half sNan ();
+
+
+ //--------------------------------------
+ // Access to the internal representation
+ //--------------------------------------
+
+ unsigned short bits () const;
+ void setBits (unsigned short bits);
+
+
+ public:
+
+ union uif
+ {
+ unsigned int i;
+ float f;
+ };
+
+ private:
+
+ static short convert (int i);
+ static float overflow ();
+
+ unsigned short _h;
+
+ //---------------------------------------------------
+ // Windows dynamic libraries don't like static
+ // member variables.
+ //---------------------------------------------------
+#ifndef OPENEXR_DLL
+ static const uif _toFloat[1 << 16];
+ static const unsigned short _eLut[1 << 9];
+#endif
+};
+
+#if defined(OPENEXR_DLL)
+ //--------------------------------------
+ // Lookup tables defined for Windows DLL
+ //--------------------------------------
+ #if defined(HALF_EXPORTS)
+ extern __declspec(dllexport) half::uif _toFloat[1 << 16];
+ extern __declspec(dllexport) unsigned short _eLut[1 << 9];
+ #else
+ extern __declspec(dllimport) half::uif _toFloat[1 << 16];
+ extern __declspec(dllimport) unsigned short _eLut[1 << 9];
+ #endif
+#endif
+
+
+//-----------
+// Stream I/O
+//-----------
+
+std::ostream & operator << (std::ostream &os, half h);
+std::istream & operator >> (std::istream &is, half &h);
+
+
+//----------
+// Debugging
+//----------
+
+void printBits (std::ostream &os, half h);
+void printBits (std::ostream &os, float f);
+void printBits (char c[19], half h);
+void printBits (char c[35], float f);
+
+
+//-------------------------------------------------------------------------
+// Limits
+//
+// Visual C++ will complain if HALF_MIN, HALF_NRM_MIN etc. are not float
+// constants, but at least one other compiler (gcc 2.96) produces incorrect
+// results if they are.
+//-------------------------------------------------------------------------
+
+#if (defined _WIN32 || defined _WIN64) && defined _MSC_VER
+
+#define HALF_MIN 5.96046448e-08f // Smallest positive half
+
+#define HALF_NRM_MIN 6.10351562e-05f // Smallest positive normalized half
+
+#define HALF_MAX 65504.0f // Largest positive half
+
+#define HALF_EPSILON 0.00097656f // Smallest positive e for which
+ // half (1.0 + e) != half (1.0)
+#else
+
+#define HALF_MIN 5.96046448e-08 // Smallest positive half
+
+#define HALF_NRM_MIN 6.10351562e-05 // Smallest positive normalized half
+
+#define HALF_MAX 65504.0 // Largest positive half
+
+#define HALF_EPSILON 0.00097656 // Smallest positive e for which
+ // half (1.0 + e) != half (1.0)
+#endif
+
+
+#define HALF_MANT_DIG 11 // Number of digits in mantissa
+ // (significand + hidden leading 1)
+
+#define HALF_DIG 2 // Number of base 10 digits that
+ // can be represented without change
+
+#define HALF_RADIX 2 // Base of the exponent
+
+#define HALF_MIN_EXP -13 // Minimum negative integer such that
+ // HALF_RADIX raised to the power of
+ // one less than that integer is a
+ // normalized half
+
+#define HALF_MAX_EXP 16 // Maximum positive integer such that
+ // HALF_RADIX raised to the power of
+ // one less than that integer is a
+ // normalized half
+
+#define HALF_MIN_10_EXP -4 // Minimum positive integer such
+ // that 10 raised to that power is
+ // a normalized half
+
+#define HALF_MAX_10_EXP 4 // Maximum positive integer such
+ // that 10 raised to that power is
+ // a normalized half
+
+
+//---------------------------------------------------------------------------
+//
+// Implementation --
+//
+// Representation of a float:
+//
+// We assume that a float, f, is an IEEE 754 single-precision
+// floating point number, whose bits are arranged as follows:
+//
+// 31 (msb)
+// |
+// | 30 23
+// | | |
+// | | | 22 0 (lsb)
+// | | | | |
+// X XXXXXXXX XXXXXXXXXXXXXXXXXXXXXXX
+//
+// s e m
+//
+// S is the sign-bit, e is the exponent and m is the significand.
+//
+// If e is between 1 and 254, f is a normalized number:
+//
+// s e-127
+// f = (-1) * 2 * 1.m
+//
+// If e is 0, and m is not zero, f is a denormalized number:
+//
+// s -126
+// f = (-1) * 2 * 0.m
+//
+// If e and m are both zero, f is zero:
+//
+// f = 0.0
+//
+// If e is 255, f is an "infinity" or "not a number" (NAN),
+// depending on whether m is zero or not.
+//
+// Examples:
+//
+// 0 00000000 00000000000000000000000 = 0.0
+// 0 01111110 00000000000000000000000 = 0.5
+// 0 01111111 00000000000000000000000 = 1.0
+// 0 10000000 00000000000000000000000 = 2.0
+// 0 10000000 10000000000000000000000 = 3.0
+// 1 10000101 11110000010000000000000 = -124.0625
+// 0 11111111 00000000000000000000000 = +infinity
+// 1 11111111 00000000000000000000000 = -infinity
+// 0 11111111 10000000000000000000000 = NAN
+// 1 11111111 11111111111111111111111 = NAN
+//
+// Representation of a half:
+//
+// Here is the bit-layout for a half number, h:
+//
+// 15 (msb)
+// |
+// | 14 10
+// | | |
+// | | | 9 0 (lsb)
+// | | | | |
+// X XXXXX XXXXXXXXXX
+//
+// s e m
+//
+// S is the sign-bit, e is the exponent and m is the significand.
+//
+// If e is between 1 and 30, h is a normalized number:
+//
+// s e-15
+// h = (-1) * 2 * 1.m
+//
+// If e is 0, and m is not zero, h is a denormalized number:
+//
+// S -14
+// h = (-1) * 2 * 0.m
+//
+// If e and m are both zero, h is zero:
+//
+// h = 0.0
+//
+// If e is 31, h is an "infinity" or "not a number" (NAN),
+// depending on whether m is zero or not.
+//
+// Examples:
+//
+// 0 00000 0000000000 = 0.0
+// 0 01110 0000000000 = 0.5
+// 0 01111 0000000000 = 1.0
+// 0 10000 0000000000 = 2.0
+// 0 10000 1000000000 = 3.0
+// 1 10101 1111000001 = -124.0625
+// 0 11111 0000000000 = +infinity
+// 1 11111 0000000000 = -infinity
+// 0 11111 1000000000 = NAN
+// 1 11111 1111111111 = NAN
+//
+// Conversion:
+//
+// Converting from a float to a half requires some non-trivial bit
+// manipulations. In some cases, this makes conversion relatively
+// slow, but the most common case is accelerated via table lookups.
+//
+// Converting back from a half to a float is easier because we don't
+// have to do any rounding. In addition, there are only 65536
+// different half numbers; we can convert each of those numbers once
+// and store the results in a table. Later, all conversions can be
+// done using only simple table lookups.
+//
+//---------------------------------------------------------------------------
+
+
+//--------------------
+// Simple constructors
+//--------------------
+
+inline
+half::half ()
+{
+ // no initialization
+}
+
+
+//----------------------------
+// Half-from-float constructor
+//----------------------------
+
+inline
+half::half (float f)
+{
+ if (f == 0)
+ {
+ //
+ // Common special case - zero.
+ // For speed, we don't preserve the zero's sign.
+ //
+
+ _h = 0;
+ }
+ else
+ {
+ //
+ // We extract the combined sign and exponent, e, from our
+ // floating-point number, f. Then we convert e to the sign
+ // and exponent of the half number via a table lookup.
+ //
+ // For the most common case, where a normalized half is produced,
+ // the table lookup returns a non-zero value; in this case, all
+ // we have to do, is round f's significand to 10 bits and combine
+ // the result with e.
+ //
+ // For all other cases (overflow, zeroes, denormalized numbers
+ // resulting from underflow, infinities and NANs), the table
+ // lookup returns zero, and we call a longer, non-inline function
+ // to do the float-to-half conversion.
+ //
+
+ uif x;
+
+ x.f = f;
+
+ register int e = (x.i >> 23) & 0x000001ff;
+
+ e = _eLut[e];
+
+ if (e)
+ {
+ //
+ // Simple case - round the significand and
+ // combine it with the sign and exponent.
+ //
+
+ _h = e + (((x.i & 0x007fffff) + 0x00001000) >> 13);
+ }
+ else
+ {
+ //
+ // Difficult case - call a function.
+ //
+
+ _h = convert (x.i);
+ }
+ }
+}
+
+
+//------------------------------------------
+// Half-to-float conversion via table lookup
+//------------------------------------------
+
+inline
+half::operator float () const
+{
+ return _toFloat[_h].f;
+}
+
+
+//-------------------------
+// Round to n-bit precision
+//-------------------------
+
+inline half
+half::round (unsigned int n) const
+{
+ //
+ // Parameter check.
+ //
+
+ if (n >= 10)
+ return *this;
+
+ //
+ // Disassemble h into the sign, s,
+ // and the combined exponent and significand, e.
+ //
+
+ unsigned short s = _h & 0x8000;
+ unsigned short e = _h & 0x7fff;
+
+ //
+ // Round the exponent and significand to the nearest value
+ // where ones occur only in the (10-n) most significant bits.
+ // Note that the exponent adjusts automatically if rounding
+ // up causes the significand to overflow.
+ //
+
+ e >>= 9 - n;
+ e += e & 1;
+ e <<= 9 - n;
+
+ //
+ // Check for exponent overflow.
+ //
+
+ if (e >= 0x7c00)
+ {
+ //
+ // Overflow occurred -- truncate instead of rounding.
+ //
+
+ e = _h;
+ e >>= 10 - n;
+ e <<= 10 - n;
+ }
+
+ //
+ // Put the original sign bit back.
+ //
+
+ half h;
+ h._h = s | e;
+
+ return h;
+}
+
+
+//-----------------------
+// Other inline functions
+//-----------------------
+
+inline half
+half::operator - () const
+{
+ half h;
+ h._h = _h ^ 0x8000;
+ return h;
+}
+
+
+inline half &
+half::operator = (half h)
+{
+ _h = h._h;
+ return *this;
+}
+
+
+inline half &
+half::operator = (float f)
+{
+ *this = half (f);
+ return *this;
+}
+
+
+inline half &
+half::operator += (half h)
+{
+ *this = half (float (*this) + float (h));
+ return *this;
+}
+
+
+inline half &
+half::operator += (float f)
+{
+ *this = half (float (*this) + f);
+ return *this;
+}
+
+
+inline half &
+half::operator -= (half h)
+{
+ *this = half (float (*this) - float (h));
+ return *this;
+}
+
+
+inline half &
+half::operator -= (float f)
+{
+ *this = half (float (*this) - f);
+ return *this;
+}
+
+
+inline half &
+half::operator *= (half h)
+{
+ *this = half (float (*this) * float (h));
+ return *this;
+}
+
+
+inline half &
+half::operator *= (float f)
+{
+ *this = half (float (*this) * f);
+ return *this;
+}
+
+
+inline half &
+half::operator /= (half h)
+{
+ *this = half (float (*this) / float (h));
+ return *this;
+}
+
+
+inline half &
+half::operator /= (float f)
+{
+ *this = half (float (*this) / f);
+ return *this;
+}
+
+
+inline bool
+half::isFinite () const
+{
+ unsigned short e = (_h >> 10) & 0x001f;
+ return e < 31;
+}
+
+
+inline bool
+half::isNormalized () const
+{
+ unsigned short e = (_h >> 10) & 0x001f;
+ return e > 0 && e < 31;
+}
+
+
+inline bool
+half::isDenormalized () const
+{
+ unsigned short e = (_h >> 10) & 0x001f;
+ unsigned short m = _h & 0x3ff;
+ return e == 0 && m != 0;
+}
+
+
+inline bool
+half::isZero () const
+{
+ return (_h & 0x7fff) == 0;
+}
+
+
+inline bool
+half::isNan () const
+{
+ unsigned short e = (_h >> 10) & 0x001f;
+ unsigned short m = _h & 0x3ff;
+ return e == 31 && m != 0;
+}
+
+
+inline bool
+half::isInfinity () const
+{
+ unsigned short e = (_h >> 10) & 0x001f;
+ unsigned short m = _h & 0x3ff;
+ return e == 31 && m == 0;
+}
+
+
+inline bool
+half::isNegative () const
+{
+ return (_h & 0x8000) != 0;
+}
+
+
+inline half
+half::posInf ()
+{
+ half h;
+ h._h = 0x7c00;
+ return h;
+}
+
+
+inline half
+half::negInf ()
+{
+ half h;
+ h._h = 0xfc00;
+ return h;
+}
+
+
+inline half
+half::qNan ()
+{
+ half h;
+ h._h = 0x7fff;
+ return h;
+}
+
+
+inline half
+half::sNan ()
+{
+ half h;
+ h._h = 0x7dff;
+ return h;
+}
+
+
+inline unsigned short
+half::bits () const
+{
+ return _h;
+}
+
+
+inline void
+half::setBits (unsigned short bits)
+{
+ _h = bits;
+}
+
+#undef HALF_EXPORT_CONST
+
+#endif
projects / opencv / blobdiff