Merge remote-tracking branch 'upstream/3.4' into merge-3.4

3rdparty/openexr/AUTHORS.openexr

@@ -8,6 +8,10 @@ Paul Schneider <paultschneider@mac.com>
 Bill Anderson <wja@ilm.com>
 Wojciech Jarosz <wjarosz@ucsd.edu>
 Andrew Kunz <akunz@ilm.com>
+Piotr Stanczyk <pstanczyk@ilm.com>
+Peter Hillman <peterh@weta.co.nz>
+Nick Porcino <nick.porcino@gmail.com>
+Kimball Thurston
 
 Contributors:
 -------------
@@ -20,6 +24,10 @@ Rodrigo Damazio <rdamazio@lsi.usp.br>
 Greg Ward <gward@lmi.net>
 Joseph Goldstone <joseph@lp.com>
 Loren Carpenter, Pixar Animation Studios
+Nicholas Yue <yue.nicholas@gmail.com>
+Yunfeng Bai (ILM)
+Pascal Jette (Autodesk)
+Karl Rasche, DreamWorks Animation <Karl.Rasche@dreamworks.com>
 
 Win32 build system:
 -------------------

3rdparty/openexr/CMakeLists.txt

@@ -5,15 +5,75 @@
 
 project(openexr CXX)
 
-if(UNIX)
+
-  if(APPLE)
+if(NOT HAVE_CXX11)
-    set(HAVE_POSIX_SEMAPHORES 0)  # Unnamed semaphores are not supported: https://github.com/opencv/opencv/issues/9361
+  ocv_check_compiler_flag(CXX "-std=c++11" HAVE_STD_CXX11 "${OpenCV_SOURCE_DIR}/cmake/checks/cxx11.cpp")
+  if(HAVE_STD_CXX11)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
   else()
-    include(CheckIncludeFile)
+    if(BUILD_OPENEXR)
-    check_include_file(semaphore.h HAVE_POSIX_SEMAPHORES)
+      message(WARNING "OpenCV: builtin OpenEXR requires C++11 support. OpenEXR is disabled.")
+    endif()
+    return()
   endif()
 endif()
 
+
+
+set(ILMBASE_VERSION_MAJOR "2")
+set(ILMBASE_VERSION_MINOR "3")
+set(ILMBASE_VERSION_PATCH "0")
+
+set(ILMBASE_VERSION "${ILMBASE_VERSION_MAJOR}.${ILMBASE_VERSION_MINOR}.${ILMBASE_VERSION_PATCH}")
+set(ILMBASE_VERSION_API ${ILMBASE_VERSION_MAJOR}_${ILMBASE_VERSION_MINOR})
+
+set(OPENEXR_VERSION_MAJOR "2")
+set(OPENEXR_VERSION_MINOR "3")
+set(OPENEXR_VERSION_PATCH "0")
+
+set(OPENEXR_VERSION "${OPENEXR_VERSION_MAJOR}.${OPENEXR_VERSION_MINOR}.${OPENEXR_VERSION_PATCH}")
+set(OPENEXR_VERSION_API ${OPENEXR_VERSION_MAJOR}_${OPENEXR_VERSION_MINOR})
+
+set(OPENEXR_VERSION "${OPENEXR_VERSION}" PARENT_SCOPE)
+
+if(WIN32)
+  set(HAVE_COMPLETE_IOMANIP 1)
+  set(OPENEXR_IMF_HAVE_COMPLETE_IOMANIP 1)
+  set(PLATFORM_WINDOWS 1)
+elseif(APPLE)
+  set(HAVE_POSIX_SEMAPHORES 0)  # Unnamed semaphores are not supported: https://github.com/opencv/opencv/issues/9361
+  if(DARWIN)
+    set(OPENEXR_IMF_HAVE_DARWIN 1)
+  endif()
+elseif(UNIX)
+  include(CheckIncludeFile)
+  check_include_file(semaphore.h HAVE_POSIX_SEMAPHORES)
+endif()
+
+set(ILMBASE_VERSION_API "opencv")
+set(ILMBASE_INTERNAL_NAMESPACE_CUSTOM 1)
+set(IMATH_INTERNAL_NAMESPACE "Imath_${ILMBASE_VERSION_API}")
+set(IEX_INTERNAL_NAMESPACE "Iex_${ILMBASE_VERSION_API}")
+set(ILMTHREAD_INTERNAL_NAMESPACE "IlmThread_${ILMBASE_VERSION_API}")
+
+set(ILMBASE_NAMESPACE_CUSTOM 0)
+set(IMATH_NAMESPACE "Imath")
+set(IEX_NAMESPACE "Iex")
+set(ILMTHREAD_NAMESPACE "IlmThread")
+set(ILMBASE_VERSION_STRING "\"${ILMBASE_VERSION}\"" )
+set(ILMBASE_PACKAGE_STRING "\"IlmBase ${ILMBASE_VERSION}\"" )
+
+
+set(OPENEXR_VERSION_API "opencv")
+set(OPENEXR_IMF_INTERNAL_NAMESPACE_CUSTOM 1)
+set(OPENEXR_IMF_INTERNAL_NAMESPACE "Imf_${ILMBASE_VERSION_API}")
+set(OPENEXR_IMF_NAMESPACE_CUSTOM 0)
+set(OPENEXR_IMF_NAMESPACE "Imf")
+
+set(OPENEXR_VERSION_STRING "\"${OPENEXR_VERSION}\"" )
+set(OPENEXR_PACKAGE_STRING "\"OpenEXR ${OPENEXR_VERSION}\"" )
+
+
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/IlmBaseConfig.h.cmakein"
                "${CMAKE_CURRENT_BINARY_DIR}/IlmBaseConfig.h" @ONLY)
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/OpenEXRConfig.h.cmakein"
@@ -23,7 +83,8 @@ set(OPENEXR_INCLUDE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/Half"
                           "${CMAKE_CURRENT_SOURCE_DIR}/Iex"
                           "${CMAKE_CURRENT_SOURCE_DIR}/IlmThread"
                           "${CMAKE_CURRENT_SOURCE_DIR}/Imath"
-                          "${CMAKE_CURRENT_SOURCE_DIR}/IlmImf")
+                          "${CMAKE_CURRENT_SOURCE_DIR}/IlmImf"
+                          "${CMAKE_CURRENT_BINARY_DIR}")
 
 ocv_include_directories("${CMAKE_CURRENT_BINARY_DIR}" ${ZLIB_INCLUDE_DIRS} ${OPENEXR_INCLUDE_PATHS})
 
@@ -31,8 +92,6 @@ file(GLOB lib_srcs Half/half.cpp Iex/*.cpp IlmThread/*.cpp Imath/*.cpp IlmImf/*.
 file(GLOB lib_hdrs Half/*.h Iex/Iex*.h IlmThread/IlmThread*.h Imath/Imath*.h IlmImf/*.h)
 list(APPEND lib_hdrs "${CMAKE_CURRENT_BINARY_DIR}/IlmBaseConfig.h" "${CMAKE_CURRENT_BINARY_DIR}/OpenEXRConfig.h")
 
-ocv_list_filterout(lib_srcs IlmImf/b44ExpLogTable.cpp)
-
 if(WIN32)
   ocv_list_filterout(lib_srcs Posix.*cpp)
 else()
@@ -46,6 +105,10 @@ ocv_warnings_disable(CMAKE_CXX_FLAGS -Wshadow -Wunused -Wsign-compare -Wundef -W
                                      -Wdeprecated-declarations -Wmisleading-indentation -Wdeprecated
                                      -Wsuggest-override -Winconsistent-missing-override
                                      -Wimplicit-fallthrough
+                                     -Wtautological-compare  # clang
+                                     -Wmissing-prototypes  # gcc/clang
+                                     -Wreorder
+                                     -Wunused-result
 )
 if(CV_GCC AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 8.0)
   ocv_warnings_disable(CMAKE_CXX_FLAGS -Wclass-memaccess)
@@ -82,7 +145,6 @@ if(NOT BUILD_SHARED_LIBS)
   ocv_install_target(IlmImf EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
 endif()
 
-ocv_install_3rdparty_licenses(openexr LICENSE AUTHORS.ilmbase AUTHORS.openexr fix_msvc2013_errors.patch)
+ocv_install_3rdparty_licenses(openexr LICENSE AUTHORS.ilmbase AUTHORS.openexr)
 
 set(OPENEXR_INCLUDE_PATHS ${OPENEXR_INCLUDE_PATHS} PARENT_SCOPE)
-set(OPENEXR_VERSION "1.7.1" PARENT_SCOPE)

3rdparty/openexr/ChangeLog.ilmbase

@@ -1,3 +1,30 @@
+Version 2.x.x
+	* Bumped version to track OpenEXR
+	  (Piotr Stanczyk)
+
+Version 2.0.1
+	* Bumped version to track OpenEXR
+	  (Piotr Stanczyk)
+
+Version 2.0.0
+	* Bumped version to track OpenEXR
+	  (Piotr Stanczyk)
+	* Numerous minor fixes, missing includes etc
+
+Version 1.1.0.beta.1
+	* Added new module PyIlmBase : python bindings for IlmBase
+	  (Nick Rasmussen)
+	* Added git specific files 
+	  (Piotr Stanczyk)
+	* Minor fixes for newer gcc versions and OS X.
+	  (misc)
+	* Preparation for OpenEXR v2 release { remove message for final release }
+	  (Piotr Stanczyk)
+        * Updated the so verison to 10
+	  (Piotr Stanczyk)
+	* Initial use of the CMake build system 
+	  (Nicholas Yue)
+
 Version 1.0.3
         * Added support for enabling/disabling large stack optimisations, used in
           halfFunction.h.

3rdparty/openexr/ChangeLog.openexr

@@ -1,5 +1,43 @@
+Version 2.0.1
+	* Temporarily turning off optimisation code path
+	  (Piotr Stanczyk)
+	* Added additional tests for future optimisation refactoring
+	  (Piotr Stanczyk / Peter Hillman)
+	* Fixes for StringVectors
+	  (Peter Hillman)
+	* Additional checks for type mismatches
+	  (Peter Hillman)
+	* Fix for Composite Deep Scanline
+	  (Brendan Bolles)
+
+Version 2.0.0
+	* Updated Documentation
+	   (Peter Hillman)
+	* Updated Namespacing mechanism
+	   (Piotr Stanczyk)
+	* Fixes for succd & predd
+	   (Peter Hillman)
+	* Fixes for FPE control registers
+	   (Piotr Stanczyk)
+	* Additional checks and tests on DeepImages, scanlines and tiles
+	   (Peter Hillman)
+	* Folded in Autodesk read optimisations for RGB(A) files
+	  (Pascal Jette, Peter Hillman)
+	* Updated the bootstrap scripts to use libtoolize if glibtoolize isn't available on darwin. 
+	  (Nick Rasmussen)
+	* Numerous minor fixes, missing includes etc
+
+Version 2.0.0.beta.1:
+* Please read the separate file for v2 additions and changes.
+	* Added git specific files 
+	  (Piotr Stanczyk)
+	* Updated the so verison to 20
+	  (Piotr Stanczyk)
+	* Initial use of the CMake build system 
+	  (Nicholas Yue)
+
 Version 1.7.1:
-        * Updated the .so verison to 7.
+	* Updated the .so verison to 7.
 	  (Piotr Stanczyk)     
 
 Version 1.7.0:

3rdparty/openexr/Half/half.cpp

@@ -53,11 +53,10 @@ using namespace std;
 // Lookup tables for half-to-float and float-to-half conversion
 //-------------------------------------------------------------
 
-HALF_EXPORT_CONST half::uif half::_toFloat[1 << 16] =
+HALF_EXPORT const half::uif half::_toFloat[1 << 16] =
-#include "toFloat.h"
+    #include "toFloat.h"
-HALF_EXPORT_CONST unsigned short half::_eLut[1 << 9] =
+HALF_EXPORT const unsigned short half::_eLut[1 << 9] =
-#include "eLut.h"
+    #include "eLut.h"
-
 
 //-----------------------------------------------
 // Overflow handler for float-to-half conversion;
@@ -65,14 +64,14 @@ HALF_EXPORT_CONST unsigned short half::_eLut[1 << 9] =
 // which may be trapped by the operating system.
 //-----------------------------------------------
 
-float
+HALF_EXPORT float
 half::overflow ()
 {
     volatile float f = 1e10;
 
     for (int i = 0; i < 10; i++)	
-    f *= f;				// this will overflow before
+	f *= f;				// this will overflow before
-                    // the for­loop terminates
+					// the for­loop terminates
     return f;
 }
 
@@ -82,7 +81,7 @@ half::overflow ()
 // zeroes, denormalized numbers and exponent overflows.
 //-----------------------------------------------------
 
-short
+HALF_EXPORT short
 half::convert (int i)
 {
     //
@@ -95,9 +94,9 @@ half::convert (int i)
     // of float and half (127 versus 15).
     //
 
-    register int s =  (i >> 16) & 0x00008000;
+    int s =  (i >> 16) & 0x00008000;
-    register int e = ((i >> 23) & 0x000000ff) - (127 - 15);
+    int e = ((i >> 23) & 0x000000ff) - (127 - 15);
-    register int m =   i        & 0x007fffff;
+    int m =   i        & 0x007fffff;
 
     //
     // Now reassemble s, e and m into a half:
@@ -105,115 +104,115 @@ half::convert (int i)
 
     if (e <= 0)
     {
-    if (e < -10)
+	if (e < -10)
-    {
+	{
-        //
+	    //
-        // E is less than -10.  The absolute value of f is
+	    // E is less than -10.  The absolute value of f is
-        // less than HALF_MIN (f may be a small normalized
+	    // less than HALF_MIN (f may be a small normalized
-        // float, a denormalized float or a zero).
+	    // float, a denormalized float or a zero).
-        //
+	    //
-        // We convert f to a half zero with the same sign as f.
+	    // We convert f to a half zero with the same sign as f.
-        //
+	    //
 
-        return s;
+	    return s;
-    }
+	}
 
-    //
+	//
-    // E is between -10 and 0.  F is a normalized float
+	// E is between -10 and 0.  F is a normalized float
-    // whose magnitude is less than HALF_NRM_MIN.
+	// whose magnitude is less than HALF_NRM_MIN.
-    //
+	//
-    // We convert f to a denormalized half.
+	// We convert f to a denormalized half.
-    //
+	//
 
-    //
+	//
-    // Add an explicit leading 1 to the significand.
+	// Add an explicit leading 1 to the significand.
-    //
+	// 
 
-    m = m | 0x00800000;
+	m = m | 0x00800000;
 
-    //
+	//
-    // Round to m to the nearest (10+e)-bit value (with e between
+	// Round to m to the nearest (10+e)-bit value (with e between
-    // -10 and 0); in case of a tie, round to the nearest even value.
+	// -10 and 0); in case of a tie, round to the nearest even value.
-    //
+	//
-    // Rounding may cause the significand to overflow and make
+	// Rounding may cause the significand to overflow and make
-    // our number normalized.  Because of the way a half's bits
+	// our number normalized.  Because of the way a half's bits
-    // are laid out, we don't have to treat this case separately;
+	// are laid out, we don't have to treat this case separately;
-    // the code below will handle it correctly.
+	// the code below will handle it correctly.
-    //
+	// 
 
-    int t = 14 - e;
+	int t = 14 - e;
-    int a = (1 << (t - 1)) - 1;
+	int a = (1 << (t - 1)) - 1;
-    int b = (m >> t) & 1;
+	int b = (m >> t) & 1;
 
-    m = (m + a + b) >> t;
+	m = (m + a + b) >> t;
 
-    //
+	//
-    // Assemble the half from s, e (zero) and m.
+	// Assemble the half from s, e (zero) and m.
-    //
+	//
 
-    return s | m;
+	return s | m;
     }
     else if (e == 0xff - (127 - 15))
     {
-    if (m == 0)
+	if (m == 0)
-    {
+	{
-        //
+	    //
-        // F is an infinity; convert f to a half
+	    // F is an infinity; convert f to a half
-        // infinity with the same sign as f.
+	    // infinity with the same sign as f.
-        //
+	    //
 
-        return s | 0x7c00;
+	    return s | 0x7c00;
+	}
+	else
+	{
+	    //
+	    // F is a NAN; we produce a half NAN that preserves
+	    // the sign bit and the 10 leftmost bits of the
+	    // significand of f, with one exception: If the 10
+	    // leftmost bits are all zero, the NAN would turn 
+	    // into an infinity, so we have to set at least one
+	    // bit in the significand.
+	    //
+
+	    m >>= 13;
+	    return s | 0x7c00 | m | (m == 0);
+	}
     }
     else
     {
-        //
+	//
-        // F is a NAN; we produce a half NAN that preserves
+	// E is greater than zero.  F is a normalized float.
-        // the sign bit and the 10 leftmost bits of the
+	// We try to convert f to a normalized half.
-        // significand of f, with one exception: If the 10
+	//
-        // leftmost bits are all zero, the NAN would turn
-        // into an infinity, so we have to set at least one
-        // bit in the significand.
-        //
 
-        m >>= 13;
+	//
-        return s | 0x7c00 | m | (m == 0);
+	// Round to m to the nearest 10-bit value.  In case of
-    }
+	// a tie, round to the nearest even value.
-    }
+	//
-    else
-    {
-    //
-    // E is greater than zero.  F is a normalized float.
-    // We try to convert f to a normalized half.
-    //
 
-    //
+	m = m + 0x00000fff + ((m >> 13) & 1);
-    // Round to m to the nearest 10-bit value.  In case of
-    // a tie, round to the nearest even value.
-    //
 
-    m = m + 0x00000fff + ((m >> 13) & 1);
+	if (m & 0x00800000)
+	{
+	    m =  0;		// overflow in significand,
+	    e += 1;		// adjust exponent
+	}
 
-    if (m & 0x00800000)
+	//
-    {
+	// Handle exponent overflow
-        m =  0;		// overflow in significand,
+	//
-        e += 1;		// adjust exponent
-    }
 
-    //
+	if (e > 30)
-    // Handle exponent overflow
+	{
-    //
+	    overflow ();	// Cause a hardware floating point overflow;
+	    return s | 0x7c00;	// if this returns, the half becomes an
+	}   			// infinity with the same sign as f.
 
-    if (e > 30)
+	//
-    {
+	// Assemble the half from s, e and m.
-        overflow ();	// Cause a hardware floating point overflow;
+	//
-        return s | 0x7c00;	// if this returns, the half becomes an
-    }   			// infinity with the same sign as f.
 
-    //
+	return s | (e << 10) | (m >> 13);
-    // Assemble the half from s, e and m.
-    //
-
-    return s | (e << 10) | (m >> 13);
     }
 }
 
@@ -222,7 +221,7 @@ half::convert (int i)
 // Stream I/O operators
 //---------------------
 
-ostream &
+HALF_EXPORT ostream &
 operator << (ostream &os, half h)
 {
     os << float (h);
@@ -230,7 +229,7 @@ operator << (ostream &os, half h)
 }
 
 
-istream &
+HALF_EXPORT istream &
 operator >> (istream &is, half &h)
 {
     float f;
@@ -245,22 +244,22 @@ operator >> (istream &is, half &h)
 // floats and halfs, mostly for debugging
 //---------------------------------------
 
-void
+HALF_EXPORT void
 printBits (ostream &os, half h)
 {
     unsigned short b = h.bits();
 
     for (int i = 15; i >= 0; i--)
     {
-    os << (((b >> i) & 1)? '1': '0');
+	os << (((b >> i) & 1)? '1': '0');
 
-    if (i == 15 || i == 10)
+	if (i == 15 || i == 10)
-        os << ' ';
+	    os << ' ';
     }
 }
 
 
-void
+HALF_EXPORT void
 printBits (ostream &os, float f)
 {
     half::uif x;
@@ -268,32 +267,32 @@ printBits (ostream &os, float f)
 
     for (int i = 31; i >= 0; i--)
     {
-    os << (((x.i >> i) & 1)? '1': '0');
+	os << (((x.i >> i) & 1)? '1': '0');
 
-    if (i == 31 || i == 23)
+	if (i == 31 || i == 23)
-        os << ' ';
+	    os << ' ';
     }
 }
 
 
-void
+HALF_EXPORT void
 printBits (char c[19], half h)
 {
     unsigned short b = h.bits();
 
     for (int i = 15, j = 0; i >= 0; i--, j++)
     {
-    c[j] = (((b >> i) & 1)? '1': '0');
+	c[j] = (((b >> i) & 1)? '1': '0');
 
-    if (i == 15 || i == 10)
+	if (i == 15 || i == 10)
-        c[++j] = ' ';
+	    c[++j] = ' ';
     }
     
     c[18] = 0;
 }
 
 
-void
+HALF_EXPORT void
 printBits (char c[35], float f)
 {
     half::uif x;
@@ -301,10 +300,10 @@ printBits (char c[35], float f)
 
     for (int i = 31, j = 0; i >= 0; i--, j++)
     {
-    c[j] = (((x.i >> i) & 1)? '1': '0');
+	c[j] = (((x.i >> i) & 1)? '1': '0');
 
-    if (i == 31 || i == 23)
+	if (i == 31 || i == 23)
-        c[++j] = ' ';
+	    c[++j] = ' ';
     }
 
     c[34] = 0;

3rdparty/openexr/Half/half.h

@@ -85,21 +85,10 @@
 #ifndef _HALF_H_
 #define _HALF_H_
 
+#include "halfExport.h"    // for definition of HALF_EXPORT
 #include <iostream>
 
-#if defined(OPENEXR_DLL)
+class half
-    #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
-
-class HALF_EXPORT half
 {
   public:
 
@@ -208,45 +197,47 @@ class HALF_EXPORT half
     // Access to the internal representation
     //--------------------------------------
 
-    unsigned short	bits () const;
+    HALF_EXPORT unsigned short	bits () const;
-    void		setBits (unsigned short bits);
+    HALF_EXPORT void		setBits (unsigned short bits);
 
 
   public:
 
     union uif
     {
-    unsigned int	i;
+	unsigned int	i;
-    float		f;
+	float		f;
     };
 
   private:
 
-    static short	convert (int i);
+    HALF_EXPORT static short                  convert (int i);
-    static float	overflow ();
+    HALF_EXPORT static float                  overflow ();
 
-    unsigned short	_h;
+    unsigned short                            _h;
 
-    static HALF_EXPORT_CONST uif		_toFloat[1 << 16];
+    HALF_EXPORT static const uif              _toFloat[1 << 16];
-    static HALF_EXPORT_CONST unsigned short _eLut[1 << 9];
+    HALF_EXPORT static const unsigned short   _eLut[1 << 9];
 };
 
+
+
 //-----------
 // Stream I/O
 //-----------
 
-HALF_EXPORT std::ostream &		operator << (std::ostream &os, half  h);
+HALF_EXPORT std::ostream &      operator << (std::ostream &os, half  h);
-HALF_EXPORT std::istream &		operator >> (std::istream &is, half &h);
+HALF_EXPORT std::istream &      operator >> (std::istream &is, half &h);
 
 
 //----------
 // Debugging
 //----------
 
-HALF_EXPORT void			printBits   (std::ostream &os, half  h);
+HALF_EXPORT void        printBits   (std::ostream &os, half  h);
-HALF_EXPORT void			printBits   (std::ostream &os, float f);
+HALF_EXPORT void        printBits   (std::ostream &os, float f);
-HALF_EXPORT void			printBits   (char  c[19], half  h);
+HALF_EXPORT void        printBits   (char  c[19], half  h);
-HALF_EXPORT void			printBits   (char  c[35], float f);
+HALF_EXPORT void        printBits   (char  c[35], float f);
 
 
 //-------------------------------------------------------------------------
@@ -266,7 +257,7 @@ HALF_EXPORT void			printBits   (char  c[35], float f);
   #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)
+					// half (1.0 + e) != half (1.0)
 #else
 
   #define HALF_MIN	5.96046448e-08	// Smallest positive half
@@ -276,35 +267,39 @@ HALF_EXPORT void			printBits   (char  c[35], float f);
   #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)
+					// half (1.0 + e) != half (1.0)
 #endif
 
 
 #define HALF_MANT_DIG	11		// Number of digits in mantissa
-                    // (significand + hidden leading 1)
+					// (significand + hidden leading 1)
 
 #define HALF_DIG	2		// Number of base 10 digits that
-                    // can be represented without change
+					// can be represented without change
+
+#define HALF_DECIMAL_DIG	5	// Number of base-10 digits that are
+					// necessary to uniquely represent all
+					// distinct values
 
 #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
+					// HALF_RADIX raised to the power of
-                    // one less than that integer is a
+					// one less than that integer is a
-                    // normalized half
+					// normalized half
 
 #define HALF_MAX_EXP	16		// Maximum positive integer such that
-                    // HALF_RADIX raised to the power of
+					// HALF_RADIX raised to the power of
-                    // one less than that integer is a
+					// one less than that integer is a
-                    // normalized half
+					// normalized half
 
 #define HALF_MIN_10_EXP	-4		// Minimum positive integer such
-                    // that 10 raised to that power is
+					// that 10 raised to that power is
-                    // a normalized half
+					// a normalized half
 
 #define HALF_MAX_10_EXP	4		// Maximum positive integer such
-                    // that 10 raised to that power is
+					// that 10 raised to that power is
-                    // a normalized half
+					// a normalized half
 
 
 //---------------------------------------------------------------------------
@@ -443,53 +438,53 @@ half::half (float f)
 
     if (f == 0)
     {
-    //
+	//
-    // Common special case - zero.
+	// Common special case - zero.
-    // Preserve the zero's sign bit.
+	// Preserve the zero's sign bit.
-    //
+	//
 
-    _h = (x.i >> 16);
+	_h = (x.i >> 16);
     }
     else
     {
-    //
+	//
-    // We extract the combined sign and exponent, e, from our
+	// We extract the combined sign and exponent, e, from our
-    // floating-point number, f.  Then we convert e to the sign
+	// floating-point number, f.  Then we convert e to the sign
-    // and exponent of the half number via a table lookup.
+	// and exponent of the half number via a table lookup.
-    //
+	//
-    // For the most common case, where a normalized half is produced,
+	// For the most common case, where a normalized half is produced,
-    // the table lookup returns a non-zero value; in this case, all
+	// 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
+	// we have to do is round f's significand to 10 bits and combine
-    // the result with e.
+	// the result with e.
-    //
+	//
-    // For all other cases (overflow, zeroes, denormalized numbers
+	// For all other cases (overflow, zeroes, denormalized numbers
-    // resulting from underflow, infinities and NANs), the table
+	// resulting from underflow, infinities and NANs), the table
-    // lookup returns zero, and we call a longer, non-inline function
+	// lookup returns zero, and we call a longer, non-inline function
-    // to do the float-to-half conversion.
+	// to do the float-to-half conversion.
-    //
+	//
 
-    register int e = (x.i >> 23) & 0x000001ff;
+	int e = (x.i >> 23) & 0x000001ff;
 
-    e = _eLut[e];
+	e = _eLut[e];
 
-    if (e)
+	if (e)
-    {
+	{
-        //
+	    //
-        // Simple case - round the significand, m, to 10
+	    // Simple case - round the significand, m, to 10
-        // bits and combine it with the sign and exponent.
+	    // bits and combine it with the sign and exponent.
-        //
+	    //
 
-        register int m = x.i & 0x007fffff;
+	    int m = x.i & 0x007fffff;
-        _h = e + ((m + 0x00000fff + ((m >> 13) & 1)) >> 13);
+	    _h = (unsigned short)(e + ((m + 0x00000fff + ((m >> 13) & 1)) >> 13));
-    }
+	}
-    else
+	else
-    {
+	{
-        //
+	    //
-        // Difficult case - call a function.
+	    // Difficult case - call a function.
-        //
+	    //
 
-        _h = convert (x.i);
+	    _h = convert (x.i);
-    }
+	}
     }
 }
 
@@ -517,7 +512,7 @@ half::round (unsigned int n) const
     //
 
     if (n >= 10)
-    return *this;
+	return *this;
 
     //
     // Disassemble h into the sign, s,
@@ -544,13 +539,13 @@ half::round (unsigned int n) const
 
     if (e >= 0x7c00)
     {
-    //
+	//
-    // Overflow occurred -- truncate instead of rounding.
+	// Overflow occurred -- truncate instead of rounding.
-    //
+	//
 
-    e = _h;
+	e = _h;
-    e >>= 10 - n;
+	e >>= 10 - n;
-    e <<= 10 - n;
+	e <<= 10 - n;
     }
 
     //

3rdparty/openexr/Half/halfExport.h

@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
+// Copyright (c) 2008, Industrial Light & Magic, a division of Lucas
 // Digital Ltd. LLC
 //
 // All rights reserved.
@@ -32,23 +32,20 @@
 //
 ///////////////////////////////////////////////////////////////////////////
 
+#ifndef HALFEXPORT_H
+#define HALFEXPORT_H
 
-
+#if defined(OPENEXR_DLL)
-#ifndef INCLUDED_IMATHGLU_H
+    #if defined(HALF_EXPORTS)
-#define INCLUDED_IMATHGLU_H
+    #define HALF_EXPORT __declspec(dllexport)
-
+    #else
-#include <GL/gl.h>
+    #define HALF_EXPORT __declspec(dllimport)
-#include <GL/glu.h>
+    #endif
-
+    #define HALF_EXPORT_CONST
-#include "ImathVec.h"
+#else
-
+    #define HALF_EXPORT
-inline
+    #define HALF_EXPORT_CONST const
-void
-gluLookAt(const Imath::V3f &pos, const Imath::V3f &interest, const Imath::V3f &up)
-{
-    gluLookAt(pos.x,      pos.y,      pos.z,
-              interest.x, interest.y, interest.z,
-              up.x,       up.y,       up.z);
-}
-
 #endif
+
+#endif // #ifndef HALFEXPORT_H
+

3rdparty/openexr/Half/halfFunction.h

@@ -85,7 +85,7 @@
 
 #include "half.h"
 
-#include <IlmBaseConfig.h>
+#include "IlmBaseConfig.h"
 #ifndef ILMBASE_HAVE_LARGE_STACK  
 #include <string.h>     // need this for memset
 #else 
@@ -105,12 +105,12 @@ class halfFunction
 
     template <class Function>
     halfFunction (Function f,
-          half domainMin = -HALF_MAX,
+		  half domainMin = -HALF_MAX,
-          half domainMax =  HALF_MAX,
+		  half domainMax =  HALF_MAX,
-          T defaultValue = 0,
+		  T defaultValue = 0,
-          T posInfValue  = 0,
+		  T posInfValue  = 0,
-          T negInfValue  = 0,
+		  T negInfValue  = 0,
-          T nanValue     = 0);
+		  T nanValue     = 0);
 
 #ifndef ILMBASE_HAVE_LARGE_STACK
     ~halfFunction () { delete [] _lut; }    
@@ -123,6 +123,7 @@ class halfFunction
     T		operator () (half x) const;
 
   private:
+
 #ifdef ILMBASE_HAVE_LARGE_STACK
     T		_lut[1 << 16];
 #else
@@ -138,12 +139,12 @@ class halfFunction
 template <class T>
 template <class Function>
 halfFunction<T>::halfFunction (Function f,
-                   half domainMin,
+			       half domainMin,
-                   half domainMax,
+			       half domainMax,
-                   T defaultValue,
+			       T defaultValue,
-                   T posInfValue,
+			       T posInfValue,
-                   T negInfValue,
+			       T negInfValue,
-                   T nanValue)
+			       T nanValue)
 {
 #ifndef ILMBASE_HAVE_LARGE_STACK
     _lut = new T[1<<16];
@@ -152,17 +153,17 @@ halfFunction<T>::halfFunction (Function f,
     
     for (int i = 0; i < (1 << 16); i++)
     {
-    half x;
+	half x;
-    x.setBits (i);
+	x.setBits (i);
 
-    if (x.isNan())
+	if (x.isNan())
-        _lut[i] = nanValue;
+	    _lut[i] = nanValue;
-    else if (x.isInfinity())
+	else if (x.isInfinity())
-        _lut[i] = x.isNegative()? negInfValue: posInfValue;
+	    _lut[i] = x.isNegative()? negInfValue: posInfValue;
-    else if (x < domainMin || x > domainMax)
+	else if (x < domainMin || x > domainMax)
-        _lut[i] = defaultValue;
+	    _lut[i] = defaultValue;
-    else
+	else
-        _lut[i] = f (x);
+	    _lut[i] = f (x);
     }
 }
 

3rdparty/openexr/Half/halfLimits.h

@@ -94,6 +94,15 @@ class numeric_limits <half>
     static const bool traps = true;
     static const bool tinyness_before = false;
     static const float_round_style round_style = round_to_nearest;
+
+#if __cplusplus >= 201103L
+
+    // C++11 additions.
+    static constexpr int max_digits10 = HALF_DECIMAL_DIG;
+    static half lowest () {return -HALF_MAX;}
+
+#endif
+
 };
 
 

3rdparty/openexr/Half/toFloat.cpp

@@ -1,164 +0,0 @@
-///////////////////////////////////////////////////////////////////////////
-//
-// 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;
-}

3rdparty/openexr/Iex/IexBaseExc.cpp

@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
+// Copyright (c) 2002-2012, Industrial Light & Magic, a division of Lucas
 // Digital Ltd. LLC
 // 
 // All rights reserved.
@@ -40,15 +40,23 @@
 //
 //---------------------------------------------------------------------
 
+#include "IexExport.h"
 #include "IexBaseExc.h"
+#include "IexMacros.h"
+
+#ifdef PLATFORM_WINDOWS
+#include <windows.h>
+#endif
+
+#include <stdlib.h>
+
+IEX_INTERNAL_NAMESPACE_SOURCE_ENTER
+
 
-namespace Iex {
 namespace {
 
-
 StackTracer currentStackTracer = 0;
 
-
 } // namespace
 
 
@@ -67,7 +75,7 @@ stackTracer ()
 
 
 BaseExc::BaseExc (const char* s) throw () :
-    std::string (s? s: ""),
+    _message (s? s: ""),
     _stackTrace (currentStackTracer? currentStackTracer(): "")
 {
     // empty
@@ -75,7 +83,7 @@ BaseExc::BaseExc (const char* s) throw () :
 
 
 BaseExc::BaseExc (const std::string &s) throw () :
-    std::string (s),
+    _message (s),
     _stackTrace (currentStackTracer? currentStackTracer(): "")
 {
     // empty
@@ -83,7 +91,7 @@ BaseExc::BaseExc (const std::string &s) throw () :
 
 
 BaseExc::BaseExc (std::stringstream &s) throw () :
-    std::string (s.str()),
+    _message (s.str()),
     _stackTrace (currentStackTracer? currentStackTracer(): "")
 {
     // empty
@@ -91,7 +99,7 @@ BaseExc::BaseExc (std::stringstream &s) throw () :
 
 
 BaseExc::BaseExc (const BaseExc &be) throw () :
-    std::string (be),
+    _message (be._message),
     _stackTrace (be._stackTrace)
 {
     // empty
@@ -107,23 +115,99 @@ BaseExc::~BaseExc () throw ()
 const char *
 BaseExc::what () const throw ()
 {
-    return c_str();
+    return _message.c_str();
 }
 
 
 BaseExc &
 BaseExc::assign (std::stringstream &s)
 {
-    std::string::assign (s.str());
+    _message.assign (s.str());
     return *this;
 }
 
 BaseExc &
 BaseExc::append (std::stringstream &s)
 {
-    std::string::append (s.str());
+    _message.append (s.str());
+    return *this;
+}
+
+const std::string &
+BaseExc::message() const
+{
+	return _message;
+}
+
+BaseExc &
+BaseExc::operator = (std::stringstream &s)
+{
+    return assign (s);
+}
+
+
+BaseExc &
+BaseExc::operator += (std::stringstream &s)
+{
+    return append (s);
+}
+
+
+BaseExc &
+BaseExc::assign (const char *s)
+{
+    _message.assign(s);
     return *this;
 }
 
 
-} // namespace Iex
+BaseExc &
+BaseExc::operator = (const char *s)
+{
+    return assign(s);
+}
+
+
+BaseExc &
+BaseExc::append (const char *s)
+{
+    _message.append(s);
+    return *this;
+}
+
+
+BaseExc &
+BaseExc::operator += (const char *s)
+{
+    return append(s);
+}
+
+
+const std::string &
+BaseExc::stackTrace () const
+{
+    return _stackTrace;
+}
+
+
+IEX_INTERNAL_NAMESPACE_SOURCE_EXIT
+
+
+#ifdef PLATFORM_WINDOWS
+
+#pragma optimize("", off)
+void
+iex_debugTrap()
+{
+    if (0 != getenv("IEXDEBUGTHROW"))
+        ::DebugBreak();
+}
+#else
+void
+iex_debugTrap()
+{
+    // how to in Linux?
+    if (0 != ::getenv("IEXDEBUGTHROW"))
+        __builtin_trap();
+}
+#endif

3rdparty/openexr/Iex/IexBaseExc.h

@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
+// Copyright (c) 2002-2012, Industrial Light & Magic, a division of Lucas
 // Digital Ltd. LLC
 // 
 // All rights reserved.
@@ -33,10 +33,11 @@
 ///////////////////////////////////////////////////////////////////////////
 
 
-
 #ifndef INCLUDED_IEXBASEEXC_H
 #define INCLUDED_IEXBASEEXC_H
 
+#include "IexNamespace.h"
+#include "IexExport.h"
 
 //----------------------------------------------------------
 //
@@ -49,18 +50,14 @@
 #include <exception>
 #include <sstream>
 
-namespace Iex {
+IEX_INTERNAL_NAMESPACE_HEADER_ENTER
 
-#if (defined _WIN32 || defined _WIN64) && defined _MSC_VER
-// Tell MS VC++ to suppress exception specification warnings
-#pragma warning(disable:4290)
-#endif
 
 //-------------------------------
 // Our most basic exception class
 //-------------------------------
 
-class BaseExc: public std::string, public std::exception
+class BaseExc: public std::exception
 {
   public:
 
@@ -68,29 +65,29 @@ class BaseExc: public std::string, public std::exception
     // Constructors and destructor
     //----------------------------
 
-    BaseExc (const char *s = 0) throw();	// std::string (s)
+    IEX_EXPORT BaseExc (const char *s = 0) throw();     // std::string (s)
-    BaseExc (const std::string &s) throw();	// std::string (s)
+    IEX_EXPORT BaseExc (const std::string &s) throw();  // std::string (s)
-    BaseExc (std::stringstream &s) throw();	// std::string (s.str())
+    IEX_EXPORT BaseExc (std::stringstream &s) throw();  // std::string (s.str())
 
-    BaseExc (const BaseExc &be) throw();
+    IEX_EXPORT BaseExc (const BaseExc &be) throw();
-    virtual ~BaseExc () throw ();
+    IEX_EXPORT virtual ~BaseExc () throw ();
 
-    //--------------------------------------------
+    //---------------------------------------------------
-    // what() method -- e.what() returns e.c_str()
+    // what() method -- e.what() returns _message.c_str()
-    //--------------------------------------------
+    //---------------------------------------------------
 
-    virtual const char * what () const throw ();
+    IEX_EXPORT virtual const char * what () const throw ();
 
 
     //--------------------------------------------------
     // Convenient methods to change the exception's text
     //--------------------------------------------------
 
-    BaseExc &		assign (std::stringstream &s);	// assign (s.str())
+    IEX_EXPORT BaseExc &            assign (std::stringstream &s);	// assign (s.str())
-    BaseExc &		operator = (std::stringstream &s);
+    IEX_EXPORT BaseExc &            operator = (std::stringstream &s);
 
-    BaseExc &		append (std::stringstream &s);	// append (s.str())
+    IEX_EXPORT BaseExc &            append (std::stringstream &s);	// append (s.str())
-    BaseExc &		operator += (std::stringstream &s);
+    IEX_EXPORT BaseExc &            operator += (std::stringstream &s);
 
 
     //--------------------------------------------------
@@ -98,12 +95,17 @@ class BaseExc: public std::string, public std::exception
     // the definitions above.
     //--------------------------------------------------
 
-    BaseExc &		assign (const char *s);
+    IEX_EXPORT BaseExc &            assign (const char *s);
-    BaseExc &		operator = (const char *s);
+    IEX_EXPORT BaseExc &            operator = (const char *s);
 
-    BaseExc &		append (const char *s);
+    IEX_EXPORT BaseExc &            append (const char *s);
-    BaseExc &		operator += (const char *s);
+    IEX_EXPORT BaseExc &            operator += (const char *s);
 
+    //---------------------------------------------------
+    // Access to the string representation of the message
+    //---------------------------------------------------
+
+    IEX_EXPORT const std::string &  message () const;
 
     //--------------------------------------------------
     // Stack trace for the point at which the exception
@@ -112,11 +114,12 @@ class BaseExc: public std::string, public std::exception
     // has been installed (see below, setStackTracer()).
     //--------------------------------------------------
 
-    const std::string &	stackTrace () const;
+    IEX_EXPORT const std::string &  stackTrace () const;
 
   private:
 
-    std::string		_stackTrace;
+    std::string                     _message;
+    std::string                     _stackTrace;
 };
 
 
@@ -125,50 +128,54 @@ class BaseExc: public std::string, public std::exception
 // class derived directly or indirectly from BaseExc:
 //-----------------------------------------------------
 
-#define DEFINE_EXC(name, base)				        \
+#define DEFINE_EXC_EXP(exp, name, base)                             \
-    class name: public base				        \
+    class name: public base                                         \
-    {							        \
+    {                                                               \
-      public:                                                   \
+      public:                                                       \
-    name (const char* text=0)      throw(): base (text) {}	\
+        exp name()                         throw(): base (0)    {}  \
-    name (const std::string &text) throw(): base (text) {}	\
+        exp name (const char* text)        throw(): base (text) {}  \
-    name (std::stringstream &text) throw(): base (text) {}	\
+        exp name (const std::string &text) throw(): base (text) {}  \
+        exp name (std::stringstream &text) throw(): base (text) {}  \
+        exp ~name() throw() { }                                     \
     };
 
+// For backward compatibility.
+#define DEFINE_EXC(name, base) DEFINE_EXC_EXP(, name, base)
+
 
 //--------------------------------------------------------
 // Some exceptions which should be useful in most programs
 //--------------------------------------------------------
+DEFINE_EXC_EXP (IEX_EXPORT, ArgExc, BaseExc)    // Invalid arguments to a function call
 
-DEFINE_EXC (ArgExc,   BaseExc) 	 // Invalid arguments to a function call
+DEFINE_EXC_EXP (IEX_EXPORT, LogicExc, BaseExc)  // General error in a program's logic,
+                                                // for example, a function was called
+                                                // in a context where the call does
+                                                // not make sense.
 
-DEFINE_EXC (LogicExc, BaseExc) 	 // General error in a program's logic,
+DEFINE_EXC_EXP (IEX_EXPORT, InputExc, BaseExc)  // Invalid input data, e.g. from a file
-                 // for example, a function was called
-                 // in a context where the call does
-                 // not make sense.
 
-DEFINE_EXC (InputExc, BaseExc) 	 // Invalid input data, e.g. from a file
+DEFINE_EXC_EXP (IEX_EXPORT, IoExc, BaseExc)     // Input or output operation failed
 
-DEFINE_EXC (IoExc, BaseExc) 	 // Input or output operation failed
+DEFINE_EXC_EXP (IEX_EXPORT, MathExc, BaseExc) 	// Arithmetic exception; more specific
+                                                // exceptions derived from this class
+                                                // are defined in ExcMath.h
 
-DEFINE_EXC (MathExc,  BaseExc) 	 // Arithmetic exception; more specific
+DEFINE_EXC_EXP (IEX_EXPORT, ErrnoExc, BaseExc)  // Base class for exceptions corresponding
-                 // exceptions derived from this class
+                                                // to errno values (see errno.h); more
-                 // are defined in ExcMath.h
+                                                // specific exceptions derived from this
+                                                // class are defined in ExcErrno.h
 
-DEFINE_EXC (ErrnoExc, BaseExc) 	 // Base class for exceptions corresponding
+DEFINE_EXC_EXP (IEX_EXPORT, NoImplExc, BaseExc) // Missing method exception e.g. from a
-                 // to errno values (see errno.h); more
+                                                // call to a method that is only partially
-                 // specific exceptions derived from this
+                                                // or not at all implemented. A reminder
-                 // class are defined in ExcErrno.h
+                                                // to lazy software people to get back
+                                                // to work.
 
-DEFINE_EXC (NoImplExc, BaseExc)  // Missing method exception e.g. from a
+DEFINE_EXC_EXP (IEX_EXPORT, NullExc, BaseExc)   // A pointer is inappropriately null.
-                 // call to a method that is only partially
-                 // or not at all implemented. A reminder
-                 // to lazy software people to get back
-                 // to work.
 
-DEFINE_EXC (NullExc, BaseExc) 	 // A pointer is inappropriately null.
+DEFINE_EXC_EXP (IEX_EXPORT, TypeExc, BaseExc)   // An object is an inappropriate type,
-
+                                                // i.e. a dynamnic_cast failed.
-DEFINE_EXC (TypeExc, BaseExc) 	 // An object is an inappropriate type,
-                 // i.e. a dynamnic_cast failed.
 
 
 //----------------------------------------------------------------------
@@ -199,68 +206,10 @@ DEFINE_EXC (TypeExc, BaseExc) 	 // An object is an inappropriate type,
 
 typedef std::string (* StackTracer) ();
 
-void		setStackTracer (StackTracer stackTracer);
+IEX_EXPORT void        setStackTracer (StackTracer stackTracer);
-StackTracer	stackTracer ();
+IEX_EXPORT StackTracer stackTracer ();
 
 
-//-----------------
+IEX_INTERNAL_NAMESPACE_HEADER_EXIT
-// Inline functions
-//-----------------
 
-inline BaseExc &
+#endif // INCLUDED_IEXBASEEXC_H
-BaseExc::operator = (std::stringstream &s)
-{
-    return assign (s);
-}
-
-
-inline BaseExc &
-BaseExc::operator += (std::stringstream &s)
-{
-    return append (s);
-}
-
-
-inline BaseExc &
-BaseExc::assign (const char *s)
-{
-    std::string::assign(s);
-    return *this;
-}
-
-
-inline BaseExc &
-BaseExc::operator = (const char *s)
-{
-    return assign(s);
-}
-
-
-inline BaseExc &
-BaseExc::append (const char *s)
-{
-    std::string::append(s);
-    return *this;
-}
-
-
-inline BaseExc &
-BaseExc::operator += (const char *s)
-{
-    return append(s);
-}
-
-
-inline const std::string &
-BaseExc::stackTrace () const
-{
-    return _stackTrace;
-}
-
-#if (defined _WIN32 || defined _WIN64) && defined _MSC_VER
-#pragma warning(default:4290)
-#endif
-
-} // namespace Iex
-
-#endif

3rdparty/openexr/Iex/IexErrnoExc.h

@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
+// Copyright (c) 2002-2012, Industrial Light & Magic, a division of Lucas
 // Digital Ltd. LLC
 // 
 // All rights reserved.
@@ -45,8 +45,7 @@
 
 #include "IexBaseExc.h"
 
-namespace Iex {
+IEX_INTERNAL_NAMESPACE_HEADER_ENTER
-
 
 DEFINE_EXC (EpermExc, ErrnoExc)
 DEFINE_EXC (EnoentExc, ErrnoExc)
@@ -204,7 +203,6 @@ DEFINE_EXC (EcantextentExc, ErrnoExc)
 DEFINE_EXC (EinvaltimeExc, ErrnoExc)
 DEFINE_EXC (EdestroyedExc, ErrnoExc)
 
-
+IEX_INTERNAL_NAMESPACE_HEADER_EXIT
-} // namespace Iex
 
 #endif

3rdparty/openexr/Iex/IexExport.h

@@ -0,0 +1,51 @@
+#ifndef IEXEXPORT_H
+#define IEXEXPORT_H
+
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2012, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#if defined(OPENEXR_DLL)
+    #if defined(IEX_EXPORTS)
+    #define IEX_EXPORT __declspec(dllexport)
+    #else
+    #define IEX_EXPORT __declspec(dllimport)
+    #endif
+    #define IEX_EXPORT_CONST
+#else
+    #define IEX_EXPORT
+    #define IEX_EXPORT_CONST const
+#endif
+
+#endif // #ifndef IEXEXPORT_H
+

3rdparty/openexr/Iex/IexForward.h

@@ -0,0 +1,229 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2012, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDED_IEXFORWARD_H
+#define INCLUDED_IEXFORWARD_H
+
+#include "IexNamespace.h"
+
+IEX_INTERNAL_NAMESPACE_HEADER_ENTER
+
+//
+// Base exceptions.
+//
+
+class BaseExc;
+class ArgExc;
+class LogicExc;
+class InputExc;
+class IoExc;
+class MathExc;
+class ErrnoExc;
+class NoImplExc;
+class NullExc;
+class TypeExc;
+
+//
+// Math exceptions.
+//
+
+class OverflowExc;
+class UnderflowExc;
+class DivzeroExc;
+class InexactExc;
+class InvalidFpOpExc;
+
+//
+// Errno exceptions.
+//
+
+class EpermExc;
+class EnoentExc;
+class EsrchExc;
+class EintrExc;
+class EioExc;
+class EnxioExc;
+class E2bigExc;
+class EnoexecExc;
+class EbadfExc;
+class EchildExc;
+class EagainExc;
+class EnomemExc;
+class EaccesExc;
+class EfaultExc;
+class EnotblkExc;
+class EbusyExc;
+class EexistExc;
+class ExdevExc;
+class EnodevExc;
+class EnotdirExc;
+class EisdirExc;
+class EinvalExc;
+class EnfileExc;
+class EmfileExc;
+class EnottyExc;
+class EtxtbsyExc;
+class EfbigExc;
+class EnospcExc;
+class EspipeExc;
+class ErofsExc;
+class EmlinkExc;
+class EpipeExc;
+class EdomExc;
+class ErangeExc;
+class EnomsgExc;
+class EidrmExc;
+class EchrngExc;
+class El2nsyncExc;
+class El3hltExc;
+class El3rstExc;
+class ElnrngExc;
+class EunatchExc;
+class EnocsiExc;
+class El2hltExc;
+class EdeadlkExc;
+class EnolckExc;
+class EbadeExc;
+class EbadrExc;
+class ExfullExc;
+class EnoanoExc;
+class EbadrqcExc;
+class EbadsltExc;
+class EdeadlockExc;
+class EbfontExc;
+class EnostrExc;
+class EnodataExc;
+class EtimeExc;
+class EnosrExc;
+class EnonetExc;
+class EnopkgExc;
+class EremoteExc;
+class EnolinkExc;
+class EadvExc;
+class EsrmntExc;
+class EcommExc;
+class EprotoExc;
+class EmultihopExc;
+class EbadmsgExc;
+class EnametoolongExc;
+class EoverflowExc;
+class EnotuniqExc;
+class EbadfdExc;
+class EremchgExc;
+class ElibaccExc;
+class ElibbadExc;
+class ElibscnExc;
+class ElibmaxExc;
+class ElibexecExc;
+class EilseqExc;
+class EnosysExc;
+class EloopExc;
+class ErestartExc;
+class EstrpipeExc;
+class EnotemptyExc;
+class EusersExc;
+class EnotsockExc;
+class EdestaddrreqExc;
+class EmsgsizeExc;
+class EprototypeExc;
+class EnoprotooptExc;
+class EprotonosupportExc;
+class EsocktnosupportExc;
+class EopnotsuppExc;
+class EpfnosupportExc;
+class EafnosupportExc;
+class EaddrinuseExc;
+class EaddrnotavailExc;
+class EnetdownExc;
+class EnetunreachExc;
+class EnetresetExc;
+class EconnabortedExc;
+class EconnresetExc;
+class EnobufsExc;
+class EisconnExc;
+class EnotconnExc;
+class EshutdownExc;
+class EtoomanyrefsExc;
+class EtimedoutExc;
+class EconnrefusedExc;
+class EhostdownExc;
+class EhostunreachExc;
+class EalreadyExc;
+class EinprogressExc;
+class EstaleExc;
+class EioresidExc;
+class EucleanExc;
+class EnotnamExc;
+class EnavailExc;
+class EisnamExc;
+class EremoteioExc;
+class EinitExc;
+class EremdevExc;
+class EcanceledExc;
+class EnolimfileExc;
+class EproclimExc;
+class EdisjointExc;
+class EnologinExc;
+class EloginlimExc;
+class EgrouploopExc;
+class EnoattachExc;
+class EnotsupExc;
+class EnoattrExc;
+class EdircorruptedExc;
+class EdquotExc;
+class EnfsremoteExc;
+class EcontrollerExc;
+class EnotcontrollerExc;
+class EenqueuedExc;
+class EnotenqueuedExc;
+class EjoinedExc;
+class EnotjoinedExc;
+class EnoprocExc;
+class EmustrunExc;
+class EnotstoppedExc;
+class EclockcpuExc;
+class EinvalstateExc;
+class EnoexistExc;
+class EendofminorExc;
+class EbufsizeExc;
+class EemptyExc;
+class EnointrgroupExc;
+class EinvalmodeExc;
+class EcantextentExc;
+class EinvaltimeExc;
+class EdestroyedExc;
+
+IEX_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif // INCLUDED_IEXFORWARD_H

3rdparty/openexr/Iex/IexMacros.h

@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
+// Copyright (c) 2002-2018, Industrial Light & Magic, a division of Lucas
 // Digital Ltd. LLC
 // 
 // All rights reserved.
@@ -55,13 +55,19 @@
 //	
 //----------------------------------------------------------------------------
 
-#define THROW(type, text)	\
+#include "IexExport.h"
-    do				\
+#include "IexForward.h"
-    {				\
+
-    std::stringstream s;	\
+IEX_EXPORT void iex_debugTrap();
-    s << text;		\
+
-    throw type (s);		\
+#define THROW(type, text)                  \
-    }				\
+    do                                     \
+    {                                      \
+        iex_debugTrap();                   \
+        std::stringstream _iex_throw_s;	   \
+        _iex_throw_s << text;              \
+        throw type (_iex_throw_s);         \
+    }                                      \
     while (0)
 
 
@@ -88,22 +94,22 @@
 //	}
 //----------------------------------------------------------------------------
 
-#define APPEND_EXC(exc, text)	\
+#define APPEND_EXC(exc, text)               \
-    do				\
+    do                                      \
-    {				\
+    {                                       \
-    std::stringstream s;	\
+        std::stringstream _iex_append_s;    \
-    s << text;		\
+        _iex_append_s << text;              \
-    exc.append (s);		\
+        exc.append (_iex_append_s);         \
-    }				\
+    }                                       \
     while (0)
 
-#define REPLACE_EXC(exc, text)	\
+#define REPLACE_EXC(exc, text)               \
-    do				\
+    do                                       \
-    {				\
+    {                                        \
-    std::stringstream s;	\
+        std::stringstream _iex_replace_s;    \
-    s << text;		\
+        _iex_replace_s << text;              \
-    exc.assign (s);		\
+        exc.assign (_iex_replace_s);         \
-    }				\
+    }                                        \
     while (0)
 
 
@@ -117,13 +123,13 @@
 //
 //-------------------------------------------------------------
 
-#define THROW_ERRNO(text)		\
+#define THROW_ERRNO(text)                                          \
-    do					\
+    do                                                             \
-    {					\
+    {                                                              \
-    std::stringstream s;		\
+        std::stringstream _iex_throw_errno_s;                      \
-    s << text;			\
+        _iex_throw_errno_s << text;                                \
-    ::Iex::throwErrnoExc (s.str());	\
+        ::IEX_NAMESPACE::throwErrnoExc (_iex_throw_errno_s.str()); \
-    }					\
+    }                                                              \
     while (0)
 
 
@@ -132,17 +138,33 @@
 //
 // Example:
 //
-//	ASSERT (ptr != NULL, NullExc, "Null pointer" );
+//	ASSERT (ptr != 0, NullExc, "Null pointer" );
 //
 //-------------------------------------------------------------
 
 #define ASSERT(assertion, type, text)   \
     do                                  \
     {                                   \
-    if ((assertion) == false)       \
+        if( bool(assertion) == false )      \
-        THROW (type, text);         \
+        {                               \
+            THROW( type, text );        \
+        }                               \
     }                                   \
     while (0)
 
+//-------------------------------------------------------------
+// A macro to throw an IEX_NAMESPACE::LogicExc if an assertion is false,
+// with the text composed from the source code file, line number,
+// and assertion argument text.
+//
+// Example:
+//
+//      LOGIC_ASSERT (i < n);
+//
+//-------------------------------------------------------------
+#define LOGIC_ASSERT(assertion)           \
+    ASSERT(assertion,                     \
+           IEX_NAMESPACE::LogicExc,       \
+           __FILE__ << "(" << __LINE__ << "): logical assertion failed: " << #assertion )
 
 #endif

3rdparty/openexr/Iex/IexMathExc.h

@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
+// Copyright (c) 2002-2012, Industrial Light & Magic, a division of Lucas
 // Digital Ltd. LLC
 // 
 // All rights reserved.
@@ -39,7 +39,7 @@
 
 #include "IexBaseExc.h"
 
-namespace Iex {
+IEX_INTERNAL_NAMESPACE_HEADER_ENTER
 
 //---------------------------------------------------------
 // Exception classess which correspond to specific floating
@@ -52,7 +52,6 @@ DEFINE_EXC (DivzeroExc,     MathExc)	// Division by zero
 DEFINE_EXC (InexactExc,     MathExc)	// Inexact result
 DEFINE_EXC (InvalidFpOpExc, MathExc)	// Invalid operation
 
+IEX_INTERNAL_NAMESPACE_HEADER_EXIT
 
-} // namespace Iex
+#endif // INCLUDED_IEXMATHEXC_H
-
-#endif

3rdparty/openexr/Iex/IexNamespace.h

@@ -0,0 +1,112 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2012, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDED_IEXNAMESPACE_H
+#define INCLUDED_IEXNAMESPACE_H
+
+//
+// The purpose of this file is to make it possible to specify an
+// IEX_INTERNAL_NAMESPACE as a preprocessor definition and have all of the
+// Iex symbols defined within that namespace rather than the standard
+// Iex namespace.  Those symbols are made available to client code through
+// the IEX_NAMESPACE in addition to the IEX_INTERNAL_NAMESPACE.
+//
+// To ensure source code compatibility, the IEX_NAMESPACE defaults to Iex
+// and then "using namespace IEX_INTERNAL_NAMESPACE;" brings all of the
+// declarations from the IEX_INTERNAL_NAMESPACE into the IEX_NAMESPACE.  This
+// means that client code can continue to use syntax like Iex::BaseExc, but
+// at link time it will resolve to a mangled symbol based on the
+// IEX_INTERNAL_NAMESPACE.
+//
+// As an example, if one needed to build against a newer version of Iex and
+// have it run alongside an older version in the same application, it is now
+// possible to use an internal namespace to prevent collisions between the
+// older versions of Iex symbols and the newer ones.  To do this, the
+// following could be defined at build time:
+//
+// IEX_INTERNAL_NAMESPACE = Iex_v2
+//
+// This means that declarations inside Iex headers look like this (after the
+// preprocessor has done its work):
+//
+// namespace Iex_v2 {
+//     ...
+//     class declarations
+//     ...
+// }
+//
+// namespace Iex {
+//     using namespace Iex_v2;
+// }
+//
+
+//
+// Open Source version of this file pulls in the IlmBaseConfig.h file
+// for the configure time options.
+//
+#include "IlmBaseConfig.h"
+
+#ifndef IEX_NAMESPACE
+#define IEX_NAMESPACE Iex
+#endif
+
+#ifndef IEX_INTERNAL_NAMESPACE
+#define IEX_INTERNAL_NAMESPACE IEX_NAMESPACE
+#endif
+
+//
+// We need to be sure that we import the internal namespace into the public one.
+// To do this, we use the small bit of code below which initially defines
+// IEX_INTERNAL_NAMESPACE (so it can be referenced) and then defines
+// IEX_NAMESPACE and pulls the internal symbols into the public namespace.
+//
+
+namespace IEX_INTERNAL_NAMESPACE {}
+namespace IEX_NAMESPACE {
+    using namespace IEX_INTERNAL_NAMESPACE;
+}
+
+//
+// There are identical pairs of HEADER/SOURCE ENTER/EXIT macros so that
+// future extension to the namespace mechanism is possible without changing
+// project source code.
+//
+
+#define IEX_INTERNAL_NAMESPACE_HEADER_ENTER namespace IEX_INTERNAL_NAMESPACE {
+#define IEX_INTERNAL_NAMESPACE_HEADER_EXIT }
+
+#define IEX_INTERNAL_NAMESPACE_SOURCE_ENTER namespace IEX_INTERNAL_NAMESPACE {
+#define IEX_INTERNAL_NAMESPACE_SOURCE_EXIT }
+
+#endif // INCLUDED_IEXNAMESPACE_H

3rdparty/openexr/Iex/IexThrowErrnoExc.h

@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
+// Copyright (c) 2002-2012, Industrial Light & Magic, a division of Lucas
 // Digital Ltd. LLC
 // 
 // All rights reserved.
@@ -44,8 +44,9 @@
 //----------------------------------------------------------
 
 #include "IexBaseExc.h"
+#include "IexExport.h"
 
-namespace Iex {
+IEX_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
 //--------------------------------------------------------------------------
@@ -87,10 +88,10 @@ namespace Iex {
 //
 //--------------------------------------------------------------------------
 
-void throwErrnoExc (const std::string &txt, int errnum);
+IEX_EXPORT void throwErrnoExc(const std::string &txt, int errnum);
-void throwErrnoExc (const std::string &txt = "%T." /*, int errnum = oserror() */);
+IEX_EXPORT void throwErrnoExc(const std::string &txt);
+IEX_EXPORT void throwErrnoExc();
 
+IEX_INTERNAL_NAMESPACE_HEADER_EXIT
 
-} // namespace Iex
+#endif // INCLUDED_IEXTHROWERRNOEXC_H
-
-#endif

3rdparty/openexr/IlmBaseConfig.h.cmakein

@@ -1,3 +1,15 @@
+#cmakedefine PLATFORM_WINDOWS
+
+//
+// Define and set to 1 if the target system has c++11/14 support
+// and you want IlmBase to NOT use it's features
+//
+
+#cmakedefine01 ILMBASE_FORCE_CXX03
+#if ILMBASE_FORCE_CXX03 == 0
+#undef ILMBASE_FORCE_CXX03
+#endif
+
 //
 // Define and set to 1 if the target system has POSIX thread support
 // and you want IlmBase to use it for multithreaded file I/O.
@@ -13,18 +25,59 @@
 
 #cmakedefine01 HAVE_POSIX_SEMAPHORES
 
-#undef HAVE_UCONTEXT_H
+
+#cmakedefine HAVE_UCONTEXT_H
+
+
+//
+// Dealing with FPEs
+//
+#cmakedefine01 ILMBASE_HAVE_CONTROL_REGISTER_SUPPORT
+
 
 //
 // Define and set to 1 if the target system has support for large
 // stack sizes.
 //
 
-#undef ILMBASE_HAVE_LARGE_STACK
+#cmakedefine ILMBASE_HAVE_LARGE_STACK
+
+//
+// Current (internal) library namepace name and corresponding public
+// client namespaces.
+//
+#define ILMBASE_INTERNAL_NAMESPACE_CUSTOM @ILMBASE_INTERNAL_NAMESPACE_CUSTOM@
+#define IMATH_INTERNAL_NAMESPACE @IMATH_INTERNAL_NAMESPACE@
+#define IEX_INTERNAL_NAMESPACE @IEX_INTERNAL_NAMESPACE@
+#define ILMTHREAD_INTERNAL_NAMESPACE @ILMTHREAD_INTERNAL_NAMESPACE@
+
+#define ILMBASE_NAMESPACE_CUSTOM @ILMBASE_NAMESPACE_CUSTOM@
+#define IMATH_NAMESPACE @IMATH_NAMESPACE@
+#define IEX_NAMESPACE @IEX_NAMESPACE@
+#define ILMTHREAD_NAMESPACE @ILMTHREAD_NAMESPACE@
 
 
 //
-// Version string for runtime access
+// Define and set to 1 if the target system has support for large
+// stack sizes.
 //
-#define ILMBASE_VERSION_STRING "1.0.3"
+
-#define ILMBASE_PACKAGE_STRING "IlmBase 1.0.3"
+#cmakedefine ILMBASE_HAVE_LARGE_STACK
+
+
+//
+// Version information
+//
+#define ILMBASE_VERSION_STRING @ILMBASE_VERSION_STRING@
+#define ILMBASE_PACKAGE_STRING @ILMBASE_PACKAGE_STRING@
+
+#define ILMBASE_VERSION_MAJOR @ILMBASE_VERSION_MAJOR@
+#define ILMBASE_VERSION_MINOR @ILMBASE_VERSION_MINOR@
+#define ILMBASE_VERSION_PATCH @ILMBASE_VERSION_PATCH@
+
+// Version as a single hex number, e.g. 0x01000300 == 1.0.3
+#define ILMBASE_VERSION_HEX ((ILMBASE_VERSION_MAJOR << 24) | \
+                             (ILMBASE_VERSION_MINOR << 16) | \
+                             (ILMBASE_VERSION_PATCH <<  8))
+
+

3rdparty/openexr/IlmImf/ImfAcesFile.cpp

@@ -42,23 +42,24 @@
 #include <ImfRgbaFile.h>
 #include <ImfStandardAttributes.h>
 #include <Iex.h>
-#include <algorithm> // for std::max()
+#include <algorithm>
 
 using namespace std;
-using namespace Imath;
+using namespace IMATH_NAMESPACE;
-using namespace Iex;
+using namespace IEX_NAMESPACE;
+#include "ImfNamespace.h"
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
 
 
 const Chromaticities &
 acesChromaticities ()
 {
     static const Chromaticities acesChr 
-        (V2f (0.73470,  0.26530),	// red
+	    (V2f (0.73470,  0.26530),	// red
-         V2f (0.00000,  1.00000),	// green
+	     V2f (0.00000,  1.00000),	// green
-         V2f (0.00010, -0.07700),	// blue
+	     V2f (0.00010, -0.07700),	// blue
-         V2f (0.32168,  0.33767));	// white
+	     V2f (0.32168,  0.33767));	// white
 
     return acesChr;
 }
@@ -102,10 +103,10 @@ checkCompression (Compression compression)
       case NO_COMPRESSION:
       case PIZ_COMPRESSION:
       case B44A_COMPRESSION:
-    break;
+	break;
 
       default:
-    throw ArgExc ("Invalid compression type for ACES file.");
+	throw ArgExc ("Invalid compression type for ACES file.");
     }
 }
 
@@ -127,16 +128,16 @@ AcesOutputFile::AcesOutputFile
     addAdoptedNeutral (newHeader, acesChromaticities().white);
 
     _data->rgbaFile = new RgbaOutputFile (name.c_str(),
-                      newHeader,
+					  newHeader,
-                      rgbaChannels,
+					  rgbaChannels,
-                      numThreads);
+					  numThreads);
 
     _data->rgbaFile->setYCRounding (7, 6);
 }
 
 
 AcesOutputFile::AcesOutputFile
-    (OStream &os,
+    (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os,
      const Header &header,
      RgbaChannels rgbaChannels,
      int numThreads)
@@ -150,9 +151,9 @@ AcesOutputFile::AcesOutputFile
     addAdoptedNeutral (newHeader, acesChromaticities().white);
 
     _data->rgbaFile = new RgbaOutputFile (os,
-                      header,
+					  header,
-                      rgbaChannels,
+					  rgbaChannels,
-                      numThreads);
+					  numThreads);
 
     _data->rgbaFile->setYCRounding (7, 6);
 }
@@ -160,11 +161,11 @@ AcesOutputFile::AcesOutputFile
 
 AcesOutputFile::AcesOutputFile
     (const std::string &name,
-     const Imath::Box2i &displayWindow,
+     const IMATH_NAMESPACE::Box2i &displayWindow,
-     const Imath::Box2i &dataWindow,
+     const IMATH_NAMESPACE::Box2i &dataWindow,
      RgbaChannels rgbaChannels,
      float pixelAspectRatio,
-     const Imath::V2f screenWindowCenter,
+     const IMATH_NAMESPACE::V2f screenWindowCenter,
      float screenWindowWidth,
      LineOrder lineOrder,
      Compression compression,
@@ -175,20 +176,20 @@ AcesOutputFile::AcesOutputFile
     checkCompression (compression);
 
     Header newHeader (displayWindow,
-              dataWindow.isEmpty()? displayWindow: dataWindow,
+		      dataWindow.isEmpty()? displayWindow: dataWindow,
-              pixelAspectRatio,
+		      pixelAspectRatio,
-              screenWindowCenter,
+		      screenWindowCenter,
-              screenWindowWidth,
+		      screenWindowWidth,
-              lineOrder,
+		      lineOrder,
-              compression);
+		      compression);
 
     addChromaticities (newHeader, acesChromaticities());
     addAdoptedNeutral (newHeader, acesChromaticities().white);
 
     _data->rgbaFile = new RgbaOutputFile (name.c_str(),
-                      newHeader,
+					  newHeader,
-                      rgbaChannels,
+					  rgbaChannels,
-                      numThreads);
+					  numThreads);
 
     _data->rgbaFile->setYCRounding (7, 6);
 }
@@ -200,7 +201,7 @@ AcesOutputFile::AcesOutputFile
      int height,
      RgbaChannels rgbaChannels,
      float pixelAspectRatio,
-     const Imath::V2f screenWindowCenter,
+     const IMATH_NAMESPACE::V2f screenWindowCenter,
      float screenWindowWidth,
      LineOrder lineOrder,
      Compression compression,
@@ -211,20 +212,20 @@ AcesOutputFile::AcesOutputFile
     checkCompression (compression);
 
     Header newHeader (width,
-              height,
+		      height,
-              pixelAspectRatio,
+		      pixelAspectRatio,
-              screenWindowCenter,
+		      screenWindowCenter,
-              screenWindowWidth,
+		      screenWindowWidth,
-              lineOrder,
+		      lineOrder,
-              compression);
+		      compression);
 
     addChromaticities (newHeader, acesChromaticities());
     addAdoptedNeutral (newHeader, acesChromaticities().white);
 
     _data->rgbaFile = new RgbaOutputFile (name.c_str(),
-                      newHeader,
+					  newHeader,
-                      rgbaChannels,
+					  rgbaChannels,
-                      numThreads);
+					  numThreads);
 
     _data->rgbaFile->setYCRounding (7, 6);
 }
@@ -267,14 +268,14 @@ AcesOutputFile::header () const
 }
 
 
-const Imath::Box2i &
+const IMATH_NAMESPACE::Box2i &
 AcesOutputFile::displayWindow () const
 {
     return _data->rgbaFile->displayWindow();
 }
 
 
-const Imath::Box2i &
+const IMATH_NAMESPACE::Box2i &
 AcesOutputFile::dataWindow () const
 {
     return _data->rgbaFile->dataWindow();
@@ -288,7 +289,7 @@ AcesOutputFile::pixelAspectRatio () const
 }
 
 
-const Imath::V2f
+const IMATH_NAMESPACE::V2f
 AcesOutputFile::screenWindowCenter () const
 {
     return _data->rgbaFile->screenWindowCenter();
@@ -379,28 +380,28 @@ AcesInputFile::Data::initColorConversion ()
     Chromaticities fileChr;
 
     if (hasChromaticities (header))
-    fileChr = chromaticities (header);
+	fileChr = chromaticities (header);
 
     V2f fileNeutral = fileChr.white;
 
     if (hasAdoptedNeutral (header))
-    fileNeutral = adoptedNeutral (header);
+	fileNeutral = adoptedNeutral (header);
 
     const Chromaticities acesChr = acesChromaticities();
 
     V2f acesNeutral = acesChr.white;
 
     if (fileChr.red == acesChr.red &&
-    fileChr.green == acesChr.green &&
+	fileChr.green == acesChr.green &&
-    fileChr.blue == acesChr.blue &&
+	fileChr.blue == acesChr.blue &&
-    fileChr.white == acesChr.white &&
+	fileChr.white == acesChr.white &&
-    fileNeutral == acesNeutral)
+	fileNeutral == acesNeutral)
     {
-    //
+	//
-    // The file already contains ACES data,
+	// The file already contains ACES data,
-    // color conversion is not necessary.
+	// color conversion is not necessary.
 
-    return;
+	return;
     }
 
     mustConvertColor = true;
@@ -419,16 +420,16 @@ AcesInputFile::Data::initColorConversion ()
     //
 
     static const M44f bradfordCPM
-        (0.895100, -0.750200,  0.038900,  0.000000,
+	    (0.895100, -0.750200,  0.038900,  0.000000,
-         0.266400,  1.713500, -0.068500,  0.000000,
+	     0.266400,  1.713500, -0.068500,  0.000000,
-        -0.161400,  0.036700,  1.029600,  0.000000,
+	    -0.161400,  0.036700,  1.029600,  0.000000,
-         0.000000,  0.000000,  0.000000,  1.000000);
+	     0.000000,  0.000000,  0.000000,  1.000000);
 
     const static M44f inverseBradfordCPM
-        (0.986993,  0.432305, -0.008529,  0.000000,
+	    (0.986993,  0.432305, -0.008529,  0.000000,
-        -0.147054,  0.518360,  0.040043,  0.000000,
+	    -0.147054,  0.518360,  0.040043,  0.000000,
-         0.159963,  0.049291,  0.968487,  0.000000,
+	     0.159963,  0.049291,  0.968487,  0.000000,
-         0.000000,  0.000000,  0.000000,  1.000000);
+	     0.000000,  0.000000,  0.000000,  1.000000);
 
     //
     // Convert the white points of the two RGB spaces to XYZ
@@ -447,16 +448,16 @@ AcesInputFile::Data::initColorConversion ()
     //
 
     V3f ratio ((acesNeutralXYZ * bradfordCPM) /
-           (fileNeutralXYZ * bradfordCPM));
+	       (fileNeutralXYZ * bradfordCPM));
 
     M44f ratioMat (ratio[0], 0,        0,        0,
-           0,        ratio[1], 0,        0,
+		   0,        ratio[1], 0,        0,
-           0,        0,        ratio[2], 0,
+		   0,        0,        ratio[2], 0,
-           0,        0,        0,        1);
+		   0,        0,        0,        1);
 
     M44f bradfordTrans = bradfordCPM *
                          ratioMat *
-             inverseBradfordCPM;
+			 inverseBradfordCPM;
 
     //
     // Build a combined file-RGB-to-ACES-RGB conversion matrix
@@ -514,27 +515,27 @@ AcesInputFile::readPixels (int scanLine1, int scanLine2)
     //
 
     if (!_data->mustConvertColor)
-    return;
+	return;
 
     int minY = min (scanLine1, scanLine2);
     int maxY = max (scanLine1, scanLine2);
 
     for (int y = minY; y <= maxY; ++y)
     {
-    Rgba *base = _data->fbBase +
+	Rgba *base = _data->fbBase +
-             _data->fbXStride * _data->minX +
+		     _data->fbXStride * _data->minX +
-             _data->fbYStride * y;
+		     _data->fbYStride * y;
 
-    for (int x = _data->minX; x <= _data->maxX; ++x)
+	for (int x = _data->minX; x <= _data->maxX; ++x)
-    {
+	{
-        V3f aces = V3f (base->r, base->g, base->b) * _data->fileToAces;
+	    V3f aces = V3f (base->r, base->g, base->b) * _data->fileToAces;
 
-        base->r = aces[0];
+	    base->r = aces[0];
-        base->g = aces[1];
+	    base->g = aces[1];
-        base->b = aces[2];
+	    base->b = aces[2];
 
-        base += _data->fbXStride;
+	    base += _data->fbXStride;
-    }
+	}
     }
 }
 
@@ -553,14 +554,14 @@ AcesInputFile::header () const
 }
 
 
-const Imath::Box2i &
+const IMATH_NAMESPACE::Box2i &
 AcesInputFile::displayWindow () const
 {
     return _data->rgbaFile->displayWindow();
 }
 
 
-const Imath::Box2i &
+const IMATH_NAMESPACE::Box2i &
 AcesInputFile::dataWindow () const
 {
     return _data->rgbaFile->dataWindow();
@@ -574,7 +575,7 @@ AcesInputFile::pixelAspectRatio () const
 }
 
 
-const Imath::V2f
+const IMATH_NAMESPACE::V2f
 AcesInputFile::screenWindowCenter () const
 {
     return _data->rgbaFile->screenWindowCenter();
@@ -629,4 +630,4 @@ AcesInputFile::version () const
     return _data->rgbaFile->version();
 }
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfAcesFile.h

@@ -77,21 +77,20 @@
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfHeader.h>
+#include "ImfHeader.h"
-#include <ImfRgba.h>
+#include "ImfRgba.h"
 #include "ImathVec.h"
 #include "ImathBox.h"
-#include <ImfThreading.h>
+#include "ImfThreading.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+#include "ImfForward.h"
+
 #include <string>
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
-class RgbaOutputFile;
-class RgbaInputFile;
-struct PreviewRgba;
-struct Chromaticities;
-
 //
 // ACES red, green, blue and white-point chromaticities.
 //
@@ -111,9 +110,10 @@ class AcesOutputFile
     // Constructor -- header is constructed by the caller
     //---------------------------------------------------
 
+    IMF_EXPORT
     AcesOutputFile (const std::string &name,
-            const Header &header,
+		    const Header &header,
-            RgbaChannels rgbaChannels = WRITE_RGBA,
+		    RgbaChannels rgbaChannels = WRITE_RGBA,
                     int numThreads = globalThreadCount());
 
 
@@ -123,9 +123,10 @@ class AcesOutputFile
     // automatically close the file.
     //----------------------------------------------------
 
-    AcesOutputFile (OStream &os,
+    IMF_EXPORT
-            const Header &header,
+    AcesOutputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os,
-            RgbaChannels rgbaChannels = WRITE_RGBA,
+		    const Header &header,
+		    RgbaChannels rgbaChannels = WRITE_RGBA,
                     int numThreads = globalThreadCount());
 
 
@@ -134,15 +135,16 @@ class AcesOutputFile
     // call arguments (empty dataWindow means "same as displayWindow")
     //----------------------------------------------------------------
 
+    IMF_EXPORT
     AcesOutputFile (const std::string &name,
-            const Imath::Box2i &displayWindow,
+		    const IMATH_NAMESPACE::Box2i &displayWindow,
-            const Imath::Box2i &dataWindow = Imath::Box2i(),
+		    const IMATH_NAMESPACE::Box2i &dataWindow = IMATH_NAMESPACE::Box2i(),
-            RgbaChannels rgbaChannels = WRITE_RGBA,
+		    RgbaChannels rgbaChannels = WRITE_RGBA,
-            float pixelAspectRatio = 1,
+		    float pixelAspectRatio = 1,
-            const Imath::V2f screenWindowCenter = Imath::V2f (0, 0),
+		    const IMATH_NAMESPACE::V2f screenWindowCenter = IMATH_NAMESPACE::V2f (0, 0),
-            float screenWindowWidth = 1,
+		    float screenWindowWidth = 1,
-            LineOrder lineOrder = INCREASING_Y,
+		    LineOrder lineOrder = INCREASING_Y,
-            Compression compression = PIZ_COMPRESSION,
+		    Compression compression = PIZ_COMPRESSION,
                     int numThreads = globalThreadCount());
 
 
@@ -152,15 +154,16 @@ class AcesOutputFile
     // Box2i (V2i (0, 0), V2i (width - 1, height -1))
     //-----------------------------------------------
 
+    IMF_EXPORT
     AcesOutputFile (const std::string &name,
-            int width,
+		    int width,
-            int height,
+		    int height,
-            RgbaChannels rgbaChannels = WRITE_RGBA,
+		    RgbaChannels rgbaChannels = WRITE_RGBA,
-            float pixelAspectRatio = 1,
+		    float pixelAspectRatio = 1,
-            const Imath::V2f screenWindowCenter = Imath::V2f (0, 0),
+		    const IMATH_NAMESPACE::V2f screenWindowCenter = IMATH_NAMESPACE::V2f (0, 0),
-            float screenWindowWidth = 1,
+		    float screenWindowWidth = 1,
-            LineOrder lineOrder = INCREASING_Y,
+		    LineOrder lineOrder = INCREASING_Y,
-            Compression compression = PIZ_COMPRESSION,
+		    Compression compression = PIZ_COMPRESSION,
                     int numThreads = globalThreadCount());
 
 
@@ -168,6 +171,7 @@ class AcesOutputFile
     // Destructor
     //-----------
 
+    IMF_EXPORT
     virtual ~AcesOutputFile ();
 
 
@@ -179,9 +183,10 @@ class AcesOutputFile
     //
     //------------------------------------------------
 
+    IMF_EXPORT
     void			setFrameBuffer (const Rgba *base,
-                        size_t xStride,
+						size_t xStride,
-                        size_t yStride);
+						size_t yStride);
 
 
     //-------------------------------------------------
@@ -197,14 +202,23 @@ class AcesOutputFile
     // Access to the file header
     //--------------------------
 
+    IMF_EXPORT
     const Header &		header () const;
-    const Imath::Box2i &	displayWindow () const;
+    IMF_EXPORT
-    const Imath::Box2i &	dataWindow () const;
+    const IMATH_NAMESPACE::Box2i &	displayWindow () const;
+    IMF_EXPORT
+    const IMATH_NAMESPACE::Box2i &	dataWindow () const;
+    IMF_EXPORT
     float			pixelAspectRatio () const;
-    const Imath::V2f		screenWindowCenter () const;
+    IMF_EXPORT
+    const IMATH_NAMESPACE::V2f		screenWindowCenter () const;
+    IMF_EXPORT
     float			screenWindowWidth () const;
+    IMF_EXPORT
     LineOrder			lineOrder () const;
+    IMF_EXPORT
     Compression			compression () const;
+    IMF_EXPORT
     RgbaChannels		channels () const;
 
 
@@ -212,6 +226,7 @@ class AcesOutputFile
     // Update the preview image (see Imf::OutputFile::updatePreviewImage())
     // --------------------------------------------------------------------
 
+    IMF_EXPORT
     void			updatePreviewImage (const PreviewRgba[]);
 
 
@@ -239,8 +254,9 @@ class AcesInputFile
     // destructor will automatically close the file.
     //-------------------------------------------------------
 
+    IMF_EXPORT
     AcesInputFile (const std::string &name,
-           int numThreads = globalThreadCount());
+		   int numThreads = globalThreadCount());
 
 
     //-----------------------------------------------------------
@@ -250,14 +266,16 @@ class AcesInputFile
     // close the file.
     //-----------------------------------------------------------
 
-    AcesInputFile (IStream &is,
+    IMF_EXPORT
-           int numThreads = globalThreadCount());
+    AcesInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is,
+		   int numThreads = globalThreadCount());
 
 
     //-----------
     // Destructor
     //-----------
 
+    IMF_EXPORT
     virtual ~AcesInputFile ();
 
 
@@ -269,9 +287,10 @@ class AcesInputFile
     //
     //-----------------------------------------------------
 
+    IMF_EXPORT
     void			setFrameBuffer (Rgba *base,
-                        size_t xStride,
+						size_t xStride,
-                        size_t yStride);
+						size_t yStride);
 
 
     //--------------------------------------------
@@ -279,7 +298,9 @@ class AcesInputFile
     // Pixels returned will contain ACES RGB data.
     //--------------------------------------------
 
+    IMF_EXPORT
     void			readPixels (int scanLine1, int scanLine2);
+    IMF_EXPORT
     void			readPixels (int scanLine);
 
 
@@ -287,16 +308,27 @@ class AcesInputFile
     // Access to the file header
     //--------------------------
 
+    IMF_EXPORT
     const Header &		header () const;
-    const Imath::Box2i &	displayWindow () const;
+    IMF_EXPORT
-    const Imath::Box2i &	dataWindow () const;
+    const IMATH_NAMESPACE::Box2i &	displayWindow () const;
+    IMF_EXPORT
+    const IMATH_NAMESPACE::Box2i &	dataWindow () const;
+    IMF_EXPORT
     float			pixelAspectRatio () const;
-    const Imath::V2f		screenWindowCenter () const;
+    IMF_EXPORT
+    const IMATH_NAMESPACE::V2f		screenWindowCenter () const;
+    IMF_EXPORT
     float			screenWindowWidth () const;
+    IMF_EXPORT
     LineOrder			lineOrder () const;
+    IMF_EXPORT
     Compression			compression () const;
+    IMF_EXPORT
     RgbaChannels		channels () const;
+    IMF_EXPORT
     const char *                fileName () const;
+    IMF_EXPORT
     bool			isComplete () const;
 
 
@@ -304,6 +336,7 @@ class AcesInputFile
     // Access to the file format version
     //----------------------------------
 
+    IMF_EXPORT
     int				version () const;
 
   private:
@@ -317,6 +350,9 @@ class AcesInputFile
 };
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+
+
 
 #endif

3rdparty/openexr/IlmImf/ImfArray.h

@@ -37,6 +37,8 @@
 #ifndef INCLUDED_IMF_ARRAY_H
 #define INCLUDED_IMF_ARRAY_H
 
+#include "ImfForward.h"
+
 //-------------------------------------------------------------------------
 //
 // class Array
@@ -69,8 +71,7 @@
 //
 //-------------------------------------------------------------------------
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
-
 
 template <class T>
 class Array
@@ -81,8 +82,8 @@ class Array
     // Constructors and destructors
     //-----------------------------
 
-     Array ()				{_data = 0;}
+     Array ()				{_data = 0; _size = 0;}
-     Array (long size)			{_data = new T[size];}
+     Array (long size)			{_data = new T[size]; _size = size;}
     ~Array ()				{delete [] _data;}
 
 
@@ -110,11 +111,19 @@ class Array
     void resizeEraseUnsafe (long size);
 
 
+    //-------------------------------
+    // Return the size of this array.
+    //-------------------------------
+
+    long size() const   {return _size;}
+
+
   private:
 
     Array (const Array &);		// Copying and assignment
     Array & operator = (const Array &);	// are not implemented
 
+    long _size;
     T * _data;
 };
 
@@ -157,11 +166,20 @@ class Array2D
     void resizeEraseUnsafe (long sizeX, long sizeY);
 
 
+    //-------------------------------
+    // Return the size of this array.
+    //-------------------------------
+
+    long height() const  {return _sizeX;}
+    long width() const   {return _sizeY;}
+
+
   private:
 
     Array2D (const Array2D &);			// Copying and assignment
     Array2D & operator = (const Array2D &);	// are not implemented
 
+    long        _sizeX;
     long	_sizeY;
     T *		_data;
 };
@@ -177,6 +195,7 @@ Array<T>::resizeErase (long size)
 {
     T *tmp = new T[size];
     delete [] _data;
+    _size = size;
     _data = tmp;
 }
 
@@ -187,14 +206,16 @@ Array<T>::resizeEraseUnsafe (long size)
 {
     delete [] _data;
     _data = 0;
+    _size = 0;
     _data = new T[size];
+    _size = size;
 }
 
 
 template <class T>
 inline
 Array2D<T>::Array2D ():
-    _sizeY (0), _data (0)
+    _sizeX(0), _sizeY (0), _data (0)
 {
     // emtpy
 }
@@ -203,7 +224,7 @@ Array2D<T>::Array2D ():
 template <class T>
 inline
 Array2D<T>::Array2D (long sizeX, long sizeY):
-    _sizeY (sizeY), _data (new T[sizeX * sizeY])
+    _sizeX (sizeX), _sizeY (sizeY), _data (new T[sizeX * sizeY])
 {
     // emtpy
 }
@@ -239,6 +260,7 @@ Array2D<T>::resizeErase (long sizeX, long sizeY)
 {
     T *tmp = new T[sizeX * sizeY];
     delete [] _data;
+    _sizeX = sizeX;
     _sizeY = sizeY;
     _data = tmp;
 }
@@ -250,12 +272,14 @@ Array2D<T>::resizeEraseUnsafe (long sizeX, long sizeY)
 {
     delete [] _data;
     _data = 0;
+    _sizeX = 0;
     _sizeY = 0;
     _data = new T[sizeX * sizeY];
+    _sizeX = sizeX;
     _sizeY = sizeY;
 }
 
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
 
-} // namespace Imf
 
 #endif

3rdparty/openexr/IlmImf/ImfAttribute.cpp

@@ -46,11 +46,13 @@
 #include <string.h>
 #include <map>
 
+#include "ImfNamespace.h"
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER 
 
-using IlmThread::Mutex;
+
-using IlmThread::Lock;
+using ILMTHREAD_NAMESPACE::Mutex;
+using ILMTHREAD_NAMESPACE::Lock;
 
 
 Attribute::Attribute () {}
@@ -66,7 +68,7 @@ struct NameCompare: std::binary_function <const char *, const char *, bool>
     bool
     operator () (const char *x, const char *y) const
     {
-    return strcmp (x, y) < 0;
+	return strcmp (x, y) < 0;
     }
 };
 
@@ -86,15 +88,21 @@ class LockedTypeMap: public TypeMap
 LockedTypeMap &
 typeMap ()
 {
+    // c++11 requires thread-safe static variable initialization
+#if __cplusplus >= 201103L
+    static LockedTypeMap tMap;
+    return tMap;
+#else
     static Mutex criticalSection;
     Lock lock (criticalSection);
 
     static LockedTypeMap* typeMap = 0;
 
     if (typeMap == 0)
-    typeMap = new LockedTypeMap ();
+	typeMap = new LockedTypeMap ();
 
     return *typeMap;
+#endif
 }
 
 
@@ -113,15 +121,15 @@ Attribute::knownType (const char typeName[])
 
 void	
 Attribute::registerAttributeType (const char typeName[],
-                      Attribute *(*newAttribute)())
+			          Attribute *(*newAttribute)())
 {
     LockedTypeMap& tMap = typeMap();
     Lock lock (tMap.mutex);
 
     if (tMap.find (typeName) != tMap.end())
-    THROW (Iex::ArgExc, "Cannot register image file attribute "
+	THROW (IEX_NAMESPACE::ArgExc, "Cannot register image file attribute "
-                "type \"" << typeName << "\". "
+			    "type \"" << typeName << "\". "
-                "The type has already been registered.");
+			    "The type has already been registered.");
 
     tMap.insert (TypeMap::value_type (typeName, newAttribute));
 }
@@ -146,11 +154,11 @@ Attribute::newAttribute (const char typeName[])
     TypeMap::const_iterator i = tMap.find (typeName);
 
     if (i == tMap.end())
-    THROW (Iex::ArgExc, "Cannot create image file attribute of "
+	THROW (IEX_NAMESPACE::ArgExc, "Cannot create image file attribute of "
-                "unknown type \"" << typeName << "\".");
+			    "unknown type \"" << typeName << "\".");
 
     return (i->second)();
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfAttribute.h

@@ -44,11 +44,13 @@
 //-----------------------------------------------------------------------------
 
 #include "IexBaseExc.h"
-#include <ImfIO.h>
+#include "ImfIO.h"
-#include <ImfXdr.h>
+#include "ImfXdr.h"
+#include "ImfForward.h"
+#include "ImfExport.h"
+#include "ImfNamespace.h"
 
-
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
-namespace Imf {
 
 
 class Attribute
@@ -59,7 +61,9 @@ class Attribute
     // Constructor and destructor
     //---------------------------
 
+    IMF_EXPORT
     Attribute ();
+    IMF_EXPORT
     virtual ~Attribute ();
 
 
@@ -81,12 +85,12 @@ class Attribute
     // Type-specific attribute I/O and copying
     //----------------------------------------
 
-    virtual void		writeValueTo (OStream &os,
+    virtual void		writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os,
-                          int version) const = 0;
+					      int version) const = 0;
 
-    virtual void		readValueFrom (IStream &is,
+    virtual void		readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is,
-                           int size,
+					       int size,
-                           int version) = 0;
+					       int version) = 0;
 
     virtual void		copyValueFrom (const Attribute &other) = 0;
 
@@ -95,6 +99,7 @@ class Attribute
     // Attribute factory
     //------------------
 
+    IMF_EXPORT
     static Attribute *		newAttribute (const char typeName[]);
 
 
@@ -102,6 +107,7 @@ class Attribute
     // Test if a given attribute type has already been registered
     //-----------------------------------------------------------
 
+    IMF_EXPORT
     static bool			knownType (const char typeName[]);
 
 
@@ -112,8 +118,9 @@ class Attribute
     // knows how to make objects of this type.
     //--------------------------------------------------
 
+    IMF_EXPORT
     static void		registerAttributeType (const char typeName[],
-                           Attribute *(*newAttribute)());
+					       Attribute *(*newAttribute)());
 
     //------------------------------------------------------
     // Un-register an attribute type so that newAttribute()
@@ -121,6 +128,7 @@ class Attribute
     // debugging only).
     //------------------------------------------------------
 
+    IMF_EXPORT
     static void		unRegisterAttributeType (const char typeName[]);
 };
 
@@ -186,12 +194,12 @@ class TypedAttribute: public Attribute
     // Depending on type T, these functions may have to be specialized.
     //-----------------------------------------------------------------
 
-    virtual void		writeValueTo (OStream &os,
+    virtual void		writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os,
-                          int version) const;
+					      int version) const;
 
-    virtual void		readValueFrom (IStream &is,
+    virtual void		readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is,
-                           int size,
+					       int size,
-                           int version);
+					       int version);
 
     virtual void		copyValueFrom (const Attribute &other);
 
@@ -233,11 +241,9 @@ class TypedAttribute: public Attribute
     T					_value;
 };
 
-
 //------------------------------------
 // Implementation of TypedAttribute<T>
 //------------------------------------
-
 template <class T>
 TypedAttribute<T>::TypedAttribute ():
     Attribute (),
@@ -248,7 +254,7 @@ TypedAttribute<T>::TypedAttribute ():
 
 
 template <class T>
-TypedAttribute<T>::TypedAttribute (const T &value):
+TypedAttribute<T>::TypedAttribute (const T & value):
     Attribute (),
     _value (value)
 {
@@ -316,17 +322,20 @@ TypedAttribute<T>::copy () const
 
 template <class T>
 void		
-TypedAttribute<T>::writeValueTo (OStream &os, int) const
+TypedAttribute<T>::writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os,
+                                    int version) const
 {
-    Xdr::write <StreamIO> (os, _value);
+    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (os, _value);
 }
 
 
 template <class T>
 void		
-TypedAttribute<T>::readValueFrom (IStream &is, int, int)
+TypedAttribute<T>::readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is,
+                                     int size,
+                                     int version)
 {
-    Xdr::read <StreamIO> (is, _value);
+    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (is, _value);
 }
 
 
@@ -343,10 +352,10 @@ TypedAttribute<T> *
 TypedAttribute<T>::cast (Attribute *attribute)
 {
     TypedAttribute<T> *t =
-    dynamic_cast <TypedAttribute<T> *> (attribute);
+	dynamic_cast <TypedAttribute<T> *> (attribute);
 
     if (t == 0)
-    throw Iex::TypeExc ("Unexpected attribute type.");
+	throw IEX_NAMESPACE::TypeExc ("Unexpected attribute type.");
 
     return t;
 }
@@ -357,10 +366,10 @@ const TypedAttribute<T> *
 TypedAttribute<T>::cast (const Attribute *attribute)
 {
     const TypedAttribute<T> *t =
-    dynamic_cast <const TypedAttribute<T> *> (attribute);
+	dynamic_cast <const TypedAttribute<T> *> (attribute);
 
     if (t == 0)
-    throw Iex::TypeExc ("Unexpected attribute type.");
+	throw IEX_NAMESPACE::TypeExc ("Unexpected attribute type.");
 
     return t;
 }
@@ -398,30 +407,7 @@ TypedAttribute<T>::unRegisterAttributeType ()
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
 
-#if defined(OPENEXR_DLL) && defined(_MSC_VER)
-    // Tell MS VC++ to disable "non dll-interface class used as base
-    // for dll-interface class" and "no suitable definition provided
-    // for explicit template"
-    #pragma warning (disable : 4275 4661)
-
-    #if defined (ILMIMF_EXPORTS)
-    #define IMF_EXPIMP_TEMPLATE
-    #else
-    #define IMF_EXPIMP_TEMPLATE extern
-    #endif
-
-    IMF_EXPIMP_TEMPLATE template class Imf::TypedAttribute<float>;
-    IMF_EXPIMP_TEMPLATE template class Imf::TypedAttribute<double>;
-
-    #pragma warning(default : 4251)
-    #undef EXTERN_TEMPLATE
-#endif
-
-// Metrowerks compiler wants the .cpp file inlined, too
-#ifdef __MWERKS__
-#include <ImfAttribute.cpp>
-#endif
 
 #endif

3rdparty/openexr/IlmImf/ImfAutoArray.h

@@ -44,13 +44,10 @@
 //
 //-----------------------------------------------------------------------------
 
-#include "OpenEXRConfig.h"
+#include "ImfNamespace.h"
-
-#if !defined (HAVE_LARGE_STACK)
 #include <string.h>
-#endif
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
 #if !defined (HAVE_LARGE_STACK)
@@ -61,15 +58,15 @@ namespace Imf {
     {
       public:
 
-     AutoArray (): _data (new T [size]) { memset(_data, 0, size*sizeof(T)); }
+	 AutoArray (): _data (new T [size]) { memset(_data, 0, size*sizeof(T)); }
-    ~AutoArray () {delete [] _data;}
+	~AutoArray () {delete [] _data;}
 
-    operator T * ()			{return _data;}
+	operator T * ()			{return _data;}
-    operator const T * () const	{return _data;}
+	operator const T * () const	{return _data;}
       
       private:
 
-    T *_data;
+	T *_data;
     };
 
 
@@ -81,17 +78,18 @@ namespace Imf {
     {
       public:
 
-    operator T * ()			{return _data;}
+	operator T * ()			{return _data;}
-    operator const T * () const	{return _data;}
+	operator const T * () const	{return _data;}
       
       private:
 
-    T _data[size];
+	T _data[size];
     };
 
 
 #endif
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
 
 #endif

3rdparty/openexr/IlmImf/ImfB44Compressor.h

@@ -42,60 +42,69 @@
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfCompressor.h>
+#include "ImfCompressor.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+#include "ImfForward.h"
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
-
-class ChannelList;
 
 
 class B44Compressor: public Compressor
 {
   public:
 
+    IMF_EXPORT
     B44Compressor (const Header &hdr,
                    size_t maxScanLineSize,
-           size_t numScanLines,
+		   size_t numScanLines,
-           bool optFlatFields);
+		   bool optFlatFields);
 
+    IMF_EXPORT
     virtual ~B44Compressor ();
 
+    IMF_EXPORT
     virtual int		numScanLines () const;
 
+    IMF_EXPORT
     virtual Format	format () const;
 
+    IMF_EXPORT
     virtual int		compress (const char *inPtr,
-                  int inSize,
+				  int inSize,
-                  int minY,
+				  int minY,
-                  const char *&outPtr);
+				  const char *&outPtr);                  
                   
+    IMF_EXPORT
     virtual int		compressTile (const char *inPtr,
-                      int inSize,
+				      int inSize,
-                      Imath::Box2i range,
+				      IMATH_NAMESPACE::Box2i range,
-                      const char *&outPtr);
+				      const char *&outPtr);
 
+    IMF_EXPORT
     virtual int		uncompress (const char *inPtr,
-                    int inSize,
+				    int inSize,
-                    int minY,
+				    int minY,
-                    const char *&outPtr);
+				    const char *&outPtr);
                     
+    IMF_EXPORT
     virtual int		uncompressTile (const char *inPtr,
-                    int inSize,
+					int inSize,
-                    Imath::Box2i range,
+					IMATH_NAMESPACE::Box2i range,
-                    const char *&outPtr);
+					const char *&outPtr);
   private:
 
     struct ChannelData;
     
     int			compress (const char *inPtr,
-                  int inSize,
+				  int inSize,
-                  Imath::Box2i range,
+				  IMATH_NAMESPACE::Box2i range,
-                  const char *&outPtr);
+				  const char *&outPtr);
  
     int			uncompress (const char *inPtr,
-                    int inSize,
+				    int inSize,
-                    Imath::Box2i range,
+				    IMATH_NAMESPACE::Box2i range,
-                    const char *&outPtr);
+				    const char *&outPtr);
 
     int			_maxScanLineSize;
     bool		_optFlatFields;
@@ -112,6 +121,6 @@ class B44Compressor: public Compressor
 };
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
 
 #endif

3rdparty/openexr/IlmImf/ImfBoxAttribute.cpp

@@ -44,8 +44,9 @@
 #include <ImfBoxAttribute.h>
 
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
 
+using namespace OPENEXR_IMF_INTERNAL_NAMESPACE;
 
 template <>
 const char *
@@ -57,7 +58,7 @@ Box2iAttribute::staticTypeName ()
 
 template <>
 void
-Box2iAttribute::writeValueTo (OStream &os, int) const
+Box2iAttribute::writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, int version) const
 {
     Xdr::write <StreamIO> (os, _value.min.x);
     Xdr::write <StreamIO> (os, _value.min.y);
@@ -68,7 +69,7 @@ Box2iAttribute::writeValueTo (OStream &os, int) const
 
 template <>
 void
-Box2iAttribute::readValueFrom (IStream &is, int, int)
+Box2iAttribute::readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int size, int version)
 {
     Xdr::read <StreamIO> (is, _value.min.x);
     Xdr::read <StreamIO> (is, _value.min.y);
@@ -87,7 +88,7 @@ Box2fAttribute::staticTypeName ()
 
 template <>
 void
-Box2fAttribute::writeValueTo (OStream &os, int) const
+Box2fAttribute::writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, int version) const
 {
     Xdr::write <StreamIO> (os, _value.min.x);
     Xdr::write <StreamIO> (os, _value.min.y);
@@ -98,7 +99,7 @@ Box2fAttribute::writeValueTo (OStream &os, int) const
 
 template <>
 void
-Box2fAttribute::readValueFrom (IStream &is, int, int)
+Box2fAttribute::readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int size, int version)
 {
     Xdr::read <StreamIO> (is, _value.min.x);
     Xdr::read <StreamIO> (is, _value.min.y);
@@ -107,4 +108,4 @@ Box2fAttribute::readValueFrom (IStream &is, int, int)
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT 

3rdparty/openexr/IlmImf/ImfBoxAttribute.h

@@ -44,30 +44,44 @@
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfAttribute.h>
+#include "ImfForward.h"
+#include "ImfExport.h"
+#include "ImfAttribute.h"
 #include "ImathBox.h"
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
-namespace Imf {
+typedef TypedAttribute<IMATH_NAMESPACE::Box2i> Box2iAttribute;
+
+template <>
+IMF_EXPORT
+const char *Box2iAttribute::staticTypeName ();
+template <>
+IMF_EXPORT
+void Box2iAttribute::writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &,
+                                   int) const;
+template <>
+IMF_EXPORT
+void Box2iAttribute::readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &,
+                                    int, int);
 
 
-typedef TypedAttribute<Imath::Box2i> Box2iAttribute;
+typedef TypedAttribute<IMATH_NAMESPACE::Box2f> Box2fAttribute;
-template <> const char *Box2iAttribute::staticTypeName ();
+template <>
-template <> void Box2iAttribute::writeValueTo (OStream &, int) const;
+IMF_EXPORT
-template <> void Box2iAttribute::readValueFrom (IStream &, int, int);
+const char *Box2fAttribute::staticTypeName ();
+template <>
+IMF_EXPORT
+void Box2fAttribute::writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &,
+                                   int) const;
+template <>
+IMF_EXPORT
+void Box2fAttribute::readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &,
+                                    int, int);
 
 
-typedef TypedAttribute<Imath::Box2f> Box2fAttribute;
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
-template <> const char *Box2fAttribute::staticTypeName ();
-template <> void Box2fAttribute::writeValueTo (OStream &, int) const;
-template <> void Box2fAttribute::readValueFrom (IStream &, int, int);
-
-
-} // namespace Imf
-
-// Metrowerks compiler wants the .cpp file inlined, too
-#ifdef __MWERKS__
-#include <ImfBoxAttribute.cpp>
-#endif
 
 #endif

3rdparty/openexr/IlmImf/ImfCRgbaFile.h

@@ -35,6 +35,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_IMF_C_RGBA_FILE_H
 #define INCLUDED_IMF_C_RGBA_FILE_H
 
+#include "ImfExport.h"
 
 #include <stdlib.h>
 
@@ -48,18 +49,22 @@ extern "C" {
 
 typedef unsigned short ImfHalf;
 
+IMF_EXPORT 
 void	ImfFloatToHalf (float f,
-            ImfHalf *h);
+			ImfHalf *h);
 
+IMF_EXPORT 
 void	ImfFloatToHalfArray (int n,
-                const float f[/*n*/],
+			    const float f[/*n*/],
-                ImfHalf h[/*n*/]);
+			    ImfHalf h[/*n*/]);
 
+IMF_EXPORT 
 float	ImfHalfToFloat (ImfHalf h);
 
+IMF_EXPORT 
 void	ImfHalfToFloatArray (int n,
-                const ImfHalf h[/*n*/],
+			    const ImfHalf h[/*n*/],
-                float f[/*n*/]);
+			    float f[/*n*/]);
 
 /*
 ** RGBA pixel; memory layout must be the same as struct Imf::Rgba.
@@ -93,7 +98,7 @@ typedef struct ImfRgba ImfRgba;
 
 #define IMF_INCREASING_Y	0
 #define IMF_DECREASING_Y	1
-#define IMF_RAMDOM_Y		2
+#define IMF_RANDOM_Y		2
 
 
 /*
@@ -151,153 +156,194 @@ typedef struct ImfRgba ImfRgba;
 struct ImfHeader;
 typedef struct ImfHeader ImfHeader;
 
+IMF_EXPORT 
 ImfHeader *	ImfNewHeader (void);
 
+IMF_EXPORT 
 void		ImfDeleteHeader (ImfHeader *hdr);
 
+IMF_EXPORT 
 ImfHeader *	ImfCopyHeader (const ImfHeader *hdr);
 
+IMF_EXPORT 
 void		ImfHeaderSetDisplayWindow (ImfHeader *hdr,
-                       int xMin, int yMin,
+					   int xMin, int yMin,
-                       int xMax, int yMax);
+					   int xMax, int yMax);
 
+IMF_EXPORT 
 void		ImfHeaderDisplayWindow (const ImfHeader *hdr,
-                    int *xMin, int *yMin,
+					int *xMin, int *yMin,
-                    int *xMax, int *yMax);
+					int *xMax, int *yMax);
 
+IMF_EXPORT 
 void		ImfHeaderSetDataWindow (ImfHeader *hdr,
-                    int xMin, int yMin,
+					int xMin, int yMin,
-                    int xMax, int yMax);
+					int xMax, int yMax);
 
+IMF_EXPORT 
 void		ImfHeaderDataWindow (const ImfHeader *hdr,
-                     int *xMin, int *yMin,
+				     int *xMin, int *yMin,
-                     int *xMax, int *yMax);
+				     int *xMax, int *yMax);
 
+IMF_EXPORT 
 void		ImfHeaderSetPixelAspectRatio (ImfHeader *hdr,
-                          float pixelAspectRatio);
+					      float pixelAspectRatio);
 
+IMF_EXPORT 
 float		ImfHeaderPixelAspectRatio (const ImfHeader *hdr);
 
+IMF_EXPORT 
 void		ImfHeaderSetScreenWindowCenter (ImfHeader *hdr,
-                        float x, float y);
+						float x, float y);
 
+IMF_EXPORT 
 void		ImfHeaderScreenWindowCenter (const ImfHeader *hdr,
-                         float *x, float *y);
+					     float *x, float *y);
 
+IMF_EXPORT 
 void		ImfHeaderSetScreenWindowWidth (ImfHeader *hdr,
-                           float width);
+					       float width);
 
+IMF_EXPORT 
 float		ImfHeaderScreenWindowWidth (const ImfHeader *hdr);
 
+IMF_EXPORT 
 void		ImfHeaderSetLineOrder (ImfHeader *hdr,
-                       int lineOrder);
+				       int lineOrder);
 
+IMF_EXPORT 
 int		ImfHeaderLineOrder (const ImfHeader *hdr);
 			    
+IMF_EXPORT 
 void		ImfHeaderSetCompression (ImfHeader *hdr,
-                     int compression);
+					 int compression);
 
+IMF_EXPORT 
 int		ImfHeaderCompression (const ImfHeader *hdr);
 
+IMF_EXPORT 
 int		ImfHeaderSetIntAttribute (ImfHeader *hdr,
-                      const char name[],
+					  const char name[],
-                      int value);
+					  int value);
 
+IMF_EXPORT 
 int		ImfHeaderIntAttribute (const ImfHeader *hdr,
-                       const char name[],
+				       const char name[],
-                       int *value);
+				       int *value);
 
+IMF_EXPORT 
 int		ImfHeaderSetFloatAttribute (ImfHeader *hdr,
-                        const char name[],
+					    const char name[],
-                        float value);
+					    float value);
 
+IMF_EXPORT 
 int		ImfHeaderSetDoubleAttribute (ImfHeader *hdr,
-                         const char name[],
+					     const char name[],
-                         double value);
+					     double value);
 
+IMF_EXPORT 
 int		ImfHeaderFloatAttribute (const ImfHeader *hdr,
-                         const char name[],
+				         const char name[],
-                         float *value);
+				         float *value);
 
+IMF_EXPORT 
 int		ImfHeaderDoubleAttribute (const ImfHeader *hdr,
-                          const char name[],
+				          const char name[],
-                          double *value);
+				          double *value);
 
+IMF_EXPORT 
 int		ImfHeaderSetStringAttribute (ImfHeader *hdr,
-                         const char name[],
+					     const char name[],
-                         const char value[]);
+					     const char value[]);
 
+IMF_EXPORT 
 int		ImfHeaderStringAttribute (const ImfHeader *hdr,
-                         const char name[],
+				         const char name[],
-                      const char **value);
+					  const char **value);
 
+IMF_EXPORT 
 int		ImfHeaderSetBox2iAttribute (ImfHeader *hdr,
-                        const char name[],
+					    const char name[],
-                        int xMin, int yMin,
+					    int xMin, int yMin,
-                        int xMax, int yMax);
+					    int xMax, int yMax);
 
+IMF_EXPORT 
 int		ImfHeaderBox2iAttribute (const ImfHeader *hdr,
-                     const char name[],
+					 const char name[],
-                     int *xMin, int *yMin,
+					 int *xMin, int *yMin,
-                     int *xMax, int *yMax);
+					 int *xMax, int *yMax);
 
+IMF_EXPORT 
 int		ImfHeaderSetBox2fAttribute (ImfHeader *hdr,
-                        const char name[],
+					    const char name[],
-                        float xMin, float yMin,
+					    float xMin, float yMin,
-                        float xMax, float yMax);
+					    float xMax, float yMax);
 
+IMF_EXPORT 
 int		ImfHeaderBox2fAttribute (const ImfHeader *hdr,
-                     const char name[],
+					 const char name[],
-                     float *xMin, float *yMin,
+					 float *xMin, float *yMin,
-                     float *xMax, float *yMax);
+					 float *xMax, float *yMax);
 
+IMF_EXPORT 
 int		ImfHeaderSetV2iAttribute (ImfHeader *hdr,
-                         const char name[],
+				         const char name[],
-                         int x, int y);
+				         int x, int y);
 
+IMF_EXPORT 
 int		ImfHeaderV2iAttribute (const ImfHeader *hdr,
-                       const char name[],
+				       const char name[],
-                       int *x, int *y);
+				       int *x, int *y);
 
+IMF_EXPORT 
 int		ImfHeaderSetV2fAttribute (ImfHeader *hdr,
-                          const char name[],
+				          const char name[],
-                          float x, float y);
+				          float x, float y);
 
+IMF_EXPORT 
 int		ImfHeaderV2fAttribute (const ImfHeader *hdr,
-                       const char name[],
+				       const char name[],
-                       float *x, float *y);
+				       float *x, float *y);
 
+IMF_EXPORT 
 int		ImfHeaderSetV3iAttribute (ImfHeader *hdr,
-                          const char name[],
+				          const char name[],
-                          int x, int y, int z);
+				          int x, int y, int z);
 
+IMF_EXPORT 
 int		ImfHeaderV3iAttribute (const ImfHeader *hdr,
-                       const char name[],
+				       const char name[],
-                       int *x, int *y, int *z);
+				       int *x, int *y, int *z);
 
+IMF_EXPORT 
 int		ImfHeaderSetV3fAttribute (ImfHeader *hdr,
-                          const char name[],
+				          const char name[],
-                          float x, float y, float z);
+				          float x, float y, float z);
 
+IMF_EXPORT 
 int		ImfHeaderV3fAttribute (const ImfHeader *hdr,
-                       const char name[],
+				       const char name[],
-                       float *x, float *y, float *z);
+				       float *x, float *y, float *z);
 
+IMF_EXPORT 
 int		ImfHeaderSetM33fAttribute (ImfHeader *hdr,
-                       const char name[],
+					   const char name[],
-                       const float m[3][3]);
+					   const float m[3][3]);
 
+IMF_EXPORT 
 int		ImfHeaderM33fAttribute (const ImfHeader *hdr,
-                    const char name[],
+					const char name[],
-                    float m[3][3]);
+					float m[3][3]);
 
+IMF_EXPORT 
 int		ImfHeaderSetM44fAttribute (ImfHeader *hdr,
-                       const char name[],
+					   const char name[],
-                       const float m[4][4]);
+					   const float m[4][4]);
 
+IMF_EXPORT 
 int		ImfHeaderM44fAttribute (const ImfHeader *hdr,
-                    const char name[],
+					const char name[],
-                    float m[4][4]);
+					float m[4][4]);
 
 /*
 ** RGBA output file
@@ -306,24 +352,31 @@ int		ImfHeaderM44fAttribute (const ImfHeader *hdr,
 struct ImfOutputFile;
 typedef struct ImfOutputFile ImfOutputFile;
 
+IMF_EXPORT 
 ImfOutputFile *	ImfOpenOutputFile (const char name[],
-                   const ImfHeader *hdr,
+				   const ImfHeader *hdr,
-                   int channels);
+				   int channels);
 
+IMF_EXPORT 
 int			ImfCloseOutputFile (ImfOutputFile *out);
 
+IMF_EXPORT 
 int			ImfOutputSetFrameBuffer (ImfOutputFile *out,
-                         const ImfRgba *base,
+						 const ImfRgba *base,
-                         size_t xStride,
+						 size_t xStride,
-                         size_t yStride);
+						 size_t yStride);
 
+IMF_EXPORT 
 int			ImfOutputWritePixels (ImfOutputFile *out,
-                          int numScanLines);
+					      int numScanLines);
 
+IMF_EXPORT 
 int			ImfOutputCurrentScanLine (const ImfOutputFile *out);
 
+IMF_EXPORT 
 const ImfHeader *	ImfOutputHeader (const ImfOutputFile *out);
 
+IMF_EXPORT 
 int			ImfOutputChannels (const ImfOutputFile *out);
 
 
@@ -334,39 +387,51 @@ int			ImfOutputChannels (const ImfOutputFile *out);
 struct ImfTiledOutputFile;
 typedef struct ImfTiledOutputFile ImfTiledOutputFile;
 
+IMF_EXPORT 
 ImfTiledOutputFile *	ImfOpenTiledOutputFile (const char name[],
-                            const ImfHeader *hdr,
+					        const ImfHeader *hdr,
-                        int channels,
+						int channels,
-                        int xSize, int ySize,
+						int xSize, int ySize,
-                        int mode, int rmode);
+						int mode, int rmode);
 
+IMF_EXPORT 
 int		ImfCloseTiledOutputFile (ImfTiledOutputFile *out);
 
+IMF_EXPORT 
 int		ImfTiledOutputSetFrameBuffer (ImfTiledOutputFile *out,
-                          const ImfRgba *base,
+					      const ImfRgba *base,
-                          size_t xStride,
+					      size_t xStride,
-                          size_t yStride);
+					      size_t yStride);
 
+IMF_EXPORT 
 int		ImfTiledOutputWriteTile (ImfTiledOutputFile *out,
-                     int dx, int dy,
+					 int dx, int dy,
-                     int lx, int ly);
+					 int lx, int ly);
 
+IMF_EXPORT 
 int             ImfTiledOutputWriteTiles (ImfTiledOutputFile *out,
                                           int dxMin, int dxMax,
                                           int dyMin, int dyMax,
                                           int lx, int ly);
 
+IMF_EXPORT 
 const ImfHeader *	ImfTiledOutputHeader (const ImfTiledOutputFile *out);
 
+IMF_EXPORT 
 int		ImfTiledOutputChannels (const ImfTiledOutputFile *out);
 
+IMF_EXPORT 
 int		ImfTiledOutputTileXSize (const ImfTiledOutputFile *out);
 
+IMF_EXPORT 
 int		ImfTiledOutputTileYSize (const ImfTiledOutputFile *out);
 
+IMF_EXPORT 
 int		ImfTiledOutputLevelMode (const ImfTiledOutputFile *out);
+
+IMF_EXPORT 
 int	       	ImfTiledOutputLevelRoundingMode
-                        (const ImfTiledOutputFile *out);
+						(const ImfTiledOutputFile *out);
 
 
 /*
@@ -378,21 +443,27 @@ typedef struct ImfInputFile ImfInputFile;
 
 ImfInputFile *		ImfOpenInputFile (const char name[]);
 
+IMF_EXPORT 
 int			ImfCloseInputFile (ImfInputFile *in);
 
+IMF_EXPORT 
 int			ImfInputSetFrameBuffer (ImfInputFile *in,
-                        ImfRgba *base,
+						ImfRgba *base,
-                        size_t xStride,
+						size_t xStride,
-                        size_t yStride);
+						size_t yStride);
 
+IMF_EXPORT 
 int			ImfInputReadPixels (ImfInputFile *in,
-                        int scanLine1,
+					    int scanLine1,
-                        int scanLine2);
+					    int scanLine2);
 
+IMF_EXPORT 
 const ImfHeader *	ImfInputHeader (const ImfInputFile *in);
 
+IMF_EXPORT 
 int			ImfInputChannels (const ImfInputFile *in);
 
+IMF_EXPORT 
 const char *            ImfInputFileName (const ImfInputFile *in);
 
 
@@ -403,38 +474,50 @@ const char *            ImfInputFileName (const ImfInputFile *in);
 struct ImfTiledInputFile;
 typedef struct ImfTiledInputFile ImfTiledInputFile;
 
+IMF_EXPORT 
 ImfTiledInputFile *	ImfOpenTiledInputFile (const char name[]);
 
+IMF_EXPORT 
 int		ImfCloseTiledInputFile (ImfTiledInputFile *in);
 
+IMF_EXPORT 
 int		ImfTiledInputSetFrameBuffer (ImfTiledInputFile *in,
-                         ImfRgba *base,
+					     ImfRgba *base,
-                         size_t xStride,
+					     size_t xStride,
-                         size_t yStride);
+					     size_t yStride);
 
+IMF_EXPORT 
 int		ImfTiledInputReadTile (ImfTiledInputFile *in,
-                       int dx, int dy,
+				       int dx, int dy,
-                       int lx, int ly);
+				       int lx, int ly);
 
+IMF_EXPORT 
 int		ImfTiledInputReadTiles (ImfTiledInputFile *in,
                                         int dxMin, int dxMax,
                                         int dyMin, int dyMax,
                                         int lx, int ly);
 
+IMF_EXPORT 
 const ImfHeader *	ImfTiledInputHeader (const ImfTiledInputFile *in);
 
+IMF_EXPORT 
 int		ImfTiledInputChannels (const ImfTiledInputFile *in);
 
+IMF_EXPORT 
 const char *		ImfTiledInputFileName (const ImfTiledInputFile *in);
 
+IMF_EXPORT 
 int		ImfTiledInputTileXSize (const ImfTiledInputFile *in);
 
+IMF_EXPORT 
 int		ImfTiledInputTileYSize (const ImfTiledInputFile *in);
 
+IMF_EXPORT 
 int		ImfTiledInputLevelMode (const ImfTiledInputFile *in);
 
+IMF_EXPORT 
 int	       	ImfTiledInputLevelRoundingMode
-                           (const ImfTiledInputFile *in);
+					       (const ImfTiledInputFile *in);
 
 /*
 ** Lookup tables
@@ -443,20 +526,25 @@ int	       	ImfTiledInputLevelRoundingMode
 struct ImfLut;
 typedef struct ImfLut ImfLut;
 
+IMF_EXPORT 
 ImfLut *		ImfNewRound12logLut (int channels);
 
+IMF_EXPORT 
 ImfLut *		ImfNewRoundNBitLut (unsigned int n, int channels);
 
+IMF_EXPORT 
 void			ImfDeleteLut (ImfLut *lut);
 
+IMF_EXPORT 
 void			ImfApplyLut (ImfLut *lut,
-                     ImfRgba *data,
+				     ImfRgba *data,
-                     int nData,
+				     int nData,
-                     int stride);
+				     int stride);
 /*
 ** Most recent error message
 */
 
+IMF_EXPORT 
 const char *		ImfErrorMessage (void);
 
 

3rdparty/openexr/IlmImf/ImfChannelList.cpp

@@ -47,8 +47,9 @@
 
 using std::string;
 using std::set;
+#include "ImfNamespace.h"
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
 
 
 Channel::Channel (PixelType t, int xs, int ys, bool pl):
@@ -65,9 +66,9 @@ bool
 Channel::operator == (const Channel &other) const
 {
     return type == other.type &&
-       xSampling == other.xSampling &&
+	   xSampling == other.xSampling &&
-       ySampling == other.ySampling &&
+	   ySampling == other.ySampling &&
-       pLinear == other.pLinear;
+	   pLinear == other.pLinear;
 }
 
 
@@ -75,7 +76,7 @@ void
 ChannelList::insert (const char name[], const Channel &channel)
 {
     if (name[0] == 0)
-    THROW (Iex::ArgExc, "Image channel name cannot be an empty string.");
+	THROW (IEX_NAMESPACE::ArgExc, "Image channel name cannot be an empty string.");
 
     _map[name] = channel;
 }
@@ -94,7 +95,7 @@ ChannelList::operator [] (const char name[])
     ChannelMap::iterator i = _map.find (name);
 
     if (i == _map.end())
-    THROW (Iex::ArgExc, "Cannot find image channel \"" << name << "\".");
+	THROW (IEX_NAMESPACE::ArgExc, "Cannot find image channel \"" << name << "\".");
 
     return i->second;
 }
@@ -106,7 +107,7 @@ ChannelList::operator [] (const char name[]) const
     ChannelMap::const_iterator i = _map.find (name);
 
     if (i == _map.end())
-    THROW (Iex::ArgExc, "Cannot find image channel \"" << name << "\".");
+	THROW (IEX_NAMESPACE::ArgExc, "Cannot find image channel \"" << name << "\".");
 
     return i->second;
 }
@@ -219,22 +220,22 @@ ChannelList::layers (set <string> &layerNames) const
 
     for (ConstIterator i = begin(); i != end(); ++i)
     {
-    string layerName = i.name();
+	string layerName = i.name();
-    size_t pos = layerName.rfind ('.');
+	size_t pos = layerName.rfind ('.');
 
-    if (pos != string::npos && pos != 0 && pos + 1 < layerName.size())
+	if (pos != string::npos && pos != 0 && pos + 1 < layerName.size())
-    {
+	{
-        layerName.erase (pos);
+	    layerName.erase (pos);
-        layerNames.insert (layerName);
+	    layerNames.insert (layerName);
-    }
+	}
     }
 }
 
 
 void
 ChannelList::channelsInLayer (const string &layerName,
-                  Iterator &first,
+			      Iterator &first,
-                  Iterator &last)
+			      Iterator &last)
 {
     channelsWithPrefix (layerName + '.', first, last);
 }
@@ -242,8 +243,8 @@ ChannelList::channelsInLayer (const string &layerName,
 
 void
 ChannelList::channelsInLayer (const string &layerName,
-                  ConstIterator &first,
+			      ConstIterator &first,
-                  ConstIterator &last) const
+			      ConstIterator &last) const
 {
     channelsWithPrefix (layerName + '.', first, last);
 }
@@ -251,40 +252,40 @@ ChannelList::channelsInLayer (const string &layerName,
 
 void		
 ChannelList::channelsWithPrefix (const char prefix[],
-                 Iterator &first,
+				 Iterator &first,
-                 Iterator &last)
+				 Iterator &last)
 {
     first = last = _map.lower_bound (prefix);
-    int n = strlen (prefix);
+    size_t n = int(strlen (prefix));
 
     while (last != Iterator (_map.end()) &&
-       strncmp (last.name(), prefix, n) <= 0)
+	   strncmp (last.name(), prefix, n) <= 0)
     {
-    ++last;
+	++last;
     }
 }
 
 
 void
 ChannelList::channelsWithPrefix (const char prefix[],
-                 ConstIterator &first,
+				 ConstIterator &first,
-                 ConstIterator &last) const
+				 ConstIterator &last) const
 {
     first = last = _map.lower_bound (prefix);
-    int n = strlen (prefix);
+    size_t n = strlen (prefix);
 
     while (last != ConstIterator (_map.end()) &&
-       strncmp (last.name(), prefix, n) <= 0)
+	   strncmp (last.name(), prefix, n) <= 0)
     {
-    ++last;
+	++last;
     }
 }
 
 
 void		
 ChannelList::channelsWithPrefix (const string &prefix,
-                 Iterator &first,
+				 Iterator &first,
-                 Iterator &last)
+				 Iterator &last)
 {
     return channelsWithPrefix (prefix.c_str(), first, last);
 }
@@ -292,8 +293,8 @@ ChannelList::channelsWithPrefix (const string &prefix,
 
 void
 ChannelList::channelsWithPrefix (const string &prefix,
-                 ConstIterator &first,
+				 ConstIterator &first,
-                 ConstIterator &last) const
+				 ConstIterator &last) const
 {
     return channelsWithPrefix (prefix.c_str(), first, last);
 }
@@ -307,15 +308,15 @@ ChannelList::operator == (const ChannelList &other) const
 
     while (i != end() && j != other.end())
     {
-    if (!(i.channel() == j.channel()))
+	if (!(i.channel() == j.channel()))
-        return false;
+	    return false;
 
-    ++i;
+	++i;
-    ++j;
+	++j;
     }
 
     return i == end() && j == other.end();
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfChannelList.h

@@ -44,14 +44,17 @@
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfName.h>
+#include "ImfName.h"
-#include <ImfPixelType.h>
+#include "ImfPixelType.h"
+
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+
 #include <map>
 #include <set>
 #include <string>
 
-
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
-namespace Imf {
 
 
 struct Channel
@@ -97,16 +100,18 @@ struct Channel
     // Constructor
     //------------
     
+    IMF_EXPORT
     Channel (PixelType type = HALF,
-         int xSampling = 1,
+	     int xSampling = 1,
-         int ySampling = 1,
+	     int ySampling = 1,
-         bool pLinear = false);
+	     bool pLinear = false);
 
 
     //------------
     // Operator ==
     //------------
 
+    IMF_EXPORT
     bool		operator == (const Channel &other) const;
 };
 
@@ -119,17 +124,19 @@ class ChannelList
     // Add a channel
     //--------------
 
+    IMF_EXPORT
     void			insert (const char name[],
-                    const Channel &channel);
+					const Channel &channel);
 
+    IMF_EXPORT
     void			insert (const std::string &name,
-                    const Channel &channel);
+					const Channel &channel);
 
     //------------------------------------------------------------------
     // Access to existing channels:
     //
     // [n]		Returns a reference to the channel with name n.
-    //			If no channel with name n exists, an Iex::ArgExc
+    //			If no channel with name n exists, an IEX_NAMESPACE::ArgExc
     //			is thrown.
     //
     // findChannel(n)	Returns a pointer to the channel with name n,
@@ -137,16 +144,24 @@ class ChannelList
     //
     //------------------------------------------------------------------
 
+    IMF_EXPORT
     Channel &			operator [] (const char name[]);
+    IMF_EXPORT
     const Channel &		operator [] (const char name[]) const;
 
+    IMF_EXPORT
     Channel &			operator [] (const std::string &name);
+    IMF_EXPORT
     const Channel &		operator [] (const std::string &name) const;
 
+    IMF_EXPORT
     Channel *			findChannel (const char name[]);
+    IMF_EXPORT
     const Channel *		findChannel (const char name[]) const;
 
+    IMF_EXPORT
     Channel *			findChannel (const std::string &name);
+    IMF_EXPORT
     const Channel *		findChannel (const std::string &name) const;
 
 
@@ -159,16 +174,24 @@ class ChannelList
     class Iterator;
     class ConstIterator;
 
+    IMF_EXPORT
     Iterator			begin ();
+    IMF_EXPORT
     ConstIterator		begin () const;
 
+    IMF_EXPORT
     Iterator			end ();
+    IMF_EXPORT
     ConstIterator		end () const;
 
+    IMF_EXPORT
     Iterator			find (const char name[]);
+    IMF_EXPORT
     ConstIterator		find (const char name[]) const;
 
+    IMF_EXPORT
     Iterator			find (const std::string &name);
+    IMF_EXPORT
     ConstIterator		find (const std::string &name) const;
 
     
@@ -212,15 +235,18 @@ class ChannelList
     //
     //-----------------------------------------------------------------
 
+    IMF_EXPORT
     void		layers (std::set <std::string> &layerNames) const;
 
+    IMF_EXPORT
     void		channelsInLayer (const std::string &layerName,
-                         Iterator &first,
+	    				 Iterator &first,
-                     Iterator &last);
+					 Iterator &last);
 
+    IMF_EXPORT
     void		channelsInLayer (const std::string &layerName,
-                         ConstIterator &first,
+	    				 ConstIterator &first,
-                     ConstIterator &last) const;
+					 ConstIterator &last) const;
 
 
     //-------------------------------------------------------------------
@@ -235,26 +261,31 @@ class ChannelList
     //
     //-------------------------------------------------------------------
 
+    IMF_EXPORT
     void			channelsWithPrefix (const char prefix[],
-                            Iterator &first,
+						    Iterator &first,
-                            Iterator &last);
+						    Iterator &last);
 
+    IMF_EXPORT
     void			channelsWithPrefix (const char prefix[],
-                            ConstIterator &first,
+						    ConstIterator &first,
-                            ConstIterator &last) const;
+						    ConstIterator &last) const;
 
+    IMF_EXPORT
     void			channelsWithPrefix (const std::string &prefix,
-                            Iterator &first,
+						    Iterator &first,
-                            Iterator &last);
+						    Iterator &last);
 
+    IMF_EXPORT
     void			channelsWithPrefix (const std::string &prefix,
-                            ConstIterator &first,
+						    ConstIterator &first,
-                            ConstIterator &last) const;
+						    ConstIterator &last) const;
 
     //------------
     // Operator ==
     //------------
 
+    IMF_EXPORT
     bool			operator == (const ChannelList &other) const;
 
   private:
@@ -271,13 +302,19 @@ class ChannelList::Iterator
 {
   public:
 
+    IMF_EXPORT
     Iterator ();
+    IMF_EXPORT
     Iterator (const ChannelList::ChannelMap::iterator &i);
 
+    IMF_EXPORT
     Iterator &			operator ++ ();
+    IMF_EXPORT
     Iterator 			operator ++ (int);
 
+    IMF_EXPORT
     const char *		name () const;
+    IMF_EXPORT
     Channel &			channel () const;
 
   private:
@@ -292,14 +329,21 @@ class ChannelList::ConstIterator
 {
   public:
 
+    IMF_EXPORT
     ConstIterator ();
+    IMF_EXPORT
     ConstIterator (const ChannelList::ChannelMap::const_iterator &i);
+    IMF_EXPORT
     ConstIterator (const ChannelList::Iterator &other);
 
+    IMF_EXPORT
     ConstIterator &		operator ++ ();
+    IMF_EXPORT
     ConstIterator 		operator ++ (int);
 
+    IMF_EXPORT
     const char *		name () const;
+    IMF_EXPORT
     const Channel &		channel () const;
 
   private:
@@ -414,7 +458,7 @@ ChannelList::ConstIterator::channel () const
 
 inline bool
 operator == (const ChannelList::ConstIterator &x,
-         const ChannelList::ConstIterator &y)
+	     const ChannelList::ConstIterator &y)
 {
     return x._i == y._i;
 }
@@ -422,12 +466,12 @@ operator == (const ChannelList::ConstIterator &x,
 
 inline bool
 operator != (const ChannelList::ConstIterator &x,
-         const ChannelList::ConstIterator &y)
+	     const ChannelList::ConstIterator &y)
 {
     return !(x == y);
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
 
 #endif

3rdparty/openexr/IlmImf/ImfChannelListAttribute.cpp

@@ -42,26 +42,26 @@
 
 #include <ImfChannelListAttribute.h>
 
-
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
-namespace Imf {
 
 namespace {
 
 template <size_t N>
 void checkIsNullTerminated (const char (&str)[N], const char *what)
 {
-    for (int i = 0; i < N; ++i) {
+    for (size_t i = 0; i < N; ++i) {
         if (str[i] == '\0')
             return;
    }
     std::stringstream s;
     s << "Invalid " << what << ": it is more than " << (N - 1) 
       << " characters long.";
-    throw Iex::InputExc(s);
+    throw IEX_NAMESPACE::InputExc(s);
 }
 
 } // namespace
 
+
 template <>
 const char *
 ChannelListAttribute::staticTypeName ()
@@ -69,30 +69,31 @@ ChannelListAttribute::staticTypeName ()
     return "chlist";
 }
 
+using namespace OPENEXR_IMF_INTERNAL_NAMESPACE;
 
 template <>
 void
-ChannelListAttribute::writeValueTo (OStream &os, int) const
+ChannelListAttribute::writeValueTo (OStream &os, int version) const
 {
     for (ChannelList::ConstIterator i = _value.begin();
-     i != _value.end();
+	 i != _value.end();
-     ++i)
+	 ++i)
     {
-    //
+	//
-    // Write name
+	// Write name
-    //
+	//
 
-    Xdr::write <StreamIO> (os, i.name());
+	Xdr::write <StreamIO> (os, i.name());
 
-    //
+	//
-    // Write Channel struct
+	// Write Channel struct
-    //
+	//
 
-    Xdr::write <StreamIO> (os, int (i.channel().type));
+	Xdr::write <StreamIO> (os, int (i.channel().type));
-    Xdr::write <StreamIO> (os, i.channel().pLinear);
+	Xdr::write <StreamIO> (os, i.channel().pLinear);
-    Xdr::pad   <StreamIO> (os, 3);
+	Xdr::pad   <StreamIO> (os, 3);
-    Xdr::write <StreamIO> (os, i.channel().xSampling);
+	Xdr::write <StreamIO> (os, i.channel().xSampling);
-    Xdr::write <StreamIO> (os, i.channel().ySampling);
+	Xdr::write <StreamIO> (os, i.channel().ySampling);
     }
 
     //
@@ -105,41 +106,45 @@ ChannelListAttribute::writeValueTo (OStream &os, int) const
 
 template <>
 void
-ChannelListAttribute::readValueFrom (IStream &is, int, int)
+ChannelListAttribute::readValueFrom (IStream &is,
+                                     int size,
+                                     int version)
 {
     while (true)
     {
-    //
+	//
-    // Read name; zero length name means end of channel list
+	// Read name; zero length name means end of channel list
-    //
+	//
 
-    char name[Name::SIZE];
+	char name[Name::SIZE];
-    Xdr::read <StreamIO> (is, Name::MAX_LENGTH, name);
+	Xdr::read <StreamIO> (is,Name::MAX_LENGTH,name);
 
-    if (name[0] == 0)
+	if (name[0] == 0)
-        break;
+	    break;
 
-    checkIsNullTerminated (name, "channel name");
+	checkIsNullTerminated (name, "channel name");
 
-    //
+	//
-    // Read Channel struct
+	// Read Channel struct
-    //
+	//
 
-    int type;
+	int type;
-    bool pLinear;
+	bool pLinear;
-    int xSampling;
+	int xSampling;
-    int ySampling;
+	int ySampling;
 
-    Xdr::read <StreamIO> (is, type);
+	Xdr::read <StreamIO> (is, type);
-    Xdr::read <StreamIO> (is, pLinear);
+	Xdr::read <StreamIO> (is, pLinear);
-    Xdr::skip <StreamIO> (is, 3);
+	Xdr::skip <StreamIO> (is, 3);
-    Xdr::read <StreamIO> (is, xSampling);
+	Xdr::read <StreamIO> (is, xSampling);
-    Xdr::read <StreamIO> (is, ySampling);
+	Xdr::read <StreamIO> (is, ySampling);
 
-    _value.insert
+	_value.insert (name, Channel (PixelType (type),
-        (name, Channel (PixelType (type), xSampling, ySampling, pLinear));
+	                              xSampling,
+	                              ySampling,
+	                              pLinear));
     }
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT 

3rdparty/openexr/IlmImf/ImfChannelListAttribute.h

@@ -43,25 +43,32 @@
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfAttribute.h>
+#include "ImfAttribute.h"
-#include <ImfChannelList.h>
+#include "ImfChannelList.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
-namespace Imf {
+typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::ChannelList> ChannelListAttribute;
+
+template <>
+IMF_EXPORT
+const char *ChannelListAttribute::staticTypeName ();
+
+template <>
+IMF_EXPORT
+void ChannelListAttribute::writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &,
+                                         int) const;
+
+template <>
+IMF_EXPORT
+void ChannelListAttribute::readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &,
+                                          int, int);
 
 
-typedef TypedAttribute<ChannelList> ChannelListAttribute;
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
-template <> const char *ChannelListAttribute::staticTypeName ();
-template <> void ChannelListAttribute::writeValueTo (OStream &, int) const;
-template <> void ChannelListAttribute::readValueFrom (IStream &, int, int);
 
 
-} // namespace Imf
-
-// Metrowerks compiler wants the .cpp file inlined, too
-#ifdef __MWERKS__
-#include <ImfChannelListAttribute.cpp>
-#endif
-
 #endif
 

3rdparty/openexr/IlmImf/ImfCheckedArithmetic.h

@@ -43,15 +43,16 @@
 //-----------------------------------------------------------------------------
 
 #include <limits>
-#include <IexMathExc.h>
+#include "IexMathExc.h"
+#include "ImfNamespace.h"
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
 
 template <bool b> struct StaticAssertionFailed;
 template <> struct StaticAssertionFailed <true> {};
 
 #define IMF_STATIC_ASSERT(x) \
-    do {StaticAssertionFailed <x> staticAssertionFailed;} while (false)
+    do {StaticAssertionFailed <x> staticAssertionFailed; ((void) staticAssertionFailed);} while (false)
 
 
 template <class T>
@@ -66,7 +67,7 @@ uiMult (T a, T b)
                         std::numeric_limits<T>::is_integer);
 
     if (a > 0 && b > std::numeric_limits<T>::max() / a)
-        throw Iex::OverflowExc ("Integer multiplication overflow.");
+        throw IEX_NAMESPACE::OverflowExc ("Integer multiplication overflow.");
 
     return a * b;
 }
@@ -84,7 +85,7 @@ uiDiv (T a, T b)
                         std::numeric_limits<T>::is_integer);
 
     if (b == 0)
-        throw Iex::DivzeroExc ("Integer division by zero.");
+        throw IEX_NAMESPACE::DivzeroExc ("Integer division by zero.");
 
     return a / b;
 }
@@ -102,7 +103,7 @@ uiAdd (T a, T b)
                         std::numeric_limits<T>::is_integer);
 
     if (a > std::numeric_limits<T>::max() - b)
-        throw Iex::OverflowExc ("Integer addition overflow.");
+        throw IEX_NAMESPACE::OverflowExc ("Integer addition overflow.");
 
     return a + b;
 }
@@ -120,7 +121,7 @@ uiSub (T a, T b)
                         std::numeric_limits<T>::is_integer);
 
     if (a < b)
-        throw Iex::UnderflowExc ("Integer subtraction underflow.");
+        throw IEX_NAMESPACE::UnderflowExc ("Integer subtraction underflow.");
 
     return a - b;
 }
@@ -138,7 +139,7 @@ checkArraySize (T n, size_t s)
     //
     //      size_t (n) * s
     //
-    // would overflow, then throw an Iex::OverflowExc exception.
+    // would overflow, then throw an IEX_NAMESPACE::OverflowExc exception.
     // Otherwise return
     //
     //      size_t (n).
@@ -150,12 +151,13 @@ checkArraySize (T n, size_t s)
     IMF_STATIC_ASSERT (sizeof (T) <= sizeof (size_t));
 
     if (size_t (n) > std::numeric_limits<size_t>::max() / s)
-        throw Iex::OverflowExc ("Integer multiplication overflow.");
+        throw IEX_NAMESPACE::OverflowExc ("Integer multiplication overflow.");
 
     return size_t (n);
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
 
 #endif

3rdparty/openexr/IlmImf/ImfChromaticities.cpp

@@ -41,14 +41,16 @@
 //-----------------------------------------------------------------------------
 
 #include <ImfChromaticities.h>
+#include "ImfNamespace.h"
+#include <string.h>
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
 
    
-Chromaticities::Chromaticities (const Imath::V2f &red,
+Chromaticities::Chromaticities (const IMATH_NAMESPACE::V2f &red,
-                const Imath::V2f &green,
+				const IMATH_NAMESPACE::V2f &green,
-                const Imath::V2f &blue,
+				const IMATH_NAMESPACE::V2f &blue,
-                const Imath::V2f &white)
+				const IMATH_NAMESPACE::V2f &white)
 :
     red (red),
     green (green),
@@ -59,7 +61,21 @@ Chromaticities::Chromaticities (const Imath::V2f &red,
 }
 
     
-Imath::M44f
+bool
+Chromaticities::operator == (const Chromaticities & c) const
+{
+    return red == c.red && green == c.green && blue == c.blue;
+}
+
+    
+bool
+Chromaticities::operator != (const Chromaticities & c) const
+{
+    return red != c.red || green != c.green || blue != c.blue;
+}
+    
+    
+IMATH_NAMESPACE::M44f
 RGBtoXYZ (const Chromaticities chroma, float Y)
 {
     //
@@ -82,32 +98,32 @@ RGBtoXYZ (const Chromaticities chroma, float Y)
     //
 
     float d = chroma.red.x   * (chroma.blue.y  - chroma.green.y) +
-          chroma.blue.x  * (chroma.green.y - chroma.red.y) +
+	      chroma.blue.x  * (chroma.green.y - chroma.red.y) +
-          chroma.green.x * (chroma.red.y   - chroma.blue.y);
+	      chroma.green.x * (chroma.red.y   - chroma.blue.y);
 
     float Sr = (X * (chroma.blue.y - chroma.green.y) -
-            chroma.green.x * (Y * (chroma.blue.y - 1) +
+	        chroma.green.x * (Y * (chroma.blue.y - 1) +
-        chroma.blue.y  * (X + Z)) +
+		chroma.blue.y  * (X + Z)) +
-        chroma.blue.x  * (Y * (chroma.green.y - 1) +
+		chroma.blue.x  * (Y * (chroma.green.y - 1) +
-        chroma.green.y * (X + Z))) / d;
+		chroma.green.y * (X + Z))) / d;
 
     float Sg = (X * (chroma.red.y - chroma.blue.y) +
-        chroma.red.x   * (Y * (chroma.blue.y - 1) +
+		chroma.red.x   * (Y * (chroma.blue.y - 1) +
-        chroma.blue.y  * (X + Z)) -
+		chroma.blue.y  * (X + Z)) -
-        chroma.blue.x  * (Y * (chroma.red.y - 1) +
+		chroma.blue.x  * (Y * (chroma.red.y - 1) +
-        chroma.red.y   * (X + Z))) / d;
+		chroma.red.y   * (X + Z))) / d;
 
     float Sb = (X * (chroma.green.y - chroma.red.y) -
-        chroma.red.x   * (Y * (chroma.green.y - 1) +
+		chroma.red.x   * (Y * (chroma.green.y - 1) +
-        chroma.green.y * (X + Z)) +
+		chroma.green.y * (X + Z)) +
-        chroma.green.x * (Y * (chroma.red.y - 1) +
+		chroma.green.x * (Y * (chroma.red.y - 1) +
-        chroma.red.y   * (X + Z))) / d;
+		chroma.red.y   * (X + Z))) / d;
 
     //
     // Assemble the matrix
     //
 
-    Imath::M44f M;
+    IMATH_NAMESPACE::M44f M;
 
     M[0][0] = Sr * chroma.red.x;
     M[0][1] = Sr * chroma.red.y;
@@ -125,11 +141,11 @@ RGBtoXYZ (const Chromaticities chroma, float Y)
 }
 
 
-Imath::M44f
+IMATH_NAMESPACE::M44f
 XYZtoRGB (const Chromaticities chroma, float Y)
 {
     return RGBtoXYZ (chroma, Y).inverse();
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfChromaticities.h

@@ -45,8 +45,11 @@
 
 #include "ImathVec.h"
 #include "ImathMatrix.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
 
-namespace Imf {
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
 
    
 struct Chromaticities
@@ -56,20 +59,31 @@ struct Chromaticities
     // (1,0,0), (0,1,0), (0,0,1) and (1,1,1).
     //-----------------------------------------------
 
-    Imath::V2f	red;
+    IMATH_NAMESPACE::V2f	red;
-    Imath::V2f	green;
+    IMATH_NAMESPACE::V2f	green;
-    Imath::V2f	blue;
+    IMATH_NAMESPACE::V2f	blue;
-    Imath::V2f	white;
+    IMATH_NAMESPACE::V2f	white;
 
     //--------------------------------------------
     // Default constructor produces chromaticities
     // according to Rec. ITU-R BT.709-3
     //--------------------------------------------
 
-    Chromaticities (const Imath::V2f &red   = Imath::V2f (0.6400f, 0.3300f),
+    IMF_EXPORT
-            const Imath::V2f &green = Imath::V2f (0.3000f, 0.6000f),
+    Chromaticities (const IMATH_NAMESPACE::V2f &red   = IMATH_NAMESPACE::V2f (0.6400f, 0.3300f),
-            const Imath::V2f &blue  = Imath::V2f (0.1500f, 0.0600f),
+		    const IMATH_NAMESPACE::V2f &green = IMATH_NAMESPACE::V2f (0.3000f, 0.6000f),
-            const Imath::V2f &white = Imath::V2f (0.3127f, 0.3290f));
+		    const IMATH_NAMESPACE::V2f &blue  = IMATH_NAMESPACE::V2f (0.1500f, 0.0600f),
+		    const IMATH_NAMESPACE::V2f &white = IMATH_NAMESPACE::V2f (0.3127f, 0.3290f));
+    
+    
+    //---------
+    // Equality
+    //---------
+    
+    IMF_EXPORT
+    bool		operator == (const Chromaticities &v) const;    
+    IMF_EXPORT
+    bool		operator != (const Chromaticities &v) const;
 };
 
 
@@ -111,10 +125,10 @@ struct Chromaticities
 // 	YYZtoRGB(c,Y) returns RGBtoXYZ(c,Y).inverse().
 // 
 
-Imath::M44f	RGBtoXYZ (const Chromaticities chroma, float Y);
+IMF_EXPORT IMATH_NAMESPACE::M44f    RGBtoXYZ (const Chromaticities chroma, float Y);
-Imath::M44f	XYZtoRGB (const Chromaticities chroma, float Y);
+IMF_EXPORT IMATH_NAMESPACE::M44f    XYZtoRGB (const Chromaticities chroma, float Y);
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
 
 #endif

3rdparty/openexr/IlmImf/ImfChromaticitiesAttribute.cpp

@@ -42,8 +42,9 @@
 #include <ImfChromaticitiesAttribute.h>
 
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
 
+using namespace OPENEXR_IMF_INTERNAL_NAMESPACE;
 
 template <>
 const char *
@@ -55,7 +56,7 @@ ChromaticitiesAttribute::staticTypeName ()
 
 template <>
 void
-ChromaticitiesAttribute::writeValueTo (OStream &os, int) const
+ChromaticitiesAttribute::writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, int version) const
 {
     Xdr::write <StreamIO> (os, _value.red.x);
     Xdr::write <StreamIO> (os, _value.red.y);
@@ -70,7 +71,7 @@ ChromaticitiesAttribute::writeValueTo (OStream &os, int) const
 
 template <>
 void
-ChromaticitiesAttribute::readValueFrom (IStream &is, int, int)
+ChromaticitiesAttribute::readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int size, int version)
 {
     Xdr::read <StreamIO> (is, _value.red.x);
     Xdr::read <StreamIO> (is, _value.red.y);
@@ -83,4 +84,4 @@ ChromaticitiesAttribute::readValueFrom (IStream &is, int, int)
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT 

3rdparty/openexr/IlmImf/ImfChromaticitiesAttribute.h

@@ -43,30 +43,31 @@
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfAttribute.h>
+#include "ImfAttribute.h"
-#include <ImfChromaticities.h>
+#include "ImfChromaticities.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
-namespace Imf {
+typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Chromaticities> ChromaticitiesAttribute;
-
-
-typedef TypedAttribute<Chromaticities> ChromaticitiesAttribute;
 
 template <>
+IMF_EXPORT
 const char *ChromaticitiesAttribute::staticTypeName ();
 
 template <>
-void ChromaticitiesAttribute::writeValueTo (OStream &, int) const;
+IMF_EXPORT
+void ChromaticitiesAttribute::writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &,
+                                            int) const;
 
 template <>
-void ChromaticitiesAttribute::readValueFrom (IStream &, int, int);
+IMF_EXPORT
+void ChromaticitiesAttribute::readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &,
+                                             int,
+                                             int);
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
 
-// Metrowerks compiler wants the .cpp file inlined, too
-#ifdef __MWERKS__
-#include <ImfChromaticitiesAttribute.cpp>
-#endif
 
 #endif

3rdparty/openexr/IlmImf/ImfCompositeDeepScanLine.cpp

@@ -0,0 +1,591 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2012, Weta Digital Ltd
+// 
+// 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 Weta Digital 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+#include "ImfCompositeDeepScanLine.h"
+#include "ImfDeepScanLineInputPart.h"
+#include "ImfDeepScanLineInputFile.h"
+#include "ImfChannelList.h"
+#include "ImfFrameBuffer.h"
+#include "ImfDeepFrameBuffer.h"
+#include "ImfDeepCompositing.h"
+#include "ImfPixelType.h"
+#include "IlmThreadPool.h"
+
+#include <Iex.h>
+#include <vector>
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+using std::vector;
+using std::string;
+using IMATH_NAMESPACE::Box2i;
+using ILMTHREAD_NAMESPACE::Task;
+using ILMTHREAD_NAMESPACE::TaskGroup;
+using ILMTHREAD_NAMESPACE::ThreadPool;
+
+
+
+struct CompositeDeepScanLine::Data{
+    public :
+    vector<DeepScanLineInputFile *>     _file;   // array of files    
+    vector<DeepScanLineInputPart *>     _part;   // array of parts 
+    FrameBuffer            _outputFrameBuffer;   // output frame buffer provided
+    bool                               _zback;   // true if we are using zback (otherwise channel 1 = channel 0)
+    vector< vector<float> >      _channeldata;   // pixel values, read from the input, one array per channel
+    vector< int >               _sampleCounts;   // total per-pixel sample counts,   
+    Box2i                         _dataWindow;   // data window of combined inputs
+    DeepCompositing *                   _comp;   // user-provided compositor
+    vector<string>                  _channels;   // names of channels that will be composited
+    vector<int>                    _bufferMap;   // entry _outputFrameBuffer[n].name() == _channels[ _bufferMap[n] ].name()
+    
+    void check_valid(const Header & header);     // check newly added part/file is OK; on first good call, set _zback/_dataWindow
+
+    //
+    // set up the given deep frame buffer to contain the required channels
+    // resize counts and pointers to the width of _dataWindow
+    // zero-out all counts, since the datawindow may be smaller than/not include this part
+    //
+
+    void handleDeepFrameBuffer (DeepFrameBuffer & buf,
+                                vector<unsigned int> & counts,        //per-pixel counts
+                                vector< vector<float *> > & pointers, //per-channel-per-pixel pointers to data
+                                const Header & header,
+                                int start,
+                                int end);
+
+    Data();
+};
+
+CompositeDeepScanLine::Data::Data() : _zback(false) , _comp(NULL) {}
+
+CompositeDeepScanLine::CompositeDeepScanLine() : _Data(new Data) {}
+
+CompositeDeepScanLine::~CompositeDeepScanLine()
+{
+   delete _Data;
+}
+
+void
+CompositeDeepScanLine::addSource(DeepScanLineInputPart* part)
+{
+  _Data->check_valid(part->header());
+  _Data->_part.push_back(part);
+}
+
+void
+CompositeDeepScanLine::addSource(DeepScanLineInputFile* file)
+{
+    _Data->check_valid(file->header());
+    _Data->_file.push_back(file);
+}
+
+int 
+CompositeDeepScanLine::sources() const
+{
+   return int(_Data->_part.size())+int(_Data->_file.size());
+}
+
+void
+CompositeDeepScanLine::Data::check_valid(const Header & header)
+{
+
+    bool has_z=false;
+    bool has_alpha=false;
+    // check good channel names
+    for( ChannelList::ConstIterator i=header.channels().begin();i!=header.channels().end();++i)
+    {
+        std::string n(i.name()); 
+        if(n=="ZBack")
+        {
+            _zback=true;
+        }
+        else if(n=="Z")
+        {
+            has_z=true;
+        }
+        else if(n=="A")
+        {
+            has_alpha=true;
+        }
+    }
+    
+    if(!has_z)
+    {
+        throw IEX_NAMESPACE::ArgExc("Deep data provided to CompositeDeepScanLine is missing a Z channel");
+    }
+    
+    if(!has_alpha)
+    {
+        throw IEX_NAMESPACE::ArgExc("Deep data provided to CompositeDeepScanLine is missing an alpha channel");
+    }
+    
+    
+    if(_part.size()==0 && _file.size()==0)
+    {
+       // first in - update and return
+
+       _dataWindow = header.dataWindow();
+       
+       return;
+    }
+    
+    
+    const Header * const match_header = _part.size()>0 ? &_part[0]->header() : &_file[0]->header();
+    
+    // check the sizes match
+    if(match_header->displayWindow() != header.displayWindow())
+    {
+        throw IEX_NAMESPACE::ArgExc("Deep data provided to CompositeDeepScanLine has a different displayWindow to previously provided data");
+    }
+    
+    _dataWindow.extendBy(header.dataWindow());
+    
+}
+void 
+CompositeDeepScanLine::Data::handleDeepFrameBuffer (DeepFrameBuffer& buf,
+                                                    std::vector< unsigned int > & counts,
+                                                    vector< std::vector< float* > > & pointers,
+                                                    const Header& header,
+                                                    int start,
+                                                    int end)
+{
+    int width=_dataWindow.size().x+1;
+    size_t pixelcount = width * (end-start+1);
+    pointers.resize(_channels.size());
+    counts.resize(pixelcount);
+    buf.insertSampleCountSlice (Slice (OPENEXR_IMF_INTERNAL_NAMESPACE::UINT,
+                                (char *) (&counts[0]-_dataWindow.min.x-start*width),
+                                sizeof(unsigned int),
+                                sizeof(unsigned int)*width));
+
+    pointers[0].resize(pixelcount);
+    buf.insert ("Z", DeepSlice (OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT,
+                                (char *)(&pointers[0][0]-_dataWindow.min.x-start*width),
+                                sizeof(float *),
+                                sizeof(float *)*width,
+                                sizeof(float) ));
+
+    if(_zback)
+    {
+        pointers[1].resize(pixelcount);
+        buf.insert ("ZBack", DeepSlice (OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT,
+                                        (char *)(&pointers[1][0]-_dataWindow.min.x-start*width),
+                                        sizeof(float *),
+                                        sizeof(float *)*width,
+                                        sizeof(float) ));
+    }
+
+    pointers[2].resize(pixelcount);
+    buf.insert ("A", DeepSlice (OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT,
+                                (char *)(&pointers[2][0]-_dataWindow.min.x-start*width),
+                                sizeof(float *),
+                                sizeof(float *)*width,
+                                sizeof(float) ));
+
+
+    size_t i =0;
+    for(FrameBuffer::ConstIterator qt  = _outputFrameBuffer.begin();
+                                   qt != _outputFrameBuffer.end();
+                                   qt++)
+    {
+        int channel_in_source = _bufferMap[i];
+        if(channel_in_source>2)
+        {
+            // not dealt with yet (0,1,2 previously inserted)
+            pointers[channel_in_source].resize(pixelcount);
+            buf.insert (qt.name(),
+                        DeepSlice (OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT,
+                                   (char *)(&pointers[channel_in_source][0]-_dataWindow.min.x-start*width),
+                                   sizeof(float *),
+                                   sizeof(float *)*width,
+                                   sizeof(float) ));
+        }
+
+        i++;
+    }
+
+}
+
+void
+CompositeDeepScanLine::setCompositing(DeepCompositing* c)
+{
+  _Data->_comp=c;
+}
+
+const IMATH_NAMESPACE::Box2i& CompositeDeepScanLine::dataWindow() const
+{
+  return  _Data->_dataWindow;
+}
+
+
+void
+CompositeDeepScanLine::setFrameBuffer(const FrameBuffer& fr)
+{
+    
+    //
+    // count channels; build map between channels in frame buffer
+    // and channels in internal buffers
+    //
+    
+    _Data->_channels.resize(3);
+    _Data->_channels[0]="Z";
+    _Data->_channels[1]=_Data->_zback ? "ZBack" : "Z";
+    _Data->_channels[2]="A";
+    _Data->_bufferMap.resize(0);
+    
+    for(FrameBuffer::ConstIterator q=fr.begin();q!=fr.end();q++)
+    {
+        string name(q.name());
+        if(name=="ZBack")
+        {
+            _Data->_bufferMap.push_back(1);
+        }else if(name=="Z")
+        {
+            _Data->_bufferMap.push_back(0);
+        }else if(name=="A")
+        {
+            _Data->_bufferMap.push_back(2);
+        }else{
+            _Data->_bufferMap.push_back(_Data->_channels.size());
+            _Data->_channels.push_back(name);
+        }
+    }
+    
+  _Data->_outputFrameBuffer=fr;
+}
+
+namespace 
+{
+    
+class LineCompositeTask : public Task
+{
+  public:
+
+    LineCompositeTask ( TaskGroup* group ,
+                        CompositeDeepScanLine::Data * data,
+                    int y,
+                    int start,
+                    vector<const char*>* names,
+                    vector<vector< vector<float *> > >* pointers,
+                    vector<unsigned int>* total_sizes,
+                    vector<unsigned int>* num_sources
+                  ) : Task(group) ,
+                     _Data(data),
+                     _y(y),
+                     _start(start),
+                     _names(names),
+                     _pointers(pointers),
+                     _total_sizes(total_sizes),
+                     _num_sources(num_sources)
+                     {}
+
+    virtual ~LineCompositeTask () {}
+
+    virtual void                execute ();
+    CompositeDeepScanLine::Data*         _Data;
+    int                                  _y;
+    int                                  _start;
+    vector<const char *>*                _names;
+    vector<vector< vector<float *> > >*  _pointers;
+    vector<unsigned int>*                _total_sizes;
+    vector<unsigned int>*                _num_sources;
+
+};
+
+
+void
+composite_line(int y,
+               int start,
+               CompositeDeepScanLine::Data * _Data,
+               vector<const char *> & names,
+               const vector<vector< vector<float *> > >  & pointers,
+               const vector<unsigned int> & total_sizes,
+               const vector<unsigned int> & num_sources
+              )
+{
+    vector<float> output_pixel(names.size());    //the pixel we'll output to
+    vector<const float *> inputs(names.size());
+    DeepCompositing d; // fallback compositing engine
+    DeepCompositing * comp= _Data->_comp ? _Data->_comp : &d;
+
+    int pixel = (y-start)*(_Data->_dataWindow.max.x+1-_Data->_dataWindow.min.x);
+    
+     for(int x=_Data->_dataWindow.min.x;x<=_Data->_dataWindow.max.x;x++)
+     {
+           // set inputs[] to point to the first sample of the first part of each channel
+           // if there's a zback, set all channel independently...
+
+          if(_Data->_zback)
+          {
+
+              for(size_t channel=0;channel<names.size();channel++)
+              {
+                 inputs[channel]=pointers[0][channel][pixel];
+              }
+
+          }else{
+
+              // otherwise, set 0 and 1 to point to Z
+
+
+              inputs[0]=pointers[0][0][pixel];
+              inputs[1]=pointers[0][0][pixel];
+              for(size_t channel=2;channel<names.size();channel++)
+              {
+                  inputs[channel]=pointers[0][channel][pixel];
+              }
+
+          }
+          comp->composite_pixel(&output_pixel[0],
+                                &inputs[0],
+                                &names[0],
+                                names.size(),
+                                total_sizes[pixel],
+                                num_sources[pixel]
+                               );
+
+
+           size_t channel_number=0;
+
+
+           //
+           // write out composited value into internal frame buffer
+           //
+           for(FrameBuffer::Iterator it = _Data->_outputFrameBuffer.begin();it !=_Data->_outputFrameBuffer.end();it++)
+           {
+
+               float value = output_pixel[ _Data->_bufferMap[channel_number] ]; // value to write
+
+
+                // cast to half float if necessary
+               if(it.slice().type==OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT)
+               {
+                   * (float *)(it.slice().base + y*it.slice().yStride + x*it.slice().xStride) = value;
+               }
+               else if(it.slice().type==HALF)
+               {
+                   * (half *)(it.slice().base + y*it.slice().yStride + x*it.slice().xStride) = half(value);
+               }
+
+               channel_number++;
+
+           }
+
+           pixel++;
+
+       }// next pixel on row
+}
+
+void LineCompositeTask::execute()
+{
+  composite_line(_y,_start,_Data,*_names,*_pointers,*_total_sizes,*_num_sources);
+}
+
+
+}
+
+void
+CompositeDeepScanLine::readPixels(int start, int end)
+{
+   size_t parts = _Data->_file.size() + _Data->_part.size(); // total of files+parts
+   
+   vector<DeepFrameBuffer> framebuffers(parts);
+   vector< vector<unsigned int> > counts(parts);
+   
+   //
+   // for each part, a pointer to an array of channels
+   //
+   vector<vector< vector<float *> > > pointers(parts);
+   vector<const Header *> headers(parts);
+   
+   {
+     size_t i;
+     for(i=0;i<_Data->_file.size();i++)
+     {
+         headers[i] = &_Data->_file[i]->header();
+     }
+     
+     for(size_t j=0;j<_Data->_part.size();j++)
+     {
+        headers[i+j] = &_Data->_part[j]->header();
+     }
+   }
+   
+   
+   for(size_t i=0;i<parts;i++)
+   {
+     _Data->handleDeepFrameBuffer(framebuffers[i],counts[i],pointers[i],*headers[i],start,end);
+   }
+   
+   //
+   // set frame buffers and read scanlines from all parts
+   // TODO what happens if SCANLINE not in data window?
+   //
+   
+   {
+       size_t i=0;
+       for(i=0;i<_Data->_file.size();i++)
+       {
+            _Data->_file[i]->setFrameBuffer(framebuffers[i]);
+            _Data->_file[i]->readPixelSampleCounts(start,end);
+       }
+       for(size_t j=0;j<_Data->_part.size();j++)
+       {
+           _Data->_part[j]->setFrameBuffer(framebuffers[i+j]);
+           _Data->_part[j]->readPixelSampleCounts(start,end); 
+       }
+   }   
+   
+   
+   //
+   //  total width
+   //
+   
+   size_t total_width = _Data->_dataWindow.size().x+1;
+   size_t total_pixels = total_width*(end-start+1);
+   vector<unsigned int> total_sizes(total_pixels);
+   vector<unsigned int> num_sources(total_pixels); //number of parts with non-zero sample count
+   
+   size_t overall_sample_count=0; // sum of all samples in all images between start and end
+   
+   
+   //
+   // accumulate pixel counts
+   //
+   for(size_t ptr=0;ptr<total_pixels;ptr++)
+   {
+       total_sizes[ptr]=0;
+       num_sources[ptr]=0;
+       for(size_t j=0;j<parts;j++)
+       {
+          total_sizes[ptr]+=counts[j][ptr];
+          if(counts[j][ptr]>0) num_sources[ptr]++;
+       }
+       overall_sample_count+=total_sizes[ptr];
+       
+       
+       
+   }
+   
+  
+  
+   
+   //
+   // allocate arrays for pixel data
+   // samples array accessed as in pixels[channel][sample]
+   //
+   
+   vector<vector<float> > samples( _Data->_channels.size() );
+   
+   for(size_t channel=0;channel<_Data->_channels.size();channel++)
+   {
+       if( channel!=1 || _Data->_zback)
+       {            
+           samples[channel].resize(overall_sample_count);
+       }
+   }
+   
+   for(size_t channel=0;channel<samples.size();channel++)
+   {
+       
+       if( channel!=1 || _Data->_zback)
+       {
+           
+           samples[channel].resize(overall_sample_count);
+       
+       
+          //
+          // allocate pointers for channel data
+          //
+          
+          size_t offset=0;
+       
+          for(size_t pixel=0;pixel<total_pixels;pixel++)
+          {
+              for(size_t part=0 ; part<parts && offset<overall_sample_count ; part++ )
+              {
+                      pointers[part][channel][pixel]=&samples[channel][offset];           
+                      offset+=counts[part][pixel];
+              }
+          }
+       
+       }
+   }
+   
+   //
+   // read data
+   //
+   
+   for(size_t i=0;i<_Data->_file.size();i++)
+   {
+       _Data->_file[i]->readPixels(start,end);
+   }
+   for(size_t j=0;j<_Data->_part.size();j++)
+   {
+       _Data->_part[j]->readPixels(start,end); 
+   }
+   
+   
+   
+   
+   //
+   // composite pixels and write back to framebuffer
+  //
+   
+   
+   // turn vector of strings into array of char *
+   // and make sure 'ZBack' channel is correct
+   vector<const char *> names(_Data->_channels.size());
+   for(size_t i=0;i<names.size();i++)
+   {
+       names[i]=_Data->_channels[i].c_str();
+   }
+   
+   if(!_Data->_zback) names[1]=names[0]; // no zback channel, so make it point to z
+
+   
+   
+   TaskGroup g;
+   for(int y=start;y<=end;y++)
+   {
+       ThreadPool::addGlobalTask(new LineCompositeTask(&g,_Data,y,start,&names,&pointers,&total_sizes,&num_sources));
+   }//next row
+}  
+
+const FrameBuffer& 
+CompositeDeepScanLine::frameBuffer() const
+{
+  return _Data->_outputFrameBuffer;
+}
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfCompositeDeepScanLine.h

@@ -0,0 +1,152 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2012, Weta Digital Ltd
+// 
+// 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 Weta Digital 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+#ifndef INCLUDED_IMF_COMPOSITEDEEPSCANLINE_H
+#define INCLUDED_IMF_COMPOSITEDEEPSCANLINE_H
+
+//-----------------------------------------------------------------------------
+//
+//	Class to composite deep samples into a frame buffer
+//      Initialise with a deep input part or deep inputfile
+//      (also supports multiple files and parts, and will 
+//       composite them together, as long as their sizes and channelmaps agree)
+//       
+//      Then call setFrameBuffer, and readPixels, exactly as for reading 
+//      regular scanline images.
+//
+//      Restrictions - source file(s) must contain at least Z and alpha channels
+//                   - if multiple files/parts are provided, sizes must match
+//                   - all requested channels will be composited as premultiplied
+//                   - only half and float channels can be requested
+//
+//      This object should not be considered threadsafe
+//  
+//      The default compositing engine will give spurious results with overlapping
+//      volumetric samples - you may derive from DeepCompositing class, override the 
+//      sort_pixel() and composite_pixel() functions, and pass an instance to 
+//      setCompositing(). 
+//
+//-----------------------------------------------------------------------------
+
+#include "ImfForward.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+#include <ImathBox.h>
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+class CompositeDeepScanLine
+{
+    public:
+        IMF_EXPORT
+        CompositeDeepScanLine();
+        IMF_EXPORT
+        virtual ~CompositeDeepScanLine();
+        
+        /// set the source data as a part
+        ///@note all parts must remain valid until after last interaction with DeepComp
+        IMF_EXPORT
+        void addSource(DeepScanLineInputPart * part);
+        
+        /// set the source data as a file
+        ///@note all file must remain valid until after last interaction with DeepComp
+        IMF_EXPORT
+        void addSource(DeepScanLineInputFile * file);
+        
+        
+        /////////////////////////////////////////
+        //
+        // set the frame buffer for output values
+        // the buffers specified must be large enough
+        // to handle the dataWindow() 
+        //
+        /////////////////////////////////////////
+        IMF_EXPORT
+        void setFrameBuffer(const FrameBuffer & fr);
+        
+        
+        
+        /////////////////////////////////////////
+        //
+        // retrieve frameBuffer
+        //
+        ////////////////////////////////////////
+        IMF_EXPORT
+        const FrameBuffer & frameBuffer() const;
+        
+        
+        //////////////////////////////////////////////////
+        //
+        // read scanlines start to end from the source(s)
+        // storing the result in the frame buffer provided
+        //
+        //////////////////////////////////////////////////
+        
+        IMF_EXPORT
+        void readPixels(int start,int end);
+        
+        IMF_EXPORT
+        int sources() const; // return number of sources
+        
+        /////////////////////////////////////////////////
+        //
+        // retrieve the datawindow
+        // If multiple parts are specified, this will
+        // be the union of the dataWindow of all parts
+        //
+        ////////////////////////////////////////////////
+        
+        IMF_EXPORT
+        const IMATH_NAMESPACE::Box2i & dataWindow() const;
+        
+ 
+        //
+        // override default sorting/compositing operation
+        // (otherwise an instance of the base class will be used)
+        //
+        
+        IMF_EXPORT
+        void setCompositing(DeepCompositing *);
+        
+      struct Data; 
+    private :  
+      struct Data *_Data;
+      
+      CompositeDeepScanLine(const CompositeDeepScanLine &); // not implemented
+      const CompositeDeepScanLine & operator=(const CompositeDeepScanLine &);  // not implemented
+};
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif

3rdparty/openexr/IlmImf/ImfCompression.h

@@ -42,9 +42,9 @@
 //	enum Compression
 //
 //-----------------------------------------------------------------------------
+#include "ImfNamespace.h"
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
-
 
 enum Compression
 {
@@ -61,15 +61,24 @@ enum Compression
     PXR24_COMPRESSION = 5,	// lossy 24-bit float compression
 
     B44_COMPRESSION = 6,	// lossy 4-by-4 pixel block compression,
-                    // fixed compression rate
+    				// fixed compression rate
 
     B44A_COMPRESSION = 7,	// lossy 4-by-4 pixel block compression,
-                    // flat fields are compressed more
+    				// flat fields are compressed more
+
+    DWAA_COMPRESSION = 8,       // lossy DCT based compression, in blocks
+                                // of 32 scanlines. More efficient for partial
+                                // buffer access.
+
+    DWAB_COMPRESSION = 9,       // lossy DCT based compression, in blocks
+                                // of 256 scanlines. More efficient space
+                                // wise and faster to decode full frames
+                                // than DWAA_COMPRESSION.
 
     NUM_COMPRESSION_METHODS	// number of different compression methods
 };
 
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
 
-} // namespace Imf
 
 #endif

3rdparty/openexr/IlmImf/ImfCompressionAttribute.cpp

@@ -40,10 +40,12 @@
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfCompressionAttribute.h>
+#include "ImfCompressionAttribute.h"
 
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+using namespace OPENEXR_IMF_INTERNAL_NAMESPACE;
 
 
 template <>
@@ -56,7 +58,7 @@ CompressionAttribute::staticTypeName ()
 
 template <>
 void
-CompressionAttribute::writeValueTo (OStream &os, int) const
+CompressionAttribute::writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, int version) const
 {
     unsigned char tmp = _value;
     Xdr::write <StreamIO> (os, tmp);
@@ -65,7 +67,7 @@ CompressionAttribute::writeValueTo (OStream &os, int) const
 
 template <>
 void
-CompressionAttribute::readValueFrom (IStream &is, int, int)
+CompressionAttribute::readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int size, int version)
 {
     unsigned char tmp;
     Xdr::read <StreamIO> (is, tmp);
@@ -73,4 +75,4 @@ CompressionAttribute::readValueFrom (IStream &is, int, int)
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT 

3rdparty/openexr/IlmImf/ImfCompressionAttribute.h

@@ -43,24 +43,22 @@
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfAttribute.h>
+#include "ImfAttribute.h"
-#include <ImfCompression.h>
+#include "ImfCompression.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
-namespace Imf {
+typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Compression> CompressionAttribute;
+template <> IMF_EXPORT const char *CompressionAttribute::staticTypeName ();
+template <> IMF_EXPORT void CompressionAttribute::writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &,
+                                                     int) const;
+template <> IMF_EXPORT void CompressionAttribute::readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &,
+                                                      int,
+                                                      int);
 
 
-typedef TypedAttribute<Compression> CompressionAttribute;
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
-template <> const char *CompressionAttribute::staticTypeName ();
-template <> void CompressionAttribute::writeValueTo (OStream &, int) const;
-template <> void CompressionAttribute::readValueFrom (IStream &, int, int);
 
 
-} // namespace Imf
-
-// Metrowerks compiler wants the .cpp file inlined, too
-#ifdef __MWERKS__
-#include <ImfCompressionAttribute.cpp>
-#endif
-
 #endif

3rdparty/openexr/IlmImf/ImfCompressor.cpp

@@ -40,17 +40,19 @@
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfCompressor.h>
+#include "ImfCompressor.h"
-#include <ImfRleCompressor.h>
+#include "ImfRleCompressor.h"
-#include <ImfZipCompressor.h>
+#include "ImfZipCompressor.h"
-#include <ImfPizCompressor.h>
+#include "ImfPizCompressor.h"
-#include <ImfPxr24Compressor.h>
+#include "ImfPxr24Compressor.h"
-#include <ImfB44Compressor.h>
+#include "ImfB44Compressor.h"
-#include <ImfCheckedArithmetic.h>
+#include "ImfDwaCompressor.h"
+#include "ImfCheckedArithmetic.h"
+#include "ImfNamespace.h"
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
 
-using Imath::Box2i;
+using IMATH_NAMESPACE::Box2i;
 
 
 Compressor::Compressor (const Header &hdr): _header (hdr) {}
@@ -68,9 +70,9 @@ Compressor::format () const
 
 int
 Compressor::compressTile (const char *inPtr,
-              int inSize,
+			  int inSize,
-              Box2i range,
+			  Box2i range,
-              const char *&outPtr)
+			  const char *&outPtr)
 {
     return compress (inPtr, inSize, range.min.y, outPtr);
 }
@@ -78,9 +80,9 @@ Compressor::compressTile (const char *inPtr,
              
 int
 Compressor::uncompressTile (const char *inPtr,
-                int inSize,
+			    int inSize,
-                Box2i range,
+			    Box2i range,
-                const char *&outPtr)
+			    const char *&outPtr)
 {
     return uncompress (inPtr, inSize, range.min.y, outPtr);
 }
@@ -99,15 +101,30 @@ isValidCompression (Compression c)
       case PXR24_COMPRESSION:
       case B44_COMPRESSION:
       case B44A_COMPRESSION:
+      case DWAA_COMPRESSION:
+      case DWAB_COMPRESSION:
 
-    return true;
+	return true;
 
       default:
 
-    return false;
+	return false;
     }
 }
 
+bool isValidDeepCompression(Compression c)
+{
+  switch(c)
+  {
+      case NO_COMPRESSION:
+      case RLE_COMPRESSION:
+      case ZIPS_COMPRESSION:
+          return true;
+      default :
+          return false;
+  }
+}
+
 
 Compressor *
 newCompressor (Compression c, size_t maxScanLineSize, const Header &hdr)
@@ -116,77 +133,94 @@ newCompressor (Compression c, size_t maxScanLineSize, const Header &hdr)
     {
       case RLE_COMPRESSION:
 
-    return new RleCompressor (hdr, maxScanLineSize);
+	return new RleCompressor (hdr, maxScanLineSize);
 
       case ZIPS_COMPRESSION:
 
-    return new ZipCompressor (hdr, maxScanLineSize, 1);
+	return new ZipCompressor (hdr, maxScanLineSize, 1);
 
       case ZIP_COMPRESSION:
 
-    return new ZipCompressor (hdr, maxScanLineSize, 16);
+	return new ZipCompressor (hdr, maxScanLineSize, 16);
 
       case PIZ_COMPRESSION:
 
-    return new PizCompressor (hdr, maxScanLineSize, 32);
+	return new PizCompressor (hdr, maxScanLineSize, 32);
 
       case PXR24_COMPRESSION:
 
-    return new Pxr24Compressor (hdr, maxScanLineSize, 16);
+	return new Pxr24Compressor (hdr, maxScanLineSize, 16);
 
       case B44_COMPRESSION:
 
-    return new B44Compressor (hdr, maxScanLineSize, 32, false);
+	return new B44Compressor (hdr, maxScanLineSize, 32, false);
 
       case B44A_COMPRESSION:
 
-    return new B44Compressor (hdr, maxScanLineSize, 32, true);
+	return new B44Compressor (hdr, maxScanLineSize, 32, true);
+
+      case DWAA_COMPRESSION:
+
+	return new DwaCompressor (hdr, maxScanLineSize, 32, 
+                               DwaCompressor::STATIC_HUFFMAN);
+
+      case DWAB_COMPRESSION:
+
+	return new DwaCompressor (hdr, maxScanLineSize, 256, 
+                               DwaCompressor::STATIC_HUFFMAN);
 
       default:
 
-    return 0;
+	return 0;
     }
 }
 
 
 Compressor *
 newTileCompressor (Compression c,
-           size_t tileLineSize,
+		   size_t tileLineSize,
-           size_t numTileLines,
+		   size_t numTileLines,
-           const Header &hdr)
+		   const Header &hdr)
 {
     switch (c)
     {
       case RLE_COMPRESSION:
 
-    return new RleCompressor (hdr, uiMult (tileLineSize, numTileLines));
+	return new RleCompressor (hdr, uiMult (tileLineSize, numTileLines));
 
       case ZIPS_COMPRESSION:
       case ZIP_COMPRESSION:
 
-    return new ZipCompressor (hdr, tileLineSize, numTileLines);
+	return new ZipCompressor (hdr, tileLineSize, numTileLines);
 
       case PIZ_COMPRESSION:
 
-    return new PizCompressor (hdr, tileLineSize, numTileLines);
+	return new PizCompressor (hdr, tileLineSize, numTileLines);
 
       case PXR24_COMPRESSION:
 
-    return new Pxr24Compressor (hdr, tileLineSize, numTileLines);
+	return new Pxr24Compressor (hdr, tileLineSize, numTileLines);
 
       case B44_COMPRESSION:
 
-    return new B44Compressor (hdr, tileLineSize, numTileLines, false);
+	return new B44Compressor (hdr, tileLineSize, numTileLines, false);
 
       case B44A_COMPRESSION:
 
-    return new B44Compressor (hdr, tileLineSize, numTileLines, true);
+	return new B44Compressor (hdr, tileLineSize, numTileLines, true);
+
+      case DWAA_COMPRESSION:
+      case DWAB_COMPRESSION:
+
+	return new DwaCompressor (hdr, tileLineSize, numTileLines, 
+                               DwaCompressor::DEFLATE);
 
       default:
 
-    return 0;
+	return 0;
     }
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT
+

3rdparty/openexr/IlmImf/ImfCompressor.h

@@ -43,13 +43,16 @@
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfCompression.h>
+#include "ImfCompression.h"
 #include "ImathBox.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+#include "ImfForward.h"
+
 #include <stdlib.h>
 
-namespace Imf {
 
-class Header;
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
 class Compressor
@@ -61,6 +64,7 @@ class Compressor
     // that will be compressed or uncompressed
     //---------------------------------------------
 
+    IMF_EXPORT
     Compressor (const Header &hdr);
 
 
@@ -68,6 +72,7 @@ class Compressor
     // Destructor
     //-----------
 
+    IMF_EXPORT
     virtual ~Compressor ();
 
 
@@ -76,6 +81,7 @@ class Compressor
     // a single call to compress() and uncompress().
     //----------------------------------------------
 
+    IMF_EXPORT
     virtual int		numScanLines () const = 0;
 
 
@@ -88,10 +94,11 @@ class Compressor
 
     enum Format
     {
-    NATIVE,		// the machine's native format
+        NATIVE,		// the machine's native format
-    XDR		// Xdr format
+        XDR		// Xdr format
     };
 
+    IMF_EXPORT
     virtual Format	format () const;
 
 
@@ -155,15 +162,17 @@ class Compressor
     //
     //-------------------------------------------------------------------------
 
+    IMF_EXPORT
     virtual int		compress (const char *inPtr,
-                  int inSize,
+				  int inSize,
-                  int minY,
+				  int minY,
-                  const char *&outPtr) = 0;
+				  const char *&outPtr) = 0;
 
+    IMF_EXPORT
     virtual int		compressTile (const char *inPtr,
-                      int inSize,
+				      int inSize,
-                      Imath::Box2i range,
+				      IMATH_NAMESPACE::Box2i range,
-                      const char *&outPtr);
+				      const char *&outPtr);
 
     //-------------------------------------------------------------------------
     // Uncompress an array of bytes that has been compressed by compress():
@@ -181,15 +190,17 @@ class Compressor
     //
     //-------------------------------------------------------------------------
 
+    IMF_EXPORT
     virtual int		uncompress (const char *inPtr,
-                    int inSize,
+				    int inSize,
-                    int minY,
+				    int minY,
-                    const char *&outPtr) = 0;
+				    const char *&outPtr) = 0;
 
+    IMF_EXPORT
     virtual int		uncompressTile (const char *inPtr,
-                    int inSize,
+					int inSize,
-                    Imath::Box2i range,
+					IMATH_NAMESPACE::Box2i range,
-                    const char *&outPtr);
+					const char *&outPtr);
 
   private:
 
@@ -201,7 +212,15 @@ class Compressor
 // Test if c is a valid compression type
 //--------------------------------------
 
-bool		isValidCompression (Compression c);
+IMF_EXPORT 
+bool isValidCompression (Compression c);
+
+//--------------------------------------
+// Test if c is valid for deep data
+//--------------------------------------
+
+IMF_EXPORT
+bool            isValidDeepCompression (Compression c);
 
 
 //-----------------------------------------------------------------
@@ -219,9 +238,10 @@ bool		isValidCompression (Compression c);
 //
 //-----------------------------------------------------------------
 
+IMF_EXPORT 
 Compressor *	newCompressor (Compression c,
-                   size_t maxScanLineSize,
+			       size_t maxScanLineSize,
-                   const Header &hdr);
+			       const Header &hdr);
 
 
 //-----------------------------------------------------------------
@@ -241,12 +261,13 @@ Compressor *	newCompressor (Compression c,
 //
 //-----------------------------------------------------------------
 
+IMF_EXPORT 
 Compressor *    newTileCompressor (Compression c,
-                   size_t tileLineSize,
+				   size_t tileLineSize,
-                   size_t numTileLines,
+				   size_t numTileLines,
-                   const Header &hdr);
+				   const Header &hdr);
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
 
 #endif

3rdparty/openexr/IlmImf/ImfConvert.cpp

@@ -40,10 +40,14 @@
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfConvert.h>
+#include "ImfConvert.h"
+#include "ImfNamespace.h"
+
 #include <limits.h>
 
-namespace Imf {
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
 namespace {
 
 inline bool
@@ -88,10 +92,10 @@ unsigned int
 halfToUint (half h)
 {
     if (h.isNegative() || h.isNan())
-    return 0;
+	return 0;
 
     if (h.isInfinity())
-    return UINT_MAX;
+	return UINT_MAX;
 
     return (unsigned int) h;
 }
@@ -101,10 +105,10 @@ unsigned int
 floatToUint (float f)
 {
     if (isNegative (f) || isNan (f))
-    return 0;
+	return 0;
 
     if (isInfinity (f) || f > UINT_MAX)
-    return UINT_MAX;
+	return UINT_MAX;
 
     return (unsigned int) f;
 }
@@ -114,9 +118,9 @@ half
 uintToHalf (unsigned int ui)
 {
     if (ui >  HALF_MAX)
-    return half::posInf();
+	return half::posInf();
 
-    return half (ui);
+    return half ((float) ui);
 }
 
 
@@ -125,15 +129,15 @@ floatToHalf (float f)
 {
     if (isFinite (f))
     {
-    if (f >  HALF_MAX)
+	if (f >  HALF_MAX)
-        return half::posInf();
+	    return half::posInf();
 
-    if (f < -HALF_MAX)
+	if (f < -HALF_MAX)
-        return half::negInf();
+	    return half::negInf();
     }
 
     return half (f);
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfConvert.h

@@ -47,9 +47,11 @@
 //-----------------------------------------------------------------------------
 
 #include "half.h"
+#include "ImfExport.h"
+#include "ImfNamespace.h"
 
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
 
-namespace Imf {
 
 //---------------------------------------------------------
 // Conversion from half or float to unsigned int:
@@ -70,8 +72,8 @@ namespace Imf {
 //
 //---------------------------------------------------------
 
-unsigned int	halfToUint (half h);
+IMF_EXPORT unsigned int	halfToUint (half h);
-unsigned int	floatToUint (float f);
+IMF_EXPORT unsigned int	floatToUint (float f);
 
 
 //---------------------------------------------------------
@@ -95,10 +97,11 @@ unsigned int	floatToUint (float f);
 //
 //---------------------------------------------------------
 
-half		uintToHalf (unsigned int ui);
+IMF_EXPORT half		uintToHalf (unsigned int ui);
-half		floatToHalf (float f);
+IMF_EXPORT half		floatToHalf (float f);
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
 
 #endif

3rdparty/openexr/IlmImf/ImfDeepCompositing.cpp

@@ -0,0 +1,110 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2012, Weta Digital Ltd
+// 
+// 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 Weta Digital 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#include "ImfDeepCompositing.h"
+
+#include "ImfNamespace.h"
+#include <algorithm>
+#include <vector>
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+using std::sort;
+using std::vector;
+DeepCompositing::DeepCompositing()
+{
+}
+
+DeepCompositing::~DeepCompositing()
+{
+}
+
+void 
+DeepCompositing::composite_pixel (float outputs[],
+                                  const float* inputs[],
+                                  const char*channel_names[],
+                                  int num_channels,
+                                  int num_samples,
+                                  int sources)
+{
+    for(int i=0;i<num_channels;i++) outputs[i]=0.0;
+    // no samples? do nothing
+   if(num_samples==0)
+   {
+       return;
+   }
+   
+   vector<int> sort_order;
+   if(sources>1)
+   {
+       sort_order.resize(num_samples);
+       for(int i=0;i<num_samples;i++) sort_order[i]=i;
+       sort(&sort_order[0],inputs,channel_names,num_channels,num_samples,sources);
+   }
+   
+   
+   for(int i=0;i<num_samples;i++)
+   {
+       int s=(sources>1) ? sort_order[i] : i;
+       float alpha=outputs[2]; 
+       if(alpha>=1.0) return;
+       
+       for(int c=0;c<num_channels;c++)
+       {
+           outputs[c]+=(1.0-alpha)*inputs[c][s];
+       }
+   }   
+}
+
+struct sort_helper
+{
+    const float ** inputs;
+    bool operator() (int a,int b) 
+    {
+        if(inputs[0][a] < inputs[0][b]) return true;
+        if(inputs[0][a] > inputs[0][b]) return false;
+        if(inputs[1][a] < inputs[1][b]) return true;
+        if(inputs[1][a] > inputs[1][b]) return false;
+        return a<b;
+    }
+    sort_helper(const float ** i) : inputs(i) {}
+};
+
+void
+DeepCompositing::sort(int order[], const float* inputs[], const char* channel_names[], int num_channels, int num_samples, int sources)
+{
+  std::sort(order+0,order+num_samples,sort_helper(inputs));
+}
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfDeepCompositing.h

@@ -0,0 +1,136 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2012, Weta Digital Ltd
+// 
+// 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 Weta Digital 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+#ifndef INCLUDED_IMF_DEEPCOMPOSITING_H
+#define INCLUDED_IMF_DEEPCOMPOSITING_H
+
+//-----------------------------------------------------------------------------
+//
+//	Class to sort and composite deep samples into a frame buffer
+//      You may derive from this class to change the way that CompositeDeepScanLine
+//      and CompositeDeepTile combine samples together - pass an instance of your derived
+//      class to the compositing engine
+//
+//-----------------------------------------------------------------------------
+
+#include "ImfForward.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+class DeepCompositing
+{
+    public:
+        IMF_EXPORT
+        DeepCompositing();
+        IMF_EXPORT
+        virtual ~DeepCompositing();
+        
+        
+        //////////////////////////////////////////////
+        ///
+        /// composite together the given channels
+        /// 
+        ///  @param outputs       - return array of pixel values - 
+        ///  @param inputs        - arrays of input sample
+        ///  @param channel_names - array of channel names for corresponding channels
+        ///  @param num_channels  - number of active channels (3 or greater)    
+        ///  @param num_samples   - number of values in all input arrays
+        ///  @param sources       - number of different sources
+        ///
+        /// each array input has num_channels entries: outputs[n] should be the composited
+        /// values in array inputs[n], whose name will be given by channel_names[n]
+        /// 
+        /// The channel ordering shall be as follows:
+        /// Position Channel
+        ///    0     Z
+        ///    1     ZBack (if no ZBack, then inputs[1]==inputs[0] and channel_names[1]==channel_names[0])
+        ///    2     A (alpha channel)
+        ///    3-n   other channels - only channels in the frame buffer will appear here
+        ///
+        /// since a Z and Alpha channel is required, and channel[1] is ZBack or another copy of Z
+        /// there will always be 3 or more channels.
+        ///
+        /// The default implementation calls sort() if and only if more than one source is active,
+        /// composites all samples together using the Over operator from front to back,
+        /// stopping as soon as a sample with alpha=1 is found
+        /// It also blanks all outputs if num_samples==0
+        ///
+        /// note - multiple threads may call composite_pixel simultaneously for different pixels
+        ///
+        ///
+        //////////////////////////////////////////////
+        IMF_EXPORT
+        virtual void composite_pixel(float outputs[],
+                                     const float * inputs[],
+                                     const char * channel_names[],
+                                     int num_channels,
+                                     int num_samples,
+                                     int sources
+                                     );
+                                     
+        
+       
+       ////////////////////////////////////////////////////////////////
+       ///
+       /// find the depth order for samples with given channel values
+       /// does not sort the values in-place. Instead it populates
+       /// array 'order' with the desired sorting order
+       ///
+       /// the default operation sorts samples from front to back according to their Z channel
+       ///
+       /// @param order         - required output order. order[n] shall be the nth closest sample
+       /// @param inputs        - arrays of input samples, one array per channel_name
+       /// @param channel_names - array of channel names for corresponding channels
+       /// @param num_channels  - number of channels (3 or greater)  
+       /// @param num_samples   - number of samples in each array
+       /// @param sources       - number of different sources the data arises from
+       ///
+       /// the channel layout is identical to composite_pixel() 
+       ///
+       ///////////////////////////////////////////////////////////////
+                                     
+       IMF_EXPORT
+       virtual void sort(int order[],
+                         const float * inputs[],
+                         const char * channel_names[],
+                         int num_channels,
+                         int num_samples,
+                         int sources);
+};
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif

3rdparty/openexr/IlmImf/ImfDeepFrameBuffer.cpp

@@ -0,0 +1,230 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#include "ImfDeepFrameBuffer.h"
+#include "Iex.h"
+
+
+using namespace std;
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+DeepSlice::DeepSlice (PixelType t,
+                      char *b,
+                      size_t xst,
+                      size_t yst,
+                      size_t spst,
+                      int xsm,
+                      int ysm,
+                      double fv,
+                      bool xtc,
+                      bool ytc)
+:
+    Slice (t, b, xst, yst, xsm, ysm, fv, xtc, ytc),
+    sampleStride (spst)
+{
+    // empty
+}
+
+
+void
+DeepFrameBuffer::insert (const char name[], const DeepSlice &slice)
+{
+    if (name[0] == 0)
+    {
+        THROW (IEX_NAMESPACE::ArgExc,
+               "Frame buffer slice name cannot be an empty string.");
+    }
+
+    _map[name] = slice;
+}
+
+
+void
+DeepFrameBuffer::insert (const string &name, const DeepSlice &slice)
+{
+    insert (name.c_str(), slice);
+}
+
+
+DeepSlice &
+DeepFrameBuffer::operator [] (const char name[])
+{
+    SliceMap::iterator i = _map.find (name);
+
+    if (i == _map.end())
+    {
+        THROW (IEX_NAMESPACE::ArgExc,
+               "Cannot find frame buffer slice \"" << name << "\".");
+    }
+
+    return i->second;
+}
+
+
+const DeepSlice &
+DeepFrameBuffer::operator [] (const char name[]) const
+{
+    SliceMap::const_iterator i = _map.find (name);
+
+    if (i == _map.end())
+    {
+        THROW (IEX_NAMESPACE::ArgExc,
+               "Cannot find frame buffer slice \"" << name << "\".");
+    }
+
+    return i->second;
+}
+
+
+DeepSlice &
+DeepFrameBuffer::operator [] (const string &name)
+{
+    return this->operator[] (name.c_str());
+}
+
+
+const DeepSlice &
+DeepFrameBuffer::operator [] (const string &name) const
+{
+    return this->operator[] (name.c_str());
+}
+
+
+DeepSlice *
+DeepFrameBuffer::findSlice (const char name[])
+{
+    SliceMap::iterator i = _map.find (name);
+    return (i == _map.end())? 0: &i->second;
+}
+
+
+const DeepSlice *
+DeepFrameBuffer::findSlice (const char name[]) const
+{
+    SliceMap::const_iterator i = _map.find (name);
+    return (i == _map.end())? 0: &i->second;
+}
+
+
+DeepSlice *
+DeepFrameBuffer::findSlice (const string &name)
+{
+    return findSlice (name.c_str());
+}
+
+
+const DeepSlice *
+DeepFrameBuffer::findSlice (const string &name) const
+{
+    return findSlice (name.c_str());
+}
+
+
+DeepFrameBuffer::Iterator
+DeepFrameBuffer::begin ()
+{
+    return _map.begin();
+}
+
+
+DeepFrameBuffer::ConstIterator
+DeepFrameBuffer::begin () const
+{
+    return _map.begin();
+}
+
+
+DeepFrameBuffer::Iterator
+DeepFrameBuffer::end ()
+{
+    return _map.end();
+}
+
+
+DeepFrameBuffer::ConstIterator
+DeepFrameBuffer::end () const
+{
+    return _map.end();
+}
+
+
+DeepFrameBuffer::Iterator
+DeepFrameBuffer::find (const char name[])
+{
+    return _map.find (name);
+}
+
+
+DeepFrameBuffer::ConstIterator
+DeepFrameBuffer::find (const char name[]) const
+{
+    return _map.find (name);
+}
+
+
+DeepFrameBuffer::Iterator
+DeepFrameBuffer::find (const string &name)
+{
+    return find (name.c_str());
+}
+
+
+DeepFrameBuffer::ConstIterator
+DeepFrameBuffer::find (const string &name) const
+{
+    return find (name.c_str());
+}
+
+
+void
+DeepFrameBuffer::insertSampleCountSlice(const Slice & slice)
+{
+    if (slice.type != UINT)
+    {
+        throw IEX_NAMESPACE::ArgExc("The type of sample count slice should be UINT.");
+    }
+
+    _sampleCounts = slice;
+}
+
+
+const Slice &
+DeepFrameBuffer::getSampleCountSlice() const
+{
+    return _sampleCounts;
+}
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfDeepFrameBuffer.h

@@ -0,0 +1,373 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef IMFDEEPFRAMEBUFFER_H_
+#define IMFDEEPFRAMEBUFFER_H_
+
+#include "ImfFrameBuffer.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+//--------------------------------------------------------
+// Description of a single deep slice of the frame buffer:
+//--------------------------------------------------------
+
+struct DeepSlice : public Slice
+{
+    //---------------------------------------------------------------------
+    // The stride for each sample in this slice.
+    //
+    // Memory layout:  The address of sample i in pixel (x, y) is
+    //
+    //  base + (xp / xSampling) * xStride + (yp / ySampling) * yStride
+    //       + i * sampleStride
+    //
+    // where xp and yp are computed as follows:
+    //
+    //  * If we are reading or writing a scanline-based file:
+    //
+    //      xp = x
+    //      yp = y
+    //
+    //  * If we are reading a tile whose upper left coorner is at (xt, yt):
+    //
+    //      if xTileCoords is true then xp = x - xt, else xp = x
+    //      if yTileCoords is true then yp = y - yt, else yp = y
+    //
+    //---------------------------------------------------------------------
+
+    int sampleStride;
+
+    //------------
+    // Constructor
+    //------------
+    IMF_EXPORT
+    DeepSlice (PixelType type = HALF,
+               char * base = 0,
+               size_t xStride = 0,
+               size_t yStride = 0,
+               size_t sampleStride = 0,
+               int xSampling = 1,
+               int ySampling = 1,
+               double fillValue = 0.0,
+               bool xTileCoords = false,
+               bool yTileCoords = false);
+};
+
+//-----------------
+// DeepFrameBuffer.
+//-----------------
+
+class DeepFrameBuffer
+{
+  public:
+
+
+    //------------
+    // Add a slice
+    //------------
+
+    IMF_EXPORT
+    void                        insert (const char name[],
+                                        const DeepSlice &slice);
+
+    IMF_EXPORT
+    void                        insert (const std::string &name,
+                                        const DeepSlice &slice);
+
+    //----------------------------------------------------------------
+    // Access to existing slices:
+    //
+    // [n]              Returns a reference to the slice with name n.
+    //                  If no slice with name n exists, an IEX_NAMESPACE::ArgExc
+    //                  is thrown.
+    //
+    // findSlice(n)     Returns a pointer to the slice with name n,
+    //                  or 0 if no slice with name n exists.
+    //
+    //----------------------------------------------------------------
+
+    IMF_EXPORT
+    DeepSlice &                 operator [] (const char name[]);
+    IMF_EXPORT
+    const DeepSlice &           operator [] (const char name[]) const;
+
+    IMF_EXPORT
+    DeepSlice &                 operator [] (const std::string &name);
+    IMF_EXPORT
+    const DeepSlice &           operator [] (const std::string &name) const;
+
+    IMF_EXPORT
+    DeepSlice *                 findSlice (const char name[]);
+    IMF_EXPORT
+    const DeepSlice *           findSlice (const char name[]) const;
+
+    IMF_EXPORT
+    DeepSlice *                 findSlice (const std::string &name);
+    IMF_EXPORT
+    const DeepSlice *           findSlice (const std::string &name) const;
+
+
+    //-----------------------------------------
+    // Iterator-style access to existing slices
+    //-----------------------------------------
+
+    typedef std::map <Name, DeepSlice> SliceMap;
+
+    class Iterator;
+    class ConstIterator;
+
+    IMF_EXPORT
+    Iterator                    begin ();
+    IMF_EXPORT
+    ConstIterator               begin () const;
+
+    IMF_EXPORT
+    Iterator                    end ();
+    IMF_EXPORT
+    ConstIterator               end () const;
+
+    IMF_EXPORT
+    Iterator                    find (const char name[]);
+    IMF_EXPORT
+    ConstIterator               find (const char name[]) const;
+
+    IMF_EXPORT
+    Iterator                    find (const std::string &name);
+    IMF_EXPORT
+    ConstIterator               find (const std::string &name) const;
+
+    //----------------------------------------------------
+    // Public function for accessing a sample count slice.
+    //----------------------------------------------------
+
+    IMF_EXPORT
+    void                        insertSampleCountSlice(const Slice & slice);
+    IMF_EXPORT
+    const Slice &               getSampleCountSlice() const;
+
+  private:
+
+    SliceMap                    _map;
+    Slice                       _sampleCounts;
+};
+
+//----------
+// Iterators
+//----------
+
+class DeepFrameBuffer::Iterator
+{
+  public:
+
+    IMF_EXPORT
+    Iterator ();
+    IMF_EXPORT
+    Iterator (const DeepFrameBuffer::SliceMap::iterator &i);
+
+    IMF_EXPORT
+    Iterator &                  operator ++ ();
+    IMF_EXPORT
+    Iterator                    operator ++ (int);
+
+    IMF_EXPORT
+    const char *                name () const;
+    IMF_EXPORT
+    DeepSlice &                 slice () const;
+
+  private:
+
+    friend class DeepFrameBuffer::ConstIterator;
+
+    DeepFrameBuffer::SliceMap::iterator _i;
+};
+
+
+class DeepFrameBuffer::ConstIterator
+{
+  public:
+
+    IMF_EXPORT
+    ConstIterator ();
+    IMF_EXPORT
+    ConstIterator (const DeepFrameBuffer::SliceMap::const_iterator &i);
+    IMF_EXPORT
+    ConstIterator (const DeepFrameBuffer::Iterator &other);
+
+    IMF_EXPORT
+    ConstIterator &             operator ++ ();
+    IMF_EXPORT
+    ConstIterator               operator ++ (int);
+
+    IMF_EXPORT
+    const char *                name () const;
+    IMF_EXPORT
+    const DeepSlice &           slice () const;
+
+  private:
+
+    friend bool operator == (const ConstIterator &, const ConstIterator &);
+    friend bool operator != (const ConstIterator &, const ConstIterator &);
+
+    DeepFrameBuffer::SliceMap::const_iterator _i;
+};
+
+
+//-----------------
+// Inline Functions
+//-----------------
+
+inline
+DeepFrameBuffer::Iterator::Iterator (): _i()
+{
+    // empty
+}
+
+
+inline
+DeepFrameBuffer::Iterator::Iterator (const DeepFrameBuffer::SliceMap::iterator &i):
+    _i (i)
+{
+    // empty
+}
+
+
+inline DeepFrameBuffer::Iterator &
+DeepFrameBuffer::Iterator::operator ++ ()
+{
+    ++_i;
+    return *this;
+}
+
+
+inline DeepFrameBuffer::Iterator
+DeepFrameBuffer::Iterator::operator ++ (int)
+{
+    Iterator tmp = *this;
+    ++_i;
+    return tmp;
+}
+
+
+inline const char *
+DeepFrameBuffer::Iterator::name () const
+{
+    return *_i->first;
+}
+
+
+inline DeepSlice &
+DeepFrameBuffer::Iterator::slice () const
+{
+    return _i->second;
+}
+
+
+inline
+DeepFrameBuffer::ConstIterator::ConstIterator (): _i()
+{
+    // empty
+}
+
+inline
+DeepFrameBuffer::ConstIterator::ConstIterator
+    (const DeepFrameBuffer::SliceMap::const_iterator &i): _i (i)
+{
+    // empty
+}
+
+
+inline
+DeepFrameBuffer::ConstIterator::ConstIterator (const DeepFrameBuffer::Iterator &other):
+    _i (other._i)
+{
+    // empty
+}
+
+inline DeepFrameBuffer::ConstIterator &
+DeepFrameBuffer::ConstIterator::operator ++ ()
+{
+    ++_i;
+    return *this;
+}
+
+
+inline DeepFrameBuffer::ConstIterator
+DeepFrameBuffer::ConstIterator::operator ++ (int)
+{
+    ConstIterator tmp = *this;
+    ++_i;
+    return tmp;
+}
+
+
+inline const char *
+DeepFrameBuffer::ConstIterator::name () const
+{
+    return *_i->first;
+}
+
+inline const DeepSlice &
+DeepFrameBuffer::ConstIterator::slice () const
+{
+    return _i->second;
+}
+
+
+inline bool
+operator == (const DeepFrameBuffer::ConstIterator &x,
+             const DeepFrameBuffer::ConstIterator &y)
+{
+    return x._i == y._i;
+}
+
+
+inline bool
+operator != (const DeepFrameBuffer::ConstIterator &x,
+             const DeepFrameBuffer::ConstIterator &y)
+{
+    return !(x == y);
+}
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+
+
+
+
+
+#endif /* IMFDEEPFRAMEBUFFER_H_ */

3rdparty/openexr/IlmImf/ImfDeepImageState.h

@@ -0,0 +1,96 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2013, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+#ifndef INCLUDED_IMF_DEEPIMAGESTATE_H
+#define INCLUDED_IMF_DEEPIMAGESTATE_H
+
+//-----------------------------------------------------------------------------
+//
+//      enum DeepImageState -- describes how orderly the pixel data
+//      in a deep image are
+//
+//      The samples in a deep image pixel may be sorted according to
+//      depth, and the sample depths or depth ranges may or may not
+//      overlap each other.  A pixel is
+//
+//          - SORTED if for every i and j with i < j
+//
+//              (Z[i] < Z[j]) || (Z[i] == Z[j] && ZBack[i] < ZBack[j]),
+//
+//          - NON_OVERLAPPING if for every i and j with i != j
+//
+//              (Z[i] <  Z[j] && ZBack[i] <= Z[j]) ||
+//              (Z[j] <  Z[i] && ZBack[j] <= Z[i]) ||
+//              (Z[i] == Z[j] && ZBack[i] <= Z[i] & ZBack[j] > Z[j]) ||
+//              (Z[i] == Z[j] && ZBack[j] <= Z[j] & ZBack[i] > Z[i]),
+//
+//          - TIDY if it is SORTED and NON_OVERLAPPING,
+//
+//          - MESSY if it is neither SORTED nor NON_OVERLAPPING.
+//
+//      A deep image is
+//
+//          - MESSY if at least one of its pixels is MESSY,
+//          - SORTED if all of its pixels are SORTED,
+//          - NON_OVERLAPPING if all of its pixels are NON_OVERLAPPING,
+//          - TIDY if all of its pixels are TIDY.
+//
+//      Note: the rather complicated definition of NON_OVERLAPPING prohibits
+//      overlapping volume samples, coincident point samples and point samples
+//      in the middle of a volume sample, but it does allow point samples at
+//      the front or back of a volume sample.
+//
+//-----------------------------------------------------------------------------
+
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+enum DeepImageState
+{
+    DIS_MESSY = 0,
+    DIS_SORTED = 1,
+    DIS_NON_OVERLAPPING = 2,
+    DIS_TIDY = 3,
+
+    DIS_NUMSTATES   // Number of different image states
+};
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+
+#endif

3rdparty/openexr/IlmImf/ImfDeepImageStateAttribute.cpp

@@ -0,0 +1,78 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2013, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+//-----------------------------------------------------------------------------
+//
+//	class DeepImageStateAttribute
+//
+//-----------------------------------------------------------------------------
+
+#include <ImfDeepImageStateAttribute.h>
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+using namespace OPENEXR_IMF_INTERNAL_NAMESPACE;
+
+template <>
+const char *
+DeepImageStateAttribute::staticTypeName ()
+{
+    return "deepImageState";
+}
+
+
+template <>
+void
+DeepImageStateAttribute::writeValueTo
+    (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, int version) const
+{
+    unsigned char tmp = _value;
+    Xdr::write <StreamIO> (os, tmp);
+}
+
+
+template <>
+void
+DeepImageStateAttribute::readValueFrom
+    (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int size, int version)
+{
+    unsigned char tmp;
+    Xdr::read <StreamIO> (is, tmp);
+    _value = DeepImageState (tmp);
+}
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT 

3rdparty/openexr/IlmImf/ImfDeepImageStateAttribute.h

@@ -0,0 +1,68 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2013, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDED_IMF_DEEPIMAGESTATE_ATTRIBUTE_H
+#define INCLUDED_IMF_DEEPIMAGESTATE_ATTRIBUTE_H
+
+
+//-----------------------------------------------------------------------------
+//
+//	class DeepImageStateAttribute
+//
+//-----------------------------------------------------------------------------
+
+#include "ImfAttribute.h"
+#include "ImfDeepImageState.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::DeepImageState>
+    DeepImageStateAttribute;
+
+template <> IMF_EXPORT const char *DeepImageStateAttribute::staticTypeName ();
+
+template <> IMF_EXPORT
+void DeepImageStateAttribute::writeValueTo
+    (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &, int) const;
+
+template <> IMF_EXPORT
+void DeepImageStateAttribute::readValueFrom
+    (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &, int, int);
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif

3rdparty/openexr/IlmImf/ImfDeepScanLineInputFile.h

@@ -0,0 +1,294 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+#ifndef INCLUDED_IMF_DEEP_SCAN_LINE_INPUT_FILE_H
+#define INCLUDED_IMF_DEEP_SCAN_LINE_INPUT_FILE_H
+
+//-----------------------------------------------------------------------------
+//
+//      class DeepScanLineInputFile
+//
+//-----------------------------------------------------------------------------
+
+#include "ImfThreading.h"
+#include "ImfGenericInputFile.h"
+#include "ImfNamespace.h"
+#include "ImfForward.h"
+#include "ImfExport.h"
+#include "ImfDeepScanLineOutputFile.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+class DeepScanLineInputFile : public GenericInputFile
+{
+  public:
+
+    //------------
+    // Constructor
+    //------------
+
+    IMF_EXPORT
+    DeepScanLineInputFile (const char fileName[],
+                           int numThreads = globalThreadCount());
+
+    IMF_EXPORT
+    DeepScanLineInputFile (const Header &header, OPENEXR_IMF_INTERNAL_NAMESPACE::IStream *is,
+                           int version, /*version field from file*/
+                           int numThreads = globalThreadCount());
+
+
+    //-----------------------------------------
+    // Destructor -- deallocates internal data
+    // structures, but does not close the file.
+    //-----------------------------------------
+
+    IMF_EXPORT
+    virtual ~DeepScanLineInputFile ();
+
+
+    //------------------------
+    // Access to the file name
+    //------------------------
+
+    IMF_EXPORT
+    const char *        fileName () const;
+
+
+    //--------------------------
+    // Access to the file header
+    //--------------------------
+
+    IMF_EXPORT
+    const Header &      header () const;
+
+
+    //----------------------------------
+    // Access to the file format version
+    //----------------------------------
+
+    IMF_EXPORT
+    int                 version () const;
+
+
+    //-----------------------------------------------------------
+    // Set the current frame buffer -- copies the FrameBuffer
+    // object into the InputFile object.
+    //
+    // The current frame buffer is the destination for the pixel
+    // data read from the file.  The current frame buffer must be
+    // set at least once before readPixels() is called.
+    // The current frame buffer can be changed after each call
+    // to readPixels().
+    //-----------------------------------------------------------
+
+    IMF_EXPORT
+    void                setFrameBuffer (const DeepFrameBuffer &frameBuffer);
+
+
+    //-----------------------------------
+    // Access to the current frame buffer
+    //-----------------------------------
+
+    IMF_EXPORT
+    const DeepFrameBuffer & frameBuffer () const;
+
+
+    //---------------------------------------------------------------
+    // Check if the file is complete:
+    //
+    // isComplete() returns true if all pixels in the data window are
+    // present in the input file, or false if any pixels are missing.
+    // (Another program may still be busy writing the file, or file
+    // writing may have been aborted prematurely.)
+    //---------------------------------------------------------------
+
+    IMF_EXPORT
+    bool                isComplete () const;
+
+
+    //---------------------------------------------------------------
+    // Read pixel data:
+    //
+    // readPixels(s1,s2) reads all scan lines with y coordinates
+    // in the interval [min (s1, s2), max (s1, s2)] from the file,
+    // and stores them in the current frame buffer.
+    //
+    // Both s1 and s2 must be within the interval
+    // [header().dataWindow().min.y, header.dataWindow().max.y]
+    //
+    // The scan lines can be read from the file in random order, and
+    // individual scan lines may be skipped or read multiple times.
+    // For maximum efficiency, the scan lines should be read in the
+    // order in which they were written to the file.
+    //
+    // readPixels(s) calls readPixels(s,s).
+    //
+    // If threading is enabled, readPixels (s1, s2) tries to perform
+    // decopmression of multiple scanlines in parallel.
+    //
+    //---------------------------------------------------------------
+
+    IMF_EXPORT
+    void                readPixels (int scanLine1, int scanLine2);
+    IMF_EXPORT
+    void                readPixels (int scanLine);
+
+    
+  
+    //---------------------------------------------------------------
+    // Extract pixel data from pre-read block
+    //
+    // readPixels(rawPixelData,frameBuffer,s1,s2) reads all scan lines with y coordinates
+    // in the interval [min (s1, s2), max (s1, s2)] from the data provided and
+    // stores them in the provided frameBuffer.
+    // the data can be obtained from a call to rawPixelData()
+    //
+    //
+    // Both s1 and s2 must be within the data specified
+    //
+    // you must provide a frameBuffer with a samplecountslice, which must have been read
+    // and the data valid - readPixels uses your sample count buffer to compute
+    // offsets to the data it needs
+    //
+    // This call does not block, and is thread safe for clients with an existing
+    // threading model. The InputFile's frameBuffer is not used in this call.
+    //
+    // This call is only provided for clients which have an existing threading model in place
+    // and unpredictable access patterns to the data.
+    // The fastest way to read an entire image is to enable threading,use setFrameBuffer then
+    // readPixels(header().dataWindow().min.y, header.dataWindow().max.y)
+    //
+    //---------------------------------------------------------------
+    
+    IMF_EXPORT
+    void                readPixels (const char * rawPixelData,
+                                    const DeepFrameBuffer & frameBuffer,
+                                    int scanLine1,
+                                    int scanLine2) const;
+
+    //----------------------------------------------
+    // Read a block of raw pixel data from the file,
+    // without uncompressing it (this function is
+    // used to implement OutputFile::copyPixels()).
+    // note: returns the entire payload of the relevant chunk of data, not including part number
+    // including compressed and uncompressed sizes
+    // on entry, if pixelDataSize is insufficiently large, no bytes are read (pixelData can safely be NULL)
+    // on exit, pixelDataSize is the number of bytes required to read the chunk
+    // 
+    //----------------------------------------------
+
+    IMF_EXPORT
+    void                rawPixelData (int firstScanLine,
+                                      char * pixelData,
+                                      Int64 &pixelDataSize);
+
+                                      
+    //-------------------------------------------------
+    // firstScanLineInChunk() returns the row number of the first row that's stored in the
+    // same chunk as scanline y. Depending on the compression mode, this may not be the same as y
+    //
+    // lastScanLineInChunk() returns the row number of the last row that's stored in the same
+    // chunk as scanline y.  Depending on the compression mode, this may not be the same as y.
+    // The last chunk in the file may be smaller than all the others
+    //
+    //------------------------------------------------
+    IMF_EXPORT
+    int                 firstScanLineInChunk(int y) const;
+    IMF_EXPORT
+    int                 lastScanLineInChunk (int y) const;
+                                      
+    //-----------------------------------------------------------
+    // Read pixel sample counts into a slice in the frame buffer.
+    //
+    // readPixelSampleCounts(s1, s2) reads all the counts of
+    // pixel samples with y coordinates in the interval
+    // [min (s1, s2), max (s1, s2)] from the file, and stores
+    // them in the slice naming "sample count".
+    //
+    // Both s1 and s2 must be within the interval
+    // [header().dataWindow().min.y, header.dataWindow().max.y]
+    //
+    // readPixelSampleCounts(s) calls readPixelSampleCounts(s,s).
+    // 
+    //-----------------------------------------------------------
+
+    IMF_EXPORT
+    void                readPixelSampleCounts (int scanline1,
+                                               int scanline2);
+    IMF_EXPORT
+    void                readPixelSampleCounts (int scanline);
+    
+    
+    //----------------------------------------------------------
+    // Read pixel sample counts into the provided frameBuffer
+    // using a block read of data read by rawPixelData    
+    // for multi-scanline compression schemes, you must decode the entire block
+    // so scanline1=firstScanLineInChunk(y) and scanline2=lastScanLineInChunk(y)
+    // 
+    // This call does not block, and is thread safe for clients with an existing
+    // threading model. The InputFile's frameBuffer is not used in this call.
+    //
+    // The fastest way to read an entire image is to enable threading in OpenEXR, use setFrameBuffer then
+    // readPixelSampleCounts(header().dataWindow().min.y, header.dataWindow().max.y)
+    //
+    //----------------------------------------------------------
+    IMF_EXPORT
+    void                readPixelSampleCounts (const char * rawdata , 
+                                               const DeepFrameBuffer & frameBuffer,
+                                               int scanLine1 , 
+                                               int scanLine2) const;
+
+    struct Data;
+
+  private:
+
+    Data *              _data;
+
+    DeepScanLineInputFile   (InputPartData* part);
+
+    void                initialize(const Header& header);
+    void compatibilityInitialize(OPENEXR_IMF_INTERNAL_NAMESPACE::IStream & is);
+    void multiPartInitialize(InputPartData* part);
+
+    friend class         InputFile;
+    friend class MultiPartInputFile;
+    friend void DeepScanLineOutputFile::copyPixels(DeepScanLineInputFile &);
+};
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif

3rdparty/openexr/IlmImf/ImfDeepScanLineInputPart.cpp

@@ -0,0 +1,149 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2004, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+#include "ImfDeepScanLineInputPart.h"
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+DeepScanLineInputPart::DeepScanLineInputPart(MultiPartInputFile& multiPartFile, int partNumber)
+{
+    file = multiPartFile.getInputPart<DeepScanLineInputFile>(partNumber);
+}
+
+
+const char *
+DeepScanLineInputPart::fileName () const
+{
+    return file->fileName();
+}
+
+
+const Header &
+DeepScanLineInputPart::header () const
+{
+    return file->header();
+}
+
+
+int
+DeepScanLineInputPart::version () const
+{
+    return file->version();
+}
+
+
+void
+DeepScanLineInputPart::setFrameBuffer (const DeepFrameBuffer &frameBuffer)
+{
+    file->setFrameBuffer(frameBuffer);
+}
+
+
+const DeepFrameBuffer &
+DeepScanLineInputPart::frameBuffer () const
+{
+    return file->frameBuffer();
+}
+
+
+bool
+DeepScanLineInputPart::isComplete () const
+{
+    return file->isComplete();
+}
+
+
+void
+DeepScanLineInputPart::readPixels (int scanLine1, int scanLine2)
+{
+    file->readPixels(scanLine1, scanLine2);
+}
+
+
+void
+DeepScanLineInputPart::readPixels (int scanLine)
+{
+    file->readPixels(scanLine);
+}
+
+
+void
+DeepScanLineInputPart::rawPixelData (int firstScanLine,
+                                     char *pixelData,
+                                     Int64 &pixelDataSize)
+{
+    file->rawPixelData(firstScanLine, pixelData, pixelDataSize);
+}
+
+
+void
+DeepScanLineInputPart::readPixelSampleCounts(int scanline1,
+                                            int scanline2)
+{
+    file->readPixelSampleCounts(scanline1, scanline2);
+}
+
+
+void
+DeepScanLineInputPart::readPixelSampleCounts(int scanline)
+{
+    file->readPixelSampleCounts(scanline);
+}
+
+int 
+DeepScanLineInputPart::firstScanLineInChunk(int y) const
+{
+    return file->firstScanLineInChunk(y);
+}
+
+int 
+DeepScanLineInputPart::lastScanLineInChunk(int y) const
+{
+    return file->lastScanLineInChunk(y);
+}
+
+void 
+DeepScanLineInputPart::readPixels(const char* rawPixelData, const DeepFrameBuffer& frameBuffer, int scanLine1, int scanLine2) const
+{
+    return file->readPixels(rawPixelData,frameBuffer,scanLine1,scanLine2);
+}
+void 
+DeepScanLineInputPart::readPixelSampleCounts(const char* rawdata, const DeepFrameBuffer& frameBuffer, int scanLine1, int scanLine2) const
+{
+   return file->readPixelSampleCounts(rawdata,frameBuffer,scanLine1,scanLine2);
+}
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfDeepScanLineInputPart.h

@@ -0,0 +1,197 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+#ifndef IMFDEEPSCANLINEINPUTPART_H_
+#define IMFDEEPSCANLINEINPUTPART_H_
+
+#include "ImfMultiPartInputFile.h"
+#include "ImfDeepScanLineInputFile.h"
+#include "ImfDeepScanLineOutputFile.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+class DeepScanLineInputPart
+{
+  public:
+
+    IMF_EXPORT
+    DeepScanLineInputPart(MultiPartInputFile& file, int partNumber);
+
+    //------------------------
+    // Access to the file name
+    //------------------------
+
+    IMF_EXPORT
+    const char *        fileName () const;
+
+
+    //--------------------------
+    // Access to the file header
+    //--------------------------
+
+    IMF_EXPORT
+    const Header &      header () const;
+
+
+    //----------------------------------
+    // Access to the file format version
+    //----------------------------------
+
+    IMF_EXPORT
+    int                 version () const;
+
+
+    //-----------------------------------------------------------
+    // Set the current frame buffer -- copies the FrameBuffer
+    // object into the InputFile object.
+    //
+    // The current frame buffer is the destination for the pixel
+    // data read from the file.  The current frame buffer must be
+    // set at least once before readPixels() is called.
+    // The current frame buffer can be changed after each call
+    // to readPixels().
+    //-----------------------------------------------------------
+
+    IMF_EXPORT
+    void                setFrameBuffer (const DeepFrameBuffer &frameBuffer);
+
+
+    //-----------------------------------
+    // Access to the current frame buffer
+    //-----------------------------------
+
+    IMF_EXPORT
+    const DeepFrameBuffer & frameBuffer () const;
+
+
+    //---------------------------------------------------------------
+    // Check if the file is complete:
+    //
+    // isComplete() returns true if all pixels in the data window are
+    // present in the input file, or false if any pixels are missing.
+    // (Another program may still be busy writing the file, or file
+    // writing may have been aborted prematurely.)
+    //---------------------------------------------------------------
+
+    IMF_EXPORT
+    bool                isComplete () const;
+
+
+    //---------------------------------------------------------------
+    // Read pixel data:
+    //
+    // readPixels(s1,s2) reads all scan lines with y coordinates
+    // in the interval [min (s1, s2), max (s1, s2)] from the file,
+    // and stores them in the current frame buffer.
+    //
+    // Both s1 and s2 must be within the interval
+    // [header().dataWindow().min.y, header.dataWindow().max.y]
+    //
+    // The scan lines can be read from the file in random order, and
+    // individual scan lines may be skipped or read multiple times.
+    // For maximum efficiency, the scan lines should be read in the
+    // order in which they were written to the file.
+    //
+    // readPixels(s) calls readPixels(s,s).
+    //
+    // If threading is enabled, readPixels (s1, s2) tries to perform
+    // decopmression of multiple scanlines in parallel.
+    //
+    //---------------------------------------------------------------
+
+    IMF_EXPORT
+    void                readPixels (int scanLine1, int scanLine2);
+    IMF_EXPORT
+    void                readPixels (int scanLine);
+    IMF_EXPORT
+    void                readPixels (const char * rawPixelData,const DeepFrameBuffer & frameBuffer,
+                                    int scanLine1,int scanLine2) const;
+
+    //----------------------------------------------
+    // Read a block of raw pixel data from the file,
+    // without uncompressing it (this function is
+    // used to implement OutputFile::copyPixels()).
+    //----------------------------------------------
+
+    IMF_EXPORT
+    void                rawPixelData (int firstScanLine,
+                                      char * pixelData,
+                                      Int64 &pixelDataSize);
+                             
+                                      
+    //-----------------------------------------------------------
+    // Read pixel sample counts into a slice in the frame buffer.
+    //
+    // readPixelSampleCounts(s1, s2) reads all the counts of
+    // pixel samples with y coordinates in the interval
+    // [min (s1, s2), max (s1, s2)] from the file, and stores
+    // them in the slice naming "sample count".
+    //
+    // Both s1 and s2 must be within the interval
+    // [header().dataWindow().min.y, header.dataWindow().max.y]
+    //
+    // readPixelSampleCounts(s) calls readPixelSampleCounts(s,s).
+    //-----------------------------------------------------------
+
+    IMF_EXPORT
+    void                readPixelSampleCounts(int scanline1,
+                                              int scanline2);
+    IMF_EXPORT
+    void                readPixelSampleCounts(int scanline);
+    
+    IMF_EXPORT
+    void                readPixelSampleCounts( const char * rawdata , const DeepFrameBuffer & frameBuffer,
+                                               int scanLine1 , int scanLine2) const;
+                                               
+    IMF_EXPORT
+    int                 firstScanLineInChunk(int y) const;
+    IMF_EXPORT
+    int                 lastScanLineInChunk (int y) const;
+  private:
+    DeepScanLineInputFile *file;
+    
+    // needed for copyPixels 
+    friend void DeepScanLineOutputFile::copyPixels(DeepScanLineInputPart &);
+};
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+
+
+
+
+#endif /* IMFDEEPSCANLINEINPUTPART_H_ */

3rdparty/openexr/IlmImf/ImfDeepScanLineOutputFile.h

@@ -0,0 +1,256 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef INCLUDED_IMF_DEEP_SCAN_LINE_OUTPUT_FILE_H
+#define INCLUDED_IMF_DEEP_SCAN_LINE_OUTPUT_FILE_H
+
+//-----------------------------------------------------------------------------
+//
+//      class DeepScanLineOutputFile
+//
+//-----------------------------------------------------------------------------
+
+#include "ImfHeader.h"
+#include "ImfFrameBuffer.h"
+#include "ImfThreading.h"
+#include "ImfGenericOutputFile.h"
+#include "ImfNamespace.h"
+#include "ImfForward.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+struct PreviewRgba;
+
+class DeepScanLineOutputFile : public GenericOutputFile
+{
+  public:
+
+    //-----------------------------------------------------------
+    // Constructor -- opens the file and writes the file header.
+    // The file header is also copied into the DeepScanLineOutputFile
+    // object, and can later be accessed via the header() method.
+    // Destroying this DeepScanLineOutputFile object automatically closes
+    // the file.
+    //
+    // numThreads determines the number of threads that will be
+    // used to write the file (see ImfThreading.h).
+    //-----------------------------------------------------------
+
+    IMF_EXPORT
+    DeepScanLineOutputFile (const char fileName[], const Header &header,
+                int numThreads = globalThreadCount());
+
+
+    //------------------------------------------------------------
+    // Constructor -- attaches the new DeepScanLineOutputFile object
+    // to a file that has already been opened, and writes the file header.
+    // The file header is also copied into the DeepScanLineOutputFile
+    // object, and can later be accessed via the header() method.
+    // Destroying this DeepScanLineOutputFile object does not automatically
+    // close the file.
+    //
+    // numThreads determines the number of threads that will be
+    // used to write the file (see ImfThreading.h).
+    //------------------------------------------------------------
+
+    IMF_EXPORT
+    DeepScanLineOutputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, const Header &header,
+                int numThreads = globalThreadCount());
+
+
+    //-------------------------------------------------
+    // Destructor
+    //
+    // Destroying the DeepScanLineOutputFile object
+    // before writing all scan lines within the data
+    // window results in an incomplete file.
+    //-------------------------------------------------
+
+    IMF_EXPORT
+    virtual ~DeepScanLineOutputFile ();
+
+
+    //------------------------
+    // Access to the file name
+    //------------------------
+
+    IMF_EXPORT
+    const char *        fileName () const;
+
+
+    //--------------------------
+    // Access to the file header
+    //--------------------------
+
+    IMF_EXPORT
+    const Header &      header () const;
+
+
+    //-------------------------------------------------------
+    // Set the current frame buffer -- copies the FrameBuffer
+    // object into the OutputFile object.
+    //
+    // The current frame buffer is the source of the pixel
+    // data written to the file.  The current frame buffer
+    // must be set at least once before writePixels() is
+    // called.  The current frame buffer can be changed
+    // after each call to writePixels.
+    //-------------------------------------------------------
+
+    IMF_EXPORT
+    void                setFrameBuffer (const DeepFrameBuffer &frameBuffer);
+
+
+    //-----------------------------------
+    // Access to the current frame buffer
+    //-----------------------------------
+
+    IMF_EXPORT
+    const DeepFrameBuffer & frameBuffer () const;
+
+
+    //-------------------------------------------------------------------
+    // Write pixel data:
+    //
+    // writePixels(n) retrieves the next n scan lines worth of data from
+    // the current frame buffer, starting with the scan line indicated by
+    // currentScanLine(), and stores the data in the output file, and
+    // progressing in the direction indicated by header.lineOrder().
+    //
+    // To produce a complete and correct file, exactly m scan lines must
+    // be written, where m is equal to
+    // header().dataWindow().max.y - header().dataWindow().min.y + 1.
+    //-------------------------------------------------------------------
+
+    IMF_EXPORT
+    void                writePixels (int numScanLines = 1);
+
+
+    //------------------------------------------------------------------
+    // Access to the current scan line:
+    //
+    // currentScanLine() returns the y coordinate of the first scan line
+    // that will be read from the current frame buffer during the next
+    // call to writePixels().
+    //
+    // If header.lineOrder() == INCREASING_Y:
+    //
+    //  The current scan line before the first call to writePixels()
+    //  is header().dataWindow().min.y.  After writing each scan line,
+    //  the current scan line is incremented by 1.
+    //
+    // If header.lineOrder() == DECREASING_Y:
+    //
+    //  The current scan line before the first call to writePixels()
+    //  is header().dataWindow().max.y.  After writing each scan line,
+    //  the current scan line is decremented by 1.
+    //
+    //------------------------------------------------------------------
+
+    IMF_EXPORT
+    int                 currentScanLine () const;
+
+
+    //--------------------------------------------------------------
+    // Shortcut to copy all pixels from an InputFile into this file,
+    // without uncompressing and then recompressing the pixel data.
+    // This file's header must be compatible with the InputFile's
+    // header:  The two header's "dataWindow", "compression",
+    // "lineOrder" and "channels" attributes must be the same.
+    //--------------------------------------------------------------
+
+    IMF_EXPORT
+    void                copyPixels (DeepScanLineInputFile &in);
+    
+    // --------------------------------------------------------------
+    // Shortcut to copy pixels from a given part of a multipart file
+    // --------------------------------------------------------------
+    IMF_EXPORT
+    void                copyPixels (DeepScanLineInputPart &in);
+
+
+    //--------------------------------------------------------------
+    // Updating the preview image:
+    //
+    // updatePreviewImage() supplies a new set of pixels for the
+    // preview image attribute in the file's header.  If the header
+    // does not contain a preview image, updatePreviewImage() throws
+    // an IEX_NAMESPACE::LogicExc.
+    //
+    // Note: updatePreviewImage() is necessary because images are
+    // often stored in a file incrementally, a few scan lines at a
+    // time, while the image is being generated.  Since the preview
+    // image is an attribute in the file's header, it gets stored in
+    // the file as soon as the file is opened, but we may not know
+    // what the preview image should look like until we have written
+    // the last scan line of the main image.
+    //
+    //--------------------------------------------------------------
+
+    IMF_EXPORT
+    void                updatePreviewImage (const PreviewRgba newPixels[]);
+
+
+    struct Data;
+
+  private:
+
+    //------------------------------------------------------------
+    // Constructor -- attaches the OutputStreamMutex to the
+    // given one from MultiPartOutputFile. Set the previewPosition
+    // and lineOffsetsPosition which have been acquired from
+    // the constructor of MultiPartOutputFile as well.
+    //------------------------------------------------------------
+    DeepScanLineOutputFile (const OutputPartData* part);
+
+    DeepScanLineOutputFile (const DeepScanLineOutputFile &);                    // not implemented
+    DeepScanLineOutputFile & operator = (const DeepScanLineOutputFile &);       // not implemented
+
+    void                initialize (const Header &header);
+    void                initializeLineBuffer();
+
+    Data *              _data;
+
+
+
+    friend class MultiPartOutputFile;
+};
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif

3rdparty/openexr/IlmImf/ImfDeepScanLineOutputPart.cpp

@@ -0,0 +1,107 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#include "ImfDeepScanLineOutputPart.h"
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+DeepScanLineOutputPart::DeepScanLineOutputPart(MultiPartOutputFile& multiPartFile, int partNumber)
+{
+    file = multiPartFile.getOutputPart<DeepScanLineOutputFile>(partNumber);
+}
+
+
+const char *
+DeepScanLineOutputPart::fileName () const
+{
+    return file->fileName();
+}
+
+
+const Header &
+DeepScanLineOutputPart::header () const
+{
+    return file->header();
+}
+
+
+void
+DeepScanLineOutputPart::setFrameBuffer (const DeepFrameBuffer &frameBuffer)
+{
+    file->setFrameBuffer(frameBuffer);
+}
+
+
+const DeepFrameBuffer &
+DeepScanLineOutputPart::frameBuffer () const
+{
+    return file->frameBuffer();
+}
+
+
+void
+DeepScanLineOutputPart::writePixels (int numScanLines)
+{
+    file->writePixels(numScanLines);
+}
+
+
+int
+DeepScanLineOutputPart::currentScanLine () const
+{
+    return file->currentScanLine();
+}
+
+
+void
+DeepScanLineOutputPart::copyPixels (DeepScanLineInputFile &in)
+{
+    file->copyPixels(in);
+}
+
+void
+DeepScanLineOutputPart::copyPixels (DeepScanLineInputPart &in)
+{
+    file->copyPixels(in);
+}
+
+void
+DeepScanLineOutputPart::updatePreviewImage (const PreviewRgba newPixels[])
+{
+    file->updatePreviewImage(newPixels);
+}
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT
+

3rdparty/openexr/IlmImf/ImfDeepScanLineOutputPart.h

@@ -0,0 +1,178 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef IMFDEEPSCANLINEOUTPUTPART_H_
+#define IMFDEEPSCANLINEOUTPUTPART_H_
+
+#include "ImfDeepScanLineOutputFile.h"
+#include "ImfMultiPartOutputFile.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+class DeepScanLineOutputPart
+{
+  public:
+
+    IMF_EXPORT
+    DeepScanLineOutputPart(MultiPartOutputFile& multiPartFile, int partNumber);
+
+    //------------------------
+    // Access to the file name
+    //------------------------
+
+    IMF_EXPORT
+    const char *        fileName () const;
+
+
+    //--------------------------
+    // Access to the file header
+    //--------------------------
+
+    IMF_EXPORT
+    const Header &      header () const;
+
+
+    //-------------------------------------------------------
+    // Set the current frame buffer -- copies the FrameBuffer
+    // object into the OutputFile object.
+    //
+    // The current frame buffer is the source of the pixel
+    // data written to the file.  The current frame buffer
+    // must be set at least once before writePixels() is
+    // called.  The current frame buffer can be changed
+    // after each call to writePixels.
+    //-------------------------------------------------------
+
+    IMF_EXPORT
+    void                setFrameBuffer (const DeepFrameBuffer &frameBuffer);
+
+
+    //-----------------------------------
+    // Access to the current frame buffer
+    //-----------------------------------
+
+    IMF_EXPORT
+    const DeepFrameBuffer & frameBuffer () const;
+
+
+    //-------------------------------------------------------------------
+    // Write pixel data:
+    //
+    // writePixels(n) retrieves the next n scan lines worth of data from
+    // the current frame buffer, starting with the scan line indicated by
+    // currentScanLine(), and stores the data in the output file, and
+    // progressing in the direction indicated by header.lineOrder().
+    //
+    // To produce a complete and correct file, exactly m scan lines must
+    // be written, where m is equal to
+    // header().dataWindow().max.y - header().dataWindow().min.y + 1.
+    //-------------------------------------------------------------------
+
+    IMF_EXPORT
+    void                writePixels (int numScanLines = 1);
+
+
+    //------------------------------------------------------------------
+    // Access to the current scan line:
+    //
+    // currentScanLine() returns the y coordinate of the first scan line
+    // that will be read from the current frame buffer during the next
+    // call to writePixels().
+    //
+    // If header.lineOrder() == INCREASING_Y:
+    //
+    //  The current scan line before the first call to writePixels()
+    //  is header().dataWindow().min.y.  After writing each scan line,
+    //  the current scan line is incremented by 1.
+    //
+    // If header.lineOrder() == DECREASING_Y:
+    //
+    //  The current scan line before the first call to writePixels()
+    //  is header().dataWindow().max.y.  After writing each scan line,
+    //  the current scan line is decremented by 1.
+    //
+    //------------------------------------------------------------------
+
+    IMF_EXPORT
+    int                 currentScanLine () const;
+
+
+    //--------------------------------------------------------------
+    // Shortcut to copy all pixels from an InputFile into this file,
+    // without uncompressing and then recompressing the pixel data.
+    // This file's header must be compatible with the InputFile's
+    // header:  The two header's "dataWindow", "compression",
+    // "lineOrder" and "channels" attributes must be the same.
+    //--------------------------------------------------------------
+
+    IMF_EXPORT
+    void                copyPixels (DeepScanLineInputFile &in);
+    IMF_EXPORT
+    void                copyPixels (DeepScanLineInputPart &in);
+
+
+    //--------------------------------------------------------------
+    // Updating the preview image:
+    //
+    // updatePreviewImage() supplies a new set of pixels for the
+    // preview image attribute in the file's header.  If the header
+    // does not contain a preview image, updatePreviewImage() throws
+    // an IEX_NAMESPACE::LogicExc.
+    //
+    // Note: updatePreviewImage() is necessary because images are
+    // often stored in a file incrementally, a few scan lines at a
+    // time, while the image is being generated.  Since the preview
+    // image is an attribute in the file's header, it gets stored in
+    // the file as soon as the file is opened, but we may not know
+    // what the preview image should look like until we have written
+    // the last scan line of the main image.
+    //
+    //--------------------------------------------------------------
+
+    IMF_EXPORT
+    void                updatePreviewImage (const PreviewRgba newPixels[]);
+
+  private:
+      DeepScanLineOutputFile* file;
+};
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+
+
+
+
+#endif /* IMFDEEPSCANLINEOUTPUTPART_H_ */

3rdparty/openexr/IlmImf/ImfDeepTiledInputFile.h

@@ -0,0 +1,472 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+#ifndef INCLUDED_IMF_DEEP_TILED_INPUT_FILE_H
+#define INCLUDED_IMF_DEEP_TILED_INPUT_FILE_H
+
+//-----------------------------------------------------------------------------
+//
+//      class DeepTiledInputFile
+//
+//-----------------------------------------------------------------------------
+
+#include "ImfHeader.h"
+#include "ImfFrameBuffer.h"
+#include "ImathBox.h"
+#include "ImfTileDescription.h"
+#include "ImfThreading.h"
+#include "ImfGenericInputFile.h"
+#include "ImfDeepFrameBuffer.h"
+#include "ImfDeepTiledOutputFile.h"
+#include "ImfForward.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+class DeepTiledInputFile : public GenericInputFile
+{
+  public:
+
+    //--------------------------------------------------------------------
+    // A constructor that opens the file with the specified name, and
+    // reads the file header.  The constructor throws an IEX_NAMESPACE::ArgExc
+    // exception if the file is not tiled.
+    // The numThreads parameter specifies how many worker threads this
+    // file will try to keep busy when decompressing individual tiles.
+    // Destroying TiledInputFile objects constructed with this constructor
+    // automatically closes the corresponding files.
+    //--------------------------------------------------------------------
+
+    IMF_EXPORT
+    DeepTiledInputFile (const char fileName[],
+                    int numThreads = globalThreadCount ());
+
+
+    // ----------------------------------------------------------
+    // A constructor that attaches the new TiledInputFile object
+    // to a file that has already been opened.
+    // Destroying TiledInputFile objects constructed with this
+    // constructor does not automatically close the corresponding
+    // files.
+    // ----------------------------------------------------------
+
+    IMF_EXPORT
+    DeepTiledInputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int numThreads = globalThreadCount ());
+
+
+    //-----------
+    // Destructor
+    //-----------
+
+    IMF_EXPORT
+    virtual ~DeepTiledInputFile ();
+
+
+    //------------------------
+    // Access to the file name
+    //------------------------
+
+    IMF_EXPORT
+    const char *        fileName () const;
+
+
+    //--------------------------
+    // Access to the file header
+    //--------------------------
+
+    IMF_EXPORT
+    const Header &      header () const;
+
+
+    //----------------------------------
+    // Access to the file format version
+    //----------------------------------
+
+    IMF_EXPORT
+    int                 version () const;
+
+
+    //-----------------------------------------------------------
+    // Set the current frame buffer -- copies the FrameBuffer
+    // object into the TiledInputFile object.
+    //
+    // The current frame buffer is the destination for the pixel
+    // data read from the file.  The current frame buffer must be
+    // set at least once before readTile() is called.
+    // The current frame buffer can be changed after each call
+    // to readTile().
+    //-----------------------------------------------------------
+
+    IMF_EXPORT
+    void                setFrameBuffer (const DeepFrameBuffer &frameBuffer);
+
+
+    //-----------------------------------
+    // Access to the current frame buffer
+    //-----------------------------------
+
+    IMF_EXPORT
+    const DeepFrameBuffer & frameBuffer () const;
+
+
+    //------------------------------------------------------------
+    // Check if the file is complete:
+    //
+    // isComplete() returns true if all pixels in the data window
+    // (in all levels) are present in the input file, or false if
+    // any pixels are missing.  (Another program may still be busy
+    // writing the file, or file writing may have been aborted
+    // prematurely.)
+    //------------------------------------------------------------
+
+    IMF_EXPORT
+    bool                isComplete () const;
+
+
+    //--------------------------------------------------
+    // Utility functions:
+    //--------------------------------------------------
+
+    //---------------------------------------------------------
+    // Multiresolution mode and tile size:
+    // The following functions return the xSize, ySize and mode
+    // fields of the file header's TileDescriptionAttribute.
+    //---------------------------------------------------------
+
+    IMF_EXPORT
+    unsigned int        tileXSize () const;
+    IMF_EXPORT
+    unsigned int        tileYSize () const;
+    IMF_EXPORT
+    LevelMode           levelMode () const;
+    IMF_EXPORT
+    LevelRoundingMode   levelRoundingMode () const;
+
+
+    //--------------------------------------------------------------------
+    // Number of levels:
+    //
+    // numXLevels() returns the file's number of levels in x direction.
+    //
+    //  if levelMode() == ONE_LEVEL:
+    //      return value is: 1
+    //
+    //  if levelMode() == MIPMAP_LEVELS:
+    //      return value is: rfunc (log (max (w, h)) / log (2)) + 1
+    //
+    //  if levelMode() == RIPMAP_LEVELS:
+    //      return value is: rfunc (log (w) / log (2)) + 1
+    //
+    //  where
+    //      w is the width of the image's data window,  max.x - min.x + 1,
+    //      y is the height of the image's data window, max.y - min.y + 1,
+    //      and rfunc(x) is either floor(x), or ceil(x), depending on
+    //      whether levelRoundingMode() returns ROUND_DOWN or ROUND_UP.
+    //
+    // numYLevels() returns the file's number of levels in y direction.
+    //
+    //  if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS:
+    //      return value is the same as for numXLevels()
+    //
+    //  if levelMode() == RIPMAP_LEVELS:
+    //      return value is: rfunc (log (h) / log (2)) + 1
+    //
+    //
+    // numLevels() is a convenience function for use with
+    // MIPMAP_LEVELS files.
+    //
+    //  if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS:
+    //      return value is the same as for numXLevels()
+    //
+    //  if levelMode() == RIPMAP_LEVELS:
+    //      an IEX_NAMESPACE::LogicExc exception is thrown
+    //
+    // isValidLevel(lx, ly) returns true if the file contains
+    // a level with level number (lx, ly), false if not.
+    //
+    // totalTiles() returns the total number of tiles in the image
+    //
+    //--------------------------------------------------------------------
+
+    IMF_EXPORT
+    int                 numLevels () const;
+    IMF_EXPORT
+    int                 numXLevels () const;
+    IMF_EXPORT
+    int                 numYLevels () const;
+    IMF_EXPORT
+    bool                isValidLevel (int lx, int ly) const;
+    IMF_EXPORT
+    size_t              totalTiles() const;
+
+    //----------------------------------------------------------
+    // Dimensions of a level:
+    //
+    // levelWidth(lx) returns the width of a level with level
+    // number (lx, *), where * is any number.
+    //
+    //  return value is:
+    //      max (1, rfunc (w / pow (2, lx)))
+    //
+    //
+    // levelHeight(ly) returns the height of a level with level
+    // number (*, ly), where * is any number.
+    //
+    //  return value is:
+    //      max (1, rfunc (h / pow (2, ly)))
+    //
+    //----------------------------------------------------------
+
+    IMF_EXPORT
+    int                 levelWidth  (int lx) const;
+    IMF_EXPORT
+    int                 levelHeight (int ly) const;
+
+
+    //--------------------------------------------------------------
+    // Number of tiles:
+    //
+    // numXTiles(lx) returns the number of tiles in x direction
+    // that cover a level with level number (lx, *), where * is
+    // any number.
+    //
+    //  return value is:
+    //      (levelWidth(lx) + tileXSize() - 1) / tileXSize()
+    //
+    //
+    // numYTiles(ly) returns the number of tiles in y direction
+    // that cover a level with level number (*, ly), where * is
+    // any number.
+    //
+    //  return value is:
+    //      (levelHeight(ly) + tileXSize() - 1) / tileXSize()
+    //
+    //--------------------------------------------------------------
+
+    IMF_EXPORT
+    int                 numXTiles (int lx = 0) const;
+    IMF_EXPORT
+    int                 numYTiles (int ly = 0) const;
+
+
+    //---------------------------------------------------------------
+    // Level pixel ranges:
+    //
+    // dataWindowForLevel(lx, ly) returns a 2-dimensional region of
+    // valid pixel coordinates for a level with level number (lx, ly)
+    //
+    //  return value is a Box2i with min value:
+    //      (dataWindow.min.x, dataWindow.min.y)
+    //
+    //  and max value:
+    //      (dataWindow.min.x + levelWidth(lx) - 1,
+    //       dataWindow.min.y + levelHeight(ly) - 1)
+    //
+    // dataWindowForLevel(level) is a convenience function used
+    // for ONE_LEVEL and MIPMAP_LEVELS files.  It returns
+    // dataWindowForLevel(level, level).
+    //
+    //---------------------------------------------------------------
+
+    IMF_EXPORT
+    IMATH_NAMESPACE::Box2i        dataWindowForLevel (int l = 0) const;
+    IMF_EXPORT
+    IMATH_NAMESPACE::Box2i        dataWindowForLevel (int lx, int ly) const;
+
+
+    //-------------------------------------------------------------------
+    // Tile pixel ranges:
+    //
+    // dataWindowForTile(dx, dy, lx, ly) returns a 2-dimensional
+    // region of valid pixel coordinates for a tile with tile coordinates
+    // (dx,dy) and level number (lx, ly).
+    //
+    //  return value is a Box2i with min value:
+    //      (dataWindow.min.x + dx * tileXSize(),
+    //       dataWindow.min.y + dy * tileYSize())
+    //
+    //  and max value:
+    //      (dataWindow.min.x + (dx + 1) * tileXSize() - 1,
+    //       dataWindow.min.y + (dy + 1) * tileYSize() - 1)
+    //
+    // dataWindowForTile(dx, dy, level) is a convenience function
+    // used for ONE_LEVEL and MIPMAP_LEVELS files.  It returns
+    // dataWindowForTile(dx, dy, level, level).
+    //
+    //-------------------------------------------------------------------
+
+    IMF_EXPORT
+    IMATH_NAMESPACE::Box2i        dataWindowForTile (int dx, int dy, int l = 0) const;
+
+    IMF_EXPORT
+    IMATH_NAMESPACE::Box2i        dataWindowForTile (int dx, int dy,
+                                           int lx, int ly) const;
+
+    //------------------------------------------------------------
+    // Read pixel data:
+    //
+    // readTile(dx, dy, lx, ly) reads the tile with tile
+    // coordinates (dx, dy), and level number (lx, ly),
+    // and stores it in the current frame buffer.
+    //
+    //   dx must lie in the interval [0, numXTiles(lx)-1]
+    //   dy must lie in the interval [0, numYTiles(ly)-1]
+    //
+    //   lx must lie in the interval [0, numXLevels()-1]
+    //   ly must lie in the inverval [0, numYLevels()-1]
+    //
+    // readTile(dx, dy, level) is a convenience function used
+    // for ONE_LEVEL and MIPMAP_LEVELS files.  It calls
+    // readTile(dx, dy, level, level).
+    //
+    // The two readTiles(dx1, dx2, dy1, dy2, ...) functions allow
+    // reading multiple tiles at once.  If multi-threading is used
+    // the multiple tiles are read concurrently.
+    //
+    // Pixels that are outside the pixel coordinate range for the
+    // tile's level, are never accessed by readTile().
+    //
+    // Attempting to access a tile that is not present in the file
+    // throws an InputExc exception.
+    //
+    //------------------------------------------------------------
+
+    IMF_EXPORT
+    void                readTile  (int dx, int dy, int l = 0);
+    IMF_EXPORT
+    void                readTile  (int dx, int dy, int lx, int ly);
+
+    IMF_EXPORT
+    void                readTiles (int dx1, int dx2, int dy1, int dy2,
+                                   int lx, int ly);
+
+    IMF_EXPORT
+    void                readTiles (int dx1, int dx2, int dy1, int dy2,
+                                   int l = 0);
+
+
+    //--------------------------------------------------
+    // Read a tile of raw pixel data from the file,
+    // without uncompressing it (this function is
+    // used to implement TiledOutputFile::copyPixels()).
+    //--------------------------------------------------
+
+    IMF_EXPORT
+    void                rawTileData (int &dx, int &dy,
+                                     int &lx, int &ly,
+                                     char *pixelData,
+                                     Int64 &dataSize) const;
+
+    //------------------------------------------------------------------
+    // Read pixel sample counts into a slice in the frame buffer.
+    //
+    // readPixelSampleCount(dx, dy, lx, ly) reads the sample counts
+    // for tile (dx, dy) in level (lx, ly).
+    //
+    // readPixelSampleCount(dx, dy, l) calls
+    // readPixelSampleCount(dx, dy, lx = l, ly = l)
+    //
+    // dx must lie in the interval [0, numXTiles(lx)-1]
+    // dy must lie in the interval [0, numYTiles(ly)-1]
+    //
+    // lx must lie in the interval [0, numXLevels()-1]
+    // ly must lie in the inverval [0, numYLevels()-1]
+    //
+    // readPixelSampleCounts(dx1, dx2, dy1, dy2, lx, ly) reads all
+    // the sample counts for tiles within range
+    // [(min(dx1, dx2), min(dy1, dy2))...(max(dx1, dx2), max(dy1, dy2)],
+    // and on level (lx, ly)
+    //
+    // readPixelSampleCounts(dx1, dx2, dy1, dy2, l) calls
+    // readPixelSampleCounts(dx1, dx2, dy1, dy2, lx = l, ly = l).
+    //------------------------------------------------------------------
+
+    IMF_EXPORT
+    void                readPixelSampleCount  (int dx, int dy, int l = 0);
+    IMF_EXPORT
+    void                readPixelSampleCount  (int dx, int dy, int lx, int ly);
+
+    IMF_EXPORT
+    void                readPixelSampleCounts (int dx1, int dx2,
+                                              int dy1, int dy2,
+                                              int lx, int ly);
+
+    IMF_EXPORT
+    void                readPixelSampleCounts (int dx1, int dx2,
+                                              int dy1, int dy2,
+                                              int l = 0);
+
+    struct Data;
+
+    
+    
+  private:
+
+    friend class InputFile;
+    friend class MultiPartInputFile;
+
+    DeepTiledInputFile (InputPartData* part);
+
+    DeepTiledInputFile (const DeepTiledInputFile &);              // not implemented
+    DeepTiledInputFile & operator = (const DeepTiledInputFile &); // not implemented
+
+    DeepTiledInputFile (const Header &header, OPENEXR_IMF_INTERNAL_NAMESPACE::IStream *is, int version,
+                    int numThreads);
+
+    void                initialize ();
+    void                multiPartInitialize(InputPartData* part);
+    void                compatibilityInitialize(OPENEXR_IMF_INTERNAL_NAMESPACE::IStream& is);
+
+    bool                isValidTile (int dx, int dy,
+                                     int lx, int ly) const;
+
+    size_t              bytesPerLineForTile (int dx, int dy,
+                                             int lx, int ly) const;
+           
+                                                
+    void                getTileOrder(int dx[],int dy[],int lx[],int ly[]) const;
+                                             
+    
+    Data *              _data;
+
+
+    // needed for copyPixels
+    friend void DeepTiledOutputFile::copyPixels(DeepTiledInputFile &);
+};
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif

3rdparty/openexr/IlmImf/ImfDeepTiledInputPart.cpp

@@ -0,0 +1,273 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+#include "ImfDeepTiledInputPart.h"
+#include "ImfMultiPartInputFile.h"
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+DeepTiledInputPart::DeepTiledInputPart(MultiPartInputFile& multiPartFile, int partNumber)
+{
+    file = multiPartFile.getInputPart<DeepTiledInputFile>(partNumber);
+}
+
+
+const char *
+DeepTiledInputPart::fileName () const
+{
+    return file->fileName();
+}
+
+
+const Header &
+DeepTiledInputPart::header () const
+{
+    return file->header();
+}
+
+
+int
+DeepTiledInputPart::version () const
+{
+    return file->version();
+}
+
+
+void
+DeepTiledInputPart::setFrameBuffer (const DeepFrameBuffer &frameBuffer)
+{
+    file->setFrameBuffer(frameBuffer);
+}
+
+
+const DeepFrameBuffer &
+DeepTiledInputPart::frameBuffer () const
+{
+    return file->frameBuffer();
+}
+
+
+bool
+DeepTiledInputPart::isComplete () const
+{
+    return file->isComplete();
+}
+
+
+unsigned int
+DeepTiledInputPart::tileXSize () const
+{
+    return file->tileXSize();
+}
+
+
+unsigned int
+DeepTiledInputPart::tileYSize () const
+{
+    return file->tileYSize();
+}
+
+
+LevelMode
+DeepTiledInputPart::levelMode () const
+{
+    return file->levelMode();
+}
+
+
+LevelRoundingMode
+DeepTiledInputPart::levelRoundingMode () const
+{
+    return file->levelRoundingMode();
+}
+
+
+int
+DeepTiledInputPart::numLevels () const
+{
+    return file->numLevels();
+}
+
+
+int
+DeepTiledInputPart::numXLevels () const
+{
+    return file->numXLevels();
+}
+
+
+int
+DeepTiledInputPart::numYLevels () const
+{
+    return file->numYLevels();
+}
+
+
+bool
+DeepTiledInputPart::isValidLevel (int lx, int ly) const
+{
+    return file->isValidLevel(lx, ly);
+}
+
+
+int
+DeepTiledInputPart::levelWidth  (int lx) const
+{
+    return file->levelWidth(lx);
+}
+
+
+int
+DeepTiledInputPart::levelHeight (int ly) const
+{
+    return file->levelHeight(ly);
+}
+
+
+int
+DeepTiledInputPart::numXTiles (int lx) const
+{
+    return file->numXTiles(lx);
+}
+
+
+int
+DeepTiledInputPart::numYTiles (int ly) const
+{
+    return file->numYTiles(ly);
+}
+
+
+IMATH_NAMESPACE::Box2i
+DeepTiledInputPart::dataWindowForLevel (int l) const
+{
+    return file->dataWindowForLevel(l);
+}
+
+IMATH_NAMESPACE::Box2i
+DeepTiledInputPart::dataWindowForLevel (int lx, int ly) const
+{
+    return file->dataWindowForLevel(lx, ly);
+}
+
+
+IMATH_NAMESPACE::Box2i
+DeepTiledInputPart::dataWindowForTile (int dx, int dy, int l) const
+{
+    return file->dataWindowForTile(dx, dy, l);
+}
+
+
+IMATH_NAMESPACE::Box2i
+DeepTiledInputPart::dataWindowForTile (int dx, int dy,
+                                       int lx, int ly) const
+{
+    return file->dataWindowForTile(dx, dy, lx, ly);
+}
+
+
+void
+DeepTiledInputPart::readTile  (int dx, int dy, int l)
+{
+    file->readTile(dx, dy, l);
+}
+
+
+void
+DeepTiledInputPart::readTile  (int dx, int dy, int lx, int ly)
+{
+    file->readTile(dx, dy, lx, ly);
+}
+
+
+void
+DeepTiledInputPart::readTiles (int dx1, int dx2, int dy1, int dy2,
+                               int lx, int ly)
+{
+    file->readTiles(dx1, dx2, dy1, dy2, lx, ly);
+}
+
+
+void
+DeepTiledInputPart::readTiles (int dx1, int dx2, int dy1, int dy2,
+                               int l)
+{
+    file->readTiles(dx1, dx2, dy1, dy2, l);
+}
+
+
+void
+DeepTiledInputPart::rawTileData (int &dx, int &dy,
+                                 int &lx, int &ly,
+                                 char * pixelData,
+                                 Int64 & dataSize) const
+{
+    file->rawTileData(dx, dy, lx, ly, pixelData, dataSize );
+}
+
+
+void
+DeepTiledInputPart::readPixelSampleCount  (int dx, int dy, int l)
+{
+    file->readPixelSampleCount(dx, dy, l);
+}
+
+
+void
+DeepTiledInputPart::readPixelSampleCount  (int dx, int dy, int lx, int ly)
+{
+    file->readPixelSampleCount(dx, dy, lx, ly);
+}
+
+
+void
+DeepTiledInputPart::readPixelSampleCounts (int dx1, int dx2,
+                                          int dy1, int dy2,
+                                          int lx, int ly)
+{
+    file->readPixelSampleCounts(dx1, dx2, dy1, dy2, lx, ly);
+}
+
+void
+DeepTiledInputPart::readPixelSampleCounts (int dx1, int dx2,
+                                          int dy1, int dy2,
+                                          int l)
+{
+    file->readPixelSampleCounts(dx1, dx2, dy1, dy2, l);
+}
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfDeepTiledInputPart.h

@@ -0,0 +1,394 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+#ifndef IMFDEEPTILEDINPUTPART_H_
+#define IMFDEEPTILEDINPUTPART_H_
+
+#include "ImfDeepTiledInputFile.h"
+#include "ImfNamespace.h"
+#include "ImfForward.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+class DeepTiledInputPart
+{
+  public:
+
+    IMF_EXPORT
+    DeepTiledInputPart(MultiPartInputFile& multiPartFile, int partNumber);
+
+    //------------------------
+    // Access to the file name
+    //------------------------
+
+    IMF_EXPORT
+    const char *        fileName () const;
+
+
+    //--------------------------
+    // Access to the file header
+    //--------------------------
+
+    IMF_EXPORT
+    const Header &      header () const;
+
+
+    //----------------------------------
+    // Access to the file format version
+    //----------------------------------
+
+    IMF_EXPORT
+    int                 version () const;
+
+
+    //-----------------------------------------------------------
+    // Set the current frame buffer -- copies the FrameBuffer
+    // object into the TiledInputFile object.
+    //
+    // The current frame buffer is the destination for the pixel
+    // data read from the file.  The current frame buffer must be
+    // set at least once before readTile() is called.
+    // The current frame buffer can be changed after each call
+    // to readTile().
+    //-----------------------------------------------------------
+
+    IMF_EXPORT
+    void                setFrameBuffer (const DeepFrameBuffer &frameBuffer);
+
+
+    //-----------------------------------
+    // Access to the current frame buffer
+    //-----------------------------------
+
+    IMF_EXPORT
+    const DeepFrameBuffer & frameBuffer () const;
+
+
+    //------------------------------------------------------------
+    // Check if the file is complete:
+    //
+    // isComplete() returns true if all pixels in the data window
+    // (in all levels) are present in the input file, or false if
+    // any pixels are missing.  (Another program may still be busy
+    // writing the file, or file writing may have been aborted
+    // prematurely.)
+    //------------------------------------------------------------
+
+    IMF_EXPORT
+    bool                isComplete () const;
+
+
+    //--------------------------------------------------
+    // Utility functions:
+    //--------------------------------------------------
+
+    //---------------------------------------------------------
+    // Multiresolution mode and tile size:
+    // The following functions return the xSize, ySize and mode
+    // fields of the file header's TileDescriptionAttribute.
+    //---------------------------------------------------------
+
+    IMF_EXPORT
+    unsigned int        tileXSize () const;
+    IMF_EXPORT
+    unsigned int        tileYSize () const;
+    IMF_EXPORT
+    LevelMode           levelMode () const;
+    IMF_EXPORT
+    LevelRoundingMode   levelRoundingMode () const;
+
+
+    //--------------------------------------------------------------------
+    // Number of levels:
+    //
+    // numXLevels() returns the file's number of levels in x direction.
+    //
+    //  if levelMode() == ONE_LEVEL:
+    //      return value is: 1
+    //
+    //  if levelMode() == MIPMAP_LEVELS:
+    //      return value is: rfunc (log (max (w, h)) / log (2)) + 1
+    //
+    //  if levelMode() == RIPMAP_LEVELS:
+    //      return value is: rfunc (log (w) / log (2)) + 1
+    //
+    //  where
+    //      w is the width of the image's data window,  max.x - min.x + 1,
+    //      y is the height of the image's data window, max.y - min.y + 1,
+    //      and rfunc(x) is either floor(x), or ceil(x), depending on
+    //      whether levelRoundingMode() returns ROUND_DOWN or ROUND_UP.
+    //
+    // numYLevels() returns the file's number of levels in y direction.
+    //
+    //  if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS:
+    //      return value is the same as for numXLevels()
+    //
+    //  if levelMode() == RIPMAP_LEVELS:
+    //      return value is: rfunc (log (h) / log (2)) + 1
+    //
+    //
+    // numLevels() is a convenience function for use with
+    // MIPMAP_LEVELS files.
+    //
+    //  if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS:
+    //      return value is the same as for numXLevels()
+    //
+    //  if levelMode() == RIPMAP_LEVELS:
+    //      an IEX_NAMESPACE::LogicExc exception is thrown
+    //
+    // isValidLevel(lx, ly) returns true if the file contains
+    // a level with level number (lx, ly), false if not.
+    //
+    //--------------------------------------------------------------------
+
+    IMF_EXPORT
+    int                 numLevels () const;
+    IMF_EXPORT
+    int                 numXLevels () const;
+    IMF_EXPORT
+    int                 numYLevels () const;
+    IMF_EXPORT
+    bool                isValidLevel (int lx, int ly) const;
+
+
+    //----------------------------------------------------------
+    // Dimensions of a level:
+    //
+    // levelWidth(lx) returns the width of a level with level
+    // number (lx, *), where * is any number.
+    //
+    //  return value is:
+    //      max (1, rfunc (w / pow (2, lx)))
+    //
+    //
+    // levelHeight(ly) returns the height of a level with level
+    // number (*, ly), where * is any number.
+    //
+    //  return value is:
+    //      max (1, rfunc (h / pow (2, ly)))
+    //
+    //----------------------------------------------------------
+
+    IMF_EXPORT
+    int                 levelWidth  (int lx) const;
+    IMF_EXPORT
+    int                 levelHeight (int ly) const;
+
+
+    //--------------------------------------------------------------
+    // Number of tiles:
+    //
+    // numXTiles(lx) returns the number of tiles in x direction
+    // that cover a level with level number (lx, *), where * is
+    // any number.
+    //
+    //  return value is:
+    //      (levelWidth(lx) + tileXSize() - 1) / tileXSize()
+    //
+    //
+    // numYTiles(ly) returns the number of tiles in y direction
+    // that cover a level with level number (*, ly), where * is
+    // any number.
+    //
+    //  return value is:
+    //      (levelHeight(ly) + tileXSize() - 1) / tileXSize()
+    //
+    //--------------------------------------------------------------
+
+    IMF_EXPORT
+    int                 numXTiles (int lx = 0) const;
+    IMF_EXPORT
+    int                 numYTiles (int ly = 0) const;
+
+
+    //---------------------------------------------------------------
+    // Level pixel ranges:
+    //
+    // dataWindowForLevel(lx, ly) returns a 2-dimensional region of
+    // valid pixel coordinates for a level with level number (lx, ly)
+    //
+    //  return value is a Box2i with min value:
+    //      (dataWindow.min.x, dataWindow.min.y)
+    //
+    //  and max value:
+    //      (dataWindow.min.x + levelWidth(lx) - 1,
+    //       dataWindow.min.y + levelHeight(ly) - 1)
+    //
+    // dataWindowForLevel(level) is a convenience function used
+    // for ONE_LEVEL and MIPMAP_LEVELS files.  It returns
+    // dataWindowForLevel(level, level).
+    //
+    //---------------------------------------------------------------
+
+    IMF_EXPORT
+    IMATH_NAMESPACE::Box2i        dataWindowForLevel (int l = 0) const;
+    IMF_EXPORT
+    IMATH_NAMESPACE::Box2i        dataWindowForLevel (int lx, int ly) const;
+
+
+    //-------------------------------------------------------------------
+    // Tile pixel ranges:
+    //
+    // dataWindowForTile(dx, dy, lx, ly) returns a 2-dimensional
+    // region of valid pixel coordinates for a tile with tile coordinates
+    // (dx,dy) and level number (lx, ly).
+    //
+    //  return value is a Box2i with min value:
+    //      (dataWindow.min.x + dx * tileXSize(),
+    //       dataWindow.min.y + dy * tileYSize())
+    //
+    //  and max value:
+    //      (dataWindow.min.x + (dx + 1) * tileXSize() - 1,
+    //       dataWindow.min.y + (dy + 1) * tileYSize() - 1)
+    //
+    // dataWindowForTile(dx, dy, level) is a convenience function
+    // used for ONE_LEVEL and MIPMAP_LEVELS files.  It returns
+    // dataWindowForTile(dx, dy, level, level).
+    //
+    //-------------------------------------------------------------------
+
+    IMF_EXPORT
+    IMATH_NAMESPACE::Box2i        dataWindowForTile (int dx, int dy, int l = 0) const;
+
+    IMF_EXPORT
+    IMATH_NAMESPACE::Box2i        dataWindowForTile (int dx, int dy,
+                                         int lx, int ly) const;
+
+    //------------------------------------------------------------
+    // Read pixel data:
+    //
+    // readTile(dx, dy, lx, ly) reads the tile with tile
+    // coordinates (dx, dy), and level number (lx, ly),
+    // and stores it in the current frame buffer.
+    //
+    //   dx must lie in the interval [0, numXTiles(lx)-1]
+    //   dy must lie in the interval [0, numYTiles(ly)-1]
+    //
+    //   lx must lie in the interval [0, numXLevels()-1]
+    //   ly must lie in the inverval [0, numYLevels()-1]
+    //
+    // readTile(dx, dy, level) is a convenience function used
+    // for ONE_LEVEL and MIPMAP_LEVELS files.  It calls
+    // readTile(dx, dy, level, level).
+    //
+    // The two readTiles(dx1, dx2, dy1, dy2, ...) functions allow
+    // reading multiple tiles at once.  If multi-threading is used
+    // the multiple tiles are read concurrently.
+    //
+    // Pixels that are outside the pixel coordinate range for the
+    // tile's level, are never accessed by readTile().
+    //
+    // Attempting to access a tile that is not present in the file
+    // throws an InputExc exception.
+    //
+    //------------------------------------------------------------
+
+    IMF_EXPORT
+    void                readTile  (int dx, int dy, int l = 0);
+    IMF_EXPORT
+    void                readTile  (int dx, int dy, int lx, int ly);
+
+    IMF_EXPORT
+    void                readTiles (int dx1, int dx2, int dy1, int dy2,
+                                 int lx, int ly);
+
+    IMF_EXPORT
+    void                readTiles (int dx1, int dx2, int dy1, int dy2,
+                                 int l = 0);
+
+
+    //--------------------------------------------------
+    // Read a tile of raw pixel data from the file,
+    // without uncompressing it (this function is
+    // used to implement TiledOutputFile::copyPixels()).
+    //--------------------------------------------------
+
+    IMF_EXPORT
+    void                rawTileData (int &dx, int &dy,
+                                   int &lx, int &ly,
+                                   char *data,
+                                   Int64 &dataSize
+                                   ) const;
+
+    //------------------------------------------------------------------
+    // Read pixel sample counts into a slice in the frame buffer.
+    //
+    // readPixelSampleCount(dx, dy, lx, ly) reads the sample counts
+    // for tile (dx, dy) in level (lx, ly).
+    //
+    // readPixelSampleCount(dx, dy, l) calls
+    // readPixelSampleCount(dx, dy, lx = l, ly = l)
+    //
+    // dx must lie in the interval [0, numXTiles(lx)-1]
+    // dy must lie in the interval [0, numYTiles(ly)-1]
+    //
+    // lx must lie in the interval [0, numXLevels()-1]
+    // ly must lie in the inverval [0, numYLevels()-1]
+    //
+    // readPixelSampleCounts(dx1, dx2, dy1, dy2, lx, ly) reads all
+    // the sample counts for tiles within range
+    // [(min(dx1, dx2), min(dy1, dy2))...(max(dx1, dx2), max(dy1, dy2)],
+    // and on level (lx, ly)
+    //
+    // readPixelSampleCounts(dx1, dx2, dy1, dy2, l) calls
+    // readPixelSampleCounts(dx1, dx2, dy1, dy2, lx = l, ly = l).
+    //------------------------------------------------------------------
+
+    IMF_EXPORT
+    void                readPixelSampleCount  (int dx, int dy, int l = 0);
+    IMF_EXPORT
+    void                readPixelSampleCount  (int dx, int dy, int lx, int ly);
+
+    IMF_EXPORT
+    void                readPixelSampleCounts (int dx1, int dx2,
+                                            int dy1, int dy2,
+                                            int lx, int ly);
+
+    IMF_EXPORT
+    void                readPixelSampleCounts (int dx1, int dx2,
+                                            int dy1, int dy2,
+                                            int l = 0);
+
+  private:
+    DeepTiledInputFile* file;
+
+    friend void DeepTiledOutputFile::copyPixels(DeepTiledInputPart &);
+};
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+
+#endif /* IMFDEEPTILEDINPUTPART_H_ */

3rdparty/openexr/IlmImf/ImfDeepTiledOutputFile.h

@@ -0,0 +1,506 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+#ifndef INCLUDED_IMF_DEEP_TILED_OUTPUT_FILE_H
+#define INCLUDED_IMF_DEEP_TILED_OUTPUT_FILE_H
+
+//-----------------------------------------------------------------------------
+//
+//      class DeepTiledOutputFile
+//
+//-----------------------------------------------------------------------------
+
+#include "ImfHeader.h"
+#include "ImfFrameBuffer.h"
+#include "ImathBox.h"
+#include "ImfThreading.h"
+#include "ImfGenericOutputFile.h"
+#include "ImfNamespace.h"
+#include "ImfForward.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+class DeepTiledOutputFile : public GenericOutputFile
+{
+  public:
+
+    //-------------------------------------------------------------------
+    // A constructor that opens the file with the specified name, and
+    // writes the file header.  The file header is also copied into the
+    // TiledOutputFile object, and can later be accessed via the header()
+    // method.
+    //
+    // Destroying TiledOutputFile constructed with this constructor
+    // automatically closes the corresponding files.
+    //
+    // The header must contain a TileDescriptionAttribute called "tiles".
+    //
+    // The x and y subsampling factors for all image channels must be 1;
+    // subsampling is not supported.
+    //
+    // Tiles can be written to the file in arbitrary order.  The line
+    // order attribute can be used to cause the tiles to be sorted in
+    // the file.  When the file is read later, reading the tiles in the
+    // same order as they are in the file tends to be significantly
+    // faster than reading the tiles in random order (see writeTile,
+    // below).
+    //-------------------------------------------------------------------
+
+    IMF_EXPORT
+    DeepTiledOutputFile (const char fileName[],
+                         const Header &header,
+                         int numThreads = globalThreadCount ());
+
+
+    // ----------------------------------------------------------------
+    // A constructor that attaches the new TiledOutputFile object to
+    // a file that has already been opened.  Destroying TiledOutputFile
+    // objects constructed with this constructor does not automatically
+    // close the corresponding files.
+    // ----------------------------------------------------------------
+
+    IMF_EXPORT
+    DeepTiledOutputFile (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os,
+                         const Header &header,
+                         int numThreads = globalThreadCount ());
+
+
+    //-----------------------------------------------------
+    // Destructor
+    //
+    // Destroying a TiledOutputFile object before all tiles
+    // have been written results in an incomplete file.
+    //-----------------------------------------------------
+
+    IMF_EXPORT
+    virtual ~DeepTiledOutputFile ();
+
+
+    //------------------------
+    // Access to the file name
+    //------------------------
+
+    IMF_EXPORT
+    const char *        fileName () const;
+
+
+    //--------------------------
+    // Access to the file header
+    //--------------------------
+
+    IMF_EXPORT
+    const Header &      header () const;
+
+
+    //-------------------------------------------------------
+    // Set the current frame buffer -- copies the FrameBuffer
+    // object into the TiledOutputFile object.
+    //
+    // The current frame buffer is the source of the pixel
+    // data written to the file.  The current frame buffer
+    // must be set at least once before writeTile() is
+    // called.  The current frame buffer can be changed
+    // after each call to writeTile().
+    //-------------------------------------------------------
+
+    IMF_EXPORT
+    void                setFrameBuffer (const DeepFrameBuffer &frameBuffer);
+
+
+    //-----------------------------------
+    // Access to the current frame buffer
+    //-----------------------------------
+
+    IMF_EXPORT
+    const DeepFrameBuffer & frameBuffer () const;
+
+
+    //-------------------
+    // Utility functions:
+    //-------------------
+
+    //---------------------------------------------------------
+    // Multiresolution mode and tile size:
+    // The following functions return the xSize, ySize and mode
+    // fields of the file header's TileDescriptionAttribute.
+    //---------------------------------------------------------
+
+    IMF_EXPORT
+    unsigned int        tileXSize () const;
+    IMF_EXPORT
+    unsigned int        tileYSize () const;
+    IMF_EXPORT
+    LevelMode           levelMode () const;
+    IMF_EXPORT
+    LevelRoundingMode   levelRoundingMode () const;
+
+
+    //--------------------------------------------------------------------
+    // Number of levels:
+    //
+    // numXLevels() returns the file's number of levels in x direction.
+    //
+    //  if levelMode() == ONE_LEVEL:
+    //      return value is: 1
+    //
+    //  if levelMode() == MIPMAP_LEVELS:
+    //      return value is: rfunc (log (max (w, h)) / log (2)) + 1
+    //
+    //  if levelMode() == RIPMAP_LEVELS:
+    //      return value is: rfunc (log (w) / log (2)) + 1
+    //
+    //  where
+    //      w is the width of the image's data window,  max.x - min.x + 1,
+    //      y is the height of the image's data window, max.y - min.y + 1,
+    //      and rfunc(x) is either floor(x), or ceil(x), depending on
+    //      whether levelRoundingMode() returns ROUND_DOWN or ROUND_UP.
+    //
+    // numYLevels() returns the file's number of levels in y direction.
+    //
+    //  if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS:
+    //      return value is the same as for numXLevels()
+    //
+    //  if levelMode() == RIPMAP_LEVELS:
+    //      return value is: rfunc (log (h) / log (2)) + 1
+    //
+    //
+    // numLevels() is a convenience function for use with MIPMAP_LEVELS
+    // files.
+    //
+    //  if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS:
+    //      return value is the same as for numXLevels()
+    //
+    //  if levelMode() == RIPMAP_LEVELS:
+    //      an IEX_NAMESPACE::LogicExc exception is thrown
+    //
+    // isValidLevel(lx, ly) returns true if the file contains
+    // a level with level number (lx, ly), false if not.
+    //
+    //--------------------------------------------------------------------
+
+    IMF_EXPORT
+    int                 numLevels () const;
+    IMF_EXPORT
+    int                 numXLevels () const;
+    IMF_EXPORT
+    int                 numYLevels () const;
+    IMF_EXPORT
+    bool                isValidLevel (int lx, int ly) const;
+
+
+    //---------------------------------------------------------
+    // Dimensions of a level:
+    //
+    // levelWidth(lx) returns the width of a level with level
+    // number (lx, *), where * is any number.
+    //
+    //  return value is:
+    //      max (1, rfunc (w / pow (2, lx)))
+    //
+    //
+    // levelHeight(ly) returns the height of a level with level
+    // number (*, ly), where * is any number.
+    //
+    //  return value is:
+    //      max (1, rfunc (h / pow (2, ly)))
+    //
+    //---------------------------------------------------------
+
+    IMF_EXPORT
+    int                 levelWidth  (int lx) const;
+    IMF_EXPORT
+    int                 levelHeight (int ly) const;
+
+
+    //----------------------------------------------------------
+    // Number of tiles:
+    //
+    // numXTiles(lx) returns the number of tiles in x direction
+    // that cover a level with level number (lx, *), where * is
+    // any number.
+    //
+    //  return value is:
+    //      (levelWidth(lx) + tileXSize() - 1) / tileXSize()
+    //
+    //
+    // numYTiles(ly) returns the number of tiles in y direction
+    // that cover a level with level number (*, ly), where * is
+    // any number.
+    //
+    //  return value is:
+    //      (levelHeight(ly) + tileXSize() - 1) / tileXSize()
+    //
+    //----------------------------------------------------------
+
+    IMF_EXPORT
+    int                 numXTiles (int lx = 0) const;
+    IMF_EXPORT
+    int                 numYTiles (int ly = 0) const;
+
+
+    //---------------------------------------------------------
+    // Level pixel ranges:
+    //
+    // dataWindowForLevel(lx, ly) returns a 2-dimensional
+    // region of valid pixel coordinates for a level with
+    // level number (lx, ly)
+    //
+    //  return value is a Box2i with min value:
+    //      (dataWindow.min.x, dataWindow.min.y)
+    //
+    //  and max value:
+    //      (dataWindow.min.x + levelWidth(lx) - 1,
+    //       dataWindow.min.y + levelHeight(ly) - 1)
+    //
+    // dataWindowForLevel(level) is a convenience function used
+    // for ONE_LEVEL and MIPMAP_LEVELS files.  It returns
+    // dataWindowForLevel(level, level).
+    //
+    //---------------------------------------------------------
+
+    IMF_EXPORT
+    IMATH_NAMESPACE::Box2i        dataWindowForLevel (int l = 0) const;
+    IMF_EXPORT
+    IMATH_NAMESPACE::Box2i        dataWindowForLevel (int lx, int ly) const;
+
+
+    //-------------------------------------------------------------------
+    // Tile pixel ranges:
+    //
+    // dataWindowForTile(dx, dy, lx, ly) returns a 2-dimensional
+    // region of valid pixel coordinates for a tile with tile coordinates
+    // (dx,dy) and level number (lx, ly).
+    //
+    //  return value is a Box2i with min value:
+    //      (dataWindow.min.x + dx * tileXSize(),
+    //       dataWindow.min.y + dy * tileYSize())
+    //
+    //  and max value:
+    //      (dataWindow.min.x + (dx + 1) * tileXSize() - 1,
+    //       dataWindow.min.y + (dy + 1) * tileYSize() - 1)
+    //
+    // dataWindowForTile(dx, dy, level) is a convenience function
+    // used for ONE_LEVEL and MIPMAP_LEVELS files.  It returns
+    // dataWindowForTile(dx, dy, level, level).
+    //
+    //-------------------------------------------------------------------
+
+    IMF_EXPORT
+    IMATH_NAMESPACE::Box2i        dataWindowForTile (int dx, int dy,
+                                           int l = 0) const;
+
+    IMF_EXPORT
+    IMATH_NAMESPACE::Box2i        dataWindowForTile (int dx, int dy,
+                                           int lx, int ly) const;
+
+    //------------------------------------------------------------------
+    // Write pixel data:
+    //
+    // writeTile(dx, dy, lx, ly) writes the tile with tile
+    // coordinates (dx, dy), and level number (lx, ly) to
+    // the file.
+    //
+    //   dx must lie in the interval [0, numXTiles(lx) - 1]
+    //   dy must lie in the interval [0, numYTiles(ly) - 1]
+    //
+    //   lx must lie in the interval [0, numXLevels() - 1]
+    //   ly must lie in the inverval [0, numYLevels() - 1]
+    //
+    // writeTile(dx, dy, level) is a convenience function
+    // used for ONE_LEVEL and MIPMAP_LEVEL files.  It calls
+    // writeTile(dx, dy, level, level).
+    //
+    // The two writeTiles(dx1, dx2, dy1, dy2, ...) functions allow
+    // writing multiple tiles at once.  If multi-threading is used
+    // multiple tiles are written concurrently.  The tile coordinates,
+    // dx1, dx2 and dy1, dy2, specify inclusive ranges of tile
+    // coordinates.  It is valid for dx1 < dx2 or dy1 < dy2; the
+    // tiles are always written in the order specified by the line
+    // order attribute.  Hence, it is not possible to specify an
+    // "invalid" or empty tile range.
+    //
+    // Pixels that are outside the pixel coordinate range for the tile's
+    // level, are never accessed by writeTile().
+    //
+    // Each tile in the file must be written exactly once.
+    //
+    // The file's line order attribute determines the order of the tiles
+    // in the file:
+    //
+    //   INCREASING_Y   In the file, the tiles for each level are stored
+    //                  in a contiguous block.  The levels are ordered
+    //                  like this:
+    //
+    //                      (0, 0)   (1, 0)   ... (nx-1, 0)
+    //                      (0, 1)   (1, 1)   ... (nx-1, 1)
+    //                       ...
+    //                      (0,ny-1) (1,ny-1) ... (nx-1,ny-1)
+    //
+    //                  where nx = numXLevels(), and ny = numYLevels().
+    //                  In an individual level, (lx, ly), the tiles
+    //                  are stored in the following order:
+    //
+    //                      (0, 0)   (1, 0)   ... (tx-1, 0)
+    //                      (0, 1)   (1, 1)   ... (tx-1, 1)
+    //                       ...
+    //                      (0,ty-1) (1,ty-1) ... (tx-1,ty-1)
+    //
+    //                  where tx = numXTiles(lx),
+    //                  and   ty = numYTiles(ly).
+    //
+    //   DECREASING_Y   As for INCREASING_Y, the tiles for each level
+    //                  are stored in a contiguous block.  The levels
+    //                  are ordered the same way as for INCREASING_Y,
+    //                  but within an individual level, the tiles
+    //                  are stored in this order:
+    //
+    //                      (0,ty-1) (1,ty-1) ... (tx-1,ty-1)
+    //                       ...
+    //                      (0, 1)   (1, 1)   ... (tx-1, 1)
+    //                      (0, 0)   (1, 0)   ... (tx-1, 0)
+    //
+    //
+    //   RANDOM_Y       The order of the calls to writeTile() determines
+    //                  the order of the tiles in the file.
+    //
+    //------------------------------------------------------------------
+
+    IMF_EXPORT
+    void                writeTile  (int dx, int dy, int l = 0);
+    IMF_EXPORT
+    void                writeTile  (int dx, int dy, int lx, int ly);
+
+    IMF_EXPORT
+    void                writeTiles (int dx1, int dx2, int dy1, int dy2,
+                                    int lx, int ly);
+
+    IMF_EXPORT
+    void                writeTiles (int dx1, int dx2, int dy1, int dy2,
+                                    int l = 0);
+
+
+    //------------------------------------------------------------------
+    // Shortcut to copy all pixels from a TiledInputFile into this file,
+    // without uncompressing and then recompressing the pixel data.
+    // This file's header must be compatible with the TiledInputFile's
+    // header:  The two header's "dataWindow", "compression",
+    // "lineOrder", "channels", and "tiles" attributes must be the same.
+    //------------------------------------------------------------------
+
+    IMF_EXPORT
+    void                copyPixels (DeepTiledInputFile &in);
+    IMF_EXPORT
+    void                copyPixels (DeepTiledInputPart &in);
+
+
+
+    //--------------------------------------------------------------
+    // Updating the preview image:
+    //
+    // updatePreviewImage() supplies a new set of pixels for the
+    // preview image attribute in the file's header.  If the header
+    // does not contain a preview image, updatePreviewImage() throws
+    // an IEX_NAMESPACE::LogicExc.
+    //
+    // Note: updatePreviewImage() is necessary because images are
+    // often stored in a file incrementally, a few tiles at a time,
+    // while the image is being generated.  Since the preview image
+    // is an attribute in the file's header, it gets stored in the
+    // file as soon as the file is opened, but we may not know what
+    // the preview image should look like until we have written the
+    // last tile of the main image.
+    //
+    //--------------------------------------------------------------
+
+    IMF_EXPORT
+    void                updatePreviewImage (const PreviewRgba newPixels[]);
+
+
+    //-------------------------------------------------------------
+    // Break a tile -- for testing and debugging only:
+    //
+    // breakTile(dx,dy,lx,ly,p,n,c) introduces an error into the
+    // output file by writing n copies of character c, starting
+    // p bytes from the beginning of the tile with tile coordinates
+    // (dx, dy) and level number (lx, ly).
+    //
+    // Warning: Calling this function usually results in a broken
+    // image file.  The file or parts of it may not be readable,
+    // or the file may contain bad data.
+    //
+    //-------------------------------------------------------------
+
+    IMF_EXPORT
+    void                breakTile  (int dx, int dy,
+                                    int lx, int ly,
+                                    int offset,
+                                    int length,
+                                    char c);
+    struct Data;
+
+  private:
+
+    // ----------------------------------------------------------------
+    // A constructor attaches the OutputStreamMutex to the
+    // given one from MultiPartOutputFile. Set the previewPosition
+    // and lineOffsetsPosition which have been acquired from
+    // the constructor of MultiPartOutputFile as well.
+    // ----------------------------------------------------------------
+    DeepTiledOutputFile (const OutputPartData* part);
+
+    DeepTiledOutputFile (const DeepTiledOutputFile &);              // not implemented
+    DeepTiledOutputFile & operator = (const DeepTiledOutputFile &); // not implemented
+
+    void                initialize (const Header &header);
+
+    bool                isValidTile (int dx, int dy,
+                                     int lx, int ly) const;
+
+    size_t              bytesPerLineForTile (int dx, int dy,
+                                             int lx, int ly) const;
+
+    Data *              _data;
+
+
+    friend class MultiPartOutputFile;
+
+};
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif

3rdparty/openexr/IlmImf/ImfDeepTiledOutputPart.cpp

@@ -0,0 +1,250 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#include "ImfDeepTiledOutputPart.h"
+#include "ImfMultiPartOutputFile.h"
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+DeepTiledOutputPart::DeepTiledOutputPart(MultiPartOutputFile& multiPartFile, int partNumber)
+{
+    file = multiPartFile.getOutputPart<DeepTiledOutputFile>(partNumber);
+}
+
+const char *
+DeepTiledOutputPart::fileName () const
+{
+    return file->fileName();
+}
+
+
+const Header &
+DeepTiledOutputPart::header () const
+{
+    return file->header();
+}
+
+
+void
+DeepTiledOutputPart::setFrameBuffer (const DeepFrameBuffer &frameBuffer)
+{
+    file->setFrameBuffer(frameBuffer);
+}
+
+
+const DeepFrameBuffer &
+DeepTiledOutputPart::frameBuffer () const
+{
+    return file->frameBuffer();
+}
+
+
+unsigned int
+DeepTiledOutputPart::tileXSize () const
+{
+    return file->tileXSize();
+}
+
+
+unsigned int
+DeepTiledOutputPart::tileYSize () const
+{
+    return file->tileYSize();
+}
+
+
+LevelMode
+DeepTiledOutputPart::levelMode () const
+{
+    return file->levelMode();
+}
+
+
+LevelRoundingMode
+DeepTiledOutputPart::levelRoundingMode () const
+{
+    return file->levelRoundingMode();
+}
+
+
+int
+DeepTiledOutputPart::numLevels () const
+{
+    return file->numLevels();
+}
+
+
+int
+DeepTiledOutputPart::numXLevels () const
+{
+    return file->numXLevels();
+}
+
+
+int
+DeepTiledOutputPart::numYLevels () const
+{
+    return file->numYLevels();
+}
+
+
+bool
+DeepTiledOutputPart::isValidLevel (int lx, int ly) const
+{
+    return file->isValidLevel(lx, ly);
+}
+
+
+int
+DeepTiledOutputPart::levelWidth  (int lx) const
+{
+    return file->levelWidth(lx);
+}
+
+
+int
+DeepTiledOutputPart::levelHeight (int ly) const
+{
+    return file->levelHeight(ly);
+}
+
+
+int
+DeepTiledOutputPart::numXTiles (int lx) const
+{
+    return file->numXTiles(lx);
+}
+
+
+int
+DeepTiledOutputPart::numYTiles (int ly) const
+{
+    return file->numYTiles(ly);
+}
+
+
+
+IMATH_NAMESPACE::Box2i
+DeepTiledOutputPart::dataWindowForLevel (int l) const
+{
+    return file->dataWindowForLevel(l);
+}
+
+
+IMATH_NAMESPACE::Box2i
+DeepTiledOutputPart::dataWindowForLevel (int lx, int ly) const
+{
+    return file->dataWindowForLevel(lx, ly);
+}
+
+
+IMATH_NAMESPACE::Box2i
+DeepTiledOutputPart::dataWindowForTile (int dx, int dy,
+                                        int l) const
+{
+    return file->dataWindowForTile(dx, dy, l);
+}
+
+
+IMATH_NAMESPACE::Box2i
+DeepTiledOutputPart::dataWindowForTile (int dx, int dy,
+                                        int lx, int ly) const
+{
+    return file->dataWindowForTile(dx, dy, lx, ly);
+}
+
+
+void
+DeepTiledOutputPart::writeTile  (int dx, int dy, int l)
+{
+    file->writeTile(dx, dy, l);
+}
+
+
+void
+DeepTiledOutputPart::writeTile  (int dx, int dy, int lx, int ly)
+{
+    file->writeTile(dx, dy, lx, ly);
+}
+
+
+void
+DeepTiledOutputPart::writeTiles (int dx1, int dx2, int dy1, int dy2,
+                                 int lx, int ly)
+{
+    file->writeTiles(dx1, dx2, dy1, dy2, lx, ly);
+}
+
+
+void
+DeepTiledOutputPart::writeTiles (int dx1, int dx2, int dy1, int dy2,
+                                 int l)
+{
+    file->writeTiles(dx1, dx2, dy1, dy2, l);
+}
+
+
+void
+DeepTiledOutputPart::copyPixels (DeepTiledInputFile &in)
+{
+    file->copyPixels(in);
+}
+
+
+void
+DeepTiledOutputPart::copyPixels (DeepTiledInputPart &in)
+{
+    file->copyPixels(in);
+}
+
+
+void
+DeepTiledOutputPart::updatePreviewImage (const PreviewRgba newPixels[])
+{
+    file->updatePreviewImage(newPixels);
+}
+
+
+void
+DeepTiledOutputPart::breakTile  (int dx, int dy,
+                                 int lx, int ly,
+                                 int offset,
+                                 int length,
+                                 char c)
+{
+    file->breakTile(dx, dy, lx, ly, offset, length, c);
+}
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfDeepTiledOutputPart.h

@@ -0,0 +1,423 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef IMFDEEPTILEDOUTPUTPART_H_
+#define IMFDEEPTILEDOUTPUTPART_H_
+
+#include "ImfForward.h"
+#include "ImfDeepTiledInputFile.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+class DeepTiledOutputPart
+{
+  public:
+
+    IMF_EXPORT
+    DeepTiledOutputPart(MultiPartOutputFile& multiPartFile, int partNumber);
+
+    //------------------------
+    // Access to the file name
+    //------------------------
+
+    IMF_EXPORT
+    const char *        fileName () const;
+
+
+    //--------------------------
+    // Access to the file header
+    //--------------------------
+
+    IMF_EXPORT
+    const Header &      header () const;
+
+
+    //-------------------------------------------------------
+    // Set the current frame buffer -- copies the FrameBuffer
+    // object into the TiledOutputFile object.
+    //
+    // The current frame buffer is the source of the pixel
+    // data written to the file.  The current frame buffer
+    // must be set at least once before writeTile() is
+    // called.  The current frame buffer can be changed
+    // after each call to writeTile().
+    //-------------------------------------------------------
+
+    IMF_EXPORT
+    void                setFrameBuffer (const DeepFrameBuffer &frameBuffer);
+
+
+    //-----------------------------------
+    // Access to the current frame buffer
+    //-----------------------------------
+
+    IMF_EXPORT
+    const DeepFrameBuffer & frameBuffer () const;
+
+
+    //-------------------
+    // Utility functions:
+    //-------------------
+
+    //---------------------------------------------------------
+    // Multiresolution mode and tile size:
+    // The following functions return the xSize, ySize and mode
+    // fields of the file header's TileDescriptionAttribute.
+    //---------------------------------------------------------
+
+    IMF_EXPORT
+    unsigned int        tileXSize () const;
+    IMF_EXPORT
+    unsigned int        tileYSize () const;
+    IMF_EXPORT
+    LevelMode           levelMode () const;
+    IMF_EXPORT
+    LevelRoundingMode   levelRoundingMode () const;
+
+
+    //--------------------------------------------------------------------
+    // Number of levels:
+    //
+    // numXLevels() returns the file's number of levels in x direction.
+    //
+    //  if levelMode() == ONE_LEVEL:
+    //      return value is: 1
+    //
+    //  if levelMode() == MIPMAP_LEVELS:
+    //      return value is: rfunc (log (max (w, h)) / log (2)) + 1
+    //
+    //  if levelMode() == RIPMAP_LEVELS:
+    //      return value is: rfunc (log (w) / log (2)) + 1
+    //
+    //  where
+    //      w is the width of the image's data window,  max.x - min.x + 1,
+    //      y is the height of the image's data window, max.y - min.y + 1,
+    //      and rfunc(x) is either floor(x), or ceil(x), depending on
+    //      whether levelRoundingMode() returns ROUND_DOWN or ROUND_UP.
+    //
+    // numYLevels() returns the file's number of levels in y direction.
+    //
+    //  if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS:
+    //      return value is the same as for numXLevels()
+    //
+    //  if levelMode() == RIPMAP_LEVELS:
+    //      return value is: rfunc (log (h) / log (2)) + 1
+    //
+    //
+    // numLevels() is a convenience function for use with MIPMAP_LEVELS
+    // files.
+    //
+    //  if levelMode() == ONE_LEVEL or levelMode() == MIPMAP_LEVELS:
+    //      return value is the same as for numXLevels()
+    //
+    //  if levelMode() == RIPMAP_LEVELS:
+    //      an IEX_NAMESPACE::LogicExc exception is thrown
+    //
+    // isValidLevel(lx, ly) returns true if the file contains
+    // a level with level number (lx, ly), false if not.
+    //
+    //--------------------------------------------------------------------
+
+    IMF_EXPORT
+    int                 numLevels () const;
+    IMF_EXPORT
+    int                 numXLevels () const;
+    IMF_EXPORT
+    int                 numYLevels () const;
+    IMF_EXPORT
+    bool                isValidLevel (int lx, int ly) const;
+
+
+    //---------------------------------------------------------
+    // Dimensions of a level:
+    //
+    // levelWidth(lx) returns the width of a level with level
+    // number (lx, *), where * is any number.
+    //
+    //  return value is:
+    //      max (1, rfunc (w / pow (2, lx)))
+    //
+    //
+    // levelHeight(ly) returns the height of a level with level
+    // number (*, ly), where * is any number.
+    //
+    //  return value is:
+    //      max (1, rfunc (h / pow (2, ly)))
+    //
+    //---------------------------------------------------------
+
+    IMF_EXPORT
+    int                 levelWidth  (int lx) const;
+    IMF_EXPORT
+    int                 levelHeight (int ly) const;
+
+
+    //----------------------------------------------------------
+    // Number of tiles:
+    //
+    // numXTiles(lx) returns the number of tiles in x direction
+    // that cover a level with level number (lx, *), where * is
+    // any number.
+    //
+    //  return value is:
+    //      (levelWidth(lx) + tileXSize() - 1) / tileXSize()
+    //
+    //
+    // numYTiles(ly) returns the number of tiles in y direction
+    // that cover a level with level number (*, ly), where * is
+    // any number.
+    //
+    //  return value is:
+    //      (levelHeight(ly) + tileXSize() - 1) / tileXSize()
+    //
+    //----------------------------------------------------------
+
+    IMF_EXPORT
+    int                 numXTiles (int lx = 0) const;
+    IMF_EXPORT
+    int                 numYTiles (int ly = 0) const;
+
+
+    //---------------------------------------------------------
+    // Level pixel ranges:
+    //
+    // dataWindowForLevel(lx, ly) returns a 2-dimensional
+    // region of valid pixel coordinates for a level with
+    // level number (lx, ly)
+    //
+    //  return value is a Box2i with min value:
+    //      (dataWindow.min.x, dataWindow.min.y)
+    //
+    //  and max value:
+    //      (dataWindow.min.x + levelWidth(lx) - 1,
+    //       dataWindow.min.y + levelHeight(ly) - 1)
+    //
+    // dataWindowForLevel(level) is a convenience function used
+    // for ONE_LEVEL and MIPMAP_LEVELS files.  It returns
+    // dataWindowForLevel(level, level).
+    //
+    //---------------------------------------------------------
+
+    IMF_EXPORT
+    IMATH_NAMESPACE::Box2i        dataWindowForLevel (int l = 0) const;
+    IMF_EXPORT
+    IMATH_NAMESPACE::Box2i        dataWindowForLevel (int lx, int ly) const;
+
+
+    //-------------------------------------------------------------------
+    // Tile pixel ranges:
+    //
+    // dataWindowForTile(dx, dy, lx, ly) returns a 2-dimensional
+    // region of valid pixel coordinates for a tile with tile coordinates
+    // (dx,dy) and level number (lx, ly).
+    //
+    //  return value is a Box2i with min value:
+    //      (dataWindow.min.x + dx * tileXSize(),
+    //       dataWindow.min.y + dy * tileYSize())
+    //
+    //  and max value:
+    //      (dataWindow.min.x + (dx + 1) * tileXSize() - 1,
+    //       dataWindow.min.y + (dy + 1) * tileYSize() - 1)
+    //
+    // dataWindowForTile(dx, dy, level) is a convenience function
+    // used for ONE_LEVEL and MIPMAP_LEVELS files.  It returns
+    // dataWindowForTile(dx, dy, level, level).
+    //
+    //-------------------------------------------------------------------
+
+    IMF_EXPORT
+    IMATH_NAMESPACE::Box2i        dataWindowForTile (int dx, int dy,
+                                         int l = 0) const;
+
+    IMF_EXPORT
+    IMATH_NAMESPACE::Box2i        dataWindowForTile (int dx, int dy,
+                                         int lx, int ly) const;
+
+    //------------------------------------------------------------------
+    // Write pixel data:
+    //
+    // writeTile(dx, dy, lx, ly) writes the tile with tile
+    // coordinates (dx, dy), and level number (lx, ly) to
+    // the file.
+    //
+    //   dx must lie in the interval [0, numXTiles(lx) - 1]
+    //   dy must lie in the interval [0, numYTiles(ly) - 1]
+    //
+    //   lx must lie in the interval [0, numXLevels() - 1]
+    //   ly must lie in the inverval [0, numYLevels() - 1]
+    //
+    // writeTile(dx, dy, level) is a convenience function
+    // used for ONE_LEVEL and MIPMAP_LEVEL files.  It calls
+    // writeTile(dx, dy, level, level).
+    //
+    // The two writeTiles(dx1, dx2, dy1, dy2, ...) functions allow
+    // writing multiple tiles at once.  If multi-threading is used
+    // multiple tiles are written concurrently.  The tile coordinates,
+    // dx1, dx2 and dy1, dy2, specify inclusive ranges of tile
+    // coordinates.  It is valid for dx1 < dx2 or dy1 < dy2; the
+    // tiles are always written in the order specified by the line
+    // order attribute.  Hence, it is not possible to specify an
+    // "invalid" or empty tile range.
+    //
+    // Pixels that are outside the pixel coordinate range for the tile's
+    // level, are never accessed by writeTile().
+    //
+    // Each tile in the file must be written exactly once.
+    //
+    // The file's line order attribute determines the order of the tiles
+    // in the file:
+    //
+    //   INCREASING_Y   In the file, the tiles for each level are stored
+    //                  in a contiguous block.  The levels are ordered
+    //                  like this:
+    //
+    //                      (0, 0)   (1, 0)   ... (nx-1, 0)
+    //                      (0, 1)   (1, 1)   ... (nx-1, 1)
+    //                       ...
+    //                      (0,ny-1) (1,ny-1) ... (nx-1,ny-1)
+    //
+    //                  where nx = numXLevels(), and ny = numYLevels().
+    //                  In an individual level, (lx, ly), the tiles
+    //                  are stored in the following order:
+    //
+    //                      (0, 0)   (1, 0)   ... (tx-1, 0)
+    //                      (0, 1)   (1, 1)   ... (tx-1, 1)
+    //                       ...
+    //                      (0,ty-1) (1,ty-1) ... (tx-1,ty-1)
+    //
+    //                  where tx = numXTiles(lx),
+    //                  and   ty = numYTiles(ly).
+    //
+    //   DECREASING_Y   As for INCREASING_Y, the tiles for each level
+    //                  are stored in a contiguous block.  The levels
+    //                  are ordered the same way as for INCREASING_Y,
+    //                  but within an individual level, the tiles
+    //                  are stored in this order:
+    //
+    //                      (0,ty-1) (1,ty-1) ... (tx-1,ty-1)
+    //                       ...
+    //                      (0, 1)   (1, 1)   ... (tx-1, 1)
+    //                      (0, 0)   (1, 0)   ... (tx-1, 0)
+    //
+    //
+    //   RANDOM_Y       The order of the calls to writeTile() determines
+    //                  the order of the tiles in the file.
+    //
+    //------------------------------------------------------------------
+
+    IMF_EXPORT
+    void                writeTile  (int dx, int dy, int l = 0);
+    IMF_EXPORT
+    void                writeTile  (int dx, int dy, int lx, int ly);
+
+    IMF_EXPORT
+    void                writeTiles (int dx1, int dx2, int dy1, int dy2,
+                                  int lx, int ly);
+
+    IMF_EXPORT
+    void                writeTiles (int dx1, int dx2, int dy1, int dy2,
+                                  int l = 0);
+
+
+    //------------------------------------------------------------------
+    // Shortcut to copy all pixels from a TiledInputFile into this file,
+    // without uncompressing and then recompressing the pixel data.
+    // This file's header must be compatible with the TiledInputFile's
+    // header:  The two header's "dataWindow", "compression",
+    // "lineOrder", "channels", and "tiles" attributes must be the same.
+    //------------------------------------------------------------------
+
+    IMF_EXPORT
+    void                copyPixels (DeepTiledInputFile &in);
+    IMF_EXPORT
+    void                copyPixels (DeepTiledInputPart &in);
+    
+
+
+
+    //--------------------------------------------------------------
+    // Updating the preview image:
+    //
+    // updatePreviewImage() supplies a new set of pixels for the
+    // preview image attribute in the file's header.  If the header
+    // does not contain a preview image, updatePreviewImage() throws
+    // an IEX_NAMESPACE::LogicExc.
+    //
+    // Note: updatePreviewImage() is necessary because images are
+    // often stored in a file incrementally, a few tiles at a time,
+    // while the image is being generated.  Since the preview image
+    // is an attribute in the file's header, it gets stored in the
+    // file as soon as the file is opened, but we may not know what
+    // the preview image should look like until we have written the
+    // last tile of the main image.
+    //
+    //--------------------------------------------------------------
+
+    IMF_EXPORT
+    void                updatePreviewImage (const PreviewRgba newPixels[]);
+
+
+    //-------------------------------------------------------------
+    // Break a tile -- for testing and debugging only:
+    //
+    // breakTile(dx,dy,lx,ly,p,n,c) introduces an error into the
+    // output file by writing n copies of character c, starting
+    // p bytes from the beginning of the tile with tile coordinates
+    // (dx, dy) and level number (lx, ly).
+    //
+    // Warning: Calling this function usually results in a broken
+    // image file.  The file or parts of it may not be readable,
+    // or the file may contain bad data.
+    //
+    //-------------------------------------------------------------
+
+    IMF_EXPORT
+    void                breakTile  (int dx, int dy,
+                                  int lx, int ly,
+                                  int offset,
+                                  int length,
+                                  char c);
+
+  private:
+    DeepTiledOutputFile* file;
+    
+};
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif /* IMFDEEPTILEDOUTPUTPART_H_ */

3rdparty/openexr/IlmImf/ImfDoubleAttribute.cpp

@@ -43,7 +43,7 @@
 #include <ImfDoubleAttribute.h>
 
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
 
 
 template <>
@@ -54,4 +54,4 @@ DoubleAttribute::staticTypeName ()
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT 

3rdparty/openexr/IlmImf/ImfDoubleAttribute.h

@@ -43,21 +43,17 @@
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfAttribute.h>
+#include "ImfAttribute.h"
+#include "ImfExport.h"
 
-
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
-namespace Imf {
 
 
 typedef TypedAttribute<double> DoubleAttribute;
-template <> const char *DoubleAttribute::staticTypeName ();
+template <> IMF_EXPORT const char *DoubleAttribute::staticTypeName ();
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
 
-// Metrowerks compiler wants the .cpp file inlined, too
-#ifdef __MWERKS__
-#include <ImfDoubleAttribute.cpp>
-#endif
 
 #endif

3rdparty/openexr/IlmImf/ImfDwaCompressor.h

@@ -0,0 +1,219 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2009-2014 DreamWorks Animation 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 DreamWorks Animation 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDED_IMF_DWA_COMRESSOR_H
+#define INCLUDED_IMF_DWA_COMRESSOR_H
+
+//------------------------------------------------------------------------------
+//
+// class DwaCompressor -- Store lossy RGB data by quantizing DCT components.
+//
+//------------------------------------------------------------------------------
+
+#include <vector>
+#include <half.h>
+
+#include "ImfInt64.h"
+#include "ImfZip.h"
+#include "ImfChannelList.h"
+#include "ImfCompressor.h"
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+class DwaCompressor: public Compressor
+{
+  public:
+
+    enum AcCompression 
+    {
+        STATIC_HUFFMAN,
+        DEFLATE,
+    };
+
+
+    IMF_EXPORT
+    DwaCompressor (const Header &hdr, 
+                   int           maxScanLineSize,
+                   int           numScanLines,    // ideally is a multiple of 8
+                   AcCompression acCompression);
+
+    IMF_EXPORT
+    virtual ~DwaCompressor ();
+
+    IMF_EXPORT
+    virtual int numScanLines () const;
+
+    IMF_EXPORT
+    virtual OPENEXR_IMF_NAMESPACE::Compressor::Format format () const;
+
+    IMF_EXPORT
+    virtual int compress (const char *inPtr,
+                          int         inSize,
+                          int         minY,
+                          const char *&outPtr);
+
+    IMF_EXPORT
+    virtual int compressTile (const char              *inPtr,
+                              int                     inSize,
+                              IMATH_NAMESPACE::Box2i  range,
+                              const char              *&outPtr);
+
+    IMF_EXPORT
+    virtual int uncompress (const char *inPtr,
+                            int         inSize,
+                            int         minY,
+                            const char *&outPtr);
+
+    IMF_EXPORT
+    virtual int uncompressTile (const char             *inPtr,
+                                int                    inSize,
+                                IMATH_NAMESPACE::Box2i range,
+                                const char             *&outPtr);
+
+    IMF_EXPORT
+    static void initializeFuncs ();
+
+  private:
+
+    struct ChannelData;
+    struct CscChannelSet;
+    struct Classifier;
+    
+    class LossyDctDecoderBase;
+    class LossyDctDecoder;
+    class LossyDctDecoderCsc;
+
+    class LossyDctEncoderBase;
+    class LossyDctEncoder;
+    class LossyDctEncoderCsc;
+
+    enum CompressorScheme 
+    {
+        UNKNOWN = 0,
+        LOSSY_DCT,
+        RLE,
+        
+        NUM_COMPRESSOR_SCHEMES
+    };
+
+    //
+    // Per-chunk compressed data sizes, one value per chunk
+    //
+
+    enum DataSizesSingle 
+    {
+        VERSION = 0,                  // Version number:
+                                      //   0: classic
+                                      //   1: adds "end of block" to the AC RLE
+
+        UNKNOWN_UNCOMPRESSED_SIZE,    // Size of leftover data, uncompressed.
+        UNKNOWN_COMPRESSED_SIZE,      // Size of leftover data, zlib compressed.
+
+        AC_COMPRESSED_SIZE,           // AC RLE + Huffman size
+        DC_COMPRESSED_SIZE,           // DC + Deflate size
+        RLE_COMPRESSED_SIZE,          // RLE + Deflate data size
+        RLE_UNCOMPRESSED_SIZE,        // RLE'd data size 
+        RLE_RAW_SIZE,                 // Un-RLE'd data size
+
+        AC_UNCOMPRESSED_COUNT,        // AC RLE number of elements
+        DC_UNCOMPRESSED_COUNT,        // DC number of elements
+
+        AC_COMPRESSION,               // AC compression strategy
+        NUM_SIZES_SINGLE
+    };
+
+    AcCompression     _acCompression;
+
+    int               _maxScanLineSize;
+    int               _numScanLines;
+    int               _min[2], _max[2];
+
+    ChannelList                _channels;
+    std::vector<ChannelData>   _channelData;
+    std::vector<CscChannelSet> _cscSets;
+    std::vector<Classifier>    _channelRules;
+
+    char             *_packedAcBuffer;
+    size_t            _packedAcBufferSize;
+    char             *_packedDcBuffer;
+    size_t            _packedDcBufferSize;
+    char             *_rleBuffer;
+    size_t            _rleBufferSize;
+    char             *_outBuffer;
+    size_t            _outBufferSize;
+    char             *_planarUncBuffer[NUM_COMPRESSOR_SCHEMES];
+    size_t            _planarUncBufferSize[NUM_COMPRESSOR_SCHEMES];
+
+    Zip              *_zip;
+    float             _dwaCompressionLevel;
+
+    int compress (const char              *inPtr,
+                  int                     inSize,
+                  IMATH_NAMESPACE::Box2i  range,
+                  const char              *&outPtr);
+
+    int uncompress (const char             *inPtr,
+                    int                    inSize,
+                    IMATH_NAMESPACE::Box2i range,
+                    const char             *&outPtr);
+
+    void initializeBuffers (size_t&);
+    void initializeDefaultChannelRules ();
+    void initializeLegacyChannelRules ();
+
+    void relevantChannelRules( std::vector<Classifier> &) const;
+
+    //
+    // Populate our cached version of the channel data with
+    // data from the real channel list. We want to 
+    // copy over attributes, determine compression schemes
+    // releveant for the channel type, and find sets of
+    // channels to be compressed from Y'CbCr data instead 
+    // of R'G'B'.
+    //
+
+    void classifyChannels (ChannelList                  channels,
+                           std::vector<ChannelData>    &chanData, 
+                           std::vector<CscChannelSet>  &cscData);
+
+    // 
+    // Compute various buffer pointers for each channel
+    //
+
+    void setupChannelData (int minX, int minY, int maxX, int maxY);
+};
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif 

3rdparty/openexr/IlmImf/ImfEnvmap.cpp

@@ -39,15 +39,20 @@
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfEnvmap.h>
+#include "ImfEnvmap.h"
 #include "ImathFun.h"
+#include "ImfNamespace.h"
+
 #include <algorithm>
 #include <math.h>
 
 using namespace std;
-using namespace Imath;
+using namespace IMATH_NAMESPACE;
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
 
-namespace Imf {
 namespace LatLongMap {
 
 V2f	
@@ -56,8 +61,8 @@ latLong (const V3f &dir)
     float r = sqrt (dir.z * dir.z + dir.x * dir.x);
 
     float latitude = (r < abs (dir.y))?
-             acos (r / dir.length()) * sign (dir.y):
+			 acos (r / dir.length()) * sign (dir.y):
-             asin (dir.y / dir.length());
+			 asin (dir.y / dir.length());
 
     float longitude = (dir.z == 0 && dir.x == 0)? 0: atan2 (dir.x, dir.z);
 
@@ -72,24 +77,24 @@ latLong (const Box2i &dataWindow, const V2f &pixelPosition)
 
     if (dataWindow.max.y > dataWindow.min.y)
     {
-    latitude = -M_PI *
+        latitude = -1 * float(M_PI) *
-          ((pixelPosition.y  - dataWindow.min.y) /
+            ((pixelPosition.y  - dataWindow.min.y) /
-           (dataWindow.max.y - dataWindow.min.y) - 0.5f);
+            (dataWindow.max.y - dataWindow.min.y) - 0.5f);
     }
     else
     {
-    latitude = 0;
+	latitude = 0;
     }
 
     if (dataWindow.max.x > dataWindow.min.x)
     {
-    longitude = -2 * M_PI *
+	longitude = -2 * float(M_PI) *
-           ((pixelPosition.x  - dataWindow.min.x) /
+		   ((pixelPosition.x  - dataWindow.min.x) /
-            (dataWindow.max.x - dataWindow.min.x) - 0.5f);
+		    (dataWindow.max.x - dataWindow.min.x) - 0.5f);
     }
     else
     {
-    longitude = 0;
+	longitude = 0;
     }
 
     return V2f (latitude, longitude);
@@ -99,11 +104,11 @@ latLong (const Box2i &dataWindow, const V2f &pixelPosition)
 V2f
 pixelPosition (const Box2i &dataWindow, const V2f &latLong)
 {
-    float x = latLong.y / (-2 * M_PI) + 0.5f;
+    float x = latLong.y / (-2 * float(M_PI)) + 0.5f;
-    float y = latLong.x / -M_PI + 0.5f;
+    float y = latLong.x / (-1 * float(M_PI)) + 0.5f;
 
     return V2f (x * (dataWindow.max.x - dataWindow.min.x) + dataWindow.min.x,
-        y * (dataWindow.max.y - dataWindow.min.y) + dataWindow.min.y);
+		y * (dataWindow.max.y - dataWindow.min.y) + dataWindow.min.y);
 }
 
 
@@ -120,8 +125,8 @@ direction (const Box2i &dataWindow, const V2f &pixelPosition)
     V2f ll = latLong (dataWindow, pixelPosition);
 
     return V3f (sin (ll.y) * cos (ll.x),
-        sin (ll.x),
+		sin (ll.x),
-        cos (ll.y) * cos (ll.x));
+		cos (ll.y) * cos (ll.x));
 }
 
 } // namespace LatLongMap
@@ -133,7 +138,7 @@ int
 sizeOfFace (const Box2i &dataWindow)
 {
     return min ((dataWindow.max.x - dataWindow.min.x + 1),
-        (dataWindow.max.y - dataWindow.min.y + 1) / 6);
+		(dataWindow.max.y - dataWindow.min.y + 1) / 6);
 }
 
 
@@ -163,39 +168,39 @@ pixelPosition (CubeMapFace face, const Box2i &dataWindow, V2f positionInFace)
     {
       case CUBEFACE_POS_X:
 
-    pos.x = dwf.min.x + positionInFace.y;
+	pos.x = dwf.min.x + positionInFace.y;
-    pos.y = dwf.max.y - positionInFace.x;
+	pos.y = dwf.max.y - positionInFace.x;
-    break;
+	break;
 
       case CUBEFACE_NEG_X:
 
-    pos.x = dwf.max.x - positionInFace.y;
+	pos.x = dwf.max.x - positionInFace.y;
-    pos.y = dwf.max.y - positionInFace.x;
+	pos.y = dwf.max.y - positionInFace.x;
-    break;
+	break;
 
       case CUBEFACE_POS_Y:
 
-    pos.x = dwf.min.x + positionInFace.x;
+	pos.x = dwf.min.x + positionInFace.x;
-    pos.y = dwf.max.y - positionInFace.y;
+	pos.y = dwf.max.y - positionInFace.y;
-    break;
+	break;
 
       case CUBEFACE_NEG_Y:
 
-    pos.x = dwf.min.x + positionInFace.x;
+	pos.x = dwf.min.x + positionInFace.x;
-    pos.y = dwf.min.y + positionInFace.y;
+	pos.y = dwf.min.y + positionInFace.y;
-    break;
+	break;
 
       case CUBEFACE_POS_Z:
 
-    pos.x = dwf.max.x - positionInFace.x;
+	pos.x = dwf.max.x - positionInFace.x;
-    pos.y = dwf.max.y - positionInFace.y;
+	pos.y = dwf.max.y - positionInFace.y;
-    break;
+	break;
 
       case CUBEFACE_NEG_Z:
 
-    pos.x = dwf.min.x + positionInFace.x;
+	pos.x = dwf.min.x + positionInFace.x;
-    pos.y = dwf.max.y - positionInFace.y;
+	pos.y = dwf.max.y - positionInFace.y;
-    break;
+	break;
     }
 
     return pos;
@@ -204,9 +209,9 @@ pixelPosition (CubeMapFace face, const Box2i &dataWindow, V2f positionInFace)
 
 void
 faceAndPixelPosition (const V3f &direction,
-              const Box2i &dataWindow,
+		      const Box2i &dataWindow,
-              CubeMapFace &face,
+		      CubeMapFace &face,
-              V2f &pif)
+		      V2f &pif)
 {
     int sof = sizeOfFace (dataWindow);
     float absx = abs (direction.x);
@@ -215,44 +220,44 @@ faceAndPixelPosition (const V3f &direction,
 
     if (absx >= absy && absx >= absz)
     {
-    if (absx == 0)
+	if (absx == 0)
-    {
+	{
-        //
+	    //
-        // Special case - direction is (0, 0, 0)
+	    // Special case - direction is (0, 0, 0)
-        //
+	    //
 
-        face = CUBEFACE_POS_X;
+	    face = CUBEFACE_POS_X;
-        pif = V2f (0, 0);
+	    pif = V2f (0, 0);
-        return;
+	    return;
-    }
+	}
 
-    pif.x = (direction.y / absx + 1) / 2 * (sof - 1);
+	pif.x = (direction.y / absx + 1) / 2 * (sof - 1);
-    pif.y = (direction.z / absx + 1) / 2 * (sof - 1);
+	pif.y = (direction.z / absx + 1) / 2 * (sof - 1);
 
-    if (direction.x > 0)
+	if (direction.x > 0)
-        face = CUBEFACE_POS_X;
+	    face = CUBEFACE_POS_X;
-    else
+	else
-        face = CUBEFACE_NEG_X;
+	    face = CUBEFACE_NEG_X;
     }
     else if (absy >= absz)
     {
-    pif.x = (direction.x / absy + 1) / 2 * (sof - 1);
+	pif.x = (direction.x / absy + 1) / 2 * (sof - 1);
-    pif.y = (direction.z / absy + 1) / 2 * (sof - 1);
+	pif.y = (direction.z / absy + 1) / 2 * (sof - 1);
 
-    if (direction.y > 0)
+	if (direction.y > 0)
-        face = CUBEFACE_POS_Y;
+	    face = CUBEFACE_POS_Y;
-    else
+	else
-        face = CUBEFACE_NEG_Y;
+	    face = CUBEFACE_NEG_Y;
     }
     else
     {
-    pif.x = (direction.x / absz + 1) / 2 * (sof - 1);
+	pif.x = (direction.x / absz + 1) / 2 * (sof - 1);
-    pif.y = (direction.y / absz + 1) / 2 * (sof - 1);
+	pif.y = (direction.y / absz + 1) / 2 * (sof - 1);
 
-    if (direction.z > 0)
+	if (direction.z > 0)
-        face = CUBEFACE_POS_Z;
+	    face = CUBEFACE_POS_Z;
-    else
+	else
-        face = CUBEFACE_NEG_Z;
+	    face = CUBEFACE_NEG_Z;
     }
 }
 
@@ -266,12 +271,12 @@ direction (CubeMapFace face, const Box2i &dataWindow, const V2f &positionInFace)
     
     if (sof > 1)
     {
-    pos = V2f (positionInFace.x / (sof - 1) * 2 - 1,
+	pos = V2f (positionInFace.x / (sof - 1) * 2 - 1,
-           positionInFace.y / (sof - 1) * 2 - 1);
+		   positionInFace.y / (sof - 1) * 2 - 1);
     }
     else
     {
-    pos = V2f (0, 0);
+	pos = V2f (0, 0);
     }
 
     V3f dir (1, 0, 0);
@@ -280,49 +285,51 @@ direction (CubeMapFace face, const Box2i &dataWindow, const V2f &positionInFace)
     {
       case CUBEFACE_POS_X:
 
-    dir.x = 1;
+	dir.x = 1;
-    dir.y = pos.x;
+	dir.y = pos.x;
-    dir.z = pos.y;
+	dir.z = pos.y;
-    break;
+	break;
 
       case CUBEFACE_NEG_X:
 
-    dir.x = -1;
+	dir.x = -1;
-    dir.y = pos.x;
+	dir.y = pos.x;
-    dir.z = pos.y;
+	dir.z = pos.y;
-    break;
+	break;
 
       case CUBEFACE_POS_Y:
 
-    dir.x = pos.x;
+	dir.x = pos.x;
-    dir.y = 1;
+	dir.y = 1;
-    dir.z = pos.y;
+	dir.z = pos.y;
-    break;
+	break;
 
       case CUBEFACE_NEG_Y:
 
-    dir.x = pos.x;
+	dir.x = pos.x;
-    dir.y = -1;
+	dir.y = -1;
-    dir.z = pos.y;
+	dir.z = pos.y;
-    break;
+	break;
 
       case CUBEFACE_POS_Z:
 
-    dir.x = pos.x;
+	dir.x = pos.x;
-    dir.y = pos.y;
+	dir.y = pos.y;
-    dir.z = 1;
+	dir.z = 1;
-    break;
+	break;
 
       case CUBEFACE_NEG_Z:
 
-    dir.x = pos.x;
+	dir.x = pos.x;
-    dir.y = pos.y;
+	dir.y = pos.y;
-    dir.z = -1;
+	dir.z = -1;
-    break;
+	break;
     }
 
     return dir;
 }
 
 } // namespace CubeMap
-} // namespace Imf
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfEnvmap.h

@@ -73,8 +73,11 @@
 //-----------------------------------------------------------------------------
 
 #include "ImathBox.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
 
-namespace Imf {
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
 
 //--------------------------------
 // Supported environment map types
@@ -116,7 +119,8 @@ namespace LatLongMap
     // and longitude.
     //----------------------------------------------------
 
-    Imath::V2f		latLong (const Imath::V3f &direction);
+    IMF_EXPORT 
+    IMATH_NAMESPACE::V2f		latLong (const IMATH_NAMESPACE::V3f &direction);
 
 
     //--------------------------------------------------------
@@ -125,8 +129,9 @@ namespace LatLongMap
     // and longitude.
     //--------------------------------------------------------
 
-    Imath::V2f		latLong (const Imath::Box2i &dataWindow,
+    IMF_EXPORT 
-                 const Imath::V2f &pixelPosition);
+    IMATH_NAMESPACE::V2f		latLong (const IMATH_NAMESPACE::Box2i &dataWindow,
+				 const IMATH_NAMESPACE::V2f &pixelPosition);
 
 
     //-------------------------------------------------------------
@@ -134,8 +139,9 @@ namespace LatLongMap
     // longitude and latitude, into a corresponding pixel position.
     //-------------------------------------------------------------
 
-    Imath::V2f		pixelPosition (const Imath::Box2i &dataWindow,
+    IMF_EXPORT 
-                       const Imath::V2f &latLong);
+    IMATH_NAMESPACE::V2f		pixelPosition (const IMATH_NAMESPACE::Box2i &dataWindow,
+				       const IMATH_NAMESPACE::V2f &latLong);
 
 
     //-----------------------------------------------------
@@ -144,8 +150,9 @@ namespace LatLongMap
     // to pixelPosition(dw,latLong(dw,dir)).
     //-----------------------------------------------------
 
-    Imath::V2f		pixelPosition (const Imath::Box2i &dataWindow,
+    IMF_EXPORT 
-                       const Imath::V3f &direction);
+    IMATH_NAMESPACE::V2f		pixelPosition (const IMATH_NAMESPACE::Box2i &dataWindow,
+				       const IMATH_NAMESPACE::V3f &direction);
 
 
     //--------------------------------------------------------
@@ -153,8 +160,9 @@ namespace LatLongMap
     // map into a corresponding 3D direction.
     //--------------------------------------------------------
 
-    Imath::V3f		direction (const Imath::Box2i &dataWindow,
+    IMF_EXPORT 
-                   const Imath::V2f &pixelPosition);
+    IMATH_NAMESPACE::V3f		direction (const IMATH_NAMESPACE::Box2i &dataWindow,
+				   const IMATH_NAMESPACE::V2f &pixelPosition);
 }
 
 
@@ -260,7 +268,8 @@ namespace CubeMap
     // Width and height of a cube's face, in pixels
     //---------------------------------------------
 
-    int			sizeOfFace (const Imath::Box2i &dataWindow);
+    IMF_EXPORT 
+    int			sizeOfFace (const IMATH_NAMESPACE::Box2i &dataWindow);
 
 
     //------------------------------------------
@@ -268,8 +277,9 @@ namespace CubeMap
     // that is covered by the specified face.
     //------------------------------------------
 
-    Imath::Box2i	dataWindowForFace (CubeMapFace face,
+    IMF_EXPORT 
-                       const Imath::Box2i &dataWindow);
+    IMATH_NAMESPACE::Box2i	dataWindowForFace (CubeMapFace face,
+					   const IMATH_NAMESPACE::Box2i &dataWindow);
 
 
     //----------------------------------------------------
@@ -279,9 +289,10 @@ namespace CubeMap
     // in the environment map.
     //----------------------------------------------------
 
-    Imath::V2f		pixelPosition (CubeMapFace face,
+    IMF_EXPORT 
-                       const Imath::Box2i &dataWindow,
+    IMATH_NAMESPACE::V2f		pixelPosition (CubeMapFace face,
-                       Imath::V2f positionInFace);
+				       const IMATH_NAMESPACE::Box2i &dataWindow,
+				       IMATH_NAMESPACE::V2f positionInFace);
 
 
     //--------------------------------------------------------------
@@ -300,10 +311,11 @@ namespace CubeMap
     //
     //--------------------------------------------------------------
 
-    void		faceAndPixelPosition (const Imath::V3f &direction,
+    IMF_EXPORT 
-                          const Imath::Box2i &dataWindow,
+    void		faceAndPixelPosition (const IMATH_NAMESPACE::V3f &direction,
-                          CubeMapFace &face,
+					      const IMATH_NAMESPACE::Box2i &dataWindow,
-                          Imath::V2f &positionInFace);
+					      CubeMapFace &face,
+					      IMATH_NAMESPACE::V2f &positionInFace);
 
    
     // --------------------------------------------------------
@@ -311,12 +323,14 @@ namespace CubeMap
     // compute the corresponding 3D direction.
     // --------------------------------------------------------
 
-    Imath::V3f		direction (CubeMapFace face,
+    IMF_EXPORT 
-                   const Imath::Box2i &dataWindow,
+    IMATH_NAMESPACE::V3f		direction (CubeMapFace face,
-                   const Imath::V2f &positionInFace);
+				   const IMATH_NAMESPACE::Box2i &dataWindow,
+				   const IMATH_NAMESPACE::V2f &positionInFace);
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
 
 #endif

3rdparty/openexr/IlmImf/ImfEnvmapAttribute.cpp

@@ -42,8 +42,9 @@
 #include <ImfEnvmapAttribute.h>
 
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
 
+using namespace OPENEXR_IMF_INTERNAL_NAMESPACE;
 
 template <>
 const char *
@@ -55,7 +56,7 @@ EnvmapAttribute::staticTypeName ()
 
 template <>
 void
-EnvmapAttribute::writeValueTo (OStream &os, int) const
+EnvmapAttribute::writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, int version) const
 {
     unsigned char tmp = _value;
     Xdr::write <StreamIO> (os, tmp);
@@ -64,7 +65,7 @@ EnvmapAttribute::writeValueTo (OStream &os, int) const
 
 template <>
 void
-EnvmapAttribute::readValueFrom (IStream &is, int, int)
+EnvmapAttribute::readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int size, int version)
 {
     unsigned char tmp;
     Xdr::read <StreamIO> (is, tmp);
@@ -72,4 +73,4 @@ EnvmapAttribute::readValueFrom (IStream &is, int, int)
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT 

3rdparty/openexr/IlmImf/ImfEnvmapAttribute.h

@@ -42,24 +42,27 @@
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfAttribute.h>
+#include "ImfAttribute.h"
-#include <ImfEnvmap.h>
+#include "ImfEnvmap.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
-namespace Imf {
+typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::Envmap> EnvmapAttribute;
+
+template <> IMF_EXPORT const char *EnvmapAttribute::staticTypeName ();
+
+template <> IMF_EXPORT
+void EnvmapAttribute::writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &,
+                                    int) const;
+
+template <> IMF_EXPORT
+void EnvmapAttribute::readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &,
+                                     int,
+                                     int);
 
 
-typedef TypedAttribute<Envmap> EnvmapAttribute;
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
-template <> const char *EnvmapAttribute::staticTypeName ();
-template <> void EnvmapAttribute::writeValueTo (OStream &, int) const;
-template <> void EnvmapAttribute::readValueFrom (IStream &, int, int);
-
-
-} // namespace Imf
-
-// Metrowerks compiler wants the .cpp file inlined, too
-#ifdef __MWERKS__
-#include <ImfEnvmapAttribute.cpp>
-#endif
 
 #endif

3rdparty/openexr/IlmImf/ImfExport.h

@@ -0,0 +1,46 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2012, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#if defined(OPENEXR_DLL)
+    #if defined(ILMIMF_EXPORTS)
+	    #define IMF_EXPORT __declspec(dllexport)
+        #define IMF_EXPORT_CONST extern __declspec(dllexport)
+    #else
+	    #define IMF_EXPORT __declspec(dllimport)
+	    #define IMF_EXPORT_CONST extern __declspec(dllimport)
+    #endif
+#else
+    #define IMF_EXPORT
+    #define IMF_EXPORT_CONST extern const
+#endif

3rdparty/openexr/IlmImf/ImfFastHuf.cpp

@@ -0,0 +1,768 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2009-2014 DreamWorks Animation 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 DreamWorks Animation 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#include "ImfFastHuf.h"
+#include <Iex.h>
+
+#include <string.h>
+#include <assert.h>
+#include <math.h>
+#include <vector>
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+//
+// Adapted from hufUnpackEncTable - 
+// We don't need to reconstruct the code book, just the encoded
+// lengths for each symbol. From the lengths, we can build the
+// base + offset tables. This should be a bit more efficient
+// for sparse code books.
+// 
+//   table     - ptr to the start of the code length data. Will be
+//               updated as we decode data
+//
+//   numBytes  - size of the encoded table (I think)?
+//
+//   minSymbol - smallest symbol in the code book
+//
+//   maxSymbol - largest symbol in the code book. 
+//
+//   rleSymbol - the symbol to trigger RLE in the encoded bitstream
+//
+
+FastHufDecoder::FastHufDecoder
+    (const char *&table,
+     int numBytes,
+     int minSymbol,
+     int maxSymbol,
+     int rleSymbol)
+:
+    _rleSymbol (rleSymbol),
+    _numSymbols (0),
+    _minCodeLength (255),
+    _maxCodeLength (0),
+    _idToSymbol (0)
+{
+    //
+    // List of symbols that we find with non-zero code lengths
+    // (listed in the order we find them). Store these in the
+    // same format as the code book stores codes + lengths - 
+    // low 6 bits are the length, everything above that is
+    // the symbol.
+    //
+
+    std::vector<Int64> symbols;
+
+    //
+    // The 'base' table is the minimum code at each code length. base[i]
+    // is the smallest code (numerically) of length i.
+    //
+
+    Int64 base[MAX_CODE_LEN + 1];     
+
+    //
+    // The 'offset' table is the position (in sorted order) of the first id
+    // of a given code lenght. Array is indexed by code length, like base.  
+    //
+
+    Int64 offset[MAX_CODE_LEN + 1];   
+
+    //
+    // Count of how many codes at each length there are. Array is 
+    // indexed by code length, like base and offset.
+    //
+
+    size_t codeCount[MAX_CODE_LEN + 1];    
+
+    for (int i = 0; i <= MAX_CODE_LEN; ++i)
+    {
+        codeCount[i] = 0;
+        base[i]      = 0xffffffffffffffffULL;
+        offset[i]    = 0;
+    }
+
+    //
+    // Count the number of codes, the min/max code lengths, the number of
+    // codes with each length, and record symbols with non-zero code
+    // length as we find them.
+    //
+
+    const char *currByte     = table;
+    Int64       currBits     = 0;
+    int         currBitCount = 0;
+
+    const int SHORT_ZEROCODE_RUN = 59;
+    const int LONG_ZEROCODE_RUN  = 63;
+    const int SHORTEST_LONG_RUN  = 2 + LONG_ZEROCODE_RUN - SHORT_ZEROCODE_RUN;
+
+    for (Int64 symbol = minSymbol; symbol <= maxSymbol; symbol++)
+    {
+        if (currByte - table > numBytes)
+        {
+            throw IEX_NAMESPACE::InputExc ("Error decoding Huffman table "
+                                           "(Truncated table data).");
+        }
+
+        //
+        // Next code length - either:
+        //       0-58  (literal code length)
+        //       59-62 (various lengths runs of 0)
+        //       63    (run of n 0's, with n is the next 8 bits)
+        //
+
+        Int64 codeLen = readBits (6, currBits, currBitCount, currByte);
+
+        if (codeLen == (Int64) LONG_ZEROCODE_RUN)
+        {
+            if (currByte - table > numBytes)
+            {
+                throw IEX_NAMESPACE::InputExc ("Error decoding Huffman table "
+                                               "(Truncated table data).");
+            }
+
+            int runLen = readBits (8, currBits, currBitCount, currByte) +
+                         SHORTEST_LONG_RUN;
+
+            if (symbol + runLen > maxSymbol + 1)
+            {
+                throw IEX_NAMESPACE::InputExc ("Error decoding Huffman table "
+                                               "(Run beyond end of table).");
+            }
+            
+            symbol += runLen - 1;
+
+        }
+        else if (codeLen >= (Int64) SHORT_ZEROCODE_RUN)
+        {
+            int runLen = codeLen - SHORT_ZEROCODE_RUN + 2;
+
+            if (symbol + runLen > maxSymbol + 1)
+            {
+                throw IEX_NAMESPACE::InputExc ("Error decoding Huffman table "
+                                               "(Run beyond end of table).");
+            }
+
+            symbol += runLen - 1;
+
+        }
+        else if (codeLen != 0)
+        {
+            symbols.push_back ((symbol << 6) | (codeLen & 63));
+
+            if (codeLen < _minCodeLength)
+                _minCodeLength = codeLen;
+
+            if (codeLen > _maxCodeLength)
+                _maxCodeLength = codeLen;
+
+            codeCount[codeLen]++;
+        }
+    }
+
+    for (int i = 0; i < MAX_CODE_LEN; ++i)
+        _numSymbols += codeCount[i];
+
+    table = currByte;
+
+    //
+    // Compute base - once we have the code length counts, there
+    //                is a closed form solution for this
+    //
+
+    {
+        double* countTmp = new double[_maxCodeLength+1];
+
+        for (int l = _minCodeLength; l <= _maxCodeLength; ++l)
+        {
+            countTmp[l] = (double)codeCount[l] * 
+                          (double)(2 << (_maxCodeLength-l));
+        }
+    
+        for (int l = _minCodeLength; l <= _maxCodeLength; ++l)
+        {
+            double tmp = 0;
+
+            for (int k =l + 1; k <= _maxCodeLength; ++k)
+                tmp += countTmp[k];
+            
+            tmp /= (double)(2 << (_maxCodeLength - l));
+
+            base[l] = (Int64)ceil (tmp);
+        }
+
+        delete [] countTmp;
+    }
+   
+    //
+    // Compute offset - these are the positions of the first
+    //                  id (not symbol) that has length [i]
+    //
+
+    offset[_maxCodeLength] = 0;
+
+    for (int i= _maxCodeLength - 1; i >= _minCodeLength; i--)
+        offset[i] = offset[i + 1] + codeCount[i + 1];
+
+    //
+    // Allocate and fill the symbol-to-id mapping. Smaller Ids should be
+    // mapped to less-frequent symbols (which have longer codes). Use
+    // the offset table to tell us where the id's for a given code 
+    // length start off.
+    //
+
+    _idToSymbol = new int[_numSymbols];
+
+    Int64 mapping[MAX_CODE_LEN + 1];
+    for (int i = 0; i < MAX_CODE_LEN + 1; ++i) 
+        mapping[i] = -1;
+    for (int i = _minCodeLength; i <= _maxCodeLength; ++i)
+        mapping[i] = offset[i];
+
+    for (std::vector<Int64>::const_iterator i = symbols.begin(); 
+         i != symbols.end();
+         ++i)
+    {
+        int codeLen = *i & 63;
+        int symbol  = *i >> 6;
+
+        if (mapping[codeLen] >= _numSymbols)
+            throw IEX_NAMESPACE::InputExc ("Huffman decode error "
+                                           "(Invalid symbol in header).");
+        
+        _idToSymbol[mapping[codeLen]] = symbol;
+        mapping[codeLen]++;
+    }
+
+    buildTables(base, offset);
+}
+
+
+FastHufDecoder::~FastHufDecoder()
+{
+    delete[] _idToSymbol;
+}
+
+
+//
+// Static check if the decoder is enabled.
+//
+// ATM, I only have access to little endian hardware for testing,
+// so I'm not entirely sure that we are reading fom the bit stream
+// properly on BE. 
+//
+// If you happen to have more obscure hardware, check that the 
+// byte swapping in refill() is happening sensable, add an endian 
+// check if needed, and fix the preprocessor magic here.
+//
+
+#define READ64(c) \
+    ((Int64)(c)[0] << 56) | ((Int64)(c)[1] << 48) | ((Int64)(c)[2] << 40) | \
+    ((Int64)(c)[3] << 32) | ((Int64)(c)[4] << 24) | ((Int64)(c)[5] << 16) | \
+    ((Int64)(c)[6] <<  8) | ((Int64)(c)[7] ) 
+
+#ifdef __INTEL_COMPILER // ICC built-in swap for LE hosts
+    #if defined (__i386__) || defined(__x86_64__)
+        #undef  READ64
+        #define READ64(c) _bswap64 (*(const Int64*)(c))
+    #endif
+#endif
+
+
+bool
+FastHufDecoder::enabled()
+{
+    #if defined(__INTEL_COMPILER) || defined(__GNUC__)  
+
+        //
+        // Enabled for ICC, GCC:
+        //       __i386__   -> x86
+        //       __x86_64__ -> 64-bit x86
+        //
+
+        #if defined (__i386__) || defined(__x86_64__)
+            return true;
+        #else
+            return false;
+        #endif
+
+    #elif defined (_MSC_VER)
+
+        //
+        // Enabled for Visual Studio:
+        //        _M_IX86 -> x86
+        //        _M_X64  -> 64bit x86
+
+        #if defined (_M_IX86) || defined(_M_X64)
+            return true;
+        #else
+            return false;
+        #endif
+
+    #else
+
+        //
+        // Unknown compiler - Be safe and disable.
+        //
+        return false;
+    #endif
+}
+
+//
+//
+// Built the acceleration tables for lookups on the upper bits
+// as well as the 'LJ' tables.
+//
+
+void
+FastHufDecoder::buildTables (Int64 *base, Int64 *offset)
+{
+    //
+    // Build the 'left justified' base table, by shifting base left..
+    //
+
+    for (int i = 0; i <= MAX_CODE_LEN; ++i)
+    {
+        if (base[i] != 0xffffffffffffffffULL)
+        {
+            _ljBase[i] = base[i] << (64 - i);
+        }
+        else
+        {
+            //
+            // Unused code length - insert dummy values
+            //
+
+            _ljBase[i] = 0xffffffffffffffffULL;
+        }
+    }
+
+    //
+    // Combine some terms into a big fat constant, which for
+    // lack of a better term we'll call the 'left justified' 
+    // offset table (because it serves the same function
+    // as 'offset', when using the left justified base table.
+    //
+
+    for (int i = 0; i <= MAX_CODE_LEN; ++i)
+        _ljOffset[i] = offset[i] - (_ljBase[i] >> (64 - i));
+
+    //
+    // Build the acceleration tables for the lookups of
+    // short codes ( <= TABLE_LOOKUP_BITS long)
+    //
+
+    for (Int64 i = 0; i < 1 << TABLE_LOOKUP_BITS; ++i)
+    {
+        Int64 value = i << (64 - TABLE_LOOKUP_BITS);
+
+        _tableSymbol[i]  = 0xffff;
+        _tableCodeLen[i] = 0; 
+
+        for (int codeLen = _minCodeLength; codeLen <= _maxCodeLength; ++codeLen)
+        {
+            if (_ljBase[codeLen] <= value)
+            {
+                _tableCodeLen[i] = codeLen;
+
+                Int64 id = _ljOffset[codeLen] + (value >> (64 - codeLen));
+                if (id < _numSymbols)
+                {
+                    _tableSymbol[i] = _idToSymbol[id];
+                }
+                else
+                {
+                    throw IEX_NAMESPACE::InputExc ("Huffman decode error "
+                                                   "(Overrun).");
+                }
+                break;
+            }
+        }
+    }
+
+    //
+    // Store the smallest value in the table that points to real data.
+    // This should be the entry for the largest length that has 
+    // valid data (in our case, non-dummy _ljBase)
+    //
+
+    int minIdx = TABLE_LOOKUP_BITS;
+
+    while (minIdx > 0 && _ljBase[minIdx] == 0xffffffffffffffffULL)
+        minIdx--;
+
+    if (minIdx < 0)
+    {
+        //
+        // Error, no codes with lengths 0-TABLE_LOOKUP_BITS used.
+        // Set the min value such that the table is never tested.
+        //
+
+        _tableMin = 0xffffffffffffffffULL;
+    }
+    else
+    {
+        _tableMin = _ljBase[minIdx];
+    }
+}
+
+
+// 
+// For decoding, we're holding onto 2 Int64's. 
+//
+// The first (buffer), holds the next bits from the bitstream to be 
+// decoded. For certain paths in the decoder, we only need TABLE_LOOKUP_BITS
+// valid bits to decode the next symbol. For other paths, we need a full
+// 64-bits to decode a symbol. 
+//
+// When we need to refill 'buffer', we could pull bits straight from 
+// the bitstream. But this is very slow and requires lots of book keeping
+// (what's the next bit in the next byte?). Instead, we keep another Int64
+// around that we use to refill from. While this doesn't cut down on the
+// book keeping (still need to know how many valid bits), it does cut
+// down on some of the bit shifting crazy and byte access. 
+//
+// The refill Int64 (bufferBack) gets left-shifted after we've pulled
+// off bits. If we run out of bits in the input bit stream, we just
+// shift in 0's to bufferBack. 
+//
+// The refill act takes numBits from the top of bufferBack and sticks
+// them in the bottom of buffer. If there arn't enough bits in bufferBack,
+// it gets refilled (to 64-bits) from the input bitstream.
+//
+
+inline void
+FastHufDecoder::refill
+    (Int64 &buffer,
+     int numBits,                       // number of bits to refill
+     Int64 &bufferBack,                 // the next 64-bits, to refill from
+     int &bufferBackNumBits,            // number of bits left in bufferBack
+     const unsigned char *&currByte,    // current byte in the bitstream
+     int &currBitsLeft)                 // number of bits left in the bitsream
+{
+    // 
+    // Refill bits into the bottom of buffer, from the top of bufferBack.
+    // Always top up buffer to be completely full.
+    //
+
+    buffer |= bufferBack >> (64 - numBits);
+
+    if (bufferBackNumBits < numBits)
+    {
+        numBits -= bufferBackNumBits;
+
+        // 
+        // Refill all of bufferBack from the bitstream. Either grab
+        // a full 64-bit chunk, or whatever bytes are left. If we
+        // don't have 64-bits left, pad with 0's.
+        //
+
+        if (currBitsLeft >= 64)
+        {
+            bufferBack        = READ64 (currByte); 
+            bufferBackNumBits = 64;
+            currByte         += sizeof (Int64);
+            currBitsLeft     -= 8 * sizeof (Int64);
+
+        }
+        else
+        {
+            bufferBack        = 0;
+            bufferBackNumBits = 64; 
+
+            Int64 shift = 56;
+            
+            while (currBitsLeft > 0)
+            {
+                bufferBack |= ((Int64)(*currByte)) << shift;
+
+                currByte++;
+                shift        -= 8;
+                currBitsLeft -= 8;
+            }
+
+            //
+            // At this point, currBitsLeft might be negative, just because
+            // we're subtracting whole bytes. To keep anyone from freaking
+            // out, zero the counter.
+            //
+
+            if (currBitsLeft < 0)
+                currBitsLeft = 0;
+        }
+
+        buffer |= bufferBack >> (64 - numBits);
+    }
+    
+    bufferBack         = bufferBack << numBits;
+    bufferBackNumBits -= numBits;
+
+    // 
+    // We can have cases where the previous shift of bufferBack is << 64 - 
+    // in which case no shift occurs. The bit count math still works though,
+    // so if we don't have any bits left, zero out bufferBack.
+    //
+
+    if (bufferBackNumBits == 0)
+        bufferBack = 0;
+}
+
+//
+// Read the next few bits out of a bitstream. Will be given a backing buffer
+// (buffer) that may still have data left over from previous reads
+// (bufferNumBits).  Bitstream pointer (currByte) will be advanced when needed.
+//
+
+inline Int64 
+FastHufDecoder::readBits
+    (int numBits,
+     Int64 &buffer,             // c
+     int &bufferNumBits,        // lc
+     const char *&currByte)     // in
+{
+    while (bufferNumBits < numBits)
+    {
+        buffer = (buffer << 8) | *(unsigned char*)(currByte++);
+        bufferNumBits += 8;
+    }
+
+    bufferNumBits -= numBits;
+    return (buffer >> bufferNumBits) & ((1 << numBits) - 1);
+}
+
+
+//
+// Decode using a the 'One-Shift' strategy for decoding, with a 
+// small-ish table to accelerate decoding of short codes.
+//
+// If possible, try looking up codes into the acceleration table.
+// This has a few benifits - there's no search involved; We don't
+// need an additional lookup to map id to symbol; we don't need
+// a full 64-bits (so less refilling). 
+//
+
+void
+FastHufDecoder::decode
+    (const unsigned char *src,
+     int numSrcBits,
+     unsigned short *dst, 
+     int numDstElems)
+{
+    if (numSrcBits < 128)
+        throw IEX_NAMESPACE::InputExc ("Error choosing Huffman decoder implementation "
+                                       "(insufficient number of bits).");
+
+    //
+    // Current position (byte/bit) in the src data stream
+    // (after the first buffer fill)
+    //
+
+    const unsigned char *currByte = src + 2 * sizeof (Int64);
+
+    numSrcBits -= 8 * 2 * sizeof (Int64);
+
+    //
+    // 64-bit buffer holding the current bits in the stream
+    //
+
+    Int64 buffer            = READ64 (src); 
+    int   bufferNumBits     = 64;
+
+    //
+    // 64-bit buffer holding the next bits in the stream
+    //
+
+    Int64 bufferBack        = READ64 ((src + sizeof (Int64))); 
+    int   bufferBackNumBits = 64;
+
+    int dstIdx = 0;
+
+    while (dstIdx < numDstElems)
+    {
+        int  codeLen;
+        int  symbol;
+
+        //
+        // Test if we can be table accelerated. If so, directly
+        // lookup the output symbol. Otherwise, we need to fall
+        // back to searching for the code.
+        //
+        // If we're doing table lookups, we don't really need
+        // a re-filled buffer, so long as we have TABLE_LOOKUP_BITS
+        // left. But for a search, we do need a refilled table.
+        //
+
+        if (_tableMin <= buffer)
+        {
+            int tableIdx = buffer >> (64 - TABLE_LOOKUP_BITS);
+
+            // 
+            // For invalid codes, _tableCodeLen[] should return 0. This
+            // will cause the decoder to get stuck in the current spot
+            // until we run out of elements, then barf that the codestream
+            // is bad.  So we don't need to stick a condition like
+            //     if (codeLen > _maxCodeLength) in this inner.
+            //
+
+            codeLen = _tableCodeLen[tableIdx];
+            symbol  = _tableSymbol[tableIdx];
+        }
+        else
+        {
+            if (bufferNumBits < 64)
+            {
+                refill (buffer,
+                        64 - bufferNumBits,
+                        bufferBack,
+                        bufferBackNumBits,
+                        currByte,
+                        numSrcBits);
+
+                bufferNumBits = 64;
+            }
+
+            // 
+            // Brute force search: 
+            // Find the smallest length where _ljBase[length] <= buffer
+            //
+
+            codeLen = TABLE_LOOKUP_BITS + 1;
+
+            while (_ljBase[codeLen] > buffer && codeLen <= _maxCodeLength)
+                codeLen++;
+
+            if (codeLen > _maxCodeLength)
+            {
+                throw IEX_NAMESPACE::InputExc ("Huffman decode error "
+                                               "(Decoded an invalid symbol).");
+            }
+
+            Int64 id = _ljOffset[codeLen] + (buffer >> (64 - codeLen));
+            if (id < _numSymbols)
+            {
+                symbol = _idToSymbol[id];
+            }
+            else
+            {
+                throw IEX_NAMESPACE::InputExc ("Huffman decode error "
+                                               "(Decoded an invalid symbol).");
+            }
+        }
+
+        //
+        // Shift over bit stream, and update the bit count in the buffer
+        //
+
+        buffer = buffer << codeLen;
+        bufferNumBits -= codeLen;
+
+        //
+        // If we recieved a RLE symbol (_rleSymbol), then we need
+        // to read ahead 8 bits to know how many times to repeat
+        // the previous symbol. Need to ensure we at least have
+        // 8 bits of data in the buffer
+        //
+
+        if (symbol == _rleSymbol)
+        {
+            if (bufferNumBits < 8)
+            {
+                refill (buffer,
+                        64 - bufferNumBits,
+                        bufferBack,
+                        bufferBackNumBits,
+                        currByte,
+                        numSrcBits);
+
+                bufferNumBits = 64;
+            }
+
+            int rleCount = buffer >> 56;
+
+            if (dstIdx < 1)
+            {
+                throw IEX_NAMESPACE::InputExc ("Huffman decode error (RLE code "
+                                               "with no previous symbol).");
+            }
+
+            if (dstIdx + rleCount > numDstElems)
+            {
+                throw IEX_NAMESPACE::InputExc ("Huffman decode error (Symbol run "
+                                               "beyond expected output buffer length).");
+            }
+
+            if (rleCount <= 0) 
+            {
+                throw IEX_NAMESPACE::InputExc("Huffman decode error"
+                                              " (Invalid RLE length)");
+            }
+
+            for (int i = 0; i < rleCount; ++i)
+                dst[dstIdx + i] = dst[dstIdx - 1];
+
+            dstIdx += rleCount;
+
+            buffer = buffer << 8;
+            bufferNumBits -= 8;
+        }
+        else
+        {
+            dst[dstIdx] = symbol;
+            dstIdx++;
+        }
+
+        //
+        // refill bit stream buffer if we're below the number of 
+        // bits needed for a table lookup
+        //
+
+        if (bufferNumBits < TABLE_LOOKUP_BITS)
+        {
+            refill (buffer,
+                    64 - bufferNumBits,
+                    bufferBack,
+                    bufferBackNumBits,
+                    currByte,
+                    numSrcBits);
+
+            bufferNumBits = 64;
+        }
+    }
+
+    if (numSrcBits != 0)
+    {
+        throw IEX_NAMESPACE::InputExc ("Huffman decode error (Compressed data remains "
+                                       "after filling expected output buffer).");
+    }
+}
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfFastHuf.h

@@ -0,0 +1,153 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2009-2014 DreamWorks Animation 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 DreamWorks Animation 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDED_IMF_FAST_HUF_H
+#define INCLUDED_IMF_FAST_HUF_H
+
+#include "ImfInt64.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+//
+// Alternative Canonical Huffman decoder:
+//
+// Canonical Huffman decoder based on 'On the Implementation of Minimum
+// Redundancy Prefix Codes' by Moffat and Turpin - highly recommended
+// reading as a good description of the problem space, as well as 
+// a fast decoding algorithm.
+//
+// The premise is that instead of working directly with the coded 
+// symbols, we create a new ordering based on the frequency of symbols.
+// Less frequent symbols (and thus longer codes) are ordered earler.
+// We're calling the values in this ordering 'Ids', as oppsed to 
+// 'Symbols' - which are the short values we eventually want decoded.
+//
+// With this new ordering, a few small tables can be derived ('base' 
+// and 'offset') which drive the decoding. To cut down on the 
+// linear scanning of these tables, you can add a small table
+// to directly look up short codes (as you might in a traditional
+// lookup-table driven decoder). 
+//
+// The decoder is meant to be compatible with the encoder (and decoder)
+// in ImfHuf.cpp, just faster. For ease of implementation, this decoder
+// should only be used on compressed bitstreams >= 128 bits long.
+//
+
+class FastHufDecoder
+{
+  public:
+
+    //
+    // Longest compressed code length that ImfHuf supports (58 bits)
+    //
+
+    static const int MAX_CODE_LEN = 58;
+
+    //
+    // Number of bits in our acceleration table. Should match all
+    // codes up to TABLE_LOOKUP_BITS in length.
+    //
+
+    static const int TABLE_LOOKUP_BITS = 12;
+
+    IMF_EXPORT
+    FastHufDecoder (const char*& table,
+                    int numBytes,
+                    int minSymbol,
+                    int maxSymbol,
+                    int rleSymbol);
+
+    IMF_EXPORT
+    ~FastHufDecoder ();
+
+    IMF_EXPORT
+    static bool enabled ();
+
+    IMF_EXPORT
+    void decode (const unsigned char *src,
+                 int numSrcBits,
+                 unsigned short *dst,
+                 int numDstElems);
+
+  private:
+
+    void  buildTables (Int64*, Int64*);
+    void  refill (Int64&, int, Int64&, int&, const unsigned char *&, int&);
+    Int64 readBits (int, Int64&, int&, const char *&);
+
+    int             _rleSymbol;        // RLE symbol written by the encoder.
+                                       // This could be 65536, so beware
+                                       // when you use shorts to hold things.
+
+    int             _numSymbols;       // Number of symbols in the codebook.
+
+    unsigned char   _minCodeLength;    // Minimum code length, in bits.
+    unsigned char   _maxCodeLength;    // Maximum code length, in bits.
+
+    int            *_idToSymbol;       // Maps Ids to symbols. Ids are a symbol
+                                       // ordering sorted first in terms of 
+                                       // code length, and by code within
+                                       // the same length. Ids run from 0
+                                       // to mNumSymbols-1.
+
+    Int64 _ljBase[MAX_CODE_LEN + 1];   // the 'left justified base' table.
+                                       // Takes base[i] (i = code length)
+                                       // and 'left justifies' it into an Int64
+
+    Int64 _ljOffset[MAX_CODE_LEN +1 ]; // There are some other terms that can 
+                                       // be folded into constants when taking
+                                       // the 'left justified' decode path. This
+                                       // holds those constants, indexed by
+                                       // code length
+
+    //
+    // We can accelerate the 'left justified' processing by running the
+    // top TABLE_LOOKUP_BITS through a LUT, to find the symbol and code
+    // length. These are those acceleration tables.
+    //
+    // Even though our evental 'symbols' are ushort's, the encoder adds
+    // a symbol to indicate RLE. So with a dense code book, we could
+    // have 2^16+1 codes, so both mIdToSymbol and mTableSymbol need
+    // to be bigger than 16 bits.
+    //
+
+    int            _tableSymbol[1 << TABLE_LOOKUP_BITS];
+    unsigned char  _tableCodeLen[1 << TABLE_LOOKUP_BITS];
+    Int64          _tableMin;
+};
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif 

3rdparty/openexr/IlmImf/ImfFloatAttribute.cpp

@@ -43,7 +43,7 @@
 #include <ImfFloatAttribute.h>
 
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
 
 
 template <>
@@ -54,4 +54,4 @@ FloatAttribute::staticTypeName ()
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT 

3rdparty/openexr/IlmImf/ImfFloatAttribute.h

@@ -43,21 +43,16 @@
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfAttribute.h>
+#include "ImfAttribute.h"
 
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
 typedef TypedAttribute<float> FloatAttribute;
-template <> const char *FloatAttribute::staticTypeName ();
+template <> IMF_EXPORT const char *FloatAttribute::staticTypeName ();
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
-
-// Metrowerks compiler wants the .cpp file inlined, too
-#ifdef __MWERKS__
-#include <ImfFloatAttribute.cpp>
-#endif
 
 #endif

3rdparty/openexr/IlmImf/ImfFloatVectorAttribute.cpp

@@ -1,6 +1,6 @@
 ///////////////////////////////////////////////////////////////////////////
 //
-// Copyright (c) 2006, Industrial Light & Magic, a division of Lucas
+// Copyright (c) 2013, Industrial Light & Magic, a division of Lucas
 // Digital Ltd. LLC
 // 
 // All rights reserved.
@@ -32,105 +32,53 @@
 //
 ///////////////////////////////////////////////////////////////////////////
 
-//---------------------------------------------------------------------------
-//
-//	b44ExpLogTable
-//
-//	A program to generate lookup tables for
-//
-//		y = exp (x / 8)
-//
-//	and
-//		x = 8 * log (x);
-//
-//	where x and y are 16-bit floating-point numbers
-//
-//	The tables are used by class B44Compressor.
-//
-//---------------------------------------------------------------------------
 
-#include <half.h>
+//-----------------------------------------------------------------------------
-#include <math.h>
+//
-#include <iostream>
+//	class FloatVectorAttribute
-#include <iomanip>
+//
+//-----------------------------------------------------------------------------
 
-using namespace std;
+#include <ImfFloatVectorAttribute.h>
 
-//---------------------------------------------
-// Main - prints the half-to-float lookup table
-//---------------------------------------------
 
-int
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
-main ()
+
+
+using namespace OPENEXR_IMF_INTERNAL_NAMESPACE;
+
+
+template <>
+const char *
+FloatVectorAttribute::staticTypeName ()
 {
-#ifndef HAVE_IOS_BASE
+    return "floatvector";
-    cout.setf (ios::hex, ios::basefield);
-#else
-    cout.setf (ios_base::hex, ios_base::basefield);
-#endif
-
-    cout << "//\n"
-        "// This is an automatically generated file.\n"
-        "// Do not edit.\n"
-        "//\n\n";
-
-    const int iMax = (1 << 16);
-
-    cout << "const unsigned short expTable[] =\n"
-        "{\n"
-        "    ";
-
-    for (int i = 0; i < iMax; i++)
-    {
-    half h;
-    h.setBits (i);
-
-    if (!h.isFinite())
-        h = 0;
-    else if (h >= 8 * log (HALF_MAX))
-        h = HALF_MAX;
-    else
-        h = exp (h / 8);
-
-    cout << "0x" << setfill ('0') << setw (4) << h.bits() << ", ";
-
-    if (i % 8 == 7)
-    {
-        cout << "\n";
-
-        if (i < iMax - 1)
-        cout << "    ";
-    }
-    }
-
-    cout << "};\n\n";
-
-    cout << "const unsigned short logTable[] =\n"
-        "{\n"
-        "    ";
-
-    for (int i = 0; i < iMax; i++)
-    {
-    half h;
-    h.setBits (i);
-
-    if (!h.isFinite() || h < 0)
-        h = 0;
-    else
-        h = 8 * log (h);
-
-    cout << "0x" << setfill ('0') << setw (4) << h.bits() << ", ";
-
-    if (i % 8 == 7)
-    {
-        cout << "\n";
-
-        if (i < iMax - 1)
-        cout << "    ";
-    }
-    }
-
-    cout << "};\n";
-
-    return 0;
 }
+
+
+template <>
+void
+FloatVectorAttribute::writeValueTo
+    (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os, int version) const
+{
+    int n = _value.size();
+
+    for (int i = 0; i < n; ++i)
+        Xdr::write <StreamIO> (os, _value[i]);
+}
+
+
+template <>
+void
+FloatVectorAttribute::readValueFrom
+    (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is, int size, int version)
+{
+    int n = size / Xdr::size<float>();
+    _value.resize (n);
+
+    for (int i = 0; i < n; ++i)
+       Xdr::read <StreamIO> (is, _value[i]);
+}
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT 

3rdparty/openexr/IlmImf/ImfFloatVectorAttribute.h

@@ -0,0 +1,76 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2007, Weta Digital Ltd
+// 
+// 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 Weta Digital 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef INCLUDED_IMF_FLOATVECTOR_ATTRIBUTE_H
+#define INCLUDED_IMF_FLOATVECTOR_ATTRIBUTE_H
+
+//-----------------------------------------------------------------------------
+//
+//	class FloatVectorAttribute
+//
+//-----------------------------------------------------------------------------
+
+#include "ImfAttribute.h"
+#include "ImfNamespace.h"
+
+#include <vector>
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+typedef std::vector<float>
+    FloatVector;
+
+typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::FloatVector>
+    FloatVectorAttribute;
+
+template <>
+IMF_EXPORT
+const char *FloatVectorAttribute::staticTypeName ();
+
+template <>
+IMF_EXPORT
+void FloatVectorAttribute::writeValueTo
+    (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &, int) const;
+
+template <>
+IMF_EXPORT
+void FloatVectorAttribute::readValueFrom
+    (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &, int, int);
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif

3rdparty/openexr/IlmImf/ImfForward.h

@@ -0,0 +1,127 @@
+
+
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, Industrial Light & Magic, a division of Lucas
+// Digital Ltd. LLC
+//
+// Portions (c) 2012 Weta Digital Ltd
+// 
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef INCLUDED_IMF_FORWARD_H
+#define INCLUDED_IMF_FORWARD_H
+
+////////////////////////////////////////////////////////////////////
+//
+// Forward declarations for OpenEXR - correctly declares namespace
+//
+////////////////////////////////////////////////////////////////////
+
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+// classes for basic types;
+template<class T> class Array;
+template<class T> class Array2D;
+struct Channel;
+class  ChannelList;
+struct Chromaticities;
+
+// attributes used in headers are TypedAttributes
+class Attribute;
+
+class Header;
+
+// file handling classes
+class OutputFile;
+class TiledInputFile;
+class ScanLineInputFile;
+class InputFile;
+class TiledOutputFile;
+class DeepScanLineInputFile;
+class DeepScanLineOutputFile;
+class DeepTiledInputFile;
+class DeepTiledOutputFile;
+class AcesInputFile;
+class AcesOutputFile;
+class TiledInputPart;
+class TiledInputFile;
+class TileOffsets;
+
+// multipart file handling
+class GenericInputFile;
+class GenericOutputFile;
+class MultiPartInputFile;
+class MultiPartOutputFile;
+
+class InputPart;
+class TiledInputPart;
+class DeepScanLineInputPart;
+class DeepTiledInputPart;
+
+class OutputPart;
+class ScanLineOutputPart;
+class TiledOutputPart;
+class DeepScanLineOutputPart;
+class DeepTiledOutputPart;
+
+
+// internal use only
+struct InputPartData;
+struct OutputStreamMutex;
+struct OutputPartData;
+struct InputStreamMutex;
+
+// frame buffers
+
+class  FrameBuffer;
+class  DeepFrameBuffer;
+struct DeepSlice;
+
+// compositing
+class DeepCompositing;
+class CompositeDeepScanLine;
+
+// preview image
+class PreviewImage;
+struct PreviewRgba;
+
+// streams
+class OStream;
+class IStream;
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+
+#endif // include guard

3rdparty/openexr/IlmImf/ImfFrameBuffer.cpp

@@ -36,8 +36,8 @@
 
 //-----------------------------------------------------------------------------
 //
-//	class Slice
+//      class Slice
-//	class FrameBuffer
+//      class FrameBuffer
 //
 //-----------------------------------------------------------------------------
 
@@ -47,15 +47,17 @@
 
 using namespace std;
 
-namespace Imf {
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
 
 Slice::Slice (PixelType t,
-          char *b,
+              char *b,
-          size_t xst,
+              size_t xst,
-          size_t yst,
+              size_t yst,
-          int xsm,
+              int xsm,
-          int ysm,
+              int ysm,
-          double fv,
+              double fv,
               bool xtc,
               bool ytc)
 :
@@ -78,8 +80,8 @@ FrameBuffer::insert (const char name[], const Slice &slice)
 {
     if (name[0] == 0)
     {
-    THROW (Iex::ArgExc,
+        THROW (IEX_NAMESPACE::ArgExc,
-           "Frame buffer slice name cannot be an empty string.");
+               "Frame buffer slice name cannot be an empty string.");
     }
 
     _map[name] = slice;
@@ -100,8 +102,8 @@ FrameBuffer::operator [] (const char name[])
 
     if (i == _map.end())
     {
-    THROW (Iex::ArgExc,
+        THROW (IEX_NAMESPACE::ArgExc,
-           "Cannot find frame buffer slice \"" << name << "\".");
+               "Cannot find frame buffer slice \"" << name << "\".");
     }
 
     return i->second;
@@ -115,8 +117,8 @@ FrameBuffer::operator [] (const char name[]) const
 
     if (i == _map.end())
     {
-    THROW (Iex::ArgExc,
+        THROW (IEX_NAMESPACE::ArgExc,
-           "Cannot find frame buffer slice \"" << name << "\".");
+               "Cannot find frame buffer slice \"" << name << "\".");
     }
 
     return i->second;
@@ -223,4 +225,4 @@ FrameBuffer::find (const string &name) const
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfFrameBuffer.h

@@ -39,18 +39,21 @@
 
 //-----------------------------------------------------------------------------
 //
-//	class Slice
+//      class Slice
-//	class FrameBuffer
+//      class FrameBuffer
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfName.h>
+#include "ImfName.h"
-#include <ImfPixelType.h>
+#include "ImfPixelType.h"
+#include "ImfExport.h"
+#include "ImfNamespace.h"
+
 #include <map>
 #include <string>
 
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
 
 
 //-------------------------------------------------------
@@ -68,31 +71,31 @@ struct Slice
     // Data type; see ImfPixelType.h
     //------------------------------
 
-    PixelType		type;
+    PixelType           type;
 
 
     //---------------------------------------------------------------------
     // Memory layout:  The address of pixel (x, y) is
     //
-    //	base + (xp / xSampling) * xStride + (yp / ySampling) * yStride
+    //  base + (xp / xSampling) * xStride + (yp / ySampling) * yStride
     //
     // where xp and yp are computed as follows:
     //
-    //	* If we are reading or writing a scanline-based file:
+    //  * If we are reading or writing a scanline-based file:
     //
-    //	    xp = x
+    //      xp = x
-    //	    yp = y
+    //      yp = y
     //
     //  * If we are reading a tile whose upper left coorner is at (xt, yt):
     //
-    //	    if xTileCoords is true then xp = x - xt, else xp = x
+    //      if xTileCoords is true then xp = x - xt, else xp = x
-    //	    if yTileCoords is true then yp = y - yt, else yp = y
+    //      if yTileCoords is true then yp = y - yt, else yp = y
     //
     //---------------------------------------------------------------------
 
-    char *		base;
+    char *              base;
-    size_t		xStride;
+    size_t              xStride;
-    size_t		yStride;
+    size_t              yStride;
 
 
     //--------------------------------------------
@@ -103,8 +106,8 @@ struct Slice
     //
     //--------------------------------------------
 
-    int			xSampling;
+    int                 xSampling;
-    int			ySampling;
+    int                 ySampling;
 
 
     //----------------------------------------------------------
@@ -112,7 +115,7 @@ struct Slice
     // a channel that corresponds to this slice is read.
     //----------------------------------------------------------
 
-    double		fillValue;
+    double              fillValue;
     
 
     //-------------------------------------------------------
@@ -135,13 +138,14 @@ struct Slice
     // Constructor
     //------------
 
+    IMF_EXPORT
     Slice (PixelType type = HALF,
-       char * base = 0,
+           char * base = 0,
-       size_t xStride = 0,
+           size_t xStride = 0,
-       size_t yStride = 0,
+           size_t yStride = 0,
-       int xSampling = 1,
+           int xSampling = 1,
-       int ySampling = 1,
+           int ySampling = 1,
-       double fillValue = 0.0,
+           double fillValue = 0.0,
            bool xTileCoords = false,
            bool yTileCoords = false);
 };
@@ -155,35 +159,45 @@ class FrameBuffer
     // Add a slice
     //------------
 
-    void			insert (const char name[],
+    IMF_EXPORT
-                    const Slice &slice);
+    void                        insert (const char name[],
+                                        const Slice &slice);
 
-    void			insert (const std::string &name,
+    IMF_EXPORT
-                    const Slice &slice);
+    void                        insert (const std::string &name,
+                                        const Slice &slice);
 
     //----------------------------------------------------------------
     // Access to existing slices:
     //
-    // [n]		Returns a reference to the slice with name n.
+    // [n]              Returns a reference to the slice with name n.
-    //			If no slice with name n exists, an Iex::ArgExc
+    //                  If no slice with name n exists, an IEX_NAMESPACE::ArgExc
-    //			is thrown.
+    //                  is thrown.
     //
-    // findSlice(n)	Returns a pointer to the slice with name n,
+    // findSlice(n)     Returns a pointer to the slice with name n,
-    //			or 0 if no slice with name n exists.
+    //                  or 0 if no slice with name n exists.
     //
     //----------------------------------------------------------------
 
-    Slice &			operator [] (const char name[]);
+    IMF_EXPORT
-    const Slice &		operator [] (const char name[]) const;
+    Slice &                     operator [] (const char name[]);
+    IMF_EXPORT
+    const Slice &               operator [] (const char name[]) const;
 
-    Slice &			operator [] (const std::string &name);
+    IMF_EXPORT
-    const Slice &		operator [] (const std::string &name) const;
+    Slice &                     operator [] (const std::string &name);
+    IMF_EXPORT
+    const Slice &               operator [] (const std::string &name) const;
 
-    Slice *			findSlice (const char name[]);
+    IMF_EXPORT
-    const Slice *		findSlice (const char name[]) const;
+    Slice *                     findSlice (const char name[]);
+    IMF_EXPORT
+    const Slice *               findSlice (const char name[]) const;
 
-    Slice *			findSlice (const std::string &name);
+    IMF_EXPORT
-    const Slice *		findSlice (const std::string &name) const;
+    Slice *                     findSlice (const std::string &name);
+    IMF_EXPORT
+    const Slice *               findSlice (const std::string &name) const;
 
 
     //-----------------------------------------
@@ -195,21 +209,29 @@ class FrameBuffer
     class Iterator;
     class ConstIterator;
 
-    Iterator			begin ();
+    IMF_EXPORT
-    ConstIterator		begin () const;
+    Iterator                    begin ();
+    IMF_EXPORT
+    ConstIterator               begin () const;
 
-    Iterator			end ();
+    IMF_EXPORT
-    ConstIterator		end () const;
+    Iterator                    end ();
+    IMF_EXPORT
+    ConstIterator               end () const;
 
-    Iterator			find (const char name[]);
+    IMF_EXPORT
-    ConstIterator		find (const char name[]) const;
+    Iterator                    find (const char name[]);
+    IMF_EXPORT
+    ConstIterator               find (const char name[]) const;
 
-    Iterator			find (const std::string &name);
+    IMF_EXPORT
-    ConstIterator		find (const std::string &name) const;
+    Iterator                    find (const std::string &name);
+    IMF_EXPORT
+    ConstIterator               find (const std::string &name) const;
 
   private:
 
-    SliceMap			_map;
+    SliceMap                    _map;
 };
 
 
@@ -221,14 +243,20 @@ class FrameBuffer::Iterator
 {
   public:
 
+    IMF_EXPORT
     Iterator ();
+    IMF_EXPORT
     Iterator (const FrameBuffer::SliceMap::iterator &i);
 
-    Iterator &			operator ++ ();
+    IMF_EXPORT
-    Iterator 			operator ++ (int);
+    Iterator &                  operator ++ ();
+    IMF_EXPORT
+    Iterator                    operator ++ (int);
 
-    const char *		name () const;
+    IMF_EXPORT
-    Slice &			slice () const;
+    const char *                name () const;
+    IMF_EXPORT
+    Slice &                     slice () const;
 
   private:
 
@@ -242,15 +270,22 @@ class FrameBuffer::ConstIterator
 {
   public:
 
+    IMF_EXPORT
     ConstIterator ();
+    IMF_EXPORT
     ConstIterator (const FrameBuffer::SliceMap::const_iterator &i);
+    IMF_EXPORT
     ConstIterator (const FrameBuffer::Iterator &other);
 
-    ConstIterator &		operator ++ ();
+    IMF_EXPORT
-    ConstIterator 		operator ++ (int);
+    ConstIterator &             operator ++ ();
+    IMF_EXPORT
+    ConstIterator               operator ++ (int);
 
-    const char *		name () const;
+    IMF_EXPORT
-    const Slice &		slice () const;
+    const char *                name () const;
+    IMF_EXPORT
+    const Slice &               slice () const;
 
   private:
 
@@ -364,7 +399,7 @@ FrameBuffer::ConstIterator::slice () const
 
 inline bool
 operator == (const FrameBuffer::ConstIterator &x,
-         const FrameBuffer::ConstIterator &y)
+             const FrameBuffer::ConstIterator &y)
 {
     return x._i == y._i;
 }
@@ -372,12 +407,12 @@ operator == (const FrameBuffer::ConstIterator &x,
 
 inline bool
 operator != (const FrameBuffer::ConstIterator &x,
-         const FrameBuffer::ConstIterator &y)
+             const FrameBuffer::ConstIterator &y)
 {
     return !(x == y);
 }
 
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
 
 #endif

3rdparty/openexr/IlmImf/ImfFramesPerSecond.cpp

@@ -41,9 +41,10 @@
 #include <ImfFramesPerSecond.h>
 #include "ImathFun.h"
 
-using namespace Imath;
+using namespace IMATH_NAMESPACE;
+#include "ImfNamespace.h"
 
-namespace Imf {
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
 
 Rational
 guessExactFps (double fps)
@@ -58,18 +59,18 @@ guessExactFps (const Rational &fps)
     const double e = 0.002;
 
     if (abs (double (fps) - double (fps_23_976())) < e)
-    return fps_23_976();
+	return fps_23_976();
 
     if (abs (double (fps) - double (fps_29_97())) < e)
-    return fps_29_97();
+	return fps_29_97();
 
     if (abs (double (fps) - double (fps_47_952())) < e)
-    return fps_47_952();
+	return fps_47_952();
 
     if (abs (double (fps) - double (fps_59_94())) < e)
-    return fps_59_94();
+	return fps_59_94();
 
     return fps;
 }
 
-} // namespace Imf
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfFramesPerSecond.h

@@ -65,9 +65,13 @@
 //
 //-----------------------------------------------------------------------------
 
-#include <ImfRational.h>
+#include "ImfRational.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
 
-namespace Imf {
 
 inline Rational	fps_23_976 ()	{return Rational (24000, 1001);}
 inline Rational	fps_24 ()	{return Rational (24, 1);}
@@ -80,9 +84,11 @@ inline Rational	fps_50 ()	{return Rational (50, 1);}
 inline Rational	fps_59_94 ()	{return Rational (60000, 1001);}
 inline Rational	fps_60 ()	{return Rational (60, 1);}
 
-Rational	guessExactFps (double fps);
+IMF_EXPORT Rational	guessExactFps (double fps);
-Rational	guessExactFps (const Rational &fps);
+IMF_EXPORT Rational	guessExactFps (const Rational &fps);
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
 
-} // namespace Imf
 
 #endif

3rdparty/openexr/IlmImf/ImfGenericInputFile.cpp

@@ -0,0 +1,76 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#include "ImfGenericInputFile.h"
+
+#include <ImfVersion.h>
+#include <ImfXdr.h>
+#include <Iex.h>
+#include <OpenEXRConfig.h>
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+void GenericInputFile::readMagicNumberAndVersionField(OPENEXR_IMF_INTERNAL_NAMESPACE::IStream& is, int& version)
+{
+    //
+    // Read the magic number and the file format version number.
+    // Then check if we can read the rest of this file.
+    //
+
+    int magic;
+
+    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (is, magic);
+    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (is, version);
+
+    if (magic != MAGIC)
+    {
+        throw IEX_NAMESPACE::InputExc ("File is not an image file.");
+    }
+
+    if (getVersion (version) != EXR_VERSION)
+    {
+        THROW (IEX_NAMESPACE::InputExc, "Cannot read "
+                              "version " << getVersion (version) << " "
+                              "image files.  Current file format version "
+                              "is " << EXR_VERSION << ".");
+    }
+
+    if (!supportsFlags (getFlags (version)))
+    {
+        THROW (IEX_NAMESPACE::InputExc, "The file format version number's flag field "
+                              "contains unrecognized flags.");
+    }
+}
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfGenericInputFile.h

@@ -0,0 +1,61 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef IMFGENERICINPUTFILE_H_
+#define IMFGENERICINPUTFILE_H_
+
+#include "ImfIO.h"
+#include "ImfHeader.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+class GenericInputFile
+{
+    public:
+        IMF_EXPORT
+        virtual ~GenericInputFile() {}
+
+    protected:
+        IMF_EXPORT
+        GenericInputFile() {}
+        IMF_EXPORT
+        void readMagicNumberAndVersionField(OPENEXR_IMF_INTERNAL_NAMESPACE::IStream& is, int& version);
+};
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+
+#endif /* IMFGENERICINPUTFILE_H_ */

3rdparty/openexr/IlmImf/ImfGenericOutputFile.cpp

@@ -0,0 +1,112 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#include "ImfGenericOutputFile.h"
+
+#include <ImfBoxAttribute.h>
+#include <ImfFloatAttribute.h>
+#include <ImfTimeCodeAttribute.h>
+#include <ImfChromaticitiesAttribute.h>
+
+#include <ImfMisc.h>
+#include <ImfPartType.h>
+
+#include "ImfNamespace.h"
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+    
+using namespace std;
+
+
+    
+void
+GenericOutputFile::writeMagicNumberAndVersionField (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream& os,
+                                                    const Header& header)
+{
+    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (os, MAGIC);
+
+    int version = EXR_VERSION;
+
+    if (header.hasType() && isDeepData(header.type()))
+    {
+        version |= NON_IMAGE_FLAG;
+    }
+    else
+    {
+        // (TODO) we may want to check something else in function signature
+        // instead of hasTileDescription()?
+        if (header.hasTileDescription())
+            version |= TILED_FLAG;
+    }
+
+    if (usesLongNames (header))
+        version |= LONG_NAMES_FLAG;
+
+    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (os, version);
+}
+
+void
+GenericOutputFile::writeMagicNumberAndVersionField (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream& os,
+                                                    const Header * headers,
+                                                    int parts)
+{
+    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (os, MAGIC);
+
+    int version = EXR_VERSION;
+
+    if (parts == 1)
+    {
+        if (headers[0].type() == TILEDIMAGE)
+            version |= TILED_FLAG;
+    }
+    else
+    {
+        version |= MULTI_PART_FILE_FLAG;
+    }
+    
+    for (int i = 0; i < parts; i++)
+    {
+        if (usesLongNames (headers[i]))
+            version |= LONG_NAMES_FLAG;
+
+        if (headers[i].hasType() && isImage(headers[i].type()) == false)
+            version |= NON_IMAGE_FLAG;
+    }
+
+    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (os, version);
+}
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

3rdparty/openexr/IlmImf/ImfGenericOutputFile.h

@@ -0,0 +1,66 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2011, 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.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef IMFGENERICOUTPUTFILE_H_
+#define IMFGENERICOUTPUTFILE_H_
+
+#include "ImfVersion.h"
+#include "ImfIO.h"
+#include "ImfXdr.h"
+#include "ImfHeader.h"
+#include "ImfNamespace.h"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+class GenericOutputFile
+{
+    public:
+        IMF_EXPORT
+        virtual ~GenericOutputFile() {}
+
+    protected:
+        IMF_EXPORT
+        GenericOutputFile() {}
+        IMF_EXPORT
+        void writeMagicNumberAndVersionField (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream& os, const Header& header);
+        IMF_EXPORT
+        void writeMagicNumberAndVersionField (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream& os, const Header * headers, int parts);
+  
+};
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif /* GENERICOUTPUTFILE_H_ */