Merge pull request #28: add openexr to 3rdparty libs

13 years ago · 6ee7ecb617
parent 11b403900e 52581750fc
commit 6ee7ecb617
213 changed files with 95053 additions and 149 deletions
--- a/3rdparty/ilmimf/README
+++ b/3rdparty/ilmimf/README
@ -1,123 +0,0 @@
 ABOUT THE OPENEXR LIBRARIES
 ----------------------------
 Half is a class that encapsulates our 16-bit floating-point format.
 IlmThread is a thread abstraction library for use with IlmImf.  It
 currently supports pthreads and Windows threads.
 IlmImf is our "EXR" file format for storing 16-bit FP images.
 Imath is a math library.  IlmImf only uses a subset of it,
 but we're releasing the full library because it's easier for us to 
 maintain, and we think it'll be useful to others.
 Iex is an exception-handling library.
 See the IlmImfExamples directory for some code that demonstrates how
 to use the IlmImf library to read and write OpenEXR files.  The doc
 directory contains some high-level documentation and history about the
 OpenEXR format.
 If you have questions about using the OpenEXR libraries, you may want
 to join our developer mailing list.  See http://www.openexr.com for
 details.
 LICENSE
 -------
 The OpenEXR source code distribution is free software.  See the file
 named COPYING (included in this distribution) for details.
 WHAT'S INCLUDED
 ---------------
 Besides the core OpenEXR libraries, the release includes several 
 utilities for reading, writing, viewing, and manipulating OpenEXR 
 images.  These include:
  * exrdisplay, an image viewer.
  * exrheader, a utility for dumping header information.
  * exrstdattr, a utility for modifying OpenEXR standard attributes.
  * exrmaketiled, for generating tiled and rip/mipmapped images.
  * exrenvmap, for creating OpenEXR environment maps.
  * exrmakepreview, for creating preview images for OpenEXR files.
 exrdisplay requires FLTK 1.1 or greater and OpenGL.  exrdisplay
 supports fragment shaders if you have the Nvidia Cg SDK and a graphics
 card capable of running fp30 profile fragment shaders.  See
 exrdisplay/README for details.
 We have also released an OpenEXR display driver for Renderman, a file
 I/O plugin for Shake, and a file I/O plugin for Adobe Photoshop (on
 both Windows and MacOS).  These are packaged separately.  Go to
 http://www.openexr.com to download them.  NOTE: the most recent
 versions of these applications now have native support for OpenEXR, so
 you should only use our open-source versions of the plugins if you
 have an older version of the application.
 BUILDING OPENEXR
 ----------------
 Building OpenEXR requires the zlib library.  If you want to build the
 'exrdisplay' image viewer, you'll also need FLTK 1.1, but this program
 is not required to use OpenEXR's libraries in your application.
 exrdisplay can also accelerate the display of OpenEXR images if you
 have the NVIDIA Cg SDK.
 Your OS distribution may already include these libraries, or supply
 packages for them.  That is the preferred way to obtain them for use
 with OpenEXR.  If not, you can obtain the source code for zlib and
 FLTK from:
   http://www.zlib.net
   http://www.fltk.org
 and you can download the NVIDIA Cg SDK from
 http://developer.nvidia.com.
 If you're building OpenEXR on a Windows platform, see README.win32 for
 instructions on how to build OpenEXR.  The remainder of this file
 applies only to GNU/Linux or other UNIX-like systems.
 After installing the required libraries, to build OpenEXR on
 GNU/Linux or other UNIX-like systems, do this:
 ./configure
 make
 make install
 unless you obtained OpenEXR directly from CVS, in which case you
 should first read README.CVS.
 If you have the Nvidia Cg SDK and you want to build support for
 fragment shaders into exrdisplay, specify the path to the SDK using
 the "--with-cg-prefix" flag.  There are some additional compile-time
 configuration options available; type `./configure --help` for more
 information.
 See README.OSX for details on building OpenEXR in MacOS X.
 Do `make check` to run the OpenEXR confidence tests.  They should all
 pass; if you find a test that does not pass on your system, please let
 us know.
 Other UNIX variants haven't been tested, but should be easy to build.
 Let us know if you're having problems porting OpenEXR to a particular
 platform.
 All include files needed to use the OpenEXR libraries are installed in the 
 OpenEXR subdirectory of the install prefix, e.g. /usr/local/include/OpenEXR.
 USING OPENEXR IN YOUR APPLICATIONS
 ----------------------------------
 On systems with support for pkg-config, use `pkg-config --cflags
 OpenEXR` for the C++ flags required to compile against OpenEXR
 headers; and `pkg-config --libs OpenEXR` for the linker flags required
 to link against OpenEXR libraries.
--- a/3rdparty/openexr/AUTHORS.ilmbase
+++ b/3rdparty/openexr/AUTHORS.ilmbase
@ -0,0 +1,21 @@
 Developers:
 -----------
 Florian Kainz <kainz@ilm.com>
 Rod Bogart <rgb@ilm.com>
 Drew Hess <dhess@ilm.com>
 Bill Anderson <wja@ilm.com>
 Wojciech Jarosz <wjarosz@ucsd.edu>
 Contributors:
 -------------
 Rito Trevino
 Josh Pines
 Christian Rouet
 Win32 build system:
 -------------------
 Nick Porcino <NPorcino@lucasarts.com>
 Kimball Thurston
--- a/3rdparty/openexr/AUTHORS.openexr
+++ b/3rdparty/openexr/AUTHORS.openexr
@ -0,0 +1,41 @@
 Developers:
 -----------
 Florian Kainz <kainz@ilm.com>
 Rod Bogart <rgb@ilm.com>
 Drew Hess <dhess@ilm.com>
 Paul Schneider <paultschneider@mac.com>
 Bill Anderson <wja@ilm.com>
 Wojciech Jarosz <wjarosz@ucsd.edu>
 Andrew Kunz <akunz@ilm.com>
 Contributors:
 -------------
 Simon Green <SGreen@nvidia.com>
 Rito Trevino <etrevino@ilm.com>
 Josh Pines
 Christian Rouet
 Rodrigo Damazio <rdamazio@lsi.usp.br>
 Greg Ward <gward@lmi.net>
 Joseph Goldstone <joseph@lp.com>
 Loren Carpenter, Pixar Animation Studios
 Win32 build system:
 -------------------
 Nick Porcino <NPorcino@lucasarts.com>
 Kimball Thurston
 Win32 port contributors:
 ------------------------
 Dustin Graves <dgraves@computer.org>
 Jukka Liimatta <jukka.liimatta@twilight3d.com>
 Baumann Konstantin <Konstantin.Baumann@hpi.uni-potsdam.de>
 Daniel Koch <daniel@eyeonline.com>
 E. Scott Larsen <larsene@cs.unc.edu>
 stephan mantler <step@acm.org>
 Andreas Kahler <AKahler@nxn-software.com>
 Frank Jargstorff <fjargstorff@nvidia.com>
 Lutz Latta
--- a/3rdparty/openexr/CMakeLists.txt
+++ b/3rdparty/openexr/CMakeLists.txt
@ -0,0 +1,69 @@
 # ----------------------------------------------------------------------------
 #  CMake file for openexr
 #
 # ----------------------------------------------------------------------------
 project(openexr CXX)
 if(UNIX)
  set(HAVE_PTHREAD 1)
  include(CheckIncludeFile)
  check_include_file(semaphore.h HAVE_POSIX_SEMAPHORES)
 endif()
 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"
               "${CMAKE_CURRENT_BINARY_DIR}/OpenEXRConfig.h" @ONLY)
 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")
 ocv_include_directories("${CMAKE_CURRENT_BINARY_DIR}" ${ZLIB_INCLUDE_DIR} ${OPENEXR_INCLUDE_PATHS})
 file(GLOB lib_srcs Half/half.cpp Iex/*.cpp IlmThread/*.cpp Imath/*.cpp IlmImf/*.cpp)
 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")
 if(WIN32)
  ocv_list_filterout(lib_srcs Posix.*cpp)
 else()
  ocv_list_filterout(lib_srcs Win32.cpp)
 endif()
 source_group("Include" FILES ${lib_hdrs} )
 source_group("Src" FILES ${lib_srcs})
 ocv_warnings_disable(CMAKE_CXX_FLAGS -Wshadow -Wunused -Wsign-compare -Wundef -Wmissing-declarations -Wuninitialized -Wswitch -Wparentheses)
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4018 /wd4099 /wd4100 /wd4101 /wd4127 /wd4189 /wd4245 /wd4305 /wd4389 /wd4512 /wd4701 /wd4702 /wd4706 /wd4800) # vs2005
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4334) # vs2005 Win64
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4244) # vs2008
 ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4267) # vs2008 Win64
 if(UNIX AND (CMAKE_COMPILER_IS_GNUCXX OR CV_ICC))
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
 endif()
 add_library(IlmImf STATIC ${lib_hdrs} ${lib_srcs})
 target_link_libraries(IlmImf ${ZLIB_LIBRARIES})
 set_target_properties(IlmImf
    PROPERTIES
    OUTPUT_NAME "IlmImf"
    DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
    ARCHIVE_OUTPUT_DIRECTORY ${3P_LIBRARY_OUTPUT_PATH}
    )
 if(ENABLE_SOLUTION_FOLDERS)
  set_target_properties(IlmImf PROPERTIES FOLDER "3rdparty")
 endif()
 if(NOT BUILD_SHARED_LIBS)
  install(TARGETS IlmImf ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT main)
 endif()
 set(OPENEXR_INCLUDE_PATHS ${OPENEXR_INCLUDE_PATHS} PARENT_SCOPE)
 set(OPENEXR_VERSION "1.7.1" PARENT_SCOPE)
--- a/3rdparty/openexr/ChangeLog.ilmbase
+++ b/3rdparty/openexr/ChangeLog.ilmbase
@ -0,0 +1,109 @@
 Version 1.0.3
        * Added support for enabling/disabling large stack optimisations, used in
          halfFunction.h.
          (Piotr Stanczyk)
 	* Added ImathNoise.(h/cpp) files. Initializes Perlin noise to match the
 	  Renderman implmenetation.
 	  (Pixar Contribution)
 	* Fixed a number of missing includes to comply with stricter 
 	  enforcement by gnu compilers.
 	  (Piotr Stanczyk)
 	* Depracated compiler flag: -Wno-long-double since it is no longer
 	  supported under OS X.
 	  (Piotr Stanczyk)
 	* A minor API change to Imath::Frustum has been made:  the functions
 	  'near' and 'far' have been renamed to 'nearPlane' and 'farPlane' due
 	  to conflicts with certain windows headers.  The former alternate
 	  accessor names for these values on windows ('hither' and 'yon')
 	  remain, though should be considered deprecated.
 	  (David Lenihan)
 	* Added SVD, eigenvalue solver, and procrustes fit calculations
 	  to ImathMatrixAlgo.
 	  (Chris Twigg, Ji Hun Yu)
 	* Added Imath::FrustumTest for frustum visibility testing.
 	  (Eric Johnston)
 	* Fixed a stack corruption in the matrix minorOf functions.
 	  (Nick Rasmussen)
 	* Visual studio 2008 project files have been added to the vc/vc9
 	  directory, and several minor visual studio compile fixes have
 	  been applied.
 	  (Nick Rasmussen)
 	* Updated the so verison to 7.
 	  (Piotr Stanczyk)
 	* Depracated the MacCode_Warrior and Shake submodules.
 	  (Piotr Stanczyk)
 Version 1.0.2
 	* Added support for targetting builds on 64bit Windows and minimising 
 	  number of compiler warnings on Windows. Thanks to Ger Hobbelt for his
 	  contributions to CreateDLL.
 	  (Ji Hun Yu)
 	* Removed a spurious restrict qualifier in the matrix manipulation code
 	  that was causing the 64-bit MS compiler to generate code in release 
 	  mode that caused incorrect results. 
 	  (Ji Hun Yu)
 	* Added patches for improving universal binaries on OS X. Thanks to
 	  Paul Schneider for the contribution
 	  (Piotr Stanczyk)
 	* Imath::Box optimization: remove loops from methods by partially 
 	  specializing the class, for boxes of two and three dimensions.
 	  (Piotr Stanczyk)
 	* Added explicit copy constructors to Imath::Matrix33<T> and
 	  ImathMatrix44<T> to make conversions between float and double
 	  matrices more convenient.
 	  (Florian Kainz)
 	* Added slerpShortestArc() and euclideanInnerProduct() functions
 	  to Imath::Quat<T>.
 	  (Nick Porcino)
 	* Added 4D vector class template Imath::Vec4<T>.
 	  (Nick Porcino)
 	* Copy constructors and assignment operators for Matrix33<T>
 	  and Matrix44<T> are up to 25% faster.  Added matrix constructors
 	  that do not initialize the matrix (this is faster in cases where
 	  the initial value of the matrix is immediately overwritten anyway).
 	  (Nick Porcino)
 	* Rewrote function closestPointOnBox(point,box).  Shortened
 	  the code, improved numerical accuracy, fixed a bug where
 	  closestPointOnBox(box.center(),box) would return the center
 	  of the +Z side of the box, even if the +/-X or +/-Y sides
 	  were closer.
 	  (Florian Kainz)
 	* Rewrote function findEntryAndExitPoints() in ImathBoxAlgo.h.
 	  Results are now consistent with those from intersect(), also
 	  in ImathBoxAlgo.h.
 	  (Florian Kainz)
 	* Made Vec2<T>::length() and Vec3<T>::length() more accurate for
 	  vectors whose length is less than sqrt(limits<T>::smallest());
 	  (Florian Kainz)
 	* Made Quat<T>::angle() more accurate for small angles.
 	  (Don Hatch) 
 Version 1.0.1:
 	* Removed Windows .suo files from distribution.
 	  (Eric Wimmer)
 Version 1.0.0:
 	* Bumped DSO version number to 6.0
 	  (Florian Kainz)
 	* Rounding during float-to-half conversion now implements
 	  "round to nearest even" mode: if the original float value
 	  is exactly in the middle between the two closest half values
 	  then rounding chooses the half value whose least significant
 	  bit is zero.
 	  (Florian Kainz)
 	* Installation Tuning:
 	  - Corrected version number on dso's (libtool) - now 5.0
 	  - Separated ILMBASE_LDFLAGS and ILMBASE_LIBS so that test programs
 	    in configure scripts of packages dependent on IlmBase can link
 	    with static libraries properly
 	  - eliminated some warning messages during install
 	  (Andrew Kunz)
 Version 0.9.0:
 	* Initial release of this code as a separate library.
 	  Previously the libraries contained were part of
 	  version 1.4.0 of OpenEXR
 	* New build scripts for Linux/Unix
 	  (Andrew Kunz)
 	* New Windows project files and build scripts
 	  (Kimball Thurston)
--- a/3rdparty/openexr/ChangeLog.openexr
+++ b/3rdparty/openexr/ChangeLog.openexr
@ -0,0 +1,666 @@
 Version 1.7.1:
        * Updated the .so verison to 7.
 	  (Piotr Stanczyk)     
 Version 1.7.0:
 	* Added support for targetting builds on 64bit Windows and minimising 
 	  number of compiler warnings on Windows. Thanks to Ger Hobbelt for his
 	  contributions to CreateDLL.
 	  (Ji Hun Yu)
 	* Added new atttribute types:
 	  M33dAttribute   3x3 double-precision matrix
 	  M44dAttribute   4x4 double-precision matrix
 	  V2d             2D double-precision vector
 	  V3d             3D double-precision vector
 	  (Florian Kainz)
 	* Bug fix: crash when reading a damaged image file (found
 	  by Apple).  An exception thrown inside the PIZ Huffman
 	  decoder bypasses initialization of an array of pointers.
 	  The uninitialized pointers are later passed to operator
 	  delete.
 	  (Florian Kainz)
 	* Bug fix: crash when reading a damaged image file (found by
 	  Apple).  Computing the size of input certain buffers may
 	  overflow and wrap around to a small number, later causing
 	  writes beyond the end of the buffer.
 	  (Florian Kainz)
 	* In the "Technical Introduction" document, added
 	  Premultiplied vs. Un-Premulitiplied Color section:
 	  states explicitly that pixels with zero alpha and non-zero
 	  RGB are allowed, points out that preserving such a pixel can
 	  be a problem in application programs with un-premultiplied
 	  internal image representations.
 	  (Florian Kainz)
 	* exrenvmap improvements:
 	  - New command line flags set the type of the input image to
 	    latitude-longitude map or cube-face map, overriding the
 	    envmap attribute in the input file header.
 	  - Cube-face maps can now be assembled from or split into six
 	    square sub-images.
 	  - Converting a cube-face map into a new cube-face map with
 	    the same face size copies the image instead of resampling
 	    it.  This avoids blurring when a cube-face map is assembled
 	    from or split into sub-images.
 	  (Florian Kainz)
 	* Updated standard chromaticities in ImfAcesFile.cpp to match
 	  final ACES (Academy Color Encoding Specification) document.
 	  (Florian Kainz)
 	* Added worldToCamera and worldToNDC matrices to
 	  ImfStandardAttributes.h (Florian Kainz)
 	* Increased the maximum length of attribute and channel names
 	  from 31 to 255 characters.  For files that do contain names
 	  longer than 31 characters, a new LONG_NAMES_FLAG in the fil
 	  version number is set.  This flag causes older versions of
 	  the IlmImf library (1.6.1 and earlier) to reject files with
 	  long names.  Without the flag, older library versions would
 	  mis-interpret files with long names as broken.
 	  (Florian Kainz)
 	* Reading luminance/chroma-encoded files via the RGBA
 	  interface is faster: buffer padding avoids cache thrashing
 	  for certain image sizes, redundant calls to saturation()
 	  have been eliminated.
 	  (Mike Wall)
 	* Added "hemispherical blur" option to exrenvmap.
 	  (Florian Kainz)
 	* Added experimental version of I/O classes for ACES file
 	  format (restricted OpenEXR format with special primaries
 	  and white point); added exr2aces file converter.
 	  (Florian Kainz)
 	* Added new constructors to classes Imf::RgbaInputFile and
 	  Imf::TiledRgbaInputFile.  The new constructors have a
 	  layerName parameter, which allows the caller to specify
 	  which layer of a multi-layer or multi-view image will
 	  be read.
 	  (Florian Kainz)
 	* A number of member functions in classes Imf::Header,
 	  Imf::ChannelList and Imf::FrameBuffer have parameters
 	  of type "const char *".  Added equivalent functions that
 	  take "const std::string &" parameters.
 	  (Florian Kainz)
 	* Added library support for Weta Digital multi-view images:
 	  StringVector attribute type, multiView standard attribute
 	  of type StringVector, utility functions related to grouping
 	  channels into separate views.
 	  (Peter Hillman, Florian Kainz)
 Version 1.6.1:
 	* Removed Windows .suo files from distribution.
 	  (Eric Wimmer)
 	* Bug fix: crashes, memory leaks and file descriptor leaks
 	  when reading damaged image files (some reported by Apple,
 	  others found by running IlmImfFuzzTest).
 	  (Florian Kainz)
 	* Added new IlmImfFuzzTest program to test how resilient the
 	  IlmImf library is with respect broken input files: the program
 	  first damages OpenEXR files by partially overwriting them with
 	  random data; then it tries to read the damaged files.  If all
 	  goes well, the program doesn't crash.
 	  (Florian Kainz)
 Version 1.6.0:
 	* Bumped DSO version number to 6.0
 	  (Florian Kainz)
 	* Added new standard attributes related to color rendering with
 	  CTL (Color Transformation Language): renderingTransform,
 	  lookModTransform and adoptedNeutral.
 	  (Florian Kainz)
 	* Bug fix: for pixels with luminance near HALF_MIN, conversion
 	  from RGB to luminance/chroma produces NaNs and infinities
 	  (Florian Kainz)
 	* Bug fix: excessive desaturation of small details with certain
 	  colors after repeatedly loading and saving luminance/chroma
 	  encoded images with B44 compression.
 	  (Florian Kainz)
 	* Added B44A compression, a minor variation of B44: in most cases,
 	  the compression ratio is 2.28:1, the same as with B44, but in
 	  uniform image areas where all pixels have the same value, the
 	  compression ratio increases to 10.66:1.  Uniform areas occur, for
 	  example, in an image's alpha channel, which typically contains
 	  large patches that are solid black or white, or in computer-
 	  generated images with a black background.
 	  (Florian Kainz)
 	* Added flag to configure.ac to enable or disable use of large
 	  auto arrays in the IlmImf library.  Default is "enable" for
 	  Linux, "disable" for everything else.
 	  (Darby Johnston, Florian Kainz)
 	* corrected version number on dso's (libtool) - now 5.0
 	* Separated ILMBASE_LDFLAGS and ILMBASE_LIBS so that test programs
 	  can link with static libraries properly
 	* eliminated some warning messages during install
 	  (Andrew Kunz)
 Version 1.5.0:
 	* reorganized packaging of OpenEXR libraries to facilitate
 	  integration with CTL.  Now this library depends on the library
 	  IlmBase.  Some functionality has been moved into OpenEXR_Viewers,
 	  which depends on two other libraries, CTL and OpenEXR_CTL.
 	  Note: previously there were separate releases of
 	  OpenEXR-related plugins for Renderman, Shake and Photoshop.
 	  OpenEXR is supported natively by Rendermand and Photoshop, so
 	  these plugins will not be supported for this or future
 	  versions of OpenEXR.
 	  (Andrew Kunz)
 	* New build scripts for Linux/Unix
 	  (Andrew Kunz)
 	* New Windows project files and build scripts
 	  (Kimball Thurston)
 	* float-to-half conversion now preserves the sign of float zeroes
 	  and of floats that are so small that they become half zeroes.
 	  (Florian Kainz)
 	* Bug fix: Imath::Frustum<T>::planes() returns incorrect planes
 	  if the frustum is orthogonal.
 	  (Philip Hubbard)
 	* added new framesPerSecond optional standard attribute
 	  (Florian Kainz)
 	* Imath cleanup:
 	  - Rewrote function Imath::Quat<T>::setRotation() to make it
 	    numerically more accurate, added confidence tests
 	  - Rewrote function Imath::Quat<T>::slerp() using Don Hatch's
 	    method, which is numerically more accurate, added confidence
 	    tests.
 	  - Rewrote functions Imath::closestPoints(), Imath::intersect(),
 	    added confidence tests.
 	  - Removed broken function Imath::nearestPointOnTriangle().
 	  - Rewrote Imath::drand48(), Imath::lrand48(), etc. to make
 	    them functionally identical with the Unix/Linux versions
 	    of drand48(), lrand48() and friends.
 	  - Replaced redundant definitions of Int64 in Imath and IlmImf
 	    with a single definition in ImathInt64.h.
 	  (Florian Kainz)
 	* exrdisplay: if the file's and the display's RGB chromaticities
 	  differ, the pixels RGB values are transformed from the file's
 	  to the display's RGB space.
 	  (Florian Kainz)
 	* Added new lossy B44 compression method.  HALF channels are
 	  compressed with a fixed ratio of 2.28:1.  UINT and FLOAT
 	  channels are stored verbatim, without compression.
 	  (Florian Kainz)
 Version 1.4.0a:
 	* Fixed the ReleaseDLL targets for Visual Studio 2003.
 	  (Barnaby Robson)
 Version 1.4.0:	
 	* Production release.
 	* Bug Fix: calling setFrameBuffer() for every scan line
 	  while reading a tiled file through the scan line API
 	  returns bad pixel data. (Paul Schneider, Florian Kainz)
 Version 1.3.1:
 	* Fixed the ReleaseDLL targets for Visual Studio 2005.
 	  (Nick Porcino, Drew Hess)
 	* Fixes/enhancements for createDLL.
 	  (Nick Porcino)
 Version 1.3.0:
 	* Removed openexr.spec file, it's out of date and broken to
 	  boot.
 	  (Drew Hess)
 	* Support for Visual Studio 2005.
 	  (Drew Hess, Nick Porcino)
 	* When compiling against OpenEXR headers on Windows, you
 	  no longer need to define any HAVE_* or PLATFORM_* 
 	  macros in your projects.  If you are using any OpenEXR
 	  DLLs, however, you must define OPENEXR_DLL in your
 	  project's preprocessor directives.
 	  (Drew Hess)
 	* Many fixes to the Windows VC7 build system.
 	  (Drew Hess, Nick Porcino)
 	* Support for building universal binaries on OS X 10.4.
 	  (Drew Hess, Paul Schneider)
 	* Minor configure.ac fix to accomodate OS X's automake.
 	  (Drew Hess)
 	* Removed CPU-specific optimizations from configure.ac,
 	  autoconf's guess at the CPU type isn't very useful,
 	  anyway.  Closes #13429.
 	  (Drew Hess)
 	* Fixed quoting for tests in configure.ac.  Closes #13428.
 	  (Drew Hess)
 	* Use host specification instead of target in configure.ac.
 	  Closes #13427.
 	  (Drew Hess)
 	* Fix use of AC_ARG_ENABLE in configure.ac.  Closes
 	  #13426.
 	  (Drew Hess)
 	* Removed workaround for OS X istream::read bug.
 	  (Drew Hess)
 	* Added pthread support to OpenEXR pkg-config file.
 	  (Drew Hess)
 	* Added -no-undefined to LDFLAGS and required libs to LIBADD
 	  for library projects with other library dependencies, per
 	  Rex Dieter's patch.
 	  (Drew Hess)
 	* HAVE_* macros are now defined in the OpenEXRConfig.h header
 	  file instead of via compiler flags.  There are a handful of
 	  public headers which rely on the value of these macros,
 	  and projects including these headers have previously needed
 	  to define the same macros and values as used by OpenEXR's
 	  'configure', which is bad form.  Now 'configure' writes these
 	  values to the OpenEXRConfig.h header file, which is included
 	  by any OpenEXR source files that need these macros.  This
 	  method of specifying HAVE_* macros guarantees that projects
 	  will get the proper settings without needing to add compile-
 	  time flags to accomodate OpenEXR.  Note that this isn't
 	  implemented properly for Windows yet.
 	  (Drew Hess)
 	* Platform cleanups:
 	  - No more support for IRIX or OSF1.
 	  - No more explicit support for SunOS, because we have no way to
 	    verify that it's working.  I suspect that newish versions of 
 	    SunOS will just work out of the box, but let me know if not.
 	  - No more PLATFORM_* macros (vestiges of the ILM internal build 
 	    system).  PLATFORM_DARWIN_PPC is replaced by HAVE_DARWIN.
 	    PLATFORM_REDHAT_IA32 (which was only used in IlmImfTest) is
 	    replaced by HAVE_LINUX_PROCFS.
 	  - OS X 10.4, which is the minimum version we're going to support
 	    with this version, appears to have support for nrand48 and friends,
 	    so no need to use the Imath-supplied version of them anymore.
 	  (Drew Hess)
 	* No more PLATFORM_WINDOWS or PLATFORM_WIN32, replace with 
 	  proper standard Windows macros.  (Drew Hess)
 	* Remove support for gcc 2.95, no longer supported.  (Drew Hess)
 	* Eliminate HAVE_IOS_BASE macro, OpenEXR now requires support for
 	  ios_base.  (Drew Hess)
 	* Eliminate HAVE_STL_LIMITS macro, OpenEXR now requires the ISO C++
 	  <limits> header.  (Drew Hess)
 	* Use double quote-style include dirctives for OpenEXR
 	  includes.  (Drew Hess)
 	* Added a document that gives an overview of the on-disk
 	  layout of OpenEXR files (Florian Kainz)
 	* Added sections on layers and on memory-mapped file input
 	  to the documentation.  (Florian Kainz)
 	* Bug fix: reading an incomplete file causes a deadlock while
 	  waiting on a semaphore.  (Florian Kainz)
 	* Updated documentation (ReadingAndWritingImageFiles.sxw) and
 	  sample code (IlmImfExamples):
 	  Added a section about multi-threading, updated section on
 	  thread-safety, changed documentation and sample code to use
 	  readTiles()/writeTiles() instead of readTile()/writeTile()
 	  where possible, mentioned that environment maps contain
 	  redundant pixels, updated section on testing if a file is
 	  an OpenEXR file.
 	  (Florian Kainz)
 	* Multi-threading bug fixes (exceptions could be thrown
 	  multiple times, some operations were not thread safe),
 	  updated some comments, added comments, more multithreaded
 	  testing.
 	  (Florian Kainz)
 	* Added multi-threading support: multiple threads
 	  cooperate to read or write a single OpenEXR file.
 	  (Wojciech Jarosz)
 	* Added operator== and operator!= to Imath::Frustum.
 	  (Andre Mazzone)
 	* Bug fix: Reading a PIZ-compressed file with an invalid
 	  Huffman code table caused crashes by indexing off the
 	  end of an array.
 	  (Florian Kainz)
 Version 1.2.2:
 	* Updated README to remove option for building with Visual C++ 6.0.
 	  (Drew Hess)
 	* Some older versions of gcc don't support a full iomanip
 	  implemenation; check for this during configuration. 
 	  (Drew Hess)
 	* Install PDF versions of documentation, remove old/out-of-date
 	  HTML documentation.  (Florian Kainz)
 	* Removed vc/vc6 directory; Visual C++ 6.0 is no longer
 	  supported.  (Drew Hess)
 	* Updated README.win32 with details of new build system.
 	  (Florian Kainz, Drew Hess)
 	* New build system for Windows / Visual C++ 7 builds both
 	  static libraries and DLLs.
 	  (Nick Porcino)
 	* Removed Imath::TMatrix<T> and related classes, which are not
 	  used anywhere in OpenEXR.
 	  (Florian Kainz)
 	* Added minimal support for "image layers" to class Imf::ChannelList
 	  (Florian Kainz)
 	* Added new isComplete() method to InputFile, TiledInputFile
 	  etc., that checks if a file is complete or if any pixels
 	  are missing (for example, because writing the file was
 	  aborted prematurely).
 	  (Florian Kainz)
 	* Exposed staticInitialize() function in ImfHeader.h in order
 	  to allow thread-safe library initialization in multithreaded
 	  programs.
 	  (Florian Kainz)
 	* Added a new "time code" attribute
 	  (Florian Kainz)
 	* exrmaketiled: when a MIPMAP_LEVELS or RIPMAP_LEVELS image
 	  is produced, low-pass filtering takes samples outside the
 	  image's data window.  This requires extrapolating the image.
 	  The user can now specify how the image is extrapolated
 	  horizontally and vertically (image is surrounded by black /
 	  outermost row of pixels repeats / entire image repeats /
 	  entire image repeats, every other copy is a mirror image).
 	  exrdisplay: added option to swap the top and botton half,
 	  and the left and right half of an image, so that the image's
 	  four corners end up in the center.  This is useful for checking
 	  the seams of wrap-around texture map images.
 	  IlmImf library: Added new "wrapmodes" standard attribute
 	  to indicate the extrapolation mode for MIPMAP_LEVELS and
 	  RIPMAP_LEVELS images.
 	  (Florian Kainz)
 	* Added a new "key code" attribute to identify motion picture
 	  film frames.
 	  (Florian Kainz)
 	* Removed #include <Iex.h> from ImfAttribute.h, ImfHeader.h
 	  and ImfXdr.h so that including header files such as
 	  ImfInputFile.h no longer defines ASSERT and THROW macros,
 	  which may conflict with similar macros defined by
 	  application programs.
 	  (Florian Kainz)
 	* Converted HTML documentation to OpenOffice format to
 	  make maintaining the documents easier:
 	      api.html -> ReadingAndWritingImageFiles.sxw
 	      details.html -> TechnicalIntroduction.sxw
 	  (Florian Kainz)
 Version 1.2.1:
 	* exrenvmap and exrmaketiled use slightly less memory
 	  (Florian Kainz)
 	* Added functions to IlmImf for quickly testing if a file
 	  is an OpenEXR file, and whether the file is scan-line
 	  based or tiled. (Florian Kainz)
 	* Added preview image examples to IlmImfExamples.  Added
 	  description of preview images and environment maps to
 	  docs/api.html (Florian Kainz)
 	* Bug fix: PXR24 compression did not work properly for channels
 	  with ySampling != 1.
 	  (Florian Kainz)
        * Made template <class T> become  template <class S, class T> for 
          the transform(ObjectS, ObjectT) methods. This was done to allow
          for differing templated objects to be passed in e.g.  say a 
          Box<Vec3<S>> and a Matrix44<T>, where S=float and T=double.
          (Jeff Yost, Arkell Rasiah)
        * New method Matrix44::setTheMatrix(). Used for assigning a 
          M44f to a M44d. (Jeff Yost, Arkell Rasiah)
        * Added convenience Color typedefs for half versions of Color3
          and Color4. Note the Makefile.am for both Imath and ImathTest
          have been updated with -I and/or -L pathing to Half.
          (Max Chen, Arkell Rasiah)
        * Methods equalWithAbsError() and equalWithRelError() are now
          declared as const. (Colette Mullenhoff, Arkell Rasiah)
        * Fixes for gcc34. Mainly typename/template/using/this syntax
          correctness changes. (Nick Ramussen, Arkell Rasiah)
 	* Added Custom low-level file I/O examples to IlmImfExamples
 	  and to the docs/api.html document.  (Florian Kainz)
 	* Eliminated most warnings messages when OpenEXR is compiled
 	  with Visual C++.  The OpenEXR code uses lots of (intentional
 	  and unintended) implicit type conversions.  By default, Visual
 	  C++ warns about almost all of them.  Most implicit conversions
 	  have been removed from the .h files, so that including them
 	  should not generate warnings even at warning level 3.  Most
 	  .cpp files are now compiled with warning level 1.
 	  (Florian Kainz)
 Version 1.2.0:
 	* Production-ready release.
 	* Disable long double warnings on OS X.  (Drew Hess)
 	* Add new source files to VC7 IlmImfDll target.  (Drew Hess)
 	* Iex: change the way that APPEND_EXC and REPLACE_EXC modify
 	  their what() string to work around an issue with Visual C++
 	  7.1.  (Florian Kainz, Nick Porcino)
 	* Bumped OpenEXR version to 1.2 and .so versions to 2.0.0 in
 	  preparation for the release.  (Drew Hess)
 	* Imath: fixed ImathTMatrix.h to work with gcc 3.4.  (Drew Hess)
 	* Another quoting fix in openexr.m4.  (Drew Hess)
 	* Quoting fix in acinclude.m4 for automake 1.8.  (Brad Hards)
 	* Imath: put inline at beginning of declaration in ImathMatrix.h
 	  to fix a warning.  (Ken McGaugh)
 	* Imath: made Vec equalWith*Error () methods const.
 	* Cleaned up compile-time Win32 support.  (Florian Kainz)
 	* Bug fix: Reading a particular broken PIZ-compressed file
 	  caused crashes by indexing off the end of an array.
 	  (Florian Kainz)
 Version 1.1.1:
 	* Half: operator= and variants now return by reference rather
 	  than by value.  This brings half into conformance with
 	  built-in types.  (Drew Hess)
 	* Half: remove copy constructor, let compiler supply its
 	  own.  This improves performance up to 25% on some
 	  expressions using half.  (Drew Hess)
 	* configure: don't try to be fancy with CXXFLAGS, just use
 	  what the user supplies or let configure choose a sensible
 	  default if CXXFLAGS is not defined.
        * IlmImf: fixed a bug in reading scanline files on big-endian
          architectures.  (Drew Hess)
 	* exrmaketiled: Added an option to select compression type.
 	  (Florian Kainz)
 	* exrenvmap: Added an option to select compression type.
 	  (Florian Kainz)
 	* exrdisplay: Added some new command-line options.  (Florian Kainz)
 	* IlmImf: Added Pixar's new "slightly lossy" image compression
 	  method.  The new method, named PXR24, preserves HALF and
 	  UINT data without loss, but FLOAT pixels are converted to
 	  a 24-bit representation.  PXR24 appears to compress
 	  FLOAT depth buffers very well without losing much accuracy.
 	  (Loren Carpenter, Florian Kainz)
 	* Changed top-level LICENSE file to allow for other copyright
 	  holders for individual files.
 	* IlmImf: TILED FILE FORMAT CHANGE.  TiledOutputFile was
 	  incorrectly interleaving channels and scanlines before
 	  passing pixel data to a compressor.  The lossless compressors
 	  still work, but lossy compressors do not.  Fix the bug by
 	  interleaving channels and scanlines in tiled files in the
 	  same way as ScanLineOutputFile does.  Programs compiled with
 	  the new version of IlmImf cannot read tiled images produced
 	  with version 1.1.0.  (Florian Kainz)
 	* IlmImf: ImfXdr.h fix for 64-bit architectures.  (Florian Kainz)
 	* IlmImf: OpenEXR now supports YCA (luminance/chroma/alpha)
 	  images with subsampled chroma channels.  When an image
 	  is written with the RGBA convenience interface, selecting
 	  WRITE_YCA instead of WRITE_RGBA causes the library to
 	  convert the pixels to YCA format.  If WRITE_Y is selected,
 	  only luminance is stored in the file (for black and white
 	  images).  When an image file is read with the RGBA convenience
 	  interface, YCA data are automatically converted back to RGBA.
 	  (Florian Kainz)
 	* IlmImf: speed up reading tiled files as scan lines.
 	  (Florian Kainz)
 	* Half:  Fixed subtle bug in Half where signaling float NaNs
 	  were being converted to inf in half.  (Florian Kainz)
 	* gcc 3.3 compiler warning cleanups.  (various)
 	* Imath: ImathEuler.h fixes for gcc 3.4.  (Garrick Meeker)
 Version 1.1.0:
 	* Added new targets to Visual C++ .NET 2003 project
 	  for exrmaketiled, exrenvmap, exrmakepreview, and exrstdattr.
 	  (Drew Hess)
 	* A few assorted Win32 fixes for Imath.  (Drew Hess)
 	* GNU autoconf builds now produce versioned libraries.
 	  This release is 1:0:0.  (Drew Hess)
 	* Fixes for Visual C++ .NET 2003.  (Paul Schneider)
 	* Updated Visual C++ zlib project file to zlib 1.2.1.
 	  (Drew Hess)
        * exrdisplay: Fixed fragment shader version.  (Drew Hess)
 	* *Test: Fixed some compiler issues.  (Drew Hess)
 	* Imath: Handle "restrict" keyword properly.  (Drew Hess)
 	* IlmImfExamples: Updated to latest versions of example
 	  source code, includes tiling and multi-res images.
 	  (Florian Kainz)
 	* exrmakepreview: A new utility to create preview images.
 	  (Florian Kainz)
 	* exrenvmap: A new utility to create OpenEXR environment
 	  maps.  (Florian Kainz)
 	* exrstdattr: A new utility to modify standard 
 	  attributes.  (Florian Kainz)
 	* Updated exrheader to print level rounding mode and
 	  preview image size.  (Florian Kainz)
 	* Updated exrmaketiled to use level rounding mode.
 	  (Florian Kainz)
 	* IlmImf: Changed the orientation of lat-long envmaps to
 	  match typical panoramic camera setups.  (Florian Kainz)
 	* IlmImf: Fixed a bug where partially-completed files with
 	  DECREASING_Y could not be read.  (Florian Kainz)
 	* IlmImf: Added support for selectable rounding mode (up/down)
 	  when generating multiresolution files.  (Florian Kainz)
 	* exrdisplay: Support for tiled images, mip/ripmaps, preview
 	  images, and display windows.  (Florian Kainz, Drew Hess)
 	* exrmaketiled: A new utility which generates tiled
 	  versions of OpenEXR images.  (Florian Kainz)
 	* IlmImf: Changed Imf::VERSION to Imf::EXR_VERSION to
 	  work around problems with autoconf VERSION macro
 	  conflict.  (Drew Hess)
 	* exrheader: Support for tiles, mipmaps, environment
 	  maps.  (Florian Kainz)
 	* IlmImf: Environment map support.  (Florian Kainz)
 	* IlmImf: Abstracted stream I/O support.  (Florian Kainz)
 	* IlmImf: Support for tiled and mip/ripmapped files;
 	  requires new file format.  (Wojciech Jarosz, Florian Kainz)
 	* Imath: TMatrix*, generic 2D matricies and algorithms.
 	  (Francesco Callari)
 	* Imath: major quaternions cleanup.  (Cary Phillips)
 	* Imath: added GLBegin, GLPushAttrib, GLPushMatrix objects
 	  for automatic cleanup on exceptions.  (Cary Phillips)
 	* Imath: removed implicit scalar->vector promotions and vector
 	  comparisons.  (Nick Rasmussen)
 Version 1.0.7:
 	* Fixed a typo in one of the IlmImfTest tests. (Paul Schneider)
 	* Fixed a bug in exrdisplay that causes the image to display
 	  as all black if there's a NaN or infinity in an OpenEXR
 	  image. (Florian Kainz)
 	* Updated exrheader per recent changes to IlmImf library.
 	  (Florian Kainz)
 	* Changed an errant float to a T in ImathFrame.h nextFrame().
 	  (Cary Phillips)
 	* Support for new "optional standard" attributes
 	  (chromaticities, luminance, comments, etc.).
 	  (Florian Kainz, Greg Ward, Joseph Goldstone)
 	* Fixed a buffer overrun in ImfOpaqueAttribute. (Paul Schneider)
 	* Added new function, isImfMagic (). (Florian Kainz)
 Version 1.0.6:
 	* Added README.win32 to disted files.
 	* Fixed OpenEXR.pc.in pkg-config file, OpenEXR now works
 	  with pkg-config.
 	* Random fixes to readme files for new release.
 	* Fixed openexr.m4, now looks in /usr by default.
 	* Added Visual Studio .NET 2003 "solution."
 	* Fixes for Visual Studio .NET 2003 w/ Microsoft C++ compiler.
 	  (Various)
 	* Random Imath fixes and enhancements.  Note that 
 	  extractSHRT now takes an additional optional
          argument, see ImathMatrixAlgo.h for details.  (Various)
 	* Added Wojciech Jarosz to AUTHORS file.
 	* Added test cases for uncompressed case, preview images,
 	  frame buffer type conversion.  (Wojciech Jarosz,
 	  Florian Kainz)
 	* Fix a bug in IlmImf where uncompressed data doesn't get
 	  read/written correctly.  (Wojciech Jarosz)
 	* Added support for preview images and preview image
 	  attributes (thumbnail images) in IlmImf.  (Florian Kainz)
 	* Added support for automatic frame buffer type conversion
 	  in IlmImf.  (Florian Kainz)
 	* Cleaned up some compile-time checks.
 	* Added HalfTest unit tests.
 	* [exrdisplay] Download half framebuffer to texture memory 
 	  instead of converting to float first.  Requires latest
 	  Nvidia drivers.
 Version 1.0.5:
        * Fixed IlmImf.dll to use static runtime libs (Andreas).
 	* Added exrheader project to Visual Studio 6.0 workspace.
 	* Added some example code showing how to use the IlmImf library.
 	  (Florian)
 	* Use DLL runtime libs for Win32 libraries rather than static
 	  runtime libs.
 	* Add an exrdisplay_fragshader project to the Visual Studio 6.0
 	  workspace to enable fragment shaders in Win32.
 	* Add an IlmImfDll project to the Visual Studio 6.0 workspace.
 	* In Win32, export the ImfCRgbaFile C interface via a DLL so
 	  that Visual C++ 6.0 users can link against an Intel-compiled
 	  IlmImf.  (Andreas Kahler)
 	* Use auto_ptr in ImfAutoArray on Win32, it doesn't like large 
 	  automatic stacks.
 	* Performance improvements in PIZ decoding, between
 	  20 and 60% speedup on Athlon and Pentium 4 systems.
          (Florian)
 	* Updated the README with various information, made
 	  some cosmetic changes for readability.
 	* Added fragment shader support to exrdisplay.
        * Bumped the version to 1.0.5 in prep for release.
 	* Updated README and README.OSX to talk about CodeWarrior 
          project files.
 	* Incorporated Rodrigo Damazio's patch for an openexr.m4
 	  macro file and an openexr.spec file for building RPMs.
 	* Small change in ImfAttribute.h to make IlmImf compile with gcc 2.95.
 	* Updated ImfDoubleAttribute.h for Codewarrior on MacOS.
 	* Added exrheader utility.
 	* Update to AUTHORS file.
 	* Added a README.win32 file.
 	* Added project files for Visual Studio 6.0.
 	* Initial Win32 port.  Requires Visual Studio 6.0 and Intel C++
 	  compiler version 7.0.
 	* Added new intersectT method in ImathSphere.h
 	* Fixed some bugs in ImathQuat.h
 	* Proper use of fltk-config to get platform-specific FLTK
 	  compile- and link-time flags.
 	* exrdisplay uses Imath::Math<T>::pow instead of powf now.
 	  powf is not availble on all platforms.
 	* Roll OS X "hack" into the source until Apple fixes their
 	  istream implementation.
 Version 1.0.4:
        * OpenEXR is now covered by a modified BSD license.  See LICENSE
 	  for the new terms.
 Version 1.0.3:
 	* OpenEXR is now in sf.net CVS.
 	* Imf::Xdr namespace cleanups.
 	* Some IlmImfTest cleanups for OS X.
 	* Use .cpp extension in exrdisplay sources.
 	* Iex cleanups.
 	* Make IlmImf compile with Metrowerks Codewarrior.
 	* Change large automatic stacks in ImfHuf.C to auto_ptrs allocated
 	  off the heap.  MacOS X default stack size isn't large enough.
 	* std::ios fix for MacOS X in ImfInputFile.C.
 	* Added new FP predecessor/successor functions to Imath, added
 	  tests to ImathTest
 	* Fixed a bug in Imath::extractSHRT for 3x3 matricies when
 	  exactly one of the original scaling factors is negative, updated
 	  ImathTest to check this case.
 	* Install include files when 'make install' is run.
 	* exrdisplay requires fltk 1.1+ now in an effort to support
 	  a MacOS X display program (fltk 1.1 runs on OS X), though this
 	  is untested.
 	* renamed configure.in to configure.ac
 	* Removed some tests from IexTest that are no longer used.
 	* Removed ImfHalfXdr.h, it's not used anymore.
 	* Revamped the autoconf system, added some compile-time 
          optimizations, a pkgconfig target, and some maintainer-specific
          stuff.
 Version 1.0.2:
        * More OS X fixes in Imath, IlmImf and IlmImfTest.
        * Imath updates.
        * Fixed a rotation bug in Imath
 Version 1.0.1:
 	* Used autoconf 2.53 and automake 1.6 to generate build environment.
 	* Makefile.am cleanups.
 	* OS X fixes.
        * removed images directory (now distributed separately).
 Version 1.0:
        * first official release.
        * added some high-level documentation, removed the old OpenEXR.html
          documentation.
        * fixed a few nagging build problems.
 	* bumped IMV_VERSION_NUMBER to 2
 Version 0.9:
 	* added exrdisplay viewer application.
 	* cleanup _data in Imf::InputFile and Imf::OutputFile constructors.
 	* removed old ILM copyright notices.
 Version 0.8:
 	* Initial release.
--- a/3rdparty/openexr/Half/eLut.cpp
+++ b/3rdparty/openexr/Half/eLut.cpp
@ -0,0 +1,114 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #include <iostream>
 #include <iomanip>
 using namespace std;
 //-----------------------------------------------------
 // Compute a lookup table for float-to-half conversion.
 //
 // When indexed with the combined sign and exponent of
 // a float, the table either returns the combined sign
 // and exponent of the corresponding half, or zero if
 // the corresponding half may not be normalized (zero,
 // denormalized, overflow).
 //-----------------------------------------------------
 void
 initELut (unsigned short eLut[])
 {
    for (int i = 0; i < 0x100; i++)
    {
 	int e = (i & 0x0ff) - (127 - 15);
 	if (e <= 0 || e >= 30)
 	{
 	    //
 	    // Special case
 	    //
 	    eLut[i]         = 0;
 	    eLut[i | 0x100] = 0;
 	}
 	else
 	{
 	    //
 	    // Common case - normalized half, no exponent overflow possible
 	    //
 	    eLut[i]         =  (e << 10);
 	    eLut[i | 0x100] = ((e << 10) | 0x8000);
 	}
    }
 }
 //------------------------------------------------------------
 // Main - prints the sign-and-exponent conversion lookup table
 //------------------------------------------------------------
 int
 main ()
 {
    const int tableSize = 1 << 9;
    unsigned short eLut[tableSize];
    initELut (eLut);
    cout << "//\n"
 	    "// This is an automatically generated file.\n"
 	    "// Do not edit.\n"
 	    "//\n\n";
    cout << "{\n    ";
    for (int i = 0; i < tableSize; i++)
    {
 	cout << setw (5) << eLut[i] << ", ";
 	if (i % 8 == 7)
 	{
 	    cout << "\n";
 	    if (i < tableSize - 1)
 		cout << "    ";
 	}
    }
    cout << "};\n";
    return 0;
 }
--- a/3rdparty/openexr/Half/eLut.h
+++ b/3rdparty/openexr/Half/eLut.h
@ -0,0 +1,71 @@
 //
 // This is an automatically generated file.
 // Do not edit.
 //
 {
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,  1024,  2048,  3072,  4096,  5120,  6144,  7168, 
     8192,  9216, 10240, 11264, 12288, 13312, 14336, 15360, 
    16384, 17408, 18432, 19456, 20480, 21504, 22528, 23552, 
    24576, 25600, 26624, 27648, 28672, 29696,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0, 33792, 34816, 35840, 36864, 37888, 38912, 39936, 
    40960, 41984, 43008, 44032, 45056, 46080, 47104, 48128, 
    49152, 50176, 51200, 52224, 53248, 54272, 55296, 56320, 
    57344, 58368, 59392, 60416, 61440, 62464,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
        0,     0,     0,     0,     0,     0,     0,     0, 
 };
--- a/3rdparty/openexr/Half/half.cpp
+++ b/3rdparty/openexr/Half/half.cpp
@ -0,0 +1,311 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
 // Digital Ltd. LLC
 // 
 // All rights reserved.
 // 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 // *       Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 // *       Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 // *       Neither the name of Industrial Light & Magic nor the names of
 // its contributors may be used to endorse or promote products derived
 // from this software without specific prior written permission. 
 // 
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 ///////////////////////////////////////////////////////////////////////////
 // Primary authors:
 //     Florian Kainz <kainz@ilm.com>
 //     Rod Bogart <rgb@ilm.com>
 //---------------------------------------------------------------------------
 //
 //	class half --
 //	implementation of non-inline members
 //
 //---------------------------------------------------------------------------
 #include <assert.h>
 #include "half.h"
 using namespace std;
 //-------------------------------------------------------------
 // Lookup tables for half-to-float and float-to-half conversion
 //-------------------------------------------------------------
 HALF_EXPORT_CONST half::uif half::_toFloat[1 << 16] =
 #include "toFloat.h"
 HALF_EXPORT_CONST unsigned short half::_eLut[1 << 9] =
 #include "eLut.h"
 //-----------------------------------------------
 // Overflow handler for float-to-half conversion;
 // generates a hardware floating-point overflow,
 // which may be trapped by the operating system.
 //-----------------------------------------------
 float
 half::overflow ()
 {
    volatile float f = 1e10;
    for (int i = 0; i < 10; i++)	
 	f *= f;				// this will overflow before
 					// the forloop terminates
    return f;
 }
 //-----------------------------------------------------
 // Float-to-half conversion -- general case, including
 // zeroes, denormalized numbers and exponent overflows.
 //-----------------------------------------------------
 short
 half::convert (int i)
 {
    //
    // Our floating point number, f, is represented by the bit
    // pattern in integer i.  Disassemble that bit pattern into
    // the sign, s, the exponent, e, and the significand, m.
    // Shift s into the position where it will go in in the
    // resulting half number.
    // Adjust e, accounting for the different exponent bias
    // of float and half (127 versus 15).
    //
    register int s =  (i >> 16) & 0x00008000;
    register int e = ((i >> 23) & 0x000000ff) - (127 - 15);
    register int m =   i        & 0x007fffff;
    //
    // Now reassemble s, e and m into a half:
    //
    if (e <= 0)
    {
 	if (e < -10)
 	{
 	    //
 	    // E is less than -10.  The absolute value of f is
 	    // less than HALF_MIN (f may be a small normalized
 	    // float, a denormalized float or a zero).
 	    //
 	    // We convert f to a half zero with the same sign as f.
 	    //
 	    return s;
 	}
 	//
 	// E is between -10 and 0.  F is a normalized float
 	// whose magnitude is less than HALF_NRM_MIN.
 	//
 	// We convert f to a denormalized half.
 	//
 	//
 	// Add an explicit leading 1 to the significand.
 	// 
 	m = m | 0x00800000;
 	//
 	// 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.
 	//
 	// Rounding may cause the significand to overflow and make
 	// our number normalized.  Because of the way a half's bits
 	// are laid out, we don't have to treat this case separately;
 	// the code below will handle it correctly.
 	// 
 	int t = 14 - e;
 	int a = (1 << (t - 1)) - 1;
 	int b = (m >> t) & 1;
 	m = (m + a + b) >> t;
 	//
 	// Assemble the half from s, e (zero) and m.
 	//
 	return s | m;
    }
    else if (e == 0xff - (127 - 15))
    {
 	if (m == 0)
 	{
 	    //
 	    // F is an infinity; convert f to a half
 	    // infinity with the same sign as f.
 	    //
 	    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
    {
 	//
 	// E is greater than zero.  F is a normalized float.
 	// We try to convert f to a normalized half.
 	//
 	//
 	// 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
 	}
 	//
 	// Handle exponent overflow
 	//
 	if (e > 30)
 	{
 	    overflow ();	// Cause a hardware floating point overflow;
 	    return s | 0x7c00;	// if this returns, the half becomes an
 	}   			// infinity with the same sign as f.
 	//
 	// Assemble the half from s, e and m.
 	//
 	return s | (e << 10) | (m >> 13);
    }
 }
 //---------------------
 // Stream I/O operators
 //---------------------
 ostream &
 operator << (ostream &os, half h)
 {
    os << float (h);
    return os;
 }
 istream &
 operator >> (istream &is, half &h)
 {
    float f;
    is >> f;
    h = half (f);
    return is;
 }
 //---------------------------------------
 // Functions to print the bit-layout of
 // floats and halfs, mostly for debugging
 //---------------------------------------
 void
 printBits (ostream &os, half h)
 {
    unsigned short b = h.bits();
    for (int i = 15; i >= 0; i--)
    {
 	os << (((b >> i) & 1)? '1': '0');
 	if (i == 15 || i == 10)
 	    os << ' ';
    }
 }
 void
 printBits (ostream &os, float f)
 {
    half::uif x;
    x.f = f;
    for (int i = 31; i >= 0; i--)
    {
 	os << (((x.i >> i) & 1)? '1': '0');
 	if (i == 31 || i == 23)
 	    os << ' ';
    }
 }
 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');
 	if (i == 15 || i == 10)
 	    c[++j] = ' ';
    }
    c[18] = 0;
 }
 void
 printBits (char c[35], float f)
 {
    half::uif x;
    x.f = f;
    for (int i = 31, j = 0; i >= 0; i--, j++)
    {
 	c[j] = (((x.i >> i) & 1)? '1': '0');
 	if (i == 31 || i == 23)
 	    c[++j] = ' ';
    }
    c[34] = 0;
 }
--- a/3rdparty/openexr/Half/half.h
+++ b/3rdparty/openexr/Half/half.h
@ -0,0 +1,766 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
 // Digital Ltd. LLC
 // 
 // All rights reserved.
 // 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 // *       Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 // *       Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 // *       Neither the name of Industrial Light & Magic nor the names of
 // its contributors may be used to endorse or promote products derived
 // from this software without specific prior written permission. 
 // 
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 ///////////////////////////////////////////////////////////////////////////
 // Primary authors:
 //     Florian Kainz <kainz@ilm.com>
 //     Rod Bogart <rgb@ilm.com>
 //---------------------------------------------------------------------------
 //
 //	half -- a 16-bit floating point number class:
 //
 //	Type half can represent positive and negative numbers whose
 //	magnitude is between roughly 6.1e-5 and 6.5e+4 with a relative
 //	error of 9.8e-4; numbers smaller than 6.1e-5 can be represented
 //	with an absolute error of 6.0e-8.  All integers from -2048 to
 //	+2048 can be represented exactly.
 //
 //	Type half behaves (almost) like the built-in C++ floating point
 //	types.  In arithmetic expressions, half, float and double can be
 //	mixed freely.  Here are a few examples:
 //
 //	    half a (3.5);
 //	    float b (a + sqrt (a));
 //	    a += b;
 //	    b += a;
 //	    b = a + 7;
 //
 //	Conversions from half to float are lossless; all half numbers
 //	are exactly representable as floats.
 //
 //	Conversions from float to half may not preserve a float's value
 //	exactly.  If a float is not representable as a half, then the
 //	float value is rounded to the nearest representable half.  If a
 //	float value is exactly in the middle between the two closest
 //	representable half values, then the float value is rounded to
 //	the closest half whose least significant bit is zero.
 //
 //	Overflows during float-to-half conversions cause arithmetic
 //	exceptions.  An overflow occurs when the float value to be
 //	converted is too large to be represented as a half, or if the
 //	float value is an infinity or a NAN.
 //
 //	The implementation of type half makes the following assumptions
 //	about the implementation of the built-in C++ types:
 //
 //	    float is an IEEE 754 single-precision number
 //	    sizeof (float) == 4
 //	    sizeof (unsigned int) == sizeof (float)
 //	    alignof (unsigned int) == alignof (float)
 //	    sizeof (unsigned short) == 2
 //
 //---------------------------------------------------------------------------
 #ifndef _HALF_H_
 #define _HALF_H_
 #include <iostream>
 #if defined(OPENEXR_DLL)
    #if defined(HALF_EXPORTS)
 	#define HALF_EXPORT __declspec(dllexport)
    #else
 	#define HALF_EXPORT __declspec(dllimport)
    #endif
    #define HALF_EXPORT_CONST
 #else
    #define HALF_EXPORT
    #define HALF_EXPORT_CONST const
 #endif
 class HALF_EXPORT half
 {
  public:
    //-------------
    // Constructors
    //-------------
    half ();			// no initialization
    half (float f);
    //--------------------
    // Conversion to float
    //--------------------
    operator		float () const;
    //------------
    // Unary minus
    //------------
    half		operator - () const;
    //-----------
    // Assignment
    //-----------
    half &		operator = (half  h);
    half &		operator = (float f);
    half &		operator += (half  h);
    half &		operator += (float f);
    half &		operator -= (half  h);
    half &		operator -= (float f);
    half &		operator *= (half  h);
    half &		operator *= (float f);
    half &		operator /= (half  h);
    half &		operator /= (float f);
    //---------------------------------------------------------
    // Round to n-bit precision (n should be between 0 and 10).
    // After rounding, the significand's 10-n least significant
    // bits will be zero.
    //---------------------------------------------------------
    half		round (unsigned int n) const;
    //--------------------------------------------------------------------
    // Classification:
    //
    //	h.isFinite()		returns true if h is a normalized number,
    //				a denormalized number or zero
    //
    //	h.isNormalized()	returns true if h is a normalized number
    //
    //	h.isDenormalized()	returns true if h is a denormalized number
    //
    //	h.isZero()		returns true if h is zero
    //
    //	h.isNan()		returns true if h is a NAN
    //
    //	h.isInfinity()		returns true if h is a positive
    //				or a negative infinity
    //
    //	h.isNegative()		returns true if the sign bit of h
    //				is set (negative)
    //--------------------------------------------------------------------
    bool		isFinite () const;
    bool		isNormalized () const;
    bool		isDenormalized () const;
    bool		isZero () const;
    bool		isNan () const;
    bool		isInfinity () const;
    bool		isNegative () const;
    //--------------------------------------------
    // Special values
    //
    //	posInf()	returns +infinity
    //
    //	negInf()	returns -infinity
    //
    //	qNan()		returns a NAN with the bit
    //			pattern 0111111111111111
    //
    //	sNan()		returns a NAN with the bit
    //			pattern 0111110111111111
    //--------------------------------------------
    static half		posInf ();
    static half		negInf ();
    static half		qNan ();
    static half		sNan ();
    //--------------------------------------
    // Access to the internal representation
    //--------------------------------------
    unsigned short	bits () const;
    void		setBits (unsigned short bits);
  public:
    union uif
    {
 	unsigned int	i;
 	float		f;
    };
  private:
    static short	convert (int i);
    static float	overflow ();
    unsigned short	_h;
    static HALF_EXPORT_CONST uif		_toFloat[1 << 16];
    static HALF_EXPORT_CONST unsigned short _eLut[1 << 9];
 };
 //-----------
 // Stream I/O
 //-----------
 HALF_EXPORT std::ostream &		operator << (std::ostream &os, 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, float f);
 HALF_EXPORT void			printBits   (char  c[19], half  h);
 HALF_EXPORT void			printBits   (char  c[35], float f);
 //-------------------------------------------------------------------------
 // Limits
 //
 // Visual C++ will complain if HALF_MIN, HALF_NRM_MIN etc. are not float
 // constants, but at least one other compiler (gcc 2.96) produces incorrect
 // results if they are.
 //-------------------------------------------------------------------------
 #if (defined _WIN32 || defined _WIN64) && defined _MSC_VER
  #define HALF_MIN	5.96046448e-08f	// Smallest positive half
  #define HALF_NRM_MIN	6.10351562e-05f	// Smallest positive normalized half
  #define HALF_MAX	65504.0f	// Largest positive half
  #define HALF_EPSILON	0.00097656f	// Smallest positive e for which
 					// half (1.0 + e) != half (1.0)
 #else
  #define HALF_MIN	5.96046448e-08	// Smallest positive half
  #define HALF_NRM_MIN	6.10351562e-05	// Smallest positive normalized half
  #define HALF_MAX	65504.0		// Largest positive half
  #define HALF_EPSILON	0.00097656	// Smallest positive e for which
 					// half (1.0 + e) != half (1.0)
 #endif
 #define HALF_MANT_DIG	11		// Number of digits in mantissa
 					// (significand + hidden leading 1)
 #define HALF_DIG	2		// Number of base 10 digits that
 					// can be represented without change
 #define HALF_RADIX	2		// Base of the exponent
 #define HALF_MIN_EXP	-13		// Minimum negative integer such that
 					// HALF_RADIX raised to the power of
 					// one less than that integer is a
 					// normalized half
 #define HALF_MAX_EXP	16		// Maximum positive integer such that
 					// HALF_RADIX raised to the power of
 					// one less than that integer is a
 					// normalized half
 #define HALF_MIN_10_EXP	-4		// Minimum positive integer such
 					// that 10 raised to that power is
 					// a normalized half
 #define HALF_MAX_10_EXP	4		// Maximum positive integer such
 					// that 10 raised to that power is
 					// a normalized half
 //---------------------------------------------------------------------------
 //
 // Implementation --
 //
 // Representation of a float:
 //
 //	We assume that a float, f, is an IEEE 754 single-precision
 //	floating point number, whose bits are arranged as follows:
 //
 //	    31 (msb)
 //	    | 
 //	    | 30     23
 //	    | |      | 
 //	    | |      | 22                    0 (lsb)
 //	    | |      | |                     |
 //	    X XXXXXXXX XXXXXXXXXXXXXXXXXXXXXXX
 //
 //	    s e        m
 //
 //	S is the sign-bit, e is the exponent and m is the significand.
 //
 //	If e is between 1 and 254, f is a normalized number:
 //
 //	            s    e-127
 //	    f = (-1)  * 2      * 1.m
 //
 //	If e is 0, and m is not zero, f is a denormalized number:
 //
 //	            s    -126
 //	    f = (-1)  * 2      * 0.m
 //
 //	If e and m are both zero, f is zero:
 //
 //	    f = 0.0
 //
 //	If e is 255, f is an "infinity" or "not a number" (NAN),
 //	depending on whether m is zero or not.
 //
 //	Examples:
 //
 //	    0 00000000 00000000000000000000000 = 0.0
 //	    0 01111110 00000000000000000000000 = 0.5
 //	    0 01111111 00000000000000000000000 = 1.0
 //	    0 10000000 00000000000000000000000 = 2.0
 //	    0 10000000 10000000000000000000000 = 3.0
 //	    1 10000101 11110000010000000000000 = -124.0625
 //	    0 11111111 00000000000000000000000 = +infinity
 //	    1 11111111 00000000000000000000000 = -infinity
 //	    0 11111111 10000000000000000000000 = NAN
 //	    1 11111111 11111111111111111111111 = NAN
 //
 // Representation of a half:
 //
 //	Here is the bit-layout for a half number, h:
 //
 //	    15 (msb)
 //	    | 
 //	    | 14  10
 //	    | |   |
 //	    | |   | 9        0 (lsb)
 //	    | |   | |        |
 //	    X XXXXX XXXXXXXXXX
 //
 //	    s e     m
 //
 //	S is the sign-bit, e is the exponent and m is the significand.
 //
 //	If e is between 1 and 30, h is a normalized number:
 //
 //	            s    e-15
 //	    h = (-1)  * 2     * 1.m
 //
 //	If e is 0, and m is not zero, h is a denormalized number:
 //
 //	            S    -14
 //	    h = (-1)  * 2     * 0.m
 //
 //	If e and m are both zero, h is zero:
 //
 //	    h = 0.0
 //
 //	If e is 31, h is an "infinity" or "not a number" (NAN),
 //	depending on whether m is zero or not.
 //
 //	Examples:
 //
 //	    0 00000 0000000000 = 0.0
 //	    0 01110 0000000000 = 0.5
 //	    0 01111 0000000000 = 1.0
 //	    0 10000 0000000000 = 2.0
 //	    0 10000 1000000000 = 3.0
 //	    1 10101 1111000001 = -124.0625
 //	    0 11111 0000000000 = +infinity
 //	    1 11111 0000000000 = -infinity
 //	    0 11111 1000000000 = NAN
 //	    1 11111 1111111111 = NAN
 //
 // Conversion:
 //
 //	Converting from a float to a half requires some non-trivial bit
 //	manipulations.  In some cases, this makes conversion relatively
 //	slow, but the most common case is accelerated via table lookups.
 //
 //	Converting back from a half to a float is easier because we don't
 //	have to do any rounding.  In addition, there are only 65536
 //	different half numbers; we can convert each of those numbers once
 //	and store the results in a table.  Later, all conversions can be
 //	done using only simple table lookups.
 //
 //---------------------------------------------------------------------------
 //--------------------
 // Simple constructors
 //--------------------
 inline
 half::half ()
 {
    // no initialization
 }
 //----------------------------
 // Half-from-float constructor
 //----------------------------
 inline
 half::half (float f)
 {
    uif x;
    x.f = f;
    if (f == 0)
    {
 	//
 	// Common special case - zero.
 	// Preserve the zero's sign bit.
 	//
 	_h = (x.i >> 16);
    }
    else
    {
 	//
 	// We extract the combined sign and exponent, e, from our
 	// floating-point number, f.  Then we convert e to the sign
 	// and exponent of the half number via a table lookup.
 	//
 	// For the most common case, where a normalized half is produced,
 	// the table lookup returns a non-zero value; in this case, all
 	// we have to do is round f's significand to 10 bits and combine
 	// the result with e.
 	//
 	// For all other cases (overflow, zeroes, denormalized numbers
 	// resulting from underflow, infinities and NANs), the table
 	// lookup returns zero, and we call a longer, non-inline function
 	// to do the float-to-half conversion.
 	//
 	register int e = (x.i >> 23) & 0x000001ff;
 	e = _eLut[e];
 	if (e)
 	{
 	    //
 	    // Simple case - round the significand, m, to 10
 	    // bits and combine it with the sign and exponent.
 	    //
 	    register int m = x.i & 0x007fffff;
 	    _h = e + ((m + 0x00000fff + ((m >> 13) & 1)) >> 13);
 	}
 	else
 	{
 	    //
 	    // Difficult case - call a function.
 	    //
 	    _h = convert (x.i);
 	}
    }
 }
 //------------------------------------------
 // Half-to-float conversion via table lookup
 //------------------------------------------
 inline
 half::operator float () const
 {
    return _toFloat[_h].f;
 }
 //-------------------------
 // Round to n-bit precision
 //-------------------------
 inline half
 half::round (unsigned int n) const
 {
    //
    // Parameter check.
    //
    if (n >= 10)
 	return *this;
    //
    // Disassemble h into the sign, s,
    // and the combined exponent and significand, e.
    //
    unsigned short s = _h & 0x8000;
    unsigned short e = _h & 0x7fff;
    //
    // Round the exponent and significand to the nearest value
    // where ones occur only in the (10-n) most significant bits.
    // Note that the exponent adjusts automatically if rounding
    // up causes the significand to overflow.
    //
    e >>= 9 - n;
    e  += e & 1;
    e <<= 9 - n;
    //
    // Check for exponent overflow.
    //
    if (e >= 0x7c00)
    {
 	//
 	// Overflow occurred -- truncate instead of rounding.
 	//
 	e = _h;
 	e >>= 10 - n;
 	e <<= 10 - n;
    }
    //
    // Put the original sign bit back.
    //
    half h;
    h._h = s | e;
    return h;
 }
 //-----------------------
 // Other inline functions
 //-----------------------
 inline half	
 half::operator - () const
 {
    half h;
    h._h = _h ^ 0x8000;
    return h;
 }
 inline half &
 half::operator = (half h)
 {
    _h = h._h;
    return *this;
 }
 inline half &
 half::operator = (float f)
 {
    *this = half (f);
    return *this;
 }
 inline half &
 half::operator += (half h)
 {
    *this = half (float (*this) + float (h));
    return *this;
 }
 inline half &
 half::operator += (float f)
 {
    *this = half (float (*this) + f);
    return *this;
 }
 inline half &
 half::operator -= (half h)
 {
    *this = half (float (*this) - float (h));
    return *this;
 }
 inline half &
 half::operator -= (float f)
 {
    *this = half (float (*this) - f);
    return *this;
 }
 inline half &
 half::operator *= (half h)
 {
    *this = half (float (*this) * float (h));
    return *this;
 }
 inline half &
 half::operator *= (float f)
 {
    *this = half (float (*this) * f);
    return *this;
 }
 inline half &
 half::operator /= (half h)
 {
    *this = half (float (*this) / float (h));
    return *this;
 }
 inline half &
 half::operator /= (float f)
 {
    *this = half (float (*this) / f);
    return *this;
 }
 inline bool	
 half::isFinite () const
 {
    unsigned short e = (_h >> 10) & 0x001f;
    return e < 31;
 }
 inline bool
 half::isNormalized () const
 {
    unsigned short e = (_h >> 10) & 0x001f;
    return e > 0 && e < 31;
 }
 inline bool
 half::isDenormalized () const
 {
    unsigned short e = (_h >> 10) & 0x001f;
    unsigned short m =  _h & 0x3ff;
    return e == 0 && m != 0;
 }
 inline bool
 half::isZero () const
 {
    return (_h & 0x7fff) == 0;
 }
 inline bool
 half::isNan () const
 {
    unsigned short e = (_h >> 10) & 0x001f;
    unsigned short m =  _h & 0x3ff;
    return e == 31 && m != 0;
 }
 inline bool
 half::isInfinity () const
 {
    unsigned short e = (_h >> 10) & 0x001f;
    unsigned short m =  _h & 0x3ff;
    return e == 31 && m == 0;
 }
 inline bool	
 half::isNegative () const
 {
    return (_h & 0x8000) != 0;
 }
 inline half
 half::posInf ()
 {
    half h;
    h._h = 0x7c00;
    return h;
 }
 inline half
 half::negInf ()
 {
    half h;
    h._h = 0xfc00;
    return h;
 }
 inline half
 half::qNan ()
 {
    half h;
    h._h = 0x7fff;
    return h;
 }
 inline half
 half::sNan ()
 {
    half h;
    h._h = 0x7dff;
    return h;
 }
 inline unsigned short
 half::bits () const
 {
    return _h;
 }
 inline void
 half::setBits (unsigned short bits)
 {
    _h = bits;
 }
 #endif
--- a/3rdparty/openexr/Half/halfFunction.h
+++ b/3rdparty/openexr/Half/halfFunction.h
@ -0,0 +1,178 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
 // Digital Ltd. LLC
 // 
 // All rights reserved.
 // 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 // *       Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 // *       Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 // *       Neither the name of Industrial Light & Magic nor the names of
 // its contributors may be used to endorse or promote products derived
 // from this software without specific prior written permission. 
 // 
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 ///////////////////////////////////////////////////////////////////////////
 // Primary authors:
 //     Florian Kainz <kainz@ilm.com>
 //     Rod Bogart <rgb@ilm.com>
 //---------------------------------------------------------------------------
 //
 //	halfFunction<T> -- a class for fast evaluation
 //			   of half --> T functions
 //
 //	The constructor for a halfFunction object,
 //
 //	    halfFunction (function,
 //			  domainMin, domainMax,
 //			  defaultValue,
 //			  posInfValue, negInfValue,
 //			  nanValue);
 //
 //	evaluates the function for all finite half values in the interval
 //	[domainMin, domainMax], and stores the results in a lookup table.
 //	For finite half values that are not in [domainMin, domainMax], the
 //	constructor stores defaultValue in the table.  For positive infinity,
 //	negative infinity and NANs, posInfValue, negInfValue and nanValue
 //	are stored in the table.
 //
 //	The tabulated function can then be evaluated quickly for arbitrary
 //	half values by calling the the halfFunction object's operator()
 //	method.
 //
 //	Example:
 //
 //	    #include <math.h>
 //	    #include <halfFunction.h>
 //
 //	    halfFunction<half> hsin (sin);
 //
 //	    halfFunction<half> hsqrt (sqrt,		// function
 //				      0, HALF_MAX,	// domain
 //				      half::qNan(),	// sqrt(x) for x < 0
 //				      half::posInf(),	// sqrt(+inf)
 //				      half::qNan(),	// sqrt(-inf)
 //				      half::qNan());	// sqrt(nan)
 //
 //	    half x = hsin (1);
 //	    half y = hsqrt (3.5);
 //
 //---------------------------------------------------------------------------
 #ifndef _HALF_FUNCTION_H_
 #define _HALF_FUNCTION_H_
 #include "half.h"
 #include <IlmBaseConfig.h>
 #ifndef ILMBASE_HAVE_LARGE_STACK  
 #include <string.h>     // need this for memset
 #else 
 #endif
 #include <float.h>
 template <class T>
 class halfFunction
 {
  public:
    //------------
    // Constructor
    //------------
    template <class Function>
    halfFunction (Function f,
 		  half domainMin = -HALF_MAX,
 		  half domainMax =  HALF_MAX,
 		  T defaultValue = 0,
 		  T posInfValue  = 0,
 		  T negInfValue  = 0,
 		  T nanValue     = 0);
 #ifndef ILMBASE_HAVE_LARGE_STACK
    ~halfFunction () { delete [] _lut; }    
 #endif
    //-----------
    // Evaluation
    //-----------
    T		operator () (half x) const;
  private:
 #ifdef ILMBASE_HAVE_LARGE_STACK
    T		_lut[1 << 16];
 #else
    T *         _lut;
 #endif
 };
 //---------------
 // Implementation
 //---------------
 template <class T>
 template <class Function>
 halfFunction<T>::halfFunction (Function f,
 			       half domainMin,
 			       half domainMax,
 			       T defaultValue,
 			       T posInfValue,
 			       T negInfValue,
 			       T nanValue)
 {
 #ifndef ILMBASE_HAVE_LARGE_STACK
    _lut = new T[1<<16];
    memset (_lut, 0 , (1<<16) * sizeof(T));
 #endif
    for (int i = 0; i < (1 << 16); i++)
    {
 	half x;
 	x.setBits (i);
 	if (x.isNan())
 	    _lut[i] = nanValue;
 	else if (x.isInfinity())
 	    _lut[i] = x.isNegative()? negInfValue: posInfValue;
 	else if (x < domainMin || x > domainMax)
 	    _lut[i] = defaultValue;
 	else
 	    _lut[i] = f (x);
    }
 }
 template <class T>
 inline T
 halfFunction<T>::operator () (half x) const
 {
    return _lut[x.bits()];
 }
 #endif
--- a/3rdparty/openexr/Half/halfLimits.h
+++ b/3rdparty/openexr/Half/halfLimits.h
@ -0,0 +1,102 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
 // Digital Ltd. LLC
 // 
 // All rights reserved.
 // 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 // *       Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 // *       Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 // *       Neither the name of Industrial Light & Magic nor the names of
 // its contributors may be used to endorse or promote products derived
 // from this software without specific prior written permission. 
 // 
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 ///////////////////////////////////////////////////////////////////////////
 // Primary authors:
 //     Florian Kainz <kainz@ilm.com>
 //     Rod Bogart <rgb@ilm.com>
 #ifndef INCLUDED_HALF_LIMITS_H
 #define INCLUDED_HALF_LIMITS_H
 //------------------------------------------------------------------------
 //
 //	C++ standard library-style numeric_limits for class half
 //
 //------------------------------------------------------------------------
 #include <limits>
 #include "half.h"
 namespace std {
 template <>
 class numeric_limits <half>
 {
  public:
    static const bool is_specialized = true;
    static half min () throw () {return HALF_NRM_MIN;}
    static half max () throw () {return HALF_MAX;}
    static const int digits = HALF_MANT_DIG;
    static const int digits10 = HALF_DIG;
    static const bool is_signed = true;
    static const bool is_integer = false;
    static const bool is_exact = false;
    static const int radix = HALF_RADIX;
    static half epsilon () throw () {return HALF_EPSILON;}
    static half round_error () throw () {return HALF_EPSILON / 2;}
    static const int min_exponent = HALF_MIN_EXP;
    static const int min_exponent10 = HALF_MIN_10_EXP;
    static const int max_exponent = HALF_MAX_EXP;
    static const int max_exponent10 = HALF_MAX_10_EXP;
    static const bool has_infinity = true;
    static const bool has_quiet_NaN = true;
    static const bool has_signaling_NaN = true;
    static const float_denorm_style has_denorm = denorm_present;
    static const bool has_denorm_loss = false;
    static half infinity () throw () {return half::posInf();}
    static half quiet_NaN () throw () {return half::qNan();}
    static half signaling_NaN () throw () {return half::sNan();}
    static half denorm_min () throw () {return HALF_MIN;}
    static const bool is_iec559 = false;
    static const bool is_bounded = false;
    static const bool is_modulo = false;
    static const bool traps = true;
    static const bool tinyness_before = false;
    static const float_round_style round_style = round_to_nearest;
 };
 } // namespace std
 #endif
--- a/3rdparty/openexr/Half/toFloat.cpp
+++ b/3rdparty/openexr/Half/toFloat.cpp
@ -0,0 +1,164 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
 // Digital Ltd. LLC
 // 
 // All rights reserved.
 // 
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 // *       Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 // *       Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 // *       Neither the name of Industrial Light & Magic nor the names of
 // its contributors may be used to endorse or promote products derived
 // from this software without specific prior written permission. 
 // 
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
 ///////////////////////////////////////////////////////////////////////////
 //---------------------------------------------------------------------------
 //
 //	toFloat
 //
 //	A program to generate the lookup table for half-to-float
 //	conversion needed by class half.
 //	The program loops over all 65536 possible half numbers,
 //	converts each of them to a float, and prints the result.
 //
 //---------------------------------------------------------------------------
 #include <iostream>
 #include <iomanip>
 using namespace std;
 //---------------------------------------------------
 // Interpret an unsigned short bit pattern as a half,
 // and convert that half to the corresponding float's
 // bit pattern.
 //---------------------------------------------------
 unsigned int
 halfToFloat (unsigned short y)
 {
    int s = (y >> 15) & 0x00000001;
    int e = (y >> 10) & 0x0000001f;
    int m =  y        & 0x000003ff;
    if (e == 0)
    {
 	if (m == 0)
 	{
 	    //
 	    // Plus or minus zero
 	    //
 	    return s << 31;
 	}
 	else
 	{
 	    //
 	    // Denormalized number -- renormalize it
 	    //
 	    while (!(m & 0x00000400))
 	    {
 		m <<= 1;
 		e -=  1;
 	    }
 	    e += 1;
 	    m &= ~0x00000400;
 	}
    }
    else if (e == 31)
    {
 	if (m == 0)
 	{
 	    //
 	    // Positive or negative infinity
 	    //
 	    return (s << 31) | 0x7f800000;
 	}
 	else
 	{
 	    //
 	    // Nan -- preserve sign and significand bits
 	    //
 	    return (s << 31) | 0x7f800000 | (m << 13);
 	}
    }
    //
    // Normalized number
    //
    e = e + (127 - 15);
    m = m << 13;
    //
    // Assemble s, e and m.
    //
    return (s << 31) | (e << 23) | m;
 }
 //---------------------------------------------
 // Main - prints the half-to-float lookup table
 //---------------------------------------------
 int
 main ()
 {
    cout.precision (9);
    cout.setf (ios_base::hex, ios_base::basefield);
    cout << "//\n"
 	    "// This is an automatically generated file.\n"
 	    "// Do not edit.\n"
 	    "//\n\n";
    cout << "{\n    ";
    const int iMax = (1 << 16);
    for (int i = 0; i < iMax; i++)
    {
 	cout << "{0x" << setfill ('0') << setw (8) << halfToFloat (i) << "}, ";
 	if (i % 4 == 3)
 	{
 	    cout << "\n";
 	    if (i < iMax - 1)
 		cout << "    ";
 	}
    }
    cout << "};\n";
    return 0;
 }
--- a/3rdparty/openexr/Half/toFloat.h
+++ b/3rdparty/openexr/Half/toFloat.h
--- a/3rdparty/openexr/Iex/Iex.h
+++ b/3rdparty/openexr/Iex/Iex.h
@ -0,0 +1,60 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IEX_H
 #define INCLUDED_IEX_H
 //--------------------------------
 //
 //	Exception handling
 //
 //--------------------------------
 #include "IexMacros.h"
 #include "IexBaseExc.h"
 #include "IexMathExc.h"
 #include "IexThrowErrnoExc.h"
 // Note that we do not include file IexErrnoExc.h here.  That file
 // defines over 150 classes and significantly slows down compilation.
 // If you throw ErrnoExc exceptions using the throwErrnoExc() function,
 // you don't need IexErrnoExc.h.  You have to include IexErrnoExc.h
 // only if you want to catch specific subclasses of ErrnoExc.
 #endif
--- a/3rdparty/openexr/Iex/IexBaseExc.cpp
+++ b/3rdparty/openexr/Iex/IexBaseExc.cpp
@ -0,0 +1,129 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //---------------------------------------------------------------------
 //
 //	Constructors and destructors for our exception base class.
 //
 //---------------------------------------------------------------------
 #include "IexBaseExc.h"
 namespace Iex {
 namespace {
 StackTracer currentStackTracer = 0;
 } // namespace
 void	
 setStackTracer (StackTracer stackTracer)
 {
    currentStackTracer = stackTracer;
 }
 StackTracer
 stackTracer ()
 {
    return currentStackTracer;
 }
 BaseExc::BaseExc (const char* s) throw () :
    std::string (s? s: ""),
    _stackTrace (currentStackTracer? currentStackTracer(): "")
 {
    // empty
 }
 BaseExc::BaseExc (const std::string &s) throw () :
    std::string (s),
    _stackTrace (currentStackTracer? currentStackTracer(): "")
 {
    // empty
 }
 BaseExc::BaseExc (std::stringstream &s) throw () :
    std::string (s.str()),
    _stackTrace (currentStackTracer? currentStackTracer(): "")
 {
    // empty
 }
 BaseExc::BaseExc (const BaseExc &be) throw () :
    std::string (be),
    _stackTrace (be._stackTrace)
 {
    // empty
 }
 BaseExc::~BaseExc () throw ()
 {
    // empty
 }
 const char *
 BaseExc::what () const throw ()
 {
    return c_str();
 }
 BaseExc &
 BaseExc::assign (std::stringstream &s)
 {
    std::string::assign (s.str());
    return *this;
 }
 BaseExc &
 BaseExc::append (std::stringstream &s)
 {
    std::string::append (s.str());
    return *this;
 }
 } // namespace Iex
--- a/3rdparty/openexr/Iex/IexBaseExc.h
+++ b/3rdparty/openexr/Iex/IexBaseExc.h
@ -0,0 +1,266 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IEXBASEEXC_H
 #define INCLUDED_IEXBASEEXC_H
 //----------------------------------------------------------
 //
 //	A general exception base class, and a few
 //	useful exceptions derived from the base class.
 //
 //----------------------------------------------------------
 #include <string>
 #include <exception>
 #include <sstream>
 namespace Iex {
 #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
 {
  public:
    //----------------------------
    // Constructors and destructor
    //----------------------------
    BaseExc (const char *s = 0) throw();	// std::string (s)
    BaseExc (const std::string &s) throw();	// std::string (s)
    BaseExc (std::stringstream &s) throw();	// std::string (s.str())
    BaseExc (const BaseExc &be) throw();
    virtual ~BaseExc () throw ();
    //--------------------------------------------
    // what() method -- e.what() returns e.c_str()
    //--------------------------------------------
    virtual const char * what () const throw ();
    //--------------------------------------------------
    // Convenient methods to change the exception's text
    //--------------------------------------------------
    BaseExc &		assign (std::stringstream &s);	// assign (s.str())
    BaseExc &		operator = (std::stringstream &s);
    BaseExc &		append (std::stringstream &s);	// append (s.str())
    BaseExc &		operator += (std::stringstream &s);
    //--------------------------------------------------
    // These methods from the base class get obscured by
    // the definitions above.
    //--------------------------------------------------
    BaseExc &		assign (const char *s);
    BaseExc &		operator = (const char *s);
    BaseExc &		append (const char *s);
    BaseExc &		operator += (const char *s);
    //--------------------------------------------------
    // Stack trace for the point at which the exception
    // was thrown.  The stack trace will be an empty
    // string unless a working stack-tracing routine
    // has been installed (see below, setStackTracer()).
    //--------------------------------------------------
    const std::string &	stackTrace () const;
  private:
    std::string		_stackTrace;
 };
 //-----------------------------------------------------
 // A macro to save typing when declararing an exception
 // class derived directly or indirectly from BaseExc:
 //-----------------------------------------------------
 #define DEFINE_EXC(name, base)				        \
    class name: public base				        \
    {							        \
      public:                                                   \
 	name (const char* text=0)      throw(): base (text) {}	\
 	name (const std::string &text) throw(): base (text) {}	\
 	name (std::stringstream &text) throw(): base (text) {}	\
    };
 //--------------------------------------------------------
 // Some exceptions which should be useful in most programs
 //--------------------------------------------------------
 DEFINE_EXC (ArgExc,   BaseExc) 	 // Invalid arguments to a function call
 DEFINE_EXC (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 (InputExc, BaseExc) 	 // Invalid input data, e.g. from a file
 DEFINE_EXC (IoExc, BaseExc) 	 // Input or output operation failed
 DEFINE_EXC (MathExc,  BaseExc) 	 // Arithmetic exception; more specific
 				 // exceptions derived from this class
 				 // are defined in ExcMath.h
 DEFINE_EXC (ErrnoExc, BaseExc) 	 // Base class for exceptions corresponding
 				 // to errno values (see errno.h); more
 				 // specific exceptions derived from this
 				 // class are defined in ExcErrno.h
 DEFINE_EXC (NoImplExc, BaseExc)  // Missing method exception e.g. from a
 				 // 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 (TypeExc, BaseExc) 	 // An object is an inappropriate type,
 				 // i.e. a dynamnic_cast failed.
 //----------------------------------------------------------------------
 // Stack-tracing support:
 // 
 // setStackTracer(st)
 //
 //	installs a stack-tracing routine, st, which will be called from
 //	class BaseExc's constructor every time an exception derived from
 //	BaseExc is thrown.  The stack-tracing routine should return a
 //	string that contains a printable representation of the program's
 //	current call stack.  This string will be stored in the BaseExc
 //	object; the string is accesible via the BaseExc::stackTrace()
 //	method.
 //
 // setStackTracer(0)
 //
 //	removes the current stack tracing routine.  When an exception
 //	derived from BaseExc is thrown, the stack trace string stored
 //	in the BaseExc object will be empty.
 //
 // stackTracer()
 //
 //	returns a pointer to the current stack-tracing routine, or 0
 //	if there is no current stack stack-tracing routine.
 // 
 //----------------------------------------------------------------------
 typedef std::string (* StackTracer) ();
 void		setStackTracer (StackTracer stackTracer);
 StackTracer	stackTracer ();
 //-----------------
 // Inline functions
 //-----------------
 inline BaseExc &
 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
--- a/3rdparty/openexr/Iex/IexErrnoExc.h
+++ b/3rdparty/openexr/Iex/IexErrnoExc.h
@ -0,0 +1,210 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IEXERRNOEXC_H
 #define INCLUDED_IEXERRNOEXC_H
 //----------------------------------------------------------------
 //
 //	Exceptions which correspond to "errno" error codes.
 //
 //----------------------------------------------------------------
 #include "IexBaseExc.h"
 namespace Iex {
 DEFINE_EXC (EpermExc, ErrnoExc)
 DEFINE_EXC (EnoentExc, ErrnoExc)
 DEFINE_EXC (EsrchExc, ErrnoExc)
 DEFINE_EXC (EintrExc, ErrnoExc)
 DEFINE_EXC (EioExc, ErrnoExc)
 DEFINE_EXC (EnxioExc, ErrnoExc)
 DEFINE_EXC (E2bigExc, ErrnoExc)
 DEFINE_EXC (EnoexecExc, ErrnoExc)
 DEFINE_EXC (EbadfExc, ErrnoExc)
 DEFINE_EXC (EchildExc, ErrnoExc)
 DEFINE_EXC (EagainExc, ErrnoExc)
 DEFINE_EXC (EnomemExc, ErrnoExc)
 DEFINE_EXC (EaccesExc, ErrnoExc)
 DEFINE_EXC (EfaultExc, ErrnoExc)
 DEFINE_EXC (EnotblkExc, ErrnoExc)
 DEFINE_EXC (EbusyExc, ErrnoExc)
 DEFINE_EXC (EexistExc, ErrnoExc)
 DEFINE_EXC (ExdevExc, ErrnoExc)
 DEFINE_EXC (EnodevExc, ErrnoExc)
 DEFINE_EXC (EnotdirExc, ErrnoExc)
 DEFINE_EXC (EisdirExc, ErrnoExc)
 DEFINE_EXC (EinvalExc, ErrnoExc)
 DEFINE_EXC (EnfileExc, ErrnoExc)
 DEFINE_EXC (EmfileExc, ErrnoExc)
 DEFINE_EXC (EnottyExc, ErrnoExc)
 DEFINE_EXC (EtxtbsyExc, ErrnoExc)
 DEFINE_EXC (EfbigExc, ErrnoExc)
 DEFINE_EXC (EnospcExc, ErrnoExc)
 DEFINE_EXC (EspipeExc, ErrnoExc)
 DEFINE_EXC (ErofsExc, ErrnoExc)
 DEFINE_EXC (EmlinkExc, ErrnoExc)
 DEFINE_EXC (EpipeExc, ErrnoExc)
 DEFINE_EXC (EdomExc, ErrnoExc)
 DEFINE_EXC (ErangeExc, ErrnoExc)
 DEFINE_EXC (EnomsgExc, ErrnoExc)
 DEFINE_EXC (EidrmExc, ErrnoExc)
 DEFINE_EXC (EchrngExc, ErrnoExc)
 DEFINE_EXC (El2nsyncExc, ErrnoExc)
 DEFINE_EXC (El3hltExc, ErrnoExc)
 DEFINE_EXC (El3rstExc, ErrnoExc)
 DEFINE_EXC (ElnrngExc, ErrnoExc)
 DEFINE_EXC (EunatchExc, ErrnoExc)
 DEFINE_EXC (EnocsiExc, ErrnoExc)
 DEFINE_EXC (El2hltExc, ErrnoExc)
 DEFINE_EXC (EdeadlkExc, ErrnoExc)
 DEFINE_EXC (EnolckExc, ErrnoExc)
 DEFINE_EXC (EbadeExc, ErrnoExc)
 DEFINE_EXC (EbadrExc, ErrnoExc)
 DEFINE_EXC (ExfullExc, ErrnoExc)
 DEFINE_EXC (EnoanoExc, ErrnoExc)
 DEFINE_EXC (EbadrqcExc, ErrnoExc)
 DEFINE_EXC (EbadsltExc, ErrnoExc)
 DEFINE_EXC (EdeadlockExc, ErrnoExc)
 DEFINE_EXC (EbfontExc, ErrnoExc)
 DEFINE_EXC (EnostrExc, ErrnoExc)
 DEFINE_EXC (EnodataExc, ErrnoExc)
 DEFINE_EXC (EtimeExc, ErrnoExc)
 DEFINE_EXC (EnosrExc, ErrnoExc)
 DEFINE_EXC (EnonetExc, ErrnoExc)
 DEFINE_EXC (EnopkgExc, ErrnoExc)
 DEFINE_EXC (EremoteExc, ErrnoExc)
 DEFINE_EXC (EnolinkExc, ErrnoExc)
 DEFINE_EXC (EadvExc, ErrnoExc)
 DEFINE_EXC (EsrmntExc, ErrnoExc)
 DEFINE_EXC (EcommExc, ErrnoExc)
 DEFINE_EXC (EprotoExc, ErrnoExc)
 DEFINE_EXC (EmultihopExc, ErrnoExc)
 DEFINE_EXC (EbadmsgExc, ErrnoExc)
 DEFINE_EXC (EnametoolongExc, ErrnoExc)
 DEFINE_EXC (EoverflowExc, ErrnoExc)
 DEFINE_EXC (EnotuniqExc, ErrnoExc)
 DEFINE_EXC (EbadfdExc, ErrnoExc)
 DEFINE_EXC (EremchgExc, ErrnoExc)
 DEFINE_EXC (ElibaccExc, ErrnoExc)
 DEFINE_EXC (ElibbadExc, ErrnoExc)
 DEFINE_EXC (ElibscnExc, ErrnoExc)
 DEFINE_EXC (ElibmaxExc, ErrnoExc)
 DEFINE_EXC (ElibexecExc, ErrnoExc)
 DEFINE_EXC (EilseqExc, ErrnoExc)
 DEFINE_EXC (EnosysExc, ErrnoExc)
 DEFINE_EXC (EloopExc, ErrnoExc)
 DEFINE_EXC (ErestartExc, ErrnoExc)
 DEFINE_EXC (EstrpipeExc, ErrnoExc)
 DEFINE_EXC (EnotemptyExc, ErrnoExc)
 DEFINE_EXC (EusersExc, ErrnoExc)
 DEFINE_EXC (EnotsockExc, ErrnoExc)
 DEFINE_EXC (EdestaddrreqExc, ErrnoExc)
 DEFINE_EXC (EmsgsizeExc, ErrnoExc)
 DEFINE_EXC (EprototypeExc, ErrnoExc)
 DEFINE_EXC (EnoprotooptExc, ErrnoExc)
 DEFINE_EXC (EprotonosupportExc, ErrnoExc)
 DEFINE_EXC (EsocktnosupportExc, ErrnoExc)
 DEFINE_EXC (EopnotsuppExc, ErrnoExc)
 DEFINE_EXC (EpfnosupportExc, ErrnoExc)
 DEFINE_EXC (EafnosupportExc, ErrnoExc)
 DEFINE_EXC (EaddrinuseExc, ErrnoExc)
 DEFINE_EXC (EaddrnotavailExc, ErrnoExc)
 DEFINE_EXC (EnetdownExc, ErrnoExc)
 DEFINE_EXC (EnetunreachExc, ErrnoExc)
 DEFINE_EXC (EnetresetExc, ErrnoExc)
 DEFINE_EXC (EconnabortedExc, ErrnoExc)
 DEFINE_EXC (EconnresetExc, ErrnoExc)
 DEFINE_EXC (EnobufsExc, ErrnoExc)
 DEFINE_EXC (EisconnExc, ErrnoExc)
 DEFINE_EXC (EnotconnExc, ErrnoExc)
 DEFINE_EXC (EshutdownExc, ErrnoExc)
 DEFINE_EXC (EtoomanyrefsExc, ErrnoExc)
 DEFINE_EXC (EtimedoutExc, ErrnoExc)
 DEFINE_EXC (EconnrefusedExc, ErrnoExc)
 DEFINE_EXC (EhostdownExc, ErrnoExc)
 DEFINE_EXC (EhostunreachExc, ErrnoExc)
 DEFINE_EXC (EalreadyExc, ErrnoExc)
 DEFINE_EXC (EinprogressExc, ErrnoExc)
 DEFINE_EXC (EstaleExc, ErrnoExc)
 DEFINE_EXC (EioresidExc, ErrnoExc)
 DEFINE_EXC (EucleanExc, ErrnoExc)
 DEFINE_EXC (EnotnamExc, ErrnoExc)
 DEFINE_EXC (EnavailExc, ErrnoExc)
 DEFINE_EXC (EisnamExc, ErrnoExc)
 DEFINE_EXC (EremoteioExc, ErrnoExc)
 DEFINE_EXC (EinitExc, ErrnoExc)
 DEFINE_EXC (EremdevExc, ErrnoExc)
 DEFINE_EXC (EcanceledExc, ErrnoExc)
 DEFINE_EXC (EnolimfileExc, ErrnoExc)
 DEFINE_EXC (EproclimExc, ErrnoExc)
 DEFINE_EXC (EdisjointExc, ErrnoExc)
 DEFINE_EXC (EnologinExc, ErrnoExc)
 DEFINE_EXC (EloginlimExc, ErrnoExc)
 DEFINE_EXC (EgrouploopExc, ErrnoExc)
 DEFINE_EXC (EnoattachExc, ErrnoExc)
 DEFINE_EXC (EnotsupExc, ErrnoExc)
 DEFINE_EXC (EnoattrExc, ErrnoExc)
 DEFINE_EXC (EdircorruptedExc, ErrnoExc)
 DEFINE_EXC (EdquotExc, ErrnoExc)
 DEFINE_EXC (EnfsremoteExc, ErrnoExc)
 DEFINE_EXC (EcontrollerExc, ErrnoExc)
 DEFINE_EXC (EnotcontrollerExc, ErrnoExc)
 DEFINE_EXC (EenqueuedExc, ErrnoExc)
 DEFINE_EXC (EnotenqueuedExc, ErrnoExc)
 DEFINE_EXC (EjoinedExc, ErrnoExc)
 DEFINE_EXC (EnotjoinedExc, ErrnoExc)
 DEFINE_EXC (EnoprocExc, ErrnoExc)
 DEFINE_EXC (EmustrunExc, ErrnoExc)
 DEFINE_EXC (EnotstoppedExc, ErrnoExc)
 DEFINE_EXC (EclockcpuExc, ErrnoExc)
 DEFINE_EXC (EinvalstateExc, ErrnoExc)
 DEFINE_EXC (EnoexistExc, ErrnoExc)
 DEFINE_EXC (EendofminorExc, ErrnoExc)
 DEFINE_EXC (EbufsizeExc, ErrnoExc)
 DEFINE_EXC (EemptyExc, ErrnoExc)
 DEFINE_EXC (EnointrgroupExc, ErrnoExc)
 DEFINE_EXC (EinvalmodeExc, ErrnoExc)
 DEFINE_EXC (EcantextentExc, ErrnoExc)
 DEFINE_EXC (EinvaltimeExc, ErrnoExc)
 DEFINE_EXC (EdestroyedExc, ErrnoExc)
 } // namespace Iex
 #endif
--- a/3rdparty/openexr/Iex/IexMacros.h
+++ b/3rdparty/openexr/Iex/IexMacros.h
@ -0,0 +1,148 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IEXMACROS_H
 #define INCLUDED_IEXMACROS_H
 //--------------------------------------------------------------------
 //
 //	Macros which make throwing exceptions more convenient
 //
 //--------------------------------------------------------------------
 #include <sstream>
 //----------------------------------------------------------------------------
 // A macro to throw exceptions whose text is assembled using stringstreams.
 //
 // Example:
 //
 //	THROW (InputExc, "Syntax error in line " << line ", " << file << ".");
 //	
 //----------------------------------------------------------------------------
 #define THROW(type, text)	\
    do				\
    {				\
 	std::stringstream s;	\
 	s << text;		\
 	throw type (s);		\
    }				\
    while (0)
 //----------------------------------------------------------------------------
 // Macros to add to or to replace the text of an exception.
 // The new text is assembled using stringstreams.
 //
 // Examples:
 //
 // Append to end of an exception's text:
 //
 //	catch (BaseExc &e)
 //	{
 //	    APPEND_EXC (e, " Directory " << name << " does not exist.");
 //	    throw;
 //	}
 //
 // Replace an exception's text:
 //
 //	catch (BaseExc &e)
 //	{
 //	    REPLACE_EXC (e, "Directory " << name << " does not exist. " << e);
 //	    throw;
 //	}
 //----------------------------------------------------------------------------
 #define APPEND_EXC(exc, text)	\
    do				\
    {				\
 	std::stringstream s;	\
 	s << text;		\
 	exc.append (s);		\
    }				\
    while (0)
 #define REPLACE_EXC(exc, text)	\
    do				\
    {				\
 	std::stringstream s;	\
 	s << text;		\
 	exc.assign (s);		\
    }				\
    while (0)
 //-------------------------------------------------------------
 // A macro to throw ErrnoExc exceptions whose text is assembled
 // using stringstreams:
 //
 // Example:
 //
 //	THROW_ERRNO ("Cannot open file " << name << " (%T).");
 //
 //-------------------------------------------------------------
 #define THROW_ERRNO(text)		\
    do					\
    {					\
 	std::stringstream s;		\
 	s << text;			\
 	::Iex::throwErrnoExc (s.str());	\
    }					\
    while (0)
 //-------------------------------------------------------------
 // A macro to throw exceptions if an assertion is false.
 //
 // Example:
 //
 //	ASSERT (ptr != NULL, NullExc, "Null pointer" );
 //
 //-------------------------------------------------------------
 #define ASSERT(assertion, type, text)   \
    do                                  \
    {                                   \
 	if ((assertion) == false)       \
 	    THROW (type, text);         \
    }                                   \
    while (0)
 #endif
--- a/3rdparty/openexr/Iex/IexMathExc.h
+++ b/3rdparty/openexr/Iex/IexMathExc.h
@ -0,0 +1,58 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IEXMATHEXC_H
 #define INCLUDED_IEXMATHEXC_H
 #include "IexBaseExc.h"
 namespace Iex {
 //---------------------------------------------------------
 // Exception classess which correspond to specific floating
 // point exceptions.
 //---------------------------------------------------------
 DEFINE_EXC (OverflowExc,    MathExc)	// Overflow
 DEFINE_EXC (UnderflowExc,   MathExc)	// Underflow
 DEFINE_EXC (DivzeroExc,     MathExc)	// Division by zero
 DEFINE_EXC (InexactExc,     MathExc)	// Inexact result
 DEFINE_EXC (InvalidFpOpExc, MathExc)	// Invalid operation
 } // namespace Iex
 #endif
--- a/3rdparty/openexr/Iex/IexThrowErrnoExc.cpp
+++ b/3rdparty/openexr/Iex/IexThrowErrnoExc.cpp
@ -0,0 +1,859 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //----------------------------------------------------------------
 //
 //	Exceptions that correspond to "errno" error codes,
 //	and a function to make throwing those exceptions easy.
 //
 //----------------------------------------------------------------
 #include "IexThrowErrnoExc.h"
 #include "IexErrnoExc.h"
 #include <string.h>
 #include <errno.h>
 namespace Iex {
 void throwErrnoExc (const std::string &text, int errnum)
 {
    const char *entext = strerror (errnum);
    std::string tmp (text);
    std::string::size_type pos;
    while (std::string::npos != (pos = tmp.find ("%T")))
 	tmp.replace (pos, 2, entext, strlen (entext));
    switch (errnum)
    {
      #if defined (EPERM)
 	  case EPERM:
 	    throw EpermExc (tmp);
      #endif
      #if defined (ENOENT)
 	  case ENOENT:
 	    throw EnoentExc (tmp);
      #endif
      #if defined (ESRCH)
 	  case ESRCH:
 	    throw EsrchExc (tmp);
      #endif
      #if defined (EINTR)
 	  case EINTR:
 	    throw EintrExc (tmp);
      #endif
      #if defined (EIO)
 	  case EIO:
 	    throw EioExc (tmp);
      #endif
      #if defined (ENXIO)
 	  case ENXIO:
 	    throw EnxioExc (tmp);
      #endif
      #if defined (E2BIG)
 	  case E2BIG:
 	    throw E2bigExc (tmp);
      #endif
      #if defined (ENOEXEC)
 	  case ENOEXEC:
 	    throw EnoexecExc (tmp);
      #endif
      #if defined (EBADF)
 	  case EBADF:
 	    throw EbadfExc (tmp);
      #endif
      #if defined (ECHILD)
 	  case ECHILD:
 	    throw EchildExc (tmp);
      #endif
      #if defined (EAGAIN)
 	  case EAGAIN:
 	    throw EagainExc (tmp);
      #endif
      #if defined (ENOMEM)
 	  case ENOMEM:
 	    throw EnomemExc (tmp);
      #endif
      #if defined (EACCES)
 	  case EACCES:
 	    throw EaccesExc (tmp);
      #endif
      #if defined (EFAULT)
 	  case EFAULT:
 	    throw EfaultExc (tmp);
      #endif
      #if defined (ENOTBLK)
 	  case ENOTBLK:
 	    throw EnotblkExc (tmp);
      #endif
      #if defined (EBUSY)
 	  case EBUSY:
 	    throw EbusyExc (tmp);
      #endif
      #if defined (EEXIST)
 	  case EEXIST:
 	    throw EexistExc (tmp);
      #endif
      #if defined (EXDEV)
 	  case EXDEV:
 	    throw ExdevExc (tmp);
      #endif
      #if defined (ENODEV)
 	  case ENODEV:
 	    throw EnodevExc (tmp);
      #endif
      #if defined (ENOTDIR)
 	  case ENOTDIR:
 	    throw EnotdirExc (tmp);
      #endif
      #if defined (EISDIR)
 	  case EISDIR:
 	    throw EisdirExc (tmp);
      #endif
      #if defined (EINVAL)
 	  case EINVAL:
 	    throw EinvalExc (tmp);
      #endif
      #if defined (ENFILE)
 	  case ENFILE:
 	    throw EnfileExc (tmp);
      #endif
      #if defined (EMFILE)
 	  case EMFILE:
 	    throw EmfileExc (tmp);
      #endif
      #if defined (ENOTTY)
 	  case ENOTTY:
 	    throw EnottyExc (tmp);
      #endif
      #if defined (ETXTBSY)
 	  case ETXTBSY:
 	    throw EtxtbsyExc (tmp);
      #endif
      #if defined (EFBIG)
 	  case EFBIG:
 	    throw EfbigExc (tmp);
      #endif
      #if defined (ENOSPC)
 	  case ENOSPC:
 	    throw EnospcExc (tmp);
      #endif
      #if defined (ESPIPE)
 	  case ESPIPE:
 	    throw EspipeExc (tmp);
      #endif
      #if defined (EROFS)
 	  case EROFS:
 	    throw ErofsExc (tmp);
      #endif
      #if defined (EMLINK)
 	  case EMLINK:
 	    throw EmlinkExc (tmp);
      #endif
      #if defined (EPIPE)
 	  case EPIPE:
 	    throw EpipeExc (tmp);
      #endif
      #if defined (EDOM)
 	  case EDOM:
 	    throw EdomExc (tmp);
      #endif
      #if defined (ERANGE)
 	  case ERANGE:
 	    throw ErangeExc (tmp);
      #endif
      #if defined (ENOMSG)
 	  case ENOMSG:
 	    throw EnomsgExc (tmp);
      #endif
      #if defined (EIDRM)
 	  case EIDRM:
 	    throw EidrmExc (tmp);
      #endif
      #if defined (ECHRNG)
 	  case ECHRNG:
 	    throw EchrngExc (tmp);
      #endif
      #if defined (EL2NSYNC)
 	  case EL2NSYNC:
 	    throw El2nsyncExc (tmp);
      #endif
      #if defined (EL3HLT)
 	  case EL3HLT:
 	    throw El3hltExc (tmp);
      #endif
      #if defined (EL3RST)
 	  case EL3RST:
 	    throw El3rstExc (tmp);
      #endif
      #if defined (ELNRNG)
 	  case ELNRNG:
 	    throw ElnrngExc (tmp);
      #endif
      #if defined (EUNATCH)
 	  case EUNATCH:
 	    throw EunatchExc (tmp);
      #endif
      #if defined (ENOSCI)
 	  case ENOCSI:
 	    throw EnocsiExc (tmp);
      #endif
      #if defined (EL2HLT)
 	  case EL2HLT:
 	    throw El2hltExc (tmp);
      #endif
      #if defined (EDEADLK)
 	  case EDEADLK:
 	    throw EdeadlkExc (tmp);
      #endif
      #if defined (ENOLCK)
 	  case ENOLCK:
 	    throw EnolckExc (tmp);
      #endif
      #if defined (EBADE)
 	  case EBADE:
 	    throw EbadeExc (tmp);
      #endif
      #if defined (EBADR)
 	  case EBADR:
 	    throw EbadrExc (tmp);
      #endif
      #if defined (EXFULL)
 	  case EXFULL:
 	    throw ExfullExc (tmp);
      #endif
      #if defined (ENOANO)
 	  case ENOANO:
 	    throw EnoanoExc (tmp);
      #endif
      #if defined (EBADRQC)
 	  case EBADRQC:
 	    throw EbadrqcExc (tmp);
      #endif
      #if defined (EBADSLT)
 	  case EBADSLT:
 	    throw EbadsltExc (tmp);
      #endif
      #if defined (EDEADLOCK) && defined (EDEADLK)
 	  #if EDEADLOCK != EDEADLK
 	      case EDEADLOCK:
 		throw EdeadlockExc (tmp);
 	  #endif
      #elif defined (EDEADLOCK)
 	  case EDEADLOCK:
 	    throw EdeadlockExc (tmp);
      #endif
      #if defined (EBFONT)
 	  case EBFONT:
 	    throw EbfontExc (tmp);
      #endif
      #if defined (ENOSTR)
 	  case ENOSTR:
 	    throw EnostrExc (tmp);
      #endif
      #if defined (ENODATA)
 	  case ENODATA:
 	    throw EnodataExc (tmp);
      #endif
      #if defined (ETIME)
 	  case ETIME:
 	    throw EtimeExc (tmp);
      #endif
      #if defined (ENOSR)
 	  case ENOSR:
 	    throw EnosrExc (tmp);
      #endif
      #if defined (ENONET)
 	  case ENONET:
 	    throw EnonetExc (tmp);
      #endif
      #if defined (ENOPKG)
 	  case ENOPKG:
 	    throw EnopkgExc (tmp);
      #endif
      #if defined (EREMOTE)
 	  case EREMOTE:
 	    throw EremoteExc (tmp);
      #endif
      #if defined (ENOLINK)
 	  case ENOLINK:
 	    throw EnolinkExc (tmp);
      #endif
      #if defined (EADV)
 	  case EADV:
 	    throw EadvExc (tmp);
      #endif
      #if defined (ESRMNT)
 	  case ESRMNT:
 	    throw EsrmntExc (tmp);
      #endif
      #if defined (ECOMM)
 	  case ECOMM:
 	    throw EcommExc (tmp);
      #endif
      #if defined (EPROTO)
 	  case EPROTO:
 	    throw EprotoExc (tmp);
      #endif
      #if defined (EMULTIHOP)
 	  case EMULTIHOP:
 	    throw EmultihopExc (tmp);
      #endif
      #if defined (EBADMSG)
 	  case EBADMSG:
 	    throw EbadmsgExc (tmp);
      #endif
      #if defined (ENAMETOOLONG)
 	  case ENAMETOOLONG:
 	    throw EnametoolongExc (tmp);
      #endif
      #if defined (EOVERFLOW)
 	  case EOVERFLOW:
 	    throw EoverflowExc (tmp);
      #endif
      #if defined (ENOTUNIQ)
 	  case ENOTUNIQ:
 	    throw EnotuniqExc (tmp);
      #endif
      #if defined (EBADFD)
 	  case EBADFD:
 	    throw EbadfdExc (tmp);
      #endif
      #if defined (EREMCHG)
 	  case EREMCHG:
 	    throw EremchgExc (tmp);
      #endif
      #if defined (ELIBACC)
 	  case ELIBACC:
 	    throw ElibaccExc (tmp);
      #endif
      #if defined (ELIBBAD)
 	  case ELIBBAD:
 	    throw ElibbadExc (tmp);
      #endif
      #if defined (ELIBSCN)
 	  case ELIBSCN:
 	    throw ElibscnExc (tmp);
      #endif
      #if defined (ELIBMAX)
 	  case ELIBMAX:
 	    throw ElibmaxExc (tmp);
      #endif
      #if defined (ELIBEXEC)
 	  case ELIBEXEC:
 	    throw ElibexecExc (tmp);
      #endif
      #if defined (EILSEQ)
 	  case EILSEQ:
 	    throw EilseqExc (tmp);
      #endif
      #if defined (ENOSYS)
 	  case ENOSYS:
 	    throw EnosysExc (tmp);
      #endif
      #if defined (ELOOP)
 	  case ELOOP:
 	    throw EloopExc (tmp);
      #endif
      #if defined (ERESTART)
 	  case ERESTART:
 	    throw ErestartExc (tmp);
      #endif
      #if defined (ESTRPIPE)
 	  case ESTRPIPE:
 	    throw EstrpipeExc (tmp);
      #endif
      #if defined (ENOTEMPTY)
 	  case ENOTEMPTY:
 	    throw EnotemptyExc (tmp);
      #endif
      #if defined (EUSERS)
 	  case EUSERS:
 	    throw EusersExc (tmp);
      #endif
      #if defined (ENOTSOCK)
 	  case ENOTSOCK:
 	    throw EnotsockExc (tmp);
      #endif
      #if defined (EDESTADDRREQ)
 	  case EDESTADDRREQ:
 	    throw EdestaddrreqExc (tmp);
      #endif
      #if defined (EMSGSIZE)
 	  case EMSGSIZE:
 	    throw EmsgsizeExc (tmp);
      #endif
      #if defined (EPROTOTYPE)
 	  case EPROTOTYPE:
 	    throw EprototypeExc (tmp);
      #endif
      #if defined (ENOPROTOOPT)
 	  case ENOPROTOOPT:
 	    throw EnoprotooptExc (tmp);
      #endif
      #if defined (EPROTONOSUPPORT)
 	  case EPROTONOSUPPORT:
 	    throw EprotonosupportExc (tmp);
      #endif
      #if defined (ESOCKTNOSUPPORT)
 	  case ESOCKTNOSUPPORT:
 	    throw EsocktnosupportExc (tmp);
      #endif
      #if defined (EOPNOTSUPP)
 	  case EOPNOTSUPP:
 	    throw EopnotsuppExc (tmp);
      #endif
      #if defined (EPFNOSUPPORT)
 	  case EPFNOSUPPORT:
 	    throw EpfnosupportExc (tmp);
      #endif
      #if defined (EAFNOSUPPORT)
 	  case EAFNOSUPPORT:
 	    throw EafnosupportExc (tmp);
      #endif
      #if defined (EADDRINUSE)
 	  case EADDRINUSE:
 	    throw EaddrinuseExc (tmp);
      #endif
      #if defined (EADDRNOTAVAIL)
 	  case EADDRNOTAVAIL:
 	    throw EaddrnotavailExc (tmp);
      #endif
      #if defined (ENETDOWN)
 	  case ENETDOWN:
 	    throw EnetdownExc (tmp);
      #endif
      #if defined (ENETUNREACH)
 	  case ENETUNREACH:
 	    throw EnetunreachExc (tmp);
      #endif
      #if defined (ENETRESET)
 	  case ENETRESET:
 	    throw EnetresetExc (tmp);
      #endif
      #if defined (ECONNABORTED)
 	  case ECONNABORTED:
 	    throw EconnabortedExc (tmp);
      #endif
      #if defined (ECONNRESET)
 	  case ECONNRESET:
 	    throw EconnresetExc (tmp);
      #endif
      #if defined (ENOBUFS)
 	  case ENOBUFS:
 	    throw EnobufsExc (tmp);
      #endif
      #if defined (EISCONN)
 	  case EISCONN:
 	    throw EisconnExc (tmp);
      #endif
      #if defined (ENOTCONN)
 	  case ENOTCONN:
 	    throw EnotconnExc (tmp);
      #endif
      #if defined (ESHUTDOWN)
 	  case ESHUTDOWN:
 	    throw EshutdownExc (tmp);
      #endif
      #if defined (ETOOMANYREFS)
 	  case ETOOMANYREFS:
 	    throw EtoomanyrefsExc (tmp);
      #endif
      #if defined (ETIMEDOUT)
 	  case ETIMEDOUT:
 	    throw EtimedoutExc (tmp);
      #endif
      #if defined (ECONNREFUSED)
 	  case ECONNREFUSED:
 	    throw EconnrefusedExc (tmp);
      #endif
      #if defined (EHOSTDOWN)
 	  case EHOSTDOWN:
 	    throw EhostdownExc (tmp);
      #endif
      #if defined (EHOSTUNREACH)
 	  case EHOSTUNREACH:
 	    throw EhostunreachExc (tmp);
      #endif
      #if defined (EALREADY)
 	  case EALREADY:
 	    throw EalreadyExc (tmp);
      #endif
      #if defined (EINPROGRESS)
 	  case EINPROGRESS:
 	    throw EinprogressExc (tmp);
      #endif
      #if defined (ESTALE)
 	  case ESTALE:
 	    throw EstaleExc (tmp);
      #endif
      #if defined (EIORESID)
 	  case EIORESID:
 	    throw EioresidExc (tmp);
      #endif
      #if defined (EUCLEAN)
 	  case EUCLEAN:
 	    throw EucleanExc (tmp);
      #endif
      #if defined (ENOTNAM)
 	  case ENOTNAM:
 	    throw EnotnamExc (tmp);
      #endif
      #if defined (ENAVAIL)
 	  case ENAVAIL:
 	    throw EnavailExc (tmp);
      #endif
      #if defined (EISNAM)
 	  case EISNAM:
 	    throw EisnamExc (tmp);
      #endif
      #if defined (EREMOTEIO)
 	  case EREMOTEIO:
 	    throw EremoteioExc (tmp);
      #endif
      #if defined (EINIT)
 	  case EINIT:
 	    throw EinitExc (tmp);
      #endif
      #if defined (EREMDEV)
 	  case EREMDEV:
 	    throw EremdevExc (tmp);
      #endif
      #if defined (ECANCELED)
 	  case ECANCELED:
 	    throw EcanceledExc (tmp);
      #endif
      #if defined (ENOLIMFILE)
 	  case ENOLIMFILE:
 	    throw EnolimfileExc (tmp);
      #endif
      #if defined (EPROCLIM)
 	  case EPROCLIM:
 	    throw EproclimExc (tmp);
      #endif
      #if defined (EDISJOINT)
 	  case EDISJOINT:
 	    throw EdisjointExc (tmp);
      #endif
      #if defined (ENOLOGIN)
 	  case ENOLOGIN:
 	    throw EnologinExc (tmp);
      #endif
      #if defined (ELOGINLIM)
 	  case ELOGINLIM:
 	    throw EloginlimExc (tmp);
      #endif
      #if defined (EGROUPLOOP)
 	  case EGROUPLOOP:
 	    throw EgrouploopExc (tmp);
      #endif
      #if defined (ENOATTACH)
 	  case ENOATTACH:
 	    throw EnoattachExc (tmp);
      #endif
      #if defined (ENOTSUP) && defined (EOPNOTSUPP)
 	  #if ENOTSUP != EOPNOTSUPP
 	      case ENOTSUP:
 		throw EnotsupExc (tmp);
 	  #endif
      #elif defined (ENOTSUP)
 	  case ENOTSUP:
 	    throw EnotsupExc (tmp);
      #endif
      #if defined (ENOATTR)
 	  case ENOATTR:
 	    throw EnoattrExc (tmp);
      #endif
      #if defined (EDIRCORRUPTED)
 	  case EDIRCORRUPTED:
 	    throw EdircorruptedExc (tmp);
      #endif
      #if defined (EDQUOT)
 	  case EDQUOT:
 	    throw EdquotExc (tmp);
      #endif
      #if defined (ENFSREMOTE)
 	  case ENFSREMOTE:
 	    throw EnfsremoteExc (tmp);
      #endif
      #if defined (ECONTROLLER)
 	  case ECONTROLLER:
 	    throw EcontrollerExc (tmp);
      #endif
      #if defined (ENOTCONTROLLER)
 	  case ENOTCONTROLLER:
 	    throw EnotcontrollerExc (tmp);
      #endif
      #if defined (EENQUEUED)
 	  case EENQUEUED:
 	    throw EenqueuedExc (tmp);
      #endif
      #if defined (ENOTENQUEUED)
 	  case ENOTENQUEUED:
 	    throw EnotenqueuedExc (tmp);
      #endif
      #if defined (EJOINED)
 	  case EJOINED:
 	    throw EjoinedExc (tmp);
      #endif
      #if defined (ENOTJOINED)
 	  case ENOTJOINED:
 	    throw EnotjoinedExc (tmp);
      #endif
      #if defined (ENOPROC)
 	  case ENOPROC:
 	    throw EnoprocExc (tmp);
      #endif
      #if defined (EMUSTRUN)
 	  case EMUSTRUN:
 	    throw EmustrunExc (tmp);
      #endif
      #if defined (ENOTSTOPPED)
 	  case ENOTSTOPPED:
 	    throw EnotstoppedExc (tmp);
      #endif
      #if defined (ECLOCKCPU)
 	  case ECLOCKCPU:
 	    throw EclockcpuExc (tmp);
      #endif
      #if defined (EINVALSTATE)
 	  case EINVALSTATE:
 	    throw EinvalstateExc (tmp);
      #endif
      #if defined (ENOEXIST)
 	  case ENOEXIST:
 	    throw EnoexistExc (tmp);
      #endif
      #if defined (EENDOFMINOR)
 	  case EENDOFMINOR:
 	    throw EendofminorExc (tmp);
      #endif
      #if defined (EBUFSIZE)
 	  case EBUFSIZE:
 	    throw EbufsizeExc (tmp);
      #endif
      #if defined (EEMPTY)
 	  case EEMPTY:
 	    throw EemptyExc (tmp);
      #endif
      #if defined (ENOINTRGROUP)
 	  case ENOINTRGROUP:
 	    throw EnointrgroupExc (tmp);
      #endif
      #if defined (EINVALMODE)
 	  case EINVALMODE:
 	    throw EinvalmodeExc (tmp);
      #endif
      #if defined (ECANTEXTENT)
 	  case ECANTEXTENT:
 	    throw EcantextentExc (tmp);
      #endif
      #if defined (EINVALTIME)
 	  case EINVALTIME:
 	    throw EinvaltimeExc (tmp);
      #endif
      #if defined (EDESTROYED)
 	  case EDESTROYED:
 	    throw EdestroyedExc (tmp);
      #endif
    }
    throw ErrnoExc (tmp);
 }
 void throwErrnoExc (const std::string &text)
 {
    throwErrnoExc (text, errno);
 }
 } // namespace Iex
--- a/3rdparty/openexr/Iex/IexThrowErrnoExc.h
+++ b/3rdparty/openexr/Iex/IexThrowErrnoExc.h
@ -0,0 +1,96 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IEXTHROWERRNOEXC_H
 #define INCLUDED_IEXTHROWERRNOEXC_H
 //----------------------------------------------------------
 //
 //	A function which throws ExcErrno exceptions
 //
 //----------------------------------------------------------
 #include "IexBaseExc.h"
 namespace Iex {
 //--------------------------------------------------------------------------
 //
 // Function throwErrnoExc() throws an exception which corresponds to
 // error code errnum.  The exception text is initialized with a copy
 // of the string passed to throwErrnoExc(), where all occurrences of
 // "%T" have been replaced with the output of strerror(oserror()).
 //
 // Example:
 //   
 // If opening file /tmp/output failed with an ENOENT error code,
 // calling
 //
 //	throwErrnoExc ();
 //
 // or
 //
 //	throwErrnoExc ("%T.");
 //
 // will throw an EnoentExc whose text reads
 //
 //	No such file or directory.
 //
 // More detailed messages can be assembled using stringstreams:
 //
 //	std::stringstream s;
 //	s << "Cannot open file " << name << " (%T).";
 //	throwErrnoExc (s);
 //
 // The resulting exception contains the following text:
 //
 //	Cannot open file /tmp/output (No such file or directory).
 //
 // Alternatively, you may want to use the THROW_ERRNO macro defined
 // in IexMacros.h:
 //
 //	THROW_ERRNO ("Cannot open file " << name << " (%T).")
 //
 //--------------------------------------------------------------------------
 void throwErrnoExc (const std::string &txt, int errnum);
 void throwErrnoExc (const std::string &txt = "%T." /*, int errnum = oserror() */);
 } // namespace Iex
 #endif
--- a/3rdparty/openexr/IlmBaseConfig.h.cmakein
+++ b/3rdparty/openexr/IlmBaseConfig.h.cmakein
@ -0,0 +1,30 @@
 //
 // 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.
 //
 #cmakedefine01 HAVE_PTHREAD
 //
 // Define and set to 1 if the target system supports POSIX semaphores
 // and you want OpenEXR to use them; otherwise, OpenEXR will use its
 // own semaphore implementation.
 //
 #cmakedefine01 HAVE_POSIX_SEMAPHORES
 #undef HAVE_UCONTEXT_H
 //
 // Define and set to 1 if the target system has support for large
 // stack sizes.
 //
 #undef ILMBASE_HAVE_LARGE_STACK
 //
 // Version string for runtime access
 //
 #define ILMBASE_VERSION_STRING "1.0.3"
 #define ILMBASE_PACKAGE_STRING "IlmBase 1.0.3"
--- a/3rdparty/openexr/IlmImf/ImfAcesFile.cpp
+++ b/3rdparty/openexr/IlmImf/ImfAcesFile.cpp
@ -0,0 +1,631 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2007, 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	ACES image file I/O.
 //	
 //-----------------------------------------------------------------------------
 #include <ImfAcesFile.h>
 #include <ImfRgbaFile.h>
 #include <ImfStandardAttributes.h>
 #include <Iex.h>
 using namespace std;
 using namespace Imath;
 using namespace Iex;
 namespace Imf {
 const Chromaticities &
 acesChromaticities ()
 {
    static const Chromaticities acesChr 
 	    (V2f (0.73470,  0.26530),	// red
 	     V2f (0.00000,  1.00000),	// green
 	     V2f (0.00010, -0.07700),	// blue
 	     V2f (0.32168,  0.33767));	// white
    return acesChr;
 }
 class AcesOutputFile::Data
 {
  public:
     Data();
    ~Data();
    RgbaOutputFile *	rgbaFile;
 };
 AcesOutputFile::Data::Data ():
    rgbaFile (0)
 {
    // empty
 }
 AcesOutputFile::Data::~Data ()
 {
    delete rgbaFile;
 }
 namespace {
 void
 checkCompression (Compression compression)
 {
    //
    // Not all compression methods are allowed in ACES files.
    //
    switch (compression)
    {
      case NO_COMPRESSION:
      case PIZ_COMPRESSION:
      case B44A_COMPRESSION:
 	break;
      default:
 	throw ArgExc ("Invalid compression type for ACES file.");
    }
 }
 } // namespace
 AcesOutputFile::AcesOutputFile
    (const std::string &name,
     const Header &header,
     RgbaChannels rgbaChannels,
     int numThreads)
 :
    _data (new Data)
 {
    checkCompression (header.compression());
    Header newHeader = header;
    addChromaticities (newHeader, acesChromaticities());
    addAdoptedNeutral (newHeader, acesChromaticities().white);
    _data->rgbaFile = new RgbaOutputFile (name.c_str(),
 					  newHeader,
 					  rgbaChannels,
 					  numThreads);
    _data->rgbaFile->setYCRounding (7, 6);
 }
 AcesOutputFile::AcesOutputFile
    (OStream &os,
     const Header &header,
     RgbaChannels rgbaChannels,
     int numThreads)
 :
    _data (new Data)
 {
    checkCompression (header.compression());
    Header newHeader = header;
    addChromaticities (newHeader, acesChromaticities());
    addAdoptedNeutral (newHeader, acesChromaticities().white);
    _data->rgbaFile = new RgbaOutputFile (os,
 					  header,
 					  rgbaChannels,
 					  numThreads);
    _data->rgbaFile->setYCRounding (7, 6);
 }
 AcesOutputFile::AcesOutputFile
    (const std::string &name,
     const Imath::Box2i &displayWindow,
     const Imath::Box2i &dataWindow,
     RgbaChannels rgbaChannels,
     float pixelAspectRatio,
     const Imath::V2f screenWindowCenter,
     float screenWindowWidth,
     LineOrder lineOrder,
     Compression compression,
     int numThreads)
 :
    _data (new Data)
 {
    checkCompression (compression);
    Header newHeader (displayWindow,
 		      dataWindow.isEmpty()? displayWindow: dataWindow,
 		      pixelAspectRatio,
 		      screenWindowCenter,
 		      screenWindowWidth,
 		      lineOrder,
 		      compression);
    addChromaticities (newHeader, acesChromaticities());
    addAdoptedNeutral (newHeader, acesChromaticities().white);
    _data->rgbaFile = new RgbaOutputFile (name.c_str(),
 					  newHeader,
 					  rgbaChannels,
 					  numThreads);
    _data->rgbaFile->setYCRounding (7, 6);
 }
 AcesOutputFile::AcesOutputFile
    (const std::string &name,
     int width,
     int height,
     RgbaChannels rgbaChannels,
     float pixelAspectRatio,
     const Imath::V2f screenWindowCenter,
     float screenWindowWidth,
     LineOrder lineOrder,
     Compression compression,
     int numThreads)
 :
    _data (new Data)
 {
    checkCompression (compression);
    Header newHeader (width,
 		      height,
 		      pixelAspectRatio,
 		      screenWindowCenter,
 		      screenWindowWidth,
 		      lineOrder,
 		      compression);
    addChromaticities (newHeader, acesChromaticities());
    addAdoptedNeutral (newHeader, acesChromaticities().white);
    _data->rgbaFile = new RgbaOutputFile (name.c_str(),
 					  newHeader,
 					  rgbaChannels,
 					  numThreads);
    _data->rgbaFile->setYCRounding (7, 6);
 }
 AcesOutputFile::~AcesOutputFile ()
 {
    delete _data;
 }
 void		
 AcesOutputFile::setFrameBuffer
    (const Rgba *base,
     size_t xStride,
     size_t yStride)
 {
    _data->rgbaFile->setFrameBuffer (base, xStride, yStride);
 }
 void		
 AcesOutputFile::writePixels (int numScanLines)
 {
    _data->rgbaFile->writePixels (numScanLines);
 }
 int			
 AcesOutputFile::currentScanLine () const
 {
    return _data->rgbaFile->currentScanLine();
 }
 const Header &
 AcesOutputFile::header () const
 {
    return _data->rgbaFile->header();
 }
 const Imath::Box2i &
 AcesOutputFile::displayWindow () const
 {
    return _data->rgbaFile->displayWindow();
 }
 const Imath::Box2i &
 AcesOutputFile::dataWindow () const
 {
    return _data->rgbaFile->dataWindow();
 }
 float		
 AcesOutputFile::pixelAspectRatio () const
 {
    return _data->rgbaFile->pixelAspectRatio();
 }
 const Imath::V2f
 AcesOutputFile::screenWindowCenter () const
 {
    return _data->rgbaFile->screenWindowCenter();
 }
 float		
 AcesOutputFile::screenWindowWidth () const
 {
    return _data->rgbaFile->screenWindowWidth();
 }
 LineOrder		
 AcesOutputFile::lineOrder () const
 {
    return _data->rgbaFile->lineOrder();
 }
 Compression		
 AcesOutputFile::compression () const
 {
    return _data->rgbaFile->compression();
 }
 RgbaChannels
 AcesOutputFile::channels () const
 {
    return _data->rgbaFile->channels();
 }
 void		
 AcesOutputFile::updatePreviewImage (const PreviewRgba pixels[])
 {
    _data->rgbaFile->updatePreviewImage (pixels);
 }
 class AcesInputFile::Data
 {
  public:
     Data();
    ~Data();
    void		initColorConversion ();
    RgbaInputFile *	rgbaFile;
    Rgba *		fbBase;
    size_t		fbXStride;
    size_t		fbYStride;
    int			minX;
    int			maxX;
    bool		mustConvertColor;
    M44f		fileToAces;
 };
 AcesInputFile::Data::Data ():
    rgbaFile (0),
    fbBase (0),
    fbXStride (0),
    fbYStride (0),
    minX (0),
    maxX (0),
    mustConvertColor (false)
 {
    // empty
 }
 AcesInputFile::Data::~Data ()
 {
    delete rgbaFile;
 }
 void
 AcesInputFile::Data::initColorConversion ()
 {
    const Header &header = rgbaFile->header();
    Chromaticities fileChr;
    if (hasChromaticities (header))
 	fileChr = chromaticities (header);
    V2f fileNeutral = fileChr.white;
    if (hasAdoptedNeutral (header))
 	fileNeutral = adoptedNeutral (header);
    const Chromaticities acesChr = acesChromaticities();
    V2f acesNeutral = acesChr.white;
    if (fileChr.red == acesChr.red &&
 	fileChr.green == acesChr.green &&
 	fileChr.blue == acesChr.blue &&
 	fileChr.white == acesChr.white &&
 	fileNeutral == acesNeutral)
    {
 	//
 	// The file already contains ACES data,
 	// color conversion is not necessary.
 	return;
    }
    mustConvertColor = true;
    minX = header.dataWindow().min.x;
    maxX = header.dataWindow().max.x;
    //
    // Create a matrix that transforms colors from the
    // RGB space of the input file into the ACES space
    // using a color adaptation transform to move the
    // white point.
    //
    //
    // We'll need the Bradford cone primary matrix and its inverse
    //
    static const M44f bradfordCPM
 	    (0.895100, -0.750200,  0.038900,  0.000000,
 	     0.266400,  1.713500, -0.068500,  0.000000,
 	    -0.161400,  0.036700,  1.029600,  0.000000,
 	     0.000000,  0.000000,  0.000000,  1.000000);
    const static M44f inverseBradfordCPM
 	    (0.986993,  0.432305, -0.008529,  0.000000,
 	    -0.147054,  0.518360,  0.040043,  0.000000,
 	     0.159963,  0.049291,  0.968487,  0.000000,
 	     0.000000,  0.000000,  0.000000,  1.000000);
    //
    // Convert the white points of the two RGB spaces to XYZ
    //
    float fx = fileNeutral.x;
    float fy = fileNeutral.y;
    V3f fileNeutralXYZ (fx / fy, 1, (1 - fx - fy) / fy);
    float ax = acesNeutral.x;
    float ay = acesNeutral.y;
    V3f acesNeutralXYZ (ax / ay, 1, (1 - ax - ay) / ay);
    //
    // Compute the Bradford transformation matrix
    //
    V3f ratio ((acesNeutralXYZ * bradfordCPM) /
 	       (fileNeutralXYZ * bradfordCPM));
    M44f ratioMat (ratio[0], 0,        0,        0,
 		   0,        ratio[1], 0,        0,
 		   0,        0,        ratio[2], 0,
 		   0,        0,        0,        1);
    M44f bradfordTrans = bradfordCPM *
                         ratioMat *
 			 inverseBradfordCPM;
    //
    // Build a combined file-RGB-to-ACES-RGB conversion matrix
    //
    fileToAces = RGBtoXYZ (fileChr, 1) * bradfordTrans * XYZtoRGB (acesChr, 1);
 }
 AcesInputFile::AcesInputFile (const std::string &name, int numThreads):
    _data (new Data)
 {
    _data->rgbaFile = new RgbaInputFile (name.c_str(), numThreads);
    _data->initColorConversion();
 }
 AcesInputFile::AcesInputFile (IStream &is, int numThreads):
    _data (new Data)
 {
    _data->rgbaFile = new RgbaInputFile (is, numThreads);
    _data->initColorConversion();
 }
 AcesInputFile::~AcesInputFile ()
 {
    delete _data;
 }
 void		
 AcesInputFile::setFrameBuffer (Rgba *base, size_t xStride, size_t yStride)
 {
    _data->rgbaFile->setFrameBuffer (base, xStride, yStride);
    _data->fbBase = base;
    _data->fbXStride = xStride;
    _data->fbYStride = yStride;
 }
 void		
 AcesInputFile::readPixels (int scanLine1, int scanLine2)
 {
    //
    // Copy the pixels from the RgbaInputFile into the frame buffer.
    //
    _data->rgbaFile->readPixels (scanLine1, scanLine2);
    //
    // If the RGB space of the input file is not the same as the ACES
    // RGB space, then the pixels in the frame buffer must be transformed
    // into the ACES RGB space.
    //
    if (!_data->mustConvertColor)
 	return;
    int minY = min (scanLine1, scanLine2);
    int maxY = max (scanLine1, scanLine2);
    for (int y = minY; y <= maxY; ++y)
    {
 	Rgba *base = _data->fbBase +
 		     _data->fbXStride * _data->minX +
 		     _data->fbYStride * y;
 	for (int x = _data->minX; x <= _data->maxX; ++x)
 	{
 	    V3f aces = V3f (base->r, base->g, base->b) * _data->fileToAces;
 	    base->r = aces[0];
 	    base->g = aces[1];
 	    base->b = aces[2];
 	    base += _data->fbXStride;
 	}
    }
 }
 void		
 AcesInputFile::readPixels (int scanLine)
 {
    readPixels (scanLine, scanLine);
 }
 const Header &
 AcesInputFile::header () const
 {
    return _data->rgbaFile->header();
 }
 const Imath::Box2i &
 AcesInputFile::displayWindow () const
 {
    return _data->rgbaFile->displayWindow();
 }
 const Imath::Box2i &
 AcesInputFile::dataWindow () const
 {
    return _data->rgbaFile->dataWindow();
 }
 float
 AcesInputFile::pixelAspectRatio () const
 {
    return _data->rgbaFile->pixelAspectRatio();
 }
 const Imath::V2f
 AcesInputFile::screenWindowCenter () const
 {
    return _data->rgbaFile->screenWindowCenter();
 }
 float
 AcesInputFile::screenWindowWidth () const
 {
    return _data->rgbaFile->screenWindowWidth();
 }
 LineOrder
 AcesInputFile::lineOrder () const
 {
    return _data->rgbaFile->lineOrder();
 }
 Compression
 AcesInputFile::compression () const
 {
    return _data->rgbaFile->compression();
 }
 RgbaChannels
 AcesInputFile::channels () const
 {
    return _data->rgbaFile->channels();
 }
 const char *  
 AcesInputFile::fileName () const
 {
    return _data->rgbaFile->fileName();
 }
 bool
 AcesInputFile::isComplete () const
 {
    return _data->rgbaFile->isComplete();
 }
 int
 AcesInputFile::version () const
 {
    return _data->rgbaFile->version();
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfAcesFile.h
+++ b/3rdparty/openexr/IlmImf/ImfAcesFile.h
@ -0,0 +1,322 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2007, 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_ACES_FILE_H
 #define INCLUDED_IMF_ACES_FILE_H
 //-----------------------------------------------------------------------------
 //
 //	ACES image file I/O.
 //	
 //	This header file declares two classes that directly support
 //	image file input and output according to the Academy Image
 //	Interchange Framework.
 //	
 //	The Academy Image Interchange file format is a subset of OpenEXR:
 //	
 //	    - Images are stored as scanlines.  Tiles are not allowed.
 //	
 //	    - Images contain three color channels, either
 //		    R, G, B (red, green, blue) or
 //		    Y, RY, BY (luminance, sub-sampled chroma)
 //	
 //	    - Images may optionally contain an alpha channel.
 //	
 //	    - Only three compression types are allowed:
 //		    - NO_COMPRESSION (file is not compressed)
 //		    - PIZ_COMPRESSION (lossless)
 //		    - B44A_COMPRESSION (lossy)
 //	
 //	    - The "chromaticities" header attribute must specify
 //	      the ACES RGB primaries and white point.
 //	
 //	class AcesOutputFile writes an OpenEXR file, enforcing the
 //	restrictions listed above.  Pixel data supplied by application
 //	software must already be in the ACES RGB space.
 //	
 //	class AcesInputFile reads an OpenEXR file.  Pixel data delivered
 //	to application software is guaranteed to be in the ACES RGB space.
 //	If the RGB space of the file is not the same as the ACES space,
 //	then the pixels are automatically converted: the pixels are
 //	converted to CIE XYZ, a color adaptation transform shifts the
 //	white point, and the result is converted to ACES RGB.
 //
 //-----------------------------------------------------------------------------
 #include <ImfHeader.h>
 #include <ImfRgba.h>
 #include "ImathVec.h"
 #include "ImathBox.h"
 #include <ImfThreading.h>
 #include <string>
 namespace Imf {
 class RgbaOutputFile;
 class RgbaInputFile;
 struct PreviewRgba;
 class Chromaticities;
 //
 // ACES red, green, blue and white-point chromaticities.
 //
 const Chromaticities &	acesChromaticities ();
 //
 // ACES output file.
 //
 class AcesOutputFile
 {
  public:
    //---------------------------------------------------
    // Constructor -- header is constructed by the caller
    //---------------------------------------------------
    AcesOutputFile (const std::string &name,
 		    const Header &header,
 		    RgbaChannels rgbaChannels = WRITE_RGBA,
                    int numThreads = globalThreadCount());
    //----------------------------------------------------
    // Constructor -- header is constructed by the caller,
    // file is opened by the caller, destructor will not
    // automatically close the file.
    //----------------------------------------------------
    AcesOutputFile (OStream &os,
 		    const Header &header,
 		    RgbaChannels rgbaChannels = WRITE_RGBA,
                    int numThreads = globalThreadCount());
    //----------------------------------------------------------------
    // Constructor -- header data are explicitly specified as function
    // call arguments (empty dataWindow means "same as displayWindow")
    //----------------------------------------------------------------
    AcesOutputFile (const std::string &name,
 		    const Imath::Box2i &displayWindow,
 		    const Imath::Box2i &dataWindow = Imath::Box2i(),
 		    RgbaChannels rgbaChannels = WRITE_RGBA,
 		    float pixelAspectRatio = 1,
 		    const Imath::V2f screenWindowCenter = Imath::V2f (0, 0),
 		    float screenWindowWidth = 1,
 		    LineOrder lineOrder = INCREASING_Y,
 		    Compression compression = PIZ_COMPRESSION,
                    int numThreads = globalThreadCount());
    //-----------------------------------------------
    // Constructor -- like the previous one, but both
    // the display window and the data window are
    // Box2i (V2i (0, 0), V2i (width - 1, height -1))
    //-----------------------------------------------
    AcesOutputFile (const std::string &name,
 		    int width,
 		    int height,
 		    RgbaChannels rgbaChannels = WRITE_RGBA,
 		    float pixelAspectRatio = 1,
 		    const Imath::V2f screenWindowCenter = Imath::V2f (0, 0),
 		    float screenWindowWidth = 1,
 		    LineOrder lineOrder = INCREASING_Y,
 		    Compression compression = PIZ_COMPRESSION,
                    int numThreads = globalThreadCount());
    //-----------
    // Destructor
    //-----------
    virtual ~AcesOutputFile ();
    //------------------------------------------------
    // Define a frame buffer as the pixel data source:
    // Pixel (x, y) is at address
    //
    //  base + x * xStride + y * yStride
    //
    //------------------------------------------------
    void			setFrameBuffer (const Rgba *base,
 						size_t xStride,
 						size_t yStride);
    //-------------------------------------------------
    // Write pixel data (see class Imf::OutputFile)
    // The pixels are assumed to contain ACES RGB data.
    //-------------------------------------------------
    void			writePixels (int numScanLines = 1);
    int				currentScanLine () const;
    //--------------------------
    // Access to the file header
    //--------------------------
    const Header &		header () const;
    const Imath::Box2i &	displayWindow () const;
    const Imath::Box2i &	dataWindow () const;
    float			pixelAspectRatio () const;
    const Imath::V2f		screenWindowCenter () const;
    float			screenWindowWidth () const;
    LineOrder			lineOrder () const;
    Compression			compression () const;
    RgbaChannels		channels () const;
    // --------------------------------------------------------------------
    // Update the preview image (see Imf::OutputFile::updatePreviewImage())
    // --------------------------------------------------------------------
    void			updatePreviewImage (const PreviewRgba[]);
  private:
    AcesOutputFile (const AcesOutputFile &);		  // not implemented
    AcesOutputFile & operator = (const AcesOutputFile &); // not implemented
    class Data;
    Data *			_data;
 };
 //
 // ACES input file
 //
 class AcesInputFile
 {
  public:
    //-------------------------------------------------------
    // Constructor -- opens the file with the specified name,
    // destructor will automatically close the file.
    //-------------------------------------------------------
    AcesInputFile (const std::string &name,
 		   int numThreads = globalThreadCount());
    //-----------------------------------------------------------
    // Constructor -- attaches the new AcesInputFile object to a
    // file that has already been opened by the caller.
    // Destroying the AcesInputFile object will not automatically
    // close the file.
    //-----------------------------------------------------------
    AcesInputFile (IStream &is,
 		   int numThreads = globalThreadCount());
    //-----------
    // Destructor
    //-----------
    virtual ~AcesInputFile ();
    //-----------------------------------------------------
    // Define a frame buffer as the pixel data destination:
    // Pixel (x, y) is at address
    //
    //  base + x * xStride + y * yStride
    //
    //-----------------------------------------------------
    void			setFrameBuffer (Rgba *base,
 						size_t xStride,
 						size_t yStride);
    //--------------------------------------------
    // Read pixel data (see class Imf::InputFile)
    // Pixels returned will contain ACES RGB data.
    //--------------------------------------------
    void			readPixels (int scanLine1, int scanLine2);
    void			readPixels (int scanLine);
    //--------------------------
    // Access to the file header
    //--------------------------
    const Header &		header () const;
    const Imath::Box2i &	displayWindow () const;
    const Imath::Box2i &	dataWindow () const;
    float			pixelAspectRatio () const;
    const Imath::V2f		screenWindowCenter () const;
    float			screenWindowWidth () const;
    LineOrder			lineOrder () const;
    Compression			compression () const;
    RgbaChannels		channels () const;
    const char *                fileName () const;
    bool			isComplete () const;
    //----------------------------------
    // Access to the file format version
    //----------------------------------
    int				version () const;
  private:
    AcesInputFile (const AcesInputFile &);		  // not implemented
    AcesInputFile & operator = (const AcesInputFile &);   // not implemented
    class Data;
    Data *			_data;
 };
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfArray.h
+++ b/3rdparty/openexr/IlmImf/ImfArray.h
@ -0,0 +1,261 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_ARRAY_H
 #define INCLUDED_IMF_ARRAY_H
 //-------------------------------------------------------------------------
 //
 // class Array
 // class Array2D
 //
 // "Arrays of T" whose sizes are not known at compile time.
 // When an array goes out of scope, its elements are automatically
 // deleted.
 //
 // Usage example:
 //
 //	struct C
 //	{
 //	    C ()		{std::cout << "C::C  (" << this << ")\n";};
 //	    virtual ~C ()	{std::cout << "C::~C (" << this << ")\n";};
 //	};
 // 
 //	int
 //	main ()
 //	{
 //	    Array <C> a(3);
 // 
 //	    C &b = a[1];
 //	    const C &c = a[1];
 //	    C *d = a + 2;
 //	    const C *e = a;
 // 
 //	    return 0;
 //	}
 //
 //-------------------------------------------------------------------------
 namespace Imf {
 template <class T>
 class Array
 {
  public:
    //-----------------------------
    // Constructors and destructors
    //-----------------------------
     Array ()				{_data = 0;}
     Array (long size)			{_data = new T[size];}
    ~Array ()				{delete [] _data;}
    //-----------------------------
    // Access to the array elements
    //-----------------------------
    operator T * ()			{return _data;}
    operator const T * () const		{return _data;}
    //------------------------------------------------------
    // Resize and clear the array (the contents of the array
    // are not preserved across the resize operation).
    //
    // resizeEraseUnsafe() is more memory efficient than
    // resizeErase() because it deletes the old memory block
    // before allocating a new one, but if allocating the
    // new block throws an exception, resizeEraseUnsafe()
    // leaves the array in an unusable state.
    //
    //------------------------------------------------------
    void resizeErase (long size);
    void resizeEraseUnsafe (long size);
  private:
    Array (const Array &);		// Copying and assignment
    Array & operator = (const Array &);	// are not implemented
    T * _data;
 };
 template <class T>
 class Array2D
 {
  public:
    //-----------------------------
    // Constructors and destructors
    //-----------------------------
     Array2D ();			// empty array, 0 by 0 elements
     Array2D (long sizeX, long sizeY);	// sizeX by sizeY elements
    ~Array2D ();
    //-----------------------------
    // Access to the array elements
    //-----------------------------
    T *		operator [] (long x);
    const T *	operator [] (long x) const;
    //------------------------------------------------------
    // Resize and clear the array (the contents of the array
    // are not preserved across the resize operation).
    //
    // resizeEraseUnsafe() is more memory efficient than
    // resizeErase() because it deletes the old memory block
    // before allocating a new one, but if allocating the
    // new block throws an exception, resizeEraseUnsafe()
    // leaves the array in an unusable state.
    //
    //------------------------------------------------------
    void resizeErase (long sizeX, long sizeY);
    void resizeEraseUnsafe (long sizeX, long sizeY);
  private:
    Array2D (const Array2D &);			// Copying and assignment
    Array2D & operator = (const Array2D &);	// are not implemented
    long	_sizeY;
    T *		_data;
 };
 //---------------
 // Implementation
 //---------------
 template <class T>
 inline void
 Array<T>::resizeErase (long size)
 {
    T *tmp = new T[size];
    delete [] _data;
    _data = tmp;
 }
 template <class T>
 inline void
 Array<T>::resizeEraseUnsafe (long size)
 {
    delete [] _data;
    _data = 0;
    _data = new T[size];
 }
 template <class T>
 inline
 Array2D<T>::Array2D ():
    _sizeY (0), _data (0)
 {
    // emtpy
 }
 template <class T>
 inline
 Array2D<T>::Array2D (long sizeX, long sizeY):
    _sizeY (sizeY), _data (new T[sizeX * sizeY])
 {
    // emtpy
 }
 template <class T>
 inline
 Array2D<T>::~Array2D ()
 {
    delete [] _data;
 }
 template <class T>
 inline T *	
 Array2D<T>::operator [] (long x)
 {
    return _data + x * _sizeY;
 }
 template <class T>
 inline const T *
 Array2D<T>::operator [] (long x) const
 {
    return _data + x * _sizeY;
 }
 template <class T>
 inline void
 Array2D<T>::resizeErase (long sizeX, long sizeY)
 {
    T *tmp = new T[sizeX * sizeY];
    delete [] _data;
    _sizeY = sizeY;
    _data = tmp;
 }
 template <class T>
 inline void
 Array2D<T>::resizeEraseUnsafe (long sizeX, long sizeY)
 {
    delete [] _data;
    _data = 0;
    _sizeY = 0;
    _data = new T[sizeX * sizeY];
    _sizeY = sizeY;
 }
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfAttribute.cpp
+++ b/3rdparty/openexr/IlmImf/ImfAttribute.cpp
@ -0,0 +1,156 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class Attribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfAttribute.h>
 #include "IlmThreadMutex.h"
 #include "Iex.h"
 #include <string.h>
 #include <map>
 namespace Imf {
 using IlmThread::Mutex;
 using IlmThread::Lock;
 Attribute::Attribute () {}
 Attribute::~Attribute () {}
 namespace {
 struct NameCompare: std::binary_function <const char *, const char *, bool>
 {
    bool
    operator () (const char *x, const char *y) const
    {
 	return strcmp (x, y) < 0;
    }
 };
 typedef Attribute* (*Constructor)();
 typedef std::map <const char *, Constructor, NameCompare> TypeMap;
 class LockedTypeMap: public TypeMap
 {
  public:
    Mutex mutex;
 };
 LockedTypeMap &
 typeMap ()
 {
    static Mutex criticalSection;
    Lock lock (criticalSection);
    static LockedTypeMap* typeMap = 0;
    if (typeMap == 0)
 	typeMap = new LockedTypeMap ();
    return *typeMap;
 }
 } // namespace
 bool		
 Attribute::knownType (const char typeName[])
 {
    LockedTypeMap& tMap = typeMap();
    Lock lock (tMap.mutex);
    return tMap.find (typeName) != tMap.end();
 }
 void	
 Attribute::registerAttributeType (const char typeName[],
 			          Attribute *(*newAttribute)())
 {
    LockedTypeMap& tMap = typeMap();
    Lock lock (tMap.mutex);
    if (tMap.find (typeName) != tMap.end())
 	THROW (Iex::ArgExc, "Cannot register image file attribute "
 			    "type \"" << typeName << "\". "
 			    "The type has already been registered.");
    tMap.insert (TypeMap::value_type (typeName, newAttribute));
 }
 void
 Attribute::unRegisterAttributeType (const char typeName[])
 {
    LockedTypeMap& tMap = typeMap();
    Lock lock (tMap.mutex);
    tMap.erase (typeName);
 }
 Attribute *
 Attribute::newAttribute (const char typeName[])
 {
    LockedTypeMap& tMap = typeMap();
    Lock lock (tMap.mutex);
    TypeMap::const_iterator i = tMap.find (typeName);
    if (i == tMap.end())
 	THROW (Iex::ArgExc, "Cannot create image file attribute of "
 			    "unknown type \"" << typeName << "\".");
    return (i->second)();
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfAttribute.h
+++ b/3rdparty/openexr/IlmImf/ImfAttribute.h
@ -0,0 +1,427 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_ATTRIBUTE_H
 #define INCLUDED_IMF_ATTRIBUTE_H
 //-----------------------------------------------------------------------------
 //
 //	class Attribute
 //
 //-----------------------------------------------------------------------------
 #include "IexBaseExc.h"
 #include <ImfIO.h>
 #include <ImfXdr.h>
 namespace Imf {
 class Attribute
 {
  public:
    //---------------------------
    // Constructor and destructor
    //---------------------------
    Attribute ();
    virtual ~Attribute ();
    //-------------------------------
    // Get this attribute's type name
    //-------------------------------
    virtual const char *	typeName () const = 0;
    //------------------------------
    // Make a copy of this attribute
    //------------------------------
    virtual Attribute *		copy () const = 0;
    //----------------------------------------
    // Type-specific attribute I/O and copying
    //----------------------------------------
    virtual void		writeValueTo (OStream &os,
 					      int version) const = 0;
    virtual void		readValueFrom (IStream &is,
 					       int size,
 					       int version) = 0;
    virtual void		copyValueFrom (const Attribute &other) = 0;
    //------------------
    // Attribute factory
    //------------------
    static Attribute *		newAttribute (const char typeName[]);
    //-----------------------------------------------------------
    // Test if a given attribute type has already been registered
    //-----------------------------------------------------------
    static bool			knownType (const char typeName[]);
  protected:
    //--------------------------------------------------
    // Register an attribute type so that newAttribute()
    // knows how to make objects of this type.
    //--------------------------------------------------
    static void		registerAttributeType (const char typeName[],
 					       Attribute *(*newAttribute)());
    //------------------------------------------------------
    // Un-register an attribute type so that newAttribute()
    // no longer knows how to make objects of this type (for
    // debugging only).
    //------------------------------------------------------
    static void		unRegisterAttributeType (const char typeName[]);
 };
 //-------------------------------------------------
 // Class template for attributes of a specific type
 //-------------------------------------------------
 template <class T>
 class TypedAttribute: public Attribute
 {
  public:
    //----------------------------
    // Constructors and destructor
    //------------_---------------
    TypedAttribute ();
    TypedAttribute (const T &value);
    TypedAttribute (const TypedAttribute<T> &other);
    virtual ~TypedAttribute ();
    //--------------------------------
    // Access to the attribute's value
    //--------------------------------
    T &					value ();
    const T &				value () const;
    //--------------------------------
    // Get this attribute's type name.
    //--------------------------------
    virtual const char *		typeName () const;
    //---------------------------------------------------------
    // Static version of typeName()
    // This function must be specialized for each value type T.
    //---------------------------------------------------------
    static const char *			staticTypeName ();
    //---------------------
    // Make a new attribute
    //---------------------
    static Attribute *			makeNewAttribute ();
    //------------------------------
    // Make a copy of this attribute
    //------------------------------
    virtual Attribute *			copy () const;
    //-----------------------------------------------------------------
    // Type-specific attribute I/O and copying.
    // Depending on type T, these functions may have to be specialized.
    //-----------------------------------------------------------------
    virtual void		writeValueTo (OStream &os,
 					      int version) const;
    virtual void		readValueFrom (IStream &is,
 					       int size,
 					       int version);
    virtual void		copyValueFrom (const Attribute &other);
    //------------------------------------------------------------
    // Dynamic casts that throw exceptions instead of returning 0.
    //------------------------------------------------------------
    static TypedAttribute *		cast (Attribute *attribute);
    static const TypedAttribute *	cast (const Attribute *attribute);
    static TypedAttribute &		cast (Attribute &attribute);
    static const TypedAttribute &	cast (const Attribute &attribute);
    //---------------------------------------------------------------
    // Register this attribute type so that Attribute::newAttribute()
    // knows how to make objects of this type.
    //
    // Note that this function is not thread-safe because it modifies
    // a global variable in the IlmIlm library.  A thread in a multi-
    // threaded program may call registerAttributeType() only when no
    // other thread is accessing any functions or classes in the
    // IlmImf library.
    //
    //---------------------------------------------------------------
    static void				registerAttributeType ();
    //-----------------------------------------------------
    // Un-register this attribute type (for debugging only)
    //-----------------------------------------------------
    static void				 unRegisterAttributeType ();
  private:
    T					_value;
 };
 //------------------------------------
 // Implementation of TypedAttribute<T>
 //------------------------------------
 template <class T>
 TypedAttribute<T>::TypedAttribute ():
    Attribute (),
    _value (T())
 {
    // empty
 }
 template <class T>
 TypedAttribute<T>::TypedAttribute (const T &value):
    Attribute (),
    _value (value)
 {
    // empty
 }
 template <class T>
 TypedAttribute<T>::TypedAttribute (const TypedAttribute<T> &other):
    Attribute (other),
    _value ()
 {
    copyValueFrom (other);
 }
 template <class T>
 TypedAttribute<T>::~TypedAttribute ()
 {
    // empty
 }
 template <class T>
 inline T &
 TypedAttribute<T>::value ()
 {
    return _value;
 }
 template <class T>
 inline const T &
 TypedAttribute<T>::value () const
 {
    return _value;
 }
 template <class T>
 const char *	
 TypedAttribute<T>::typeName () const
 {
    return staticTypeName();
 }
 template <class T>
 Attribute *
 TypedAttribute<T>::makeNewAttribute ()
 {
    return new TypedAttribute<T>();
 }
 template <class T>
 Attribute *
 TypedAttribute<T>::copy () const
 {
    Attribute * attribute = new TypedAttribute<T>();
    attribute->copyValueFrom (*this);
    return attribute;
 }
 template <class T>
 void		
 TypedAttribute<T>::writeValueTo (OStream &os, int version) const
 {
    Xdr::write <StreamIO> (os, _value);
 }
 template <class T>
 void		
 TypedAttribute<T>::readValueFrom (IStream &is, int size, int version)
 {
    Xdr::read <StreamIO> (is, _value);
 }
 template <class T>
 void		
 TypedAttribute<T>::copyValueFrom (const Attribute &other)
 {
    _value = cast(other)._value;
 }
 template <class T>
 TypedAttribute<T> *
 TypedAttribute<T>::cast (Attribute *attribute)
 {
    TypedAttribute<T> *t =
 	dynamic_cast <TypedAttribute<T> *> (attribute);
    if (t == 0)
 	throw Iex::TypeExc ("Unexpected attribute type.");
    return t;
 }
 template <class T>
 const TypedAttribute<T> *
 TypedAttribute<T>::cast (const Attribute *attribute)
 {
    const TypedAttribute<T> *t =
 	dynamic_cast <const TypedAttribute<T> *> (attribute);
    if (t == 0)
 	throw Iex::TypeExc ("Unexpected attribute type.");
    return t;
 }
 template <class T>
 inline TypedAttribute<T> &	
 TypedAttribute<T>::cast (Attribute &attribute)
 {
    return *cast (&attribute);
 }
 template <class T>
 inline const TypedAttribute<T> &
 TypedAttribute<T>::cast (const Attribute &attribute)
 {
    return *cast (&attribute);
 }
 template <class T>
 inline void
 TypedAttribute<T>::registerAttributeType ()
 {
    Attribute::registerAttributeType (staticTypeName(), makeNewAttribute);
 }
 template <class T>
 inline void
 TypedAttribute<T>::unRegisterAttributeType ()
 {
    Attribute::unRegisterAttributeType (staticTypeName());
 }
 } // namespace Imf
 #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
--- a/3rdparty/openexr/IlmImf/ImfAutoArray.h
+++ b/3rdparty/openexr/IlmImf/ImfAutoArray.h
@ -0,0 +1,97 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_AUTO_ARRAY_H
 #define INCLUDED_IMF_AUTO_ARRAY_H
 //-----------------------------------------------------------------------------
 //
 //	class AutoArray -- a workaround for systems with
 //	insufficient stack space for large auto arrays.
 //
 //-----------------------------------------------------------------------------
 #include "OpenEXRConfig.h"
 #if !defined (HAVE_LARGE_STACK)
 #include <string.h>
 #endif
 namespace Imf {
 #if !defined (HAVE_LARGE_STACK)
    template <class T, int size>
    class AutoArray
    {
      public:
 	 AutoArray (): _data (new T [size]) { memset(_data, 0, size*sizeof(T)); }
 	~AutoArray () {delete [] _data;}
 	operator T * ()			{return _data;}
 	operator const T * () const	{return _data;}
      private:
 	T *_data;
    };
 #else
    template <class T, int size>
    class AutoArray
    {
      public:
 	operator T * ()			{return _data;}
 	operator const T * () const	{return _data;}
      private:
 	T _data[size];
    };
 #endif
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfB44Compressor.cpp
+++ b/3rdparty/openexr/IlmImf/ImfB44Compressor.cpp
--- a/3rdparty/openexr/IlmImf/ImfB44Compressor.h
+++ b/3rdparty/openexr/IlmImf/ImfB44Compressor.h
@ -0,0 +1,117 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2006, 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_B44_COMPRESSOR_H
 #define INCLUDED_IMF_B44_COMPRESSOR_H
 //-----------------------------------------------------------------------------
 //
 //	class B44Compressor -- lossy compression of 4x4 pixel blocks
 //
 //-----------------------------------------------------------------------------
 #include <ImfCompressor.h>
 namespace Imf {
 class ChannelList;
 class B44Compressor: public Compressor
 {
  public:
    B44Compressor (const Header &hdr,
                   size_t maxScanLineSize,
 		   size_t numScanLines,
 		   bool optFlatFields);
    virtual ~B44Compressor ();
    virtual int		numScanLines () const;
    virtual Format	format () const;
    virtual int		compress (const char *inPtr,
 				  int inSize,
 				  int minY,
 				  const char *&outPtr);                  
    virtual int		compressTile (const char *inPtr,
 				      int inSize,
 				      Imath::Box2i range,
 				      const char *&outPtr);
    virtual int		uncompress (const char *inPtr,
 				    int inSize,
 				    int minY,
 				    const char *&outPtr);
    virtual int		uncompressTile (const char *inPtr,
 					int inSize,
 					Imath::Box2i range,
 					const char *&outPtr);
  private:
    struct ChannelData;
    int			compress (const char *inPtr,
 				  int inSize,
 				  Imath::Box2i range,
 				  const char *&outPtr);
    int			uncompress (const char *inPtr,
 				    int inSize,
 				    Imath::Box2i range,
 				    const char *&outPtr);
    int			_maxScanLineSize;
    bool		_optFlatFields;
    Format		_format;
    int			_numScanLines;
    unsigned short *	_tmpBuffer;
    char *		_outBuffer;
    int			_numChans;
    const ChannelList &	_channels;
    ChannelData *	_channelData;
    int			_minX;
    int			_maxX;
    int			_maxY;
 };
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfBoxAttribute.cpp
+++ b/3rdparty/openexr/IlmImf/ImfBoxAttribute.cpp
@ -0,0 +1,110 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class Box2iAttribute
 //	class Box2fAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfBoxAttribute.h>
 namespace Imf {
 template <>
 const char *
 Box2iAttribute::staticTypeName ()
 {
    return "box2i";
 }
 template <>
 void
 Box2iAttribute::writeValueTo (OStream &os, int version) const
 {
    Xdr::write <StreamIO> (os, _value.min.x);
    Xdr::write <StreamIO> (os, _value.min.y);
    Xdr::write <StreamIO> (os, _value.max.x);
    Xdr::write <StreamIO> (os, _value.max.y);
 }
 template <>
 void
 Box2iAttribute::readValueFrom (IStream &is, int size, int version)
 {
    Xdr::read <StreamIO> (is, _value.min.x);
    Xdr::read <StreamIO> (is, _value.min.y);
    Xdr::read <StreamIO> (is, _value.max.x);
    Xdr::read <StreamIO> (is, _value.max.y);
 }
 template <>
 const char *
 Box2fAttribute::staticTypeName ()
 {
    return "box2f";
 }
 template <>
 void
 Box2fAttribute::writeValueTo (OStream &os, int version) const
 {
    Xdr::write <StreamIO> (os, _value.min.x);
    Xdr::write <StreamIO> (os, _value.min.y);
    Xdr::write <StreamIO> (os, _value.max.x);
    Xdr::write <StreamIO> (os, _value.max.y);
 }
 template <>
 void
 Box2fAttribute::readValueFrom (IStream &is, int size, int version)
 {
    Xdr::read <StreamIO> (is, _value.min.x);
    Xdr::read <StreamIO> (is, _value.min.y);
    Xdr::read <StreamIO> (is, _value.max.x);
    Xdr::read <StreamIO> (is, _value.max.y);
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfBoxAttribute.h
+++ b/3rdparty/openexr/IlmImf/ImfBoxAttribute.h
@ -0,0 +1,73 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_BOX_ATTRIBUTE_H
 #define INCLUDED_IMF_BOX_ATTRIBUTE_H
 //-----------------------------------------------------------------------------
 //
 //	class Box2iAttribute
 //	class Box2fAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfAttribute.h>
 #include "ImathBox.h"
 namespace Imf {
 typedef TypedAttribute<Imath::Box2i> Box2iAttribute;
 template <> const char *Box2iAttribute::staticTypeName ();
 template <> void Box2iAttribute::writeValueTo (OStream &, int) const;
 template <> void Box2iAttribute::readValueFrom (IStream &, int, int);
 typedef TypedAttribute<Imath::Box2f> Box2fAttribute;
 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
--- a/3rdparty/openexr/IlmImf/ImfCRgbaFile.cpp
+++ b/3rdparty/openexr/IlmImf/ImfCRgbaFile.cpp
--- a/3rdparty/openexr/IlmImf/ImfCRgbaFile.h
+++ b/3rdparty/openexr/IlmImf/ImfCRgbaFile.h
@ -0,0 +1,467 @@
 /*
 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.
 */
 #ifndef INCLUDED_IMF_C_RGBA_FILE_H
 #define INCLUDED_IMF_C_RGBA_FILE_H
 #include <stdlib.h>
 #ifdef __cplusplus
 extern "C" {
 #endif
 /*
 ** Interpreting unsigned shorts as 16-bit floating point numbers
 */
 typedef unsigned short ImfHalf;
 void	ImfFloatToHalf (float f,
 			ImfHalf *h);
 void	ImfFloatToHalfArray (int n,
 			    const float f[/*n*/],
 			    ImfHalf h[/*n*/]);
 float	ImfHalfToFloat (ImfHalf h);
 void	ImfHalfToFloatArray (int n,
 			    const ImfHalf h[/*n*/],
 			    float f[/*n*/]);
 /*
 ** RGBA pixel; memory layout must be the same as struct Imf::Rgba.
 */
 struct ImfRgba
 {
    ImfHalf	r;
    ImfHalf	g;
    ImfHalf	b;
    ImfHalf	a;
 };
 typedef struct ImfRgba ImfRgba;
 /*
 ** Magic number; this must be the same as Imf::MAGIC
 */
 #define IMF_MAGIC               20000630
 /*
 ** Version number; this must be the same as Imf::EXR_VERSION
 */
 #define IMF_VERSION_NUMBER      2
 /*
 ** Line order; values must the the same as in Imf::LineOrder.
 */
 #define IMF_INCREASING_Y	0
 #define IMF_DECREASING_Y	1
 #define IMF_RAMDOM_Y		2
 /*
 ** Compression types; values must be the same as in Imf::Compression.
 */
 #define IMF_NO_COMPRESSION	0
 #define IMF_RLE_COMPRESSION	1
 #define IMF_ZIPS_COMPRESSION	2
 #define IMF_ZIP_COMPRESSION	3
 #define IMF_PIZ_COMPRESSION	4
 #define IMF_PXR24_COMPRESSION	5
 #define IMF_B44_COMPRESSION	6
 #define IMF_B44A_COMPRESSION	7
 /*
 ** Channels; values must be the same as in Imf::RgbaChannels.
 */
 #define IMF_WRITE_R		0x01
 #define IMF_WRITE_G		0x02
 #define IMF_WRITE_B		0x04
 #define IMF_WRITE_A		0x08
 #define IMF_WRITE_Y		0x10
 #define IMF_WRITE_C		0x20
 #define IMF_WRITE_RGB		0x07
 #define IMF_WRITE_RGBA		0x0f
 #define IMF_WRITE_YC		0x30
 #define IMF_WRITE_YA		0x18
 #define IMF_WRITE_YCA		0x38
 /*
 ** Level modes; values must be the same as in Imf::LevelMode
 */
 #define IMF_ONE_LEVEL		0
 #define IMF_MIPMAP_LEVELS	1
 #define IMF_RIPMAP_LEVELS	2
 /*
 ** Level rounding modes; values must be the same as in Imf::LevelRoundingMode
 */
 #define IMF_ROUND_DOWN		0
 #define IMF_ROUND_UP		1
 /*
 ** RGBA file header
 */
 struct ImfHeader;
 typedef struct ImfHeader ImfHeader;
 ImfHeader *	ImfNewHeader (void);
 void		ImfDeleteHeader (ImfHeader *hdr);
 ImfHeader *	ImfCopyHeader (const ImfHeader *hdr);
 void		ImfHeaderSetDisplayWindow (ImfHeader *hdr,
 					   int xMin, int yMin,
 					   int xMax, int yMax);
 void		ImfHeaderDisplayWindow (const ImfHeader *hdr,
 					int *xMin, int *yMin,
 					int *xMax, int *yMax);
 void		ImfHeaderSetDataWindow (ImfHeader *hdr,
 					int xMin, int yMin,
 					int xMax, int yMax);
 void		ImfHeaderDataWindow (const ImfHeader *hdr,
 				     int *xMin, int *yMin,
 				     int *xMax, int *yMax);
 void		ImfHeaderSetPixelAspectRatio (ImfHeader *hdr,
 					      float pixelAspectRatio);
 float		ImfHeaderPixelAspectRatio (const ImfHeader *hdr);
 void		ImfHeaderSetScreenWindowCenter (ImfHeader *hdr,
 						float x, float y);
 void		ImfHeaderScreenWindowCenter (const ImfHeader *hdr,
 					     float *x, float *y);
 void		ImfHeaderSetScreenWindowWidth (ImfHeader *hdr,
 					       float width);
 float		ImfHeaderScreenWindowWidth (const ImfHeader *hdr);
 void		ImfHeaderSetLineOrder (ImfHeader *hdr,
 				       int lineOrder);
 int		ImfHeaderLineOrder (const ImfHeader *hdr);
 void		ImfHeaderSetCompression (ImfHeader *hdr,
 					 int compression);
 int		ImfHeaderCompression (const ImfHeader *hdr);
 int		ImfHeaderSetIntAttribute (ImfHeader *hdr,
 					  const char name[],
 					  int value);
 int		ImfHeaderIntAttribute (const ImfHeader *hdr,
 				       const char name[],
 				       int *value);
 int		ImfHeaderSetFloatAttribute (ImfHeader *hdr,
 					    const char name[],
 					    float value);
 int		ImfHeaderSetDoubleAttribute (ImfHeader *hdr,
 					     const char name[],
 					     double value);
 int		ImfHeaderFloatAttribute (const ImfHeader *hdr,
 				         const char name[],
 				         float *value);
 int		ImfHeaderDoubleAttribute (const ImfHeader *hdr,
 				          const char name[],
 				          double *value);
 int		ImfHeaderSetStringAttribute (ImfHeader *hdr,
 					     const char name[],
 					     const char value[]);
 int		ImfHeaderStringAttribute (const ImfHeader *hdr,
 				         const char name[],
 					  const char **value);
 int		ImfHeaderSetBox2iAttribute (ImfHeader *hdr,
 					    const char name[],
 					    int xMin, int yMin,
 					    int xMax, int yMax);
 int		ImfHeaderBox2iAttribute (const ImfHeader *hdr,
 					 const char name[],
 					 int *xMin, int *yMin,
 					 int *xMax, int *yMax);
 int		ImfHeaderSetBox2fAttribute (ImfHeader *hdr,
 					    const char name[],
 					    float xMin, float yMin,
 					    float xMax, float yMax);
 int		ImfHeaderBox2fAttribute (const ImfHeader *hdr,
 					 const char name[],
 					 float *xMin, float *yMin,
 					 float *xMax, float *yMax);
 int		ImfHeaderSetV2iAttribute (ImfHeader *hdr,
 				         const char name[],
 				         int x, int y);
 int		ImfHeaderV2iAttribute (const ImfHeader *hdr,
 				       const char name[],
 				       int *x, int *y);
 int		ImfHeaderSetV2fAttribute (ImfHeader *hdr,
 				          const char name[],
 				          float x, float y);
 int		ImfHeaderV2fAttribute (const ImfHeader *hdr,
 				       const char name[],
 				       float *x, float *y);
 int		ImfHeaderSetV3iAttribute (ImfHeader *hdr,
 				          const char name[],
 				          int x, int y, int z);
 int		ImfHeaderV3iAttribute (const ImfHeader *hdr,
 				       const char name[],
 				       int *x, int *y, int *z);
 int		ImfHeaderSetV3fAttribute (ImfHeader *hdr,
 				          const char name[],
 				          float x, float y, float z);
 int		ImfHeaderV3fAttribute (const ImfHeader *hdr,
 				       const char name[],
 				       float *x, float *y, float *z);
 int		ImfHeaderSetM33fAttribute (ImfHeader *hdr,
 					   const char name[],
 					   const float m[3][3]);
 int		ImfHeaderM33fAttribute (const ImfHeader *hdr,
 					const char name[],
 					float m[3][3]);
 int		ImfHeaderSetM44fAttribute (ImfHeader *hdr,
 					   const char name[],
 					   const float m[4][4]);
 int		ImfHeaderM44fAttribute (const ImfHeader *hdr,
 					const char name[],
 					float m[4][4]);
 /*
 ** RGBA output file
 */
 struct ImfOutputFile;
 typedef struct ImfOutputFile ImfOutputFile;
 ImfOutputFile *	ImfOpenOutputFile (const char name[],
 				   const ImfHeader *hdr,
 				   int channels);
 int			ImfCloseOutputFile (ImfOutputFile *out);
 int			ImfOutputSetFrameBuffer (ImfOutputFile *out,
 						 const ImfRgba *base,
 						 size_t xStride,
 						 size_t yStride);
 int			ImfOutputWritePixels (ImfOutputFile *out,
 					      int numScanLines);
 int			ImfOutputCurrentScanLine (const ImfOutputFile *out);
 const ImfHeader *	ImfOutputHeader (const ImfOutputFile *out);
 int			ImfOutputChannels (const ImfOutputFile *out);
 /*
 ** Tiled RGBA output file
 */
 struct ImfTiledOutputFile;
 typedef struct ImfTiledOutputFile ImfTiledOutputFile;
 ImfTiledOutputFile *	ImfOpenTiledOutputFile (const char name[],
 					        const ImfHeader *hdr,
 						int channels,
 						int xSize, int ySize,
 						int mode, int rmode);
 int		ImfCloseTiledOutputFile (ImfTiledOutputFile *out);
 int		ImfTiledOutputSetFrameBuffer (ImfTiledOutputFile *out,
 					      const ImfRgba *base,
 					      size_t xStride,
 					      size_t yStride);
 int		ImfTiledOutputWriteTile (ImfTiledOutputFile *out,
 					 int dx, int dy,
 					 int lx, int ly);
 int             ImfTiledOutputWriteTiles (ImfTiledOutputFile *out,
                                          int dxMin, int dxMax,
                                          int dyMin, int dyMax,
                                          int lx, int ly);
 const ImfHeader *	ImfTiledOutputHeader (const ImfTiledOutputFile *out);
 int		ImfTiledOutputChannels (const ImfTiledOutputFile *out);
 int		ImfTiledOutputTileXSize (const ImfTiledOutputFile *out);
 int		ImfTiledOutputTileYSize (const ImfTiledOutputFile *out);
 int		ImfTiledOutputLevelMode (const ImfTiledOutputFile *out);
 int	       	ImfTiledOutputLevelRoundingMode
 						(const ImfTiledOutputFile *out);
 /*
 ** RGBA input file
 */
 struct ImfInputFile;
 typedef struct ImfInputFile ImfInputFile;
 ImfInputFile *		ImfOpenInputFile (const char name[]);
 int			ImfCloseInputFile (ImfInputFile *in);
 int			ImfInputSetFrameBuffer (ImfInputFile *in,
 						ImfRgba *base,
 						size_t xStride,
 						size_t yStride);
 int			ImfInputReadPixels (ImfInputFile *in,
 					    int scanLine1,
 					    int scanLine2);
 const ImfHeader *	ImfInputHeader (const ImfInputFile *in);
 int			ImfInputChannels (const ImfInputFile *in);
 const char *            ImfInputFileName (const ImfInputFile *in);
 /*
 ** Tiled RGBA input file
 */
 struct ImfTiledInputFile;
 typedef struct ImfTiledInputFile ImfTiledInputFile;
 ImfTiledInputFile *	ImfOpenTiledInputFile (const char name[]);
 int		ImfCloseTiledInputFile (ImfTiledInputFile *in);
 int		ImfTiledInputSetFrameBuffer (ImfTiledInputFile *in,
 					     ImfRgba *base,
 					     size_t xStride,
 					     size_t yStride);
 int		ImfTiledInputReadTile (ImfTiledInputFile *in,
 				       int dx, int dy,
 				       int lx, int ly);
 int		ImfTiledInputReadTiles (ImfTiledInputFile *in,
                                        int dxMin, int dxMax,
                                        int dyMin, int dyMax,
                                        int lx, int ly);
 const ImfHeader *	ImfTiledInputHeader (const ImfTiledInputFile *in);
 int		ImfTiledInputChannels (const ImfTiledInputFile *in);
 const char *		ImfTiledInputFileName (const ImfTiledInputFile *in);
 int		ImfTiledInputTileXSize (const ImfTiledInputFile *in);
 int		ImfTiledInputTileYSize (const ImfTiledInputFile *in);
 int		ImfTiledInputLevelMode (const ImfTiledInputFile *in);
 int	       	ImfTiledInputLevelRoundingMode
 					       (const ImfTiledInputFile *in);
 /*
 ** Lookup tables
 */
 struct ImfLut;
 typedef struct ImfLut ImfLut;
 ImfLut *		ImfNewRound12logLut (int channels);
 ImfLut *		ImfNewRoundNBitLut (unsigned int n, int channels);
 void			ImfDeleteLut (ImfLut *lut);
 void			ImfApplyLut (ImfLut *lut,
 				     ImfRgba *data,
 				     int nData,
 				     int stride);
 /*
 ** Most recent error message
 */
 const char *		ImfErrorMessage (void);
 #ifdef __cplusplus
 } /* extern "C" */
 #endif
 #endif
--- a/3rdparty/openexr/IlmImf/ImfChannelList.cpp
+++ b/3rdparty/openexr/IlmImf/ImfChannelList.cpp
@ -0,0 +1,321 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class Channel
 //	class ChannelList
 //
 //-----------------------------------------------------------------------------
 #include <ImfChannelList.h>
 #include <Iex.h>
 using std::string;
 using std::set;
 namespace Imf {
 Channel::Channel (PixelType t, int xs, int ys, bool pl):
    type (t),
    xSampling (xs),
    ySampling (ys),
    pLinear (pl)
 {
    // empty
 }
 bool	
 Channel::operator == (const Channel &other) const
 {
    return type == other.type &&
 	   xSampling == other.xSampling &&
 	   ySampling == other.ySampling &&
 	   pLinear == other.pLinear;
 }
 void	
 ChannelList::insert (const char name[], const Channel &channel)
 {
    if (name[0] == 0)
 	THROW (Iex::ArgExc, "Image channel name cannot be an empty string.");
    _map[name] = channel;
 }
 void	
 ChannelList::insert (const string &name, const Channel &channel)
 {
    insert (name.c_str(), channel);
 }
 Channel &
 ChannelList::operator [] (const char name[])
 {
    ChannelMap::iterator i = _map.find (name);
    if (i == _map.end())
 	THROW (Iex::ArgExc, "Cannot find image channel \"" << name << "\".");
    return i->second;
 }
 const Channel &
 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 << "\".");
    return i->second;
 }
 Channel &
 ChannelList::operator [] (const string &name)
 {
    return this->operator[] (name.c_str());
 }
 const Channel &
 ChannelList::operator [] (const string &name) const
 {
    return this->operator[] (name.c_str());
 }
 Channel *
 ChannelList::findChannel (const char name[])
 {
    ChannelMap::iterator i = _map.find (name);
    return (i == _map.end())? 0: &i->second;
 }
 const Channel *
 ChannelList::findChannel (const char name[]) const
 {
    ChannelMap::const_iterator i = _map.find (name);
    return (i == _map.end())? 0: &i->second;
 }
 Channel *
 ChannelList::findChannel (const string &name)
 {
    return findChannel (name.c_str());
 }
 const Channel *
 ChannelList::findChannel (const string &name) const
 {
    return findChannel (name.c_str());
 }
 ChannelList::Iterator		
 ChannelList::begin ()
 {
    return _map.begin();
 }
 ChannelList::ConstIterator	
 ChannelList::begin () const
 {
    return _map.begin();
 }
 ChannelList::Iterator
 ChannelList::end ()
 {
    return _map.end();
 }
 ChannelList::ConstIterator	
 ChannelList::end () const
 {
    return _map.end();
 }
 ChannelList::Iterator
 ChannelList::find (const char name[])
 {
    return _map.find (name);
 }
 ChannelList::ConstIterator
 ChannelList::find (const char name[]) const
 {
    return _map.find (name);
 }
 ChannelList::Iterator
 ChannelList::find (const string &name)
 {
    return find (name.c_str());
 }
 ChannelList::ConstIterator
 ChannelList::find (const string &name) const
 {
    return find (name.c_str());
 }
 void
 ChannelList::layers (set <string> &layerNames) const
 {
    layerNames.clear();
    for (ConstIterator i = begin(); i != end(); ++i)
    {
 	string layerName = i.name();
 	size_t pos = layerName.rfind ('.');
 	if (pos != string::npos && pos != 0 && pos + 1 < layerName.size())
 	{
 	    layerName.erase (pos);
 	    layerNames.insert (layerName);
 	}
    }
 }
 void
 ChannelList::channelsInLayer (const string &layerName,
 			      Iterator &first,
 			      Iterator &last)
 {
    channelsWithPrefix (layerName + '.', first, last);
 }
 void
 ChannelList::channelsInLayer (const string &layerName,
 			      ConstIterator &first,
 			      ConstIterator &last) const
 {
    channelsWithPrefix (layerName + '.', first, last);
 }
 void		
 ChannelList::channelsWithPrefix (const char prefix[],
 				 Iterator &first,
 				 Iterator &last)
 {
    first = last = _map.lower_bound (prefix);
    int n = strlen (prefix);
    while (last != Iterator (_map.end()) &&
 	   strncmp (last.name(), prefix, n) <= 0)
    {
 	++last;
    }
 }
 void
 ChannelList::channelsWithPrefix (const char prefix[],
 				 ConstIterator &first,
 				 ConstIterator &last) const
 {
    first = last = _map.lower_bound (prefix);
    int n = strlen (prefix);
    while (last != ConstIterator (_map.end()) &&
 	   strncmp (last.name(), prefix, n) <= 0)
    {
 	++last;
    }
 }
 void		
 ChannelList::channelsWithPrefix (const string &prefix,
 				 Iterator &first,
 				 Iterator &last)
 {
    return channelsWithPrefix (prefix.c_str(), first, last);
 }
 void
 ChannelList::channelsWithPrefix (const string &prefix,
 				 ConstIterator &first,
 				 ConstIterator &last) const
 {
    return channelsWithPrefix (prefix.c_str(), first, last);
 }
 bool		
 ChannelList::operator == (const ChannelList &other) const
 {
    ConstIterator i = begin();
    ConstIterator j = other.begin();
    while (i != end() && j != other.end())
    {
 	if (!(i.channel() == j.channel()))
 	    return false;
 	++i;
 	++j;
    }
    return i == end() && j == other.end();
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfChannelList.h
+++ b/3rdparty/openexr/IlmImf/ImfChannelList.h
@ -0,0 +1,433 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_CHANNEL_LIST_H
 #define INCLUDED_IMF_CHANNEL_LIST_H
 //-----------------------------------------------------------------------------
 //
 //	class Channel
 //	class ChannelList
 //
 //-----------------------------------------------------------------------------
 #include <ImfName.h>
 #include <ImfPixelType.h>
 #include <map>
 #include <set>
 #include <string>
 namespace Imf {
 struct Channel
 {
    //------------------------------
    // Data type; see ImfPixelType.h
    //------------------------------
    PixelType		type;
    //--------------------------------------------
    // Subsampling: pixel (x, y) is present in the
    // channel only if 
    //
    //  x % xSampling == 0 && y % ySampling == 0
    //
    //--------------------------------------------
    int			xSampling;
    int			ySampling;
    //--------------------------------------------------------------
    // Hint to lossy compression methods that indicates whether
    // human perception of the quantity represented by this channel
    // is closer to linear or closer to logarithmic.  Compression
    // methods may optimize image quality by adjusting pixel data
    // quantization acording to this hint.
    // For example, perception of red, green, blue and luminance is
    // approximately logarithmic; the difference between 0.1 and 0.2
    // is perceived to be roughly the same as the difference between
    // 1.0 and 2.0.  Perception of chroma coordinates tends to be
    // closer to linear than logarithmic; the difference between 0.1
    // and 0.2 is perceived to be roughly the same as the difference
    // between 1.0 and 1.1.
    //--------------------------------------------------------------
    bool		pLinear;
    //------------
    // Constructor
    //------------
    Channel (PixelType type = HALF,
 	     int xSampling = 1,
 	     int ySampling = 1,
 	     bool pLinear = false);
    //------------
    // Operator ==
    //------------
    bool		operator == (const Channel &other) const;
 };
 class ChannelList
 {
  public:
    //--------------
    // Add a channel
    //--------------
    void			insert (const char name[],
 					const Channel &channel);
    void			insert (const std::string &name,
 					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
    //			is thrown.
    //
    // findChannel(n)	Returns a pointer to the channel with name n,
    //			or 0 if no channel with name n exists.
    //
    //------------------------------------------------------------------
    Channel &			operator [] (const char name[]);
    const Channel &		operator [] (const char name[]) const;
    Channel &			operator [] (const std::string &name);
    const Channel &		operator [] (const std::string &name) const;
    Channel *			findChannel (const char name[]);
    const Channel *		findChannel (const char name[]) const;
    Channel *			findChannel (const std::string &name);
    const Channel *		findChannel (const std::string &name) const;
    //-------------------------------------------
    // Iterator-style access to existing channels
    //-------------------------------------------
    typedef std::map <Name, Channel> ChannelMap;
    class Iterator;
    class ConstIterator;
    Iterator			begin ();
    ConstIterator		begin () const;
    Iterator			end ();
    ConstIterator		end () const;
    Iterator			find (const char name[]);
    ConstIterator		find (const char name[]) const;
    Iterator			find (const std::string &name);
    ConstIterator		find (const std::string &name) const;
    //-----------------------------------------------------------------
    // Support for image layers:
    //
    // In an image file with many channels it is sometimes useful to
    // group the channels into "layers", that is, into sets of channels
    // that logically belong together.  Grouping channels into layers
    // is done using a naming convention:  channel C in layer L is
    // called "L.C".
    //
    // For example, a computer graphic image may contain separate
    // R, G and B channels for light that originated at each of
    // several different virtual light sources.  The channels in
    // this image might be called "light1.R", "light1.G", "light1.B",
    // "light2.R", "light2.G", "light2.B", etc.
    // 
    // Note that this naming convention allows layers to be nested;
    // for example, "light1.specular.R" identifies the "R" channel
    // in the "specular" sub-layer of layer "light1".
    //
    // Channel names that don't contain a "." or that contain a
    // "." only at the beginning or at the end are not considered
    // to be part of any layer.
    //
    // layers(lns)		sorts the channels in this ChannelList
    //				into layers and stores the names of
    //				all layers, sorted alphabetically,
    //				into string set lns.
    //
    // channelsInLayer(ln,f,l)	stores a pair of iterators in f and l
    // 				such that the loop
    //
    // 				for (ConstIterator i = f; i != l; ++i)
    // 				   ...
    //
    //				iterates over all channels in layer ln.
    //				channelsInLayer (ln, l, p) calls
    //				channelsWithPrefix (ln + ".", l, p).
    //
    //-----------------------------------------------------------------
    void		layers (std::set <std::string> &layerNames) const;
    void		channelsInLayer (const std::string &layerName,
 	    				 Iterator &first,
 					 Iterator &last);
    void		channelsInLayer (const std::string &layerName,
 	    				 ConstIterator &first,
 					 ConstIterator &last) const;
    //-------------------------------------------------------------------
    // Find all channels whose name begins with a given prefix:
    //
    // channelsWithPrefix(p,f,l) stores a pair of iterators in f and l
    // such that the following loop iterates over all channels whose name
    // begins with string p:
    //
    //		for (ConstIterator i = f; i != l; ++i)
    //		    ...
    //
    //-------------------------------------------------------------------
    void			channelsWithPrefix (const char prefix[],
 						    Iterator &first,
 						    Iterator &last);
    void			channelsWithPrefix (const char prefix[],
 						    ConstIterator &first,
 						    ConstIterator &last) const;
    void			channelsWithPrefix (const std::string &prefix,
 						    Iterator &first,
 						    Iterator &last);
    void			channelsWithPrefix (const std::string &prefix,
 						    ConstIterator &first,
 						    ConstIterator &last) const;
    //------------
    // Operator ==
    //------------
    bool			operator == (const ChannelList &other) const;
  private:
    ChannelMap			_map;
 };
 //----------
 // Iterators
 //----------
 class ChannelList::Iterator
 {
  public:
    Iterator ();
    Iterator (const ChannelList::ChannelMap::iterator &i);
    Iterator &			operator ++ ();
    Iterator 			operator ++ (int);
    const char *		name () const;
    Channel &			channel () const;
  private:
    friend class ChannelList::ConstIterator;
    ChannelList::ChannelMap::iterator _i;
 };
 class ChannelList::ConstIterator
 {
  public:
    ConstIterator ();
    ConstIterator (const ChannelList::ChannelMap::const_iterator &i);
    ConstIterator (const ChannelList::Iterator &other);
    ConstIterator &		operator ++ ();
    ConstIterator 		operator ++ (int);
    const char *		name () const;
    const Channel &		channel () const;
  private:
    friend bool operator == (const ConstIterator &, const ConstIterator &);
    friend bool operator != (const ConstIterator &, const ConstIterator &);
    ChannelList::ChannelMap::const_iterator _i;
 };
 //-----------------
 // Inline Functions
 //-----------------
 inline
 ChannelList::Iterator::Iterator (): _i()
 {
    // empty
 }
 inline
 ChannelList::Iterator::Iterator (const ChannelList::ChannelMap::iterator &i):
    _i (i)
 {
    // empty
 }
 inline ChannelList::Iterator &		
 ChannelList::Iterator::operator ++ ()
 {
    ++_i;
    return *this;
 }
 inline ChannelList::Iterator 	
 ChannelList::Iterator::operator ++ (int)
 {
    Iterator tmp = *this;
    ++_i;
    return tmp;
 }
 inline const char *
 ChannelList::Iterator::name () const
 {
    return *_i->first;
 }
 inline Channel &	
 ChannelList::Iterator::channel () const
 {
    return _i->second;
 }
 inline
 ChannelList::ConstIterator::ConstIterator (): _i()
 {
    // empty
 }
 inline
 ChannelList::ConstIterator::ConstIterator
    (const ChannelList::ChannelMap::const_iterator &i): _i (i)
 {
    // empty
 }
 inline
 ChannelList::ConstIterator::ConstIterator (const ChannelList::Iterator &other):
    _i (other._i)
 {
    // empty
 }
 inline ChannelList::ConstIterator &
 ChannelList::ConstIterator::operator ++ ()
 {
    ++_i;
    return *this;
 }
 inline ChannelList::ConstIterator 		
 ChannelList::ConstIterator::operator ++ (int)
 {
    ConstIterator tmp = *this;
    ++_i;
    return tmp;
 }
 inline const char *
 ChannelList::ConstIterator::name () const
 {
    return *_i->first;
 }
 inline const Channel &	
 ChannelList::ConstIterator::channel () const
 {
    return _i->second;
 }
 inline bool
 operator == (const ChannelList::ConstIterator &x,
 	     const ChannelList::ConstIterator &y)
 {
    return x._i == y._i;
 }
 inline bool
 operator != (const ChannelList::ConstIterator &x,
 	     const ChannelList::ConstIterator &y)
 {
    return !(x == y);
 }
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfChannelListAttribute.cpp
+++ b/3rdparty/openexr/IlmImf/ImfChannelListAttribute.cpp
@ -0,0 +1,145 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class ChannelListAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfChannelListAttribute.h>
 namespace Imf {
 namespace {
 template <size_t N>
 void checkIsNullTerminated (const char (&str)[N], const char *what)
 {
    for (int 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);
 }
 } // namespace
 template <>
 const char *
 ChannelListAttribute::staticTypeName ()
 {
    return "chlist";
 }
 template <>
 void
 ChannelListAttribute::writeValueTo (OStream &os, int version) const
 {
    for (ChannelList::ConstIterator i = _value.begin();
 	 i != _value.end();
 	 ++i)
    {
 	//
 	// Write name
 	//
 	Xdr::write <StreamIO> (os, i.name());
 	//
 	// Write Channel struct
 	//
 	Xdr::write <StreamIO> (os, int (i.channel().type));
 	Xdr::write <StreamIO> (os, i.channel().pLinear);
 	Xdr::pad   <StreamIO> (os, 3);
 	Xdr::write <StreamIO> (os, i.channel().xSampling);
 	Xdr::write <StreamIO> (os, i.channel().ySampling);
    }
    //
    // Write end of list marker
    //
    Xdr::write <StreamIO> (os, "");
 }
 template <>
 void
 ChannelListAttribute::readValueFrom (IStream &is, int size, int version)
 {
    while (true)
    {
 	//
 	// Read name; zero length name means end of channel list
 	//
 	char name[Name::SIZE];
 	Xdr::read <StreamIO> (is, Name::MAX_LENGTH, name);
 	if (name[0] == 0)
 	    break;
 	checkIsNullTerminated (name, "channel name");
 	//
 	// Read Channel struct
 	//
 	int type;
 	bool pLinear;
 	int xSampling;
 	int ySampling;
 	Xdr::read <StreamIO> (is, type);
 	Xdr::read <StreamIO> (is, pLinear);
 	Xdr::skip <StreamIO> (is, 3);
 	Xdr::read <StreamIO> (is, xSampling);
 	Xdr::read <StreamIO> (is, ySampling);
 	_value.insert
 	    (name, Channel (PixelType (type), xSampling, ySampling, pLinear));
    }
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfChannelListAttribute.h
+++ b/3rdparty/openexr/IlmImf/ImfChannelListAttribute.h
@ -0,0 +1,67 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_CHANNEL_LIST_ATTRIBUTE_H
 #define INCLUDED_IMF_CHANNEL_LIST_ATTRIBUTE_H
 //-----------------------------------------------------------------------------
 //
 //	class ChannelListAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfAttribute.h>
 #include <ImfChannelList.h>
 namespace Imf {
 typedef TypedAttribute<ChannelList> ChannelListAttribute;
 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
--- a/3rdparty/openexr/IlmImf/ImfCheckedArithmetic.h
+++ b/3rdparty/openexr/IlmImf/ImfCheckedArithmetic.h
@ -0,0 +1,161 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2009, 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_CHECKED_ARITHMETIC_H
 #define INCLUDED_IMF_CHECKED_ARITHMETIC_H
 //-----------------------------------------------------------------------------
 //
 //	Integer arithmetic operations that throw exceptions
 //      on overflow, underflow or division by zero.
 //
 //-----------------------------------------------------------------------------
 #include <limits>
 #include <IexMathExc.h>
 namespace Imf {
 template <bool b> struct StaticAssertionFailed;
 template <> struct StaticAssertionFailed <true> {};
 #define IMF_STATIC_ASSERT(x) \
    do {StaticAssertionFailed <x> staticAssertionFailed;} while (false)
 template <class T>
 T
 uiMult (T a, T b)
 {
    //
    // Unsigned integer multiplication
    //
    IMF_STATIC_ASSERT (!std::numeric_limits<T>::is_signed &&
                        std::numeric_limits<T>::is_integer);
    if (a > 0 && b > std::numeric_limits<T>::max() / a)
        throw Iex::OverflowExc ("Integer multiplication overflow.");
    return a * b;
 }
 template <class T>
 T
 uiDiv (T a, T b)
 {
    //
    // Unsigned integer division
    //
    IMF_STATIC_ASSERT (!std::numeric_limits<T>::is_signed &&
                        std::numeric_limits<T>::is_integer);
    if (b == 0)
        throw Iex::DivzeroExc ("Integer division by zero.");
    return a / b;
 }
 template <class T>
 T
 uiAdd (T a, T b)
 {
    //
    // Unsigned integer addition
    //
    IMF_STATIC_ASSERT (!std::numeric_limits<T>::is_signed &&
                        std::numeric_limits<T>::is_integer);
    if (a > std::numeric_limits<T>::max() - b)
        throw Iex::OverflowExc ("Integer addition overflow.");
    return a + b;
 }
 template <class T>
 T
 uiSub (T a, T b)
 {
    //
    // Unsigned integer subtraction
    //
    IMF_STATIC_ASSERT (!std::numeric_limits<T>::is_signed &&
                        std::numeric_limits<T>::is_integer);
    if (a < b)
        throw Iex::UnderflowExc ("Integer subtraction underflow.");
    return a - b;
 }
 template <class T>
 size_t
 checkArraySize (T n, size_t s)
 {
    //
    // Verify that the size, in bytes, of an array with n elements
    // of size s can be computed without overflowing:
    //
    // If computing
    //
    //      size_t (n) * s
    //
    // would overflow, then throw an Iex::OverflowExc exception.
    // Otherwise return
    //
    //      size_t (n).
    //
    IMF_STATIC_ASSERT (!std::numeric_limits<T>::is_signed &&
                        std::numeric_limits<T>::is_integer);
    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.");
    return size_t (n);
 }
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfChromaticities.cpp
+++ b/3rdparty/openexr/IlmImf/ImfChromaticities.cpp
@ -0,0 +1,135 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2003, 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	CIE (x,y) chromaticities, and conversions between
 //	RGB tiples and CIE XYZ tristimulus values.
 //
 //-----------------------------------------------------------------------------
 #include <ImfChromaticities.h>
 namespace Imf {
 Chromaticities::Chromaticities (const Imath::V2f &red,
 				const Imath::V2f &green,
 				const Imath::V2f &blue,
 				const Imath::V2f &white)
 :
    red (red),
    green (green),
    blue (blue),
    white (white)
 {
    // empty
 }
 Imath::M44f
 RGBtoXYZ (const Chromaticities chroma, float Y)
 {
    //
    // For an explanation of how the color conversion matrix is derived,
    // see Roy Hall, "Illumination and Color in Computer Generated Imagery",
    // Springer-Verlag, 1989, chapter 3, "Perceptual Response"; and 
    // Charles A. Poynton, "A Technical Introduction to Digital Video",
    // John Wiley & Sons, 1996, chapter 7, "Color science for video".
    //
    //
    // X and Z values of RGB value (1, 1, 1), or "white"
    //
    float X = chroma.white.x * Y / chroma.white.y;
    float Z = (1 - chroma.white.x - chroma.white.y) * Y / chroma.white.y;
    //
    // Scale factors for matrix rows
    //
    float d = chroma.red.x   * (chroma.blue.y  - chroma.green.y) +
 	      chroma.blue.x  * (chroma.green.y - chroma.red.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.blue.y  * (X + Z)) +
 		chroma.blue.x  * (Y * (chroma.green.y - 1) +
 		chroma.green.y * (X + Z))) / d;
    float Sg = (X * (chroma.red.y - chroma.blue.y) +
 		chroma.red.x   * (Y * (chroma.blue.y - 1) +
 		chroma.blue.y  * (X + Z)) -
 		chroma.blue.x  * (Y * (chroma.red.y - 1) +
 		chroma.red.y   * (X + Z))) / d;
    float Sb = (X * (chroma.green.y - chroma.red.y) -
 		chroma.red.x   * (Y * (chroma.green.y - 1) +
 		chroma.green.y * (X + Z)) +
 		chroma.green.x * (Y * (chroma.red.y - 1) +
 		chroma.red.y   * (X + Z))) / d;
    //
    // Assemble the matrix
    //
    Imath::M44f M;
    M[0][0] = Sr * chroma.red.x;
    M[0][1] = Sr * chroma.red.y;
    M[0][2] = Sr * (1 - chroma.red.x - chroma.red.y);
    M[1][0] = Sg * chroma.green.x;
    M[1][1] = Sg * chroma.green.y;
    M[1][2] = Sg * (1 - chroma.green.x - chroma.green.y);
    M[2][0] = Sb * chroma.blue.x;
    M[2][1] = Sb * chroma.blue.y;
    M[2][2] = Sb * (1 - chroma.blue.x - chroma.blue.y);
    return M;
 }
 Imath::M44f
 XYZtoRGB (const Chromaticities chroma, float Y)
 {
    return RGBtoXYZ (chroma, Y).inverse();
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfChromaticities.h
+++ b/3rdparty/openexr/IlmImf/ImfChromaticities.h
@ -0,0 +1,120 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2003, 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_CHROMATICITIES_H
 #define INCLUDED_IMF_CHROMATICITIES_H
 //-----------------------------------------------------------------------------
 //
 //	CIE (x,y) chromaticities, and conversions between
 //	RGB tiples and CIE XYZ tristimulus values.
 //
 //-----------------------------------------------------------------------------
 #include "ImathVec.h"
 #include "ImathMatrix.h"
 namespace Imf {
 struct Chromaticities
 {
    //-----------------------------------------------
    // The CIE x and y coordinates of the RGB triples
    // (1,0,0), (0,1,0), (0,0,1) and (1,1,1).
    //-----------------------------------------------
    Imath::V2f	red;
    Imath::V2f	green;
    Imath::V2f	blue;
    Imath::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),
 		    const Imath::V2f &green = Imath::V2f (0.3000f, 0.6000f),
 		    const Imath::V2f &blue  = Imath::V2f (0.1500f, 0.0600f),
 		    const Imath::V2f &white = Imath::V2f (0.3127f, 0.3290f));
 };
 //
 // Conversions between RGB and CIE XYZ
 //
 // RGB to XYZ:
 //
 // 	Given a set of chromaticities, c, and the luminance, Y, of the RGB
 // 	triple (1,1,1), or "white", RGBtoXYZ(c,Y) computes a matrix, M, so
 // 	that multiplying an RGB value, v, with M produces an equivalent
 // 	XYZ value, w.  (w == v * M)
 // 
 // 	If we define that
 // 
 // 	   (Xr, Yr, Zr) == (1, 0, 0) * M
 // 	   (Xg, Yg, Zg) == (0, 1, 0) * M
 // 	   (Xb, Yb, Zb) == (0, 0, 1) * M
 // 	   (Xw, Yw, Zw) == (1, 1, 1) * M,
 // 
 // 	then the following statements are true:
 // 
 // 	   Xr / (Xr + Yr + Zr) == c.red.x
 // 	   Yr / (Xr + Yr + Zr) == c.red.y
 // 
 // 	   Xg / (Xg + Yg + Zg) == c.red.x
 // 	   Yg / (Xg + Yg + Zg) == c.red.y
 // 
 // 	   Xb / (Xb + Yb + Zb) == c.red.x
 // 	   Yb / (Xb + Yb + Zb) == c.red.y
 // 
 // 	   Xw / (Xw + Yw + Zw) == c.red.x
 // 	   Yw / (Xw + Yw + Zw) == c.red.y
 // 
 // 	   Yw == Y.
 // 
 // XYZ to RGB:
 // 
 // 	YYZtoRGB(c,Y) returns RGBtoXYZ(c,Y).inverse().
 // 
 Imath::M44f	RGBtoXYZ (const Chromaticities chroma, float Y);
 Imath::M44f	XYZtoRGB (const Chromaticities chroma, float Y);
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfChromaticitiesAttribute.cpp
+++ b/3rdparty/openexr/IlmImf/ImfChromaticitiesAttribute.cpp
@ -0,0 +1,86 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2003, 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 ChromaticitiesAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfChromaticitiesAttribute.h>
 namespace Imf {
 template <>
 const char *
 ChromaticitiesAttribute::staticTypeName ()
 {
    return "chromaticities";
 }
 template <>
 void
 ChromaticitiesAttribute::writeValueTo (OStream &os, int version) const
 {
    Xdr::write <StreamIO> (os, _value.red.x);
    Xdr::write <StreamIO> (os, _value.red.y);
    Xdr::write <StreamIO> (os, _value.green.x);
    Xdr::write <StreamIO> (os, _value.green.y);
    Xdr::write <StreamIO> (os, _value.blue.x);
    Xdr::write <StreamIO> (os, _value.blue.y);
    Xdr::write <StreamIO> (os, _value.white.x);
    Xdr::write <StreamIO> (os, _value.white.y);
 }
 template <>
 void
 ChromaticitiesAttribute::readValueFrom (IStream &is, int size, int version)
 {
    Xdr::read <StreamIO> (is, _value.red.x);
    Xdr::read <StreamIO> (is, _value.red.y);
    Xdr::read <StreamIO> (is, _value.green.x);
    Xdr::read <StreamIO> (is, _value.green.y);
    Xdr::read <StreamIO> (is, _value.blue.x);
    Xdr::read <StreamIO> (is, _value.blue.y);
    Xdr::read <StreamIO> (is, _value.white.x);
    Xdr::read <StreamIO> (is, _value.white.y);
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfChromaticitiesAttribute.h
+++ b/3rdparty/openexr/IlmImf/ImfChromaticitiesAttribute.h
@ -0,0 +1,72 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2003, 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_CHROMATICITIES_ATTRIBUTE_H
 #define INCLUDED_IMF_CHROMATICITIES_ATTRIBUTE_H
 //-----------------------------------------------------------------------------
 //
 //	class ChromaticitiesAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfAttribute.h>
 #include <ImfChromaticities.h>
 namespace Imf {
 typedef TypedAttribute<Chromaticities> ChromaticitiesAttribute;
 template <>
 const char *ChromaticitiesAttribute::staticTypeName ();
 template <>
 void ChromaticitiesAttribute::writeValueTo (OStream &, int) const;
 template <>
 void ChromaticitiesAttribute::readValueFrom (IStream &, int, int);
 } // namespace Imf
 // Metrowerks compiler wants the .cpp file inlined, too
 #ifdef __MWERKS__
 #include <ImfChromaticitiesAttribute.cpp>
 #endif
 #endif
--- a/3rdparty/openexr/IlmImf/ImfCompression.h
+++ b/3rdparty/openexr/IlmImf/ImfCompression.h
@ -0,0 +1,75 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_COMPRESSION_H
 #define INCLUDED_IMF_COMPRESSION_H
 //-----------------------------------------------------------------------------
 //
 //	enum Compression
 //
 //-----------------------------------------------------------------------------
 namespace Imf {
 enum Compression
 {
    NO_COMPRESSION  = 0,	// no compression
    RLE_COMPRESSION = 1,	// run length encoding
    ZIPS_COMPRESSION = 2,	// zlib compression, one scan line at a time
    ZIP_COMPRESSION = 3,	// zlib compression, in blocks of 16 scan lines
    PIZ_COMPRESSION = 4,	// piz-based wavelet compression
    PXR24_COMPRESSION = 5,	// lossy 24-bit float compression
    B44_COMPRESSION = 6,	// lossy 4-by-4 pixel block compression,
    				// fixed compression rate
    B44A_COMPRESSION = 7,	// lossy 4-by-4 pixel block compression,
    				// flat fields are compressed more
    NUM_COMPRESSION_METHODS	// number of different compression methods
 };
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfCompressionAttribute.cpp
+++ b/3rdparty/openexr/IlmImf/ImfCompressionAttribute.cpp
@ -0,0 +1,76 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class CompressionAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfCompressionAttribute.h>
 namespace Imf {
 template <>
 const char *
 CompressionAttribute::staticTypeName ()
 {
    return "compression";
 }
 template <>
 void
 CompressionAttribute::writeValueTo (OStream &os, int version) const
 {
    unsigned char tmp = _value;
    Xdr::write <StreamIO> (os, tmp);
 }
 template <>
 void
 CompressionAttribute::readValueFrom (IStream &is, int size, int version)
 {
    unsigned char tmp;
    Xdr::read <StreamIO> (is, tmp);
    _value = Compression (tmp);
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfCompressionAttribute.h
+++ b/3rdparty/openexr/IlmImf/ImfCompressionAttribute.h
@ -0,0 +1,66 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_COMPRESSION_ATTRIBUTE_H
 #define INCLUDED_IMF_COMPRESSION_ATTRIBUTE_H
 //-----------------------------------------------------------------------------
 //
 //	class CompressionAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfAttribute.h>
 #include <ImfCompression.h>
 namespace Imf {
 typedef TypedAttribute<Compression> CompressionAttribute;
 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
--- a/3rdparty/openexr/IlmImf/ImfCompressor.cpp
+++ b/3rdparty/openexr/IlmImf/ImfCompressor.cpp
@ -0,0 +1,192 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class Compressor
 //
 //-----------------------------------------------------------------------------
 #include <ImfCompressor.h>
 #include <ImfRleCompressor.h>
 #include <ImfZipCompressor.h>
 #include <ImfPizCompressor.h>
 #include <ImfPxr24Compressor.h>
 #include <ImfB44Compressor.h>
 #include <ImfCheckedArithmetic.h>
 namespace Imf {
 using Imath::Box2i;
 Compressor::Compressor (const Header &hdr): _header (hdr) {}
 Compressor::~Compressor () {}
 Compressor::Format
 Compressor::format () const
 {
    return XDR;
 }
 int
 Compressor::compressTile (const char *inPtr,
 			  int inSize,
 			  Box2i range,
 			  const char *&outPtr)
 {
    return compress (inPtr, inSize, range.min.y, outPtr);
 }
 int
 Compressor::uncompressTile (const char *inPtr,
 			    int inSize,
 			    Box2i range,
 			    const char *&outPtr)
 {
    return uncompress (inPtr, inSize, range.min.y, outPtr);
 }
 bool	
 isValidCompression (Compression c)
 {
    switch (c)
    {
      case NO_COMPRESSION:
      case RLE_COMPRESSION:
      case ZIPS_COMPRESSION:
      case ZIP_COMPRESSION:
      case PIZ_COMPRESSION:
      case PXR24_COMPRESSION:
      case B44_COMPRESSION:
      case B44A_COMPRESSION:
 	return true;
      default:
 	return false;
    }
 }
 Compressor *
 newCompressor (Compression c, size_t maxScanLineSize, const Header &hdr)
 {
    switch (c)
    {
      case RLE_COMPRESSION:
 	return new RleCompressor (hdr, maxScanLineSize);
      case ZIPS_COMPRESSION:
 	return new ZipCompressor (hdr, maxScanLineSize, 1);
      case ZIP_COMPRESSION:
 	return new ZipCompressor (hdr, maxScanLineSize, 16);
      case PIZ_COMPRESSION:
 	return new PizCompressor (hdr, maxScanLineSize, 32);
      case PXR24_COMPRESSION:
 	return new Pxr24Compressor (hdr, maxScanLineSize, 16);
      case B44_COMPRESSION:
 	return new B44Compressor (hdr, maxScanLineSize, 32, false);
      case B44A_COMPRESSION:
 	return new B44Compressor (hdr, maxScanLineSize, 32, true);
      default:
 	return 0;
    }
 }
 Compressor *
 newTileCompressor (Compression c,
 		   size_t tileLineSize,
 		   size_t numTileLines,
 		   const Header &hdr)
 {
    switch (c)
    {
      case RLE_COMPRESSION:
 	return new RleCompressor (hdr, uiMult (tileLineSize, numTileLines));
      case ZIPS_COMPRESSION:
      case ZIP_COMPRESSION:
 	return new ZipCompressor (hdr, tileLineSize, numTileLines);
      case PIZ_COMPRESSION:
 	return new PizCompressor (hdr, tileLineSize, numTileLines);
      case PXR24_COMPRESSION:
 	return new Pxr24Compressor (hdr, tileLineSize, numTileLines);
      case B44_COMPRESSION:
 	return new B44Compressor (hdr, tileLineSize, numTileLines, false);
      case B44A_COMPRESSION:
 	return new B44Compressor (hdr, tileLineSize, numTileLines, true);
      default:
 	return 0;
    }
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfCompressor.h
+++ b/3rdparty/openexr/IlmImf/ImfCompressor.h
@ -0,0 +1,252 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_COMPRESSOR_H
 #define INCLUDED_IMF_COMPRESSOR_H
 //-----------------------------------------------------------------------------
 //
 //	class Compressor
 //
 //-----------------------------------------------------------------------------
 #include <ImfCompression.h>
 #include "ImathBox.h"
 #include <stdlib.h>
 namespace Imf {
 class Header;
 class Compressor
 {
  public:
    //---------------------------------------------
    // Constructor -- hdr is the header of the file
    // that will be compressed or uncompressed
    //---------------------------------------------
    Compressor (const Header &hdr);
    //-----------
    // Destructor
    //-----------
    virtual ~Compressor ();
    //----------------------------------------------
    // Maximum number of scan lines processed by
    // a single call to compress() and uncompress().
    //----------------------------------------------
    virtual int		numScanLines () const = 0;
    //--------------------------------------------
    // Format of the pixel data read and written
    // by the compress() and uncompress() methods.
    // The default implementation of format()
    // returns XDR.
    //--------------------------------------------
    enum Format
    {
 	NATIVE,		// the machine's native format
 	XDR		// Xdr format
    };
    virtual Format	format () const;
    //----------------------------
    // Access to the file's header
    //----------------------------
    const Header &	header () const		{return _header;}
    //-------------------------------------------------------------------------
    // Compress an array of bytes that represents the contents of up to
    // numScanLines() scan lines:
    //
    //	    inPtr		Input buffer (uncompressed data).
    //
    //	    inSize		Number of bytes in the input buffer
    //
    //	    minY		Minimum y coordinate of the scan lines to
    //				be compressed
    //
    //	    outPtr		Pointer to output buffer
    //
    //	    return value	Size of compressed data in output buffer
    //
    // Arrangement of uncompressed pixel data in the input buffer:
    //
    //	Before calling
    //
    //	        compress (buf, size, minY, ...);
    //
    //	the InputFile::writePixels() method gathers pixel data from the
    // 	frame buffer, fb, and places them in buffer buf, like this:
    //
    //  char *endOfBuf = buf;
    //
    //	for (int y = minY;
    //	     y <= min (minY + numScanLines() - 1, header().dataWindow().max.y);
    //	     ++y)
    //	{
    //	    for (ChannelList::ConstIterator c = header().channels().begin();
    //		 c != header().channels().end();
    //		 ++c)
    //	    {
    //		if (modp (y, c.channel().ySampling) != 0)
    //		    continue;
    //
    //		for (int x = header().dataWindow().min.x;
    //		     x <= header().dataWindow().max.x;
    //		     ++x)
    //		{
    //		    if (modp (x, c.channel().xSampling) != 0)
    //			continue;
    //
    //		    Xdr::write<CharPtrIO> (endOfBuf, fb.pixel (c, x, y));
    //		}
    //	    }
    //	}
    //
    //	int size = endOfBuf - buf;
    //
    //-------------------------------------------------------------------------
    virtual int		compress (const char *inPtr,
 				  int inSize,
 				  int minY,
 				  const char *&outPtr) = 0;
    virtual int		compressTile (const char *inPtr,
 				      int inSize,
 				      Imath::Box2i range,
 				      const char *&outPtr);
    //-------------------------------------------------------------------------
    // Uncompress an array of bytes that has been compressed by compress():
    //
    //	    inPtr		Input buffer (compressed data).
    //
    //	    inSize		Number of bytes in the input buffer
    //
    //	    minY		Minimum y coordinate of the scan lines to
    //				be uncompressed
    //
    //	    outPtr		Pointer to output buffer
    //
    //	    return value	Size of uncompressed data in output buffer
    //
    //-------------------------------------------------------------------------
    virtual int		uncompress (const char *inPtr,
 				    int inSize,
 				    int minY,
 				    const char *&outPtr) = 0;
    virtual int		uncompressTile (const char *inPtr,
 					int inSize,
 					Imath::Box2i range,
 					const char *&outPtr);
  private:
    const Header &	_header;
 };
 //--------------------------------------
 // Test if c is a valid compression type
 //--------------------------------------
 bool		isValidCompression (Compression c);
 //-----------------------------------------------------------------
 // Construct a Compressor for compression type c:
 //
 //  maxScanLineSize	Maximum number of bytes per uncompressed
 //			scan line.
 //
 //  header		Header of the input or output file whose
 //			pixels will be compressed or uncompressed.
 //			
 //  return value	A pointer to a new Compressor object (it
 //			is the caller's responsibility to delete
 //			the object), or 0 (if c is NO_COMPRESSION).
 //
 //-----------------------------------------------------------------
 Compressor *	newCompressor (Compression c,
 			       size_t maxScanLineSize,
 			       const Header &hdr);
 //-----------------------------------------------------------------
 // Construct a Compressor for compression type c for a tiled image:
 //
 //  tileLineSize	Maximum number of bytes per uncompressed
 //			line in a tile.
 //
 //  numTileLines	Maximum number of lines in a tile.
 //
 //  header		Header of the input or output file whose
 //			pixels will be compressed or uncompressed.
 //
 //  return value	A pointer to a new Compressor object (it
 //			is the caller's responsibility to delete
 //			the object), or 0 (if c is NO_COMPRESSION).
 //
 //-----------------------------------------------------------------
 Compressor *    newTileCompressor (Compression c,
 				   size_t tileLineSize,
 				   size_t numTileLines,
 				   const Header &hdr);
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfConvert.cpp
+++ b/3rdparty/openexr/IlmImf/ImfConvert.cpp
@ -0,0 +1,139 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	Routines for converting between pixel data types,
 //	with well-defined behavior for exceptional cases.
 //
 //-----------------------------------------------------------------------------
 #include <ImfConvert.h>
 #include <limits.h>
 namespace Imf {
 namespace {
 inline bool
 isNegative (float f)
 {
    union {float f; int i;} u;
    u.f = f;
    return (u.i & 0x80000000) != 0;
 }
 inline bool
 isNan (float f)
 {
    union {float f; int i;} u;
    u.f = f;
    return (u.i & 0x7fffffff) > 0x7f800000;
 }
 inline bool
 isInfinity (float f)
 {
    union {float f; int i;} u;
    u.f = f;
    return (u.i & 0x7fffffff) == 0x7f800000;
 }
 inline bool
 isFinite (float f)
 {
    union {float f; int i;} u;
    u.f = f;
    return (u.i & 0x7f800000) != 0x7f800000;
 }
 } // namespace
 unsigned int
 halfToUint (half h)
 {
    if (h.isNegative() || h.isNan())
 	return 0;
    if (h.isInfinity())
 	return UINT_MAX;
    return (unsigned int) h;
 }
 unsigned int
 floatToUint (float f)
 {
    if (isNegative (f) || isNan (f))
 	return 0;
    if (isInfinity (f) || f > UINT_MAX)
 	return UINT_MAX;
    return (unsigned int) f;
 }
 half	
 uintToHalf (unsigned int ui)
 {
    if (ui >  HALF_MAX)
 	return half::posInf();
    return half (ui);
 }
 half	
 floatToHalf (float f)
 {
    if (isFinite (f))
    {
 	if (f >  HALF_MAX)
 	    return half::posInf();
 	if (f < -HALF_MAX)
 	    return half::negInf();
    }
    return half (f);
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfConvert.h
+++ b/3rdparty/openexr/IlmImf/ImfConvert.h
@ -0,0 +1,104 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_CONVERT_H
 #define INCLUDED_IMF_CONVERT_H
 //-----------------------------------------------------------------------------
 //
 //	Routines for converting between pixel data types,
 //	with well-defined behavior for exceptional cases,
 //	without depending on how hardware and operating
 //	system handle integer overflows and floating-point
 //	exceptions.
 //
 //-----------------------------------------------------------------------------
 #include "half.h"
 namespace Imf {
 //---------------------------------------------------------
 // Conversion from half or float to unsigned int:
 //
 //	input			result
 //	---------------------------------------------------
 //
 //	finite, >= 0		input, cast to unsigned int
 //				(rounds towards zero)
 //
 //	finite, < 0		0
 //
 //	NaN			0
 //
 //	+infinity		UINT_MAX
 //
 //	-infinity		0
 //
 //---------------------------------------------------------
 unsigned int	halfToUint (half h);
 unsigned int	floatToUint (float f);
 //---------------------------------------------------------
 // Conversion from unsigned int or float to half:
 //
 // 	input			result
 //	---------------------------------------------------
 //
 // 	finite,			closest possible half
 // 	magnitude <= HALF_MAX
 //
 // 	finite, > HALF_MAX	+infinity
 //
 // 	finite, < -HALF_MAX	-infinity
 //
 // 	NaN			NaN
 //
 // 	+infinity		+infinity
 //
 // 	-infinity		-infinity
 //
 //---------------------------------------------------------
 half		uintToHalf (unsigned int ui);
 half		floatToHalf (float f);
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfDoubleAttribute.cpp
+++ b/3rdparty/openexr/IlmImf/ImfDoubleAttribute.cpp
@ -0,0 +1,57 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class DoubleAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfDoubleAttribute.h>
 namespace Imf {
 template <>
 const char *
 DoubleAttribute::staticTypeName ()
 {
    return "double";
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfDoubleAttribute.h
+++ b/3rdparty/openexr/IlmImf/ImfDoubleAttribute.h
@ -0,0 +1,63 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_DOUBLE_ATTRIBUTE_H
 #define INCLUDED_IMF_DOUBLE_ATTRIBUTE_H
 //-----------------------------------------------------------------------------
 //
 //	class DoubleAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfAttribute.h>
 namespace Imf {
 typedef TypedAttribute<double> DoubleAttribute;
 template <> const char *DoubleAttribute::staticTypeName ();
 } // namespace Imf
 // Metrowerks compiler wants the .cpp file inlined, too
 #ifdef __MWERKS__
 #include <ImfDoubleAttribute.cpp>
 #endif
 #endif
--- a/3rdparty/openexr/IlmImf/ImfEnvmap.cpp
+++ b/3rdparty/openexr/IlmImf/ImfEnvmap.cpp
@ -0,0 +1,328 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	Environment maps
 //
 //-----------------------------------------------------------------------------
 #include <ImfEnvmap.h>
 #include "ImathFun.h"
 #include <algorithm>
 #include <math.h>
 using namespace std;
 using namespace Imath;
 namespace Imf {
 namespace LatLongMap {
 V2f	
 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):
 			 asin (dir.y / dir.length());
    float longitude = (dir.z == 0 && dir.x == 0)? 0: atan2 (dir.x, dir.z);
    return V2f (latitude, longitude);
 }
 V2f
 latLong (const Box2i &dataWindow, const V2f &pixelPosition)
 {
    float latitude, longitude;
    if (dataWindow.max.y > dataWindow.min.y)
    {
 	latitude = -M_PI *
 		  ((pixelPosition.y  - dataWindow.min.y) /
 		   (dataWindow.max.y - dataWindow.min.y) - 0.5f);
    }
    else
    {
 	latitude = 0;
    }
    if (dataWindow.max.x > dataWindow.min.x)
    {
 	longitude = -2 * M_PI *
 		   ((pixelPosition.x  - dataWindow.min.x) /
 		    (dataWindow.max.x - dataWindow.min.x) - 0.5f);
    }
    else
    {
 	longitude = 0;
    }
    return V2f (latitude, longitude);
 }
 V2f
 pixelPosition (const Box2i &dataWindow, const V2f &latLong)
 {
    float x = latLong.y / (-2 * M_PI) + 0.5f;
    float y = latLong.x / -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);
 }
 V2f
 pixelPosition (const Box2i &dataWindow, const V3f &direction)
 {
    return pixelPosition (dataWindow, latLong (direction));
 }
 V3f
 direction (const Box2i &dataWindow, const V2f &pixelPosition)
 {
    V2f ll = latLong (dataWindow, pixelPosition);
    return V3f (sin (ll.y) * cos (ll.x),
 		sin (ll.x),
 		cos (ll.y) * cos (ll.x));
 }
 } // namespace LatLongMap
 namespace CubeMap {
 int
 sizeOfFace (const Box2i &dataWindow)
 {
    return min ((dataWindow.max.x - dataWindow.min.x + 1),
 		(dataWindow.max.y - dataWindow.min.y + 1) / 6);
 }
 Box2i
 dataWindowForFace (CubeMapFace face, const Box2i &dataWindow)
 {
    int sof = sizeOfFace (dataWindow);
    Box2i dwf;
    dwf.min.x = 0;
    dwf.min.y = int (face) * sof;
    dwf.max.x = dwf.min.x + sof - 1;
    dwf.max.y = dwf.min.y + sof - 1;
    return dwf;
 }
 V2f
 pixelPosition (CubeMapFace face, const Box2i &dataWindow, V2f positionInFace)
 {
    Box2i dwf = dataWindowForFace (face, dataWindow);
    V2f pos (0, 0);
    switch (face)
    {
      case CUBEFACE_POS_X:
 	pos.x = dwf.min.x + positionInFace.y;
 	pos.y = dwf.max.y - positionInFace.x;
 	break;
      case CUBEFACE_NEG_X:
 	pos.x = dwf.max.x - positionInFace.y;
 	pos.y = dwf.max.y - positionInFace.x;
 	break;
      case CUBEFACE_POS_Y:
 	pos.x = dwf.min.x + positionInFace.x;
 	pos.y = dwf.max.y - positionInFace.y;
 	break;
      case CUBEFACE_NEG_Y:
 	pos.x = dwf.min.x + positionInFace.x;
 	pos.y = dwf.min.y + positionInFace.y;
 	break;
      case CUBEFACE_POS_Z:
 	pos.x = dwf.max.x - positionInFace.x;
 	pos.y = dwf.max.y - positionInFace.y;
 	break;
      case CUBEFACE_NEG_Z:
 	pos.x = dwf.min.x + positionInFace.x;
 	pos.y = dwf.max.y - positionInFace.y;
 	break;
    }
    return pos;
 }
 void
 faceAndPixelPosition (const V3f &direction,
 		      const Box2i &dataWindow,
 		      CubeMapFace &face,
 		      V2f &pif)
 {
    int sof = sizeOfFace (dataWindow);
    float absx = abs (direction.x);
    float absy = abs (direction.y);
    float absz = abs (direction.z);
    if (absx >= absy && absx >= absz)
    {
 	if (absx == 0)
 	{
 	    //
 	    // Special case - direction is (0, 0, 0)
 	    //
 	    face = CUBEFACE_POS_X;
 	    pif = V2f (0, 0);
 	    return;
 	}
 	pif.x = (direction.y / absx + 1) / 2 * (sof - 1);
 	pif.y = (direction.z / absx + 1) / 2 * (sof - 1);
 	if (direction.x > 0)
 	    face = CUBEFACE_POS_X;
 	else
 	    face = CUBEFACE_NEG_X;
    }
    else if (absy >= absz)
    {
 	pif.x = (direction.x / absy + 1) / 2 * (sof - 1);
 	pif.y = (direction.z / absy + 1) / 2 * (sof - 1);
 	if (direction.y > 0)
 	    face = CUBEFACE_POS_Y;
 	else
 	    face = CUBEFACE_NEG_Y;
    }
    else
    {
 	pif.x = (direction.x / absz + 1) / 2 * (sof - 1);
 	pif.y = (direction.y / absz + 1) / 2 * (sof - 1);
 	if (direction.z > 0)
 	    face = CUBEFACE_POS_Z;
 	else
 	    face = CUBEFACE_NEG_Z;
    }
 }
 V3f
 direction (CubeMapFace face, const Box2i &dataWindow, const V2f &positionInFace)
 {
    int sof = sizeOfFace (dataWindow);
    V2f pos;
    if (sof > 1)
    {
 	pos = V2f (positionInFace.x / (sof - 1) * 2 - 1,
 		   positionInFace.y / (sof - 1) * 2 - 1);
    }
    else
    {
 	pos = V2f (0, 0);
    }
    V3f dir (1, 0, 0);
    switch (face)
    {
      case CUBEFACE_POS_X:
 	dir.x = 1;
 	dir.y = pos.x;
 	dir.z = pos.y;
 	break;
      case CUBEFACE_NEG_X:
 	dir.x = -1;
 	dir.y = pos.x;
 	dir.z = pos.y;
 	break;
      case CUBEFACE_POS_Y:
 	dir.x = pos.x;
 	dir.y = 1;
 	dir.z = pos.y;
 	break;
      case CUBEFACE_NEG_Y:
 	dir.x = pos.x;
 	dir.y = -1;
 	dir.z = pos.y;
 	break;
      case CUBEFACE_POS_Z:
 	dir.x = pos.x;
 	dir.y = pos.y;
 	dir.z = 1;
 	break;
      case CUBEFACE_NEG_Z:
 	dir.x = pos.x;
 	dir.y = pos.y;
 	dir.z = -1;
 	break;
    }
    return dir;
 }
 } // namespace CubeMap
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfEnvmap.h
+++ b/3rdparty/openexr/IlmImf/ImfEnvmap.h
@ -0,0 +1,322 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_ENVMAP_H
 #define INCLUDED_IMF_ENVMAP_H
 //-----------------------------------------------------------------------------
 //
 //	Environment maps
 //
 //	Environment maps define a mapping from 3D directions to 2D
 //	pixel space locations.  Environment maps are typically used
 //	in 3D rendering, for effects such as quickly approximating
 //	how shiny surfaces reflect their environment.
 //
 //	Environment maps can be stored in scanline-based or in tiled
 //	OpenEXR files.  The fact that an image is an environment map
 //	is indicated by the presence of an EnvmapAttribute whose name
 //	is "envmap". (Convenience functions to access this attribute
 //	are defined in header file ImfStandardAttributes.h.)
 //	The attribute's value defines the mapping from 3D directions
 //	to 2D pixel space locations.
 //
 //	This header file defines the set of possible EnvmapAttribute
 //	values.
 //
 //	For each possible EnvmapAttribute value, this header file also
 //	defines a set of convienience functions to convert between 3D
 //	directions and 2D pixel locations.
 //
 //	Most of the convenience functions defined below require a
 //	dataWindow parameter.  For scanline-based images, and for
 //	tiled images with level mode ONE_LEVEL, the dataWindow
 //	parameter should be set to the image's data window, as
 //	defined in the image header.  For tiled images with level
 //	mode MIPMAP_LEVELS or RIPMAP_LEVELS, the data window of the
 //	image level that is being accessed should be used instead.
 //	(See the dataWindowForLevel() methods in ImfTiledInputFile.h
 //	and ImfTiledOutputFile.h.)
 //
 //-----------------------------------------------------------------------------
 #include "ImathBox.h"
 namespace Imf {
 //--------------------------------
 // Supported environment map types
 //--------------------------------
 enum Envmap
 {
    ENVMAP_LATLONG = 0,		// Latitude-longitude environment map
    ENVMAP_CUBE = 1,		// Cube map
    NUM_ENVMAPTYPES		// Number of different environment map types
 };
 //-------------------------------------------------------------------------
 // Latitude-Longitude Map:
 //
 // The environment is projected onto the image using polar coordinates
 // (latitude and longitude).  A pixel's x coordinate corresponds to
 // its longitude, and the y coordinate corresponds to its latitude.
 // Pixel (dataWindow.min.x, dataWindow.min.y) has latitude +pi/2 and
 // longitude +pi; pixel (dataWindow.max.x, dataWindow.max.y) has
 // latitude -pi/2 and longitude -pi.
 //
 // In 3D space, latitudes -pi/2 and +pi/2 correspond to the negative and
 // positive y direction.  Latitude 0, longitude 0 points into positive
 // z direction; and latitude 0, longitude pi/2 points into positive x
 // direction.
 //
 // The size of the data window should be 2*N by N pixels (width by height),
 // where N can be any integer greater than 0.
 //-------------------------------------------------------------------------
 namespace LatLongMap
 {
    //----------------------------------------------------
    // Convert a 3D direction to a 2D vector whose x and y
    // components represent the corresponding latitude
    // and longitude.
    //----------------------------------------------------
    Imath::V2f		latLong (const Imath::V3f &direction);
    //--------------------------------------------------------
    // Convert the position of a pixel to a 2D vector whose
    // x and y components represent the corresponding latitude
    // and longitude.
    //--------------------------------------------------------
    Imath::V2f		latLong (const Imath::Box2i &dataWindow,
 				 const Imath::V2f &pixelPosition);
    //-------------------------------------------------------------
    // Convert a 2D vector, whose x and y components represent
    // longitude and latitude, into a corresponding pixel position.
    //-------------------------------------------------------------
    Imath::V2f		pixelPosition (const Imath::Box2i &dataWindow,
 				       const Imath::V2f &latLong);
    //-----------------------------------------------------
    // Convert a 3D direction vector into a corresponding
    // pixel position.  pixelPosition(dw,dir) is equivalent
    // to pixelPosition(dw,latLong(dw,dir)).
    //-----------------------------------------------------
    Imath::V2f		pixelPosition (const Imath::Box2i &dataWindow,
 				       const Imath::V3f &direction);
    //--------------------------------------------------------
    // Convert the position of a pixel in a latitude-longitude
    // map into a corresponding 3D direction.
    //--------------------------------------------------------
    Imath::V3f		direction (const Imath::Box2i &dataWindow,
 				   const Imath::V2f &pixelPosition);
 }
 //--------------------------------------------------------------
 // Cube Map:
 //
 // The environment is projected onto the six faces of an
 // axis-aligned cube.  The cube's faces are then arranged
 // in a 2D image as shown below.
 //
 //          2-----------3
 //         /           /|
 //        /           / |       Y
 //       /           /  |       |
 //      6-----------7   |       |
 //      |           |   |       |
 //      |           |   |       |
 //      |   0       |   1       *------- X
 //      |           |  /       /
 //      |           | /       /
 //      |           |/       /
 //      4-----------5       Z
 // 
 //   dataWindow.min
 //        /
 //       / 
 //      +-----------+
 //      |3    Y    7|
 //      |     |     |
 //      |     |     |
 //      |  ---+---Z |  +X face
 //      |     |     |
 //      |     |     |
 //      |1         5|
 //      +-----------+
 //      |6    Y    2|
 //      |     |     |
 //      |     |     |
 //      | Z---+---  |  -X face
 //      |     |     |
 //      |     |     |
 //      |4         0|
 //      +-----------+
 //      |6    Z    7|
 //      |     |     |
 //      |     |     |
 //      |  ---+---X |  +Y face
 //      |     |     |
 //      |     |     |
 //      |2         3|
 //      +-----------+
 //      |0         1|
 //      |     |     |
 //      |     |     |
 //      |  ---+---X |  -Y face
 //      |     |     |
 //      |     |     |
 //      |4    Z    5|
 //      +-----------+
 //      |7    Y    6|
 //      |     |     |
 //      |     |     |
 //      | X---+---  |  +Z face
 //      |     |     |
 //      |     |     |
 //      |5         4|
 //      +-----------+
 //      |2    Y    3|
 //      |     |     |
 //      |     |     |
 //      |  ---+---X |  -Z face
 //      |     |     |
 //      |     |     |
 //      |0         1|
 //      +-----------+
 //                 /
 //                /
 //          dataWindow.max
 //
 // The size of the data window should be N by 6*N pixels
 // (width by height), where N can be any integer greater
 // than 0.
 // 
 //--------------------------------------------------------------
 //------------------------------------
 // Names for the six faces of the cube
 //------------------------------------
 enum CubeMapFace
 {
    CUBEFACE_POS_X,	// +X face
    CUBEFACE_NEG_X,	// -X face
    CUBEFACE_POS_Y,	// +Y face
    CUBEFACE_NEG_Y,	// -Y face
    CUBEFACE_POS_Z,	// +Z face
    CUBEFACE_NEG_Z 	// -Z face
 };
 namespace CubeMap
 {
    //---------------------------------------------
    // Width and height of a cube's face, in pixels
    //---------------------------------------------
    int			sizeOfFace (const Imath::Box2i &dataWindow);
    //------------------------------------------
    // Compute the region in the environment map
    // that is covered by the specified face.
    //------------------------------------------
    Imath::Box2i	dataWindowForFace (CubeMapFace face,
 					   const Imath::Box2i &dataWindow);
    //----------------------------------------------------
    // Convert the coordinates of a pixel within a face
    // [in the range from (0,0) to (s-1,s-1), where
    // s == sizeOfFace(dataWindow)] to pixel coordinates
    // in the environment map.
    //----------------------------------------------------
    Imath::V2f		pixelPosition (CubeMapFace face,
 				       const Imath::Box2i &dataWindow,
 				       Imath::V2f positionInFace);
    //--------------------------------------------------------------
    // Convert a 3D direction into a cube face, and a pixel position
    // within that face.
    //
    // If you have a 3D direction, dir, the following code fragment
    // finds the position, pos, of the corresponding pixel in an
    // environment map with data window dw:
    //
    // CubeMapFace f;
    // V2f pif, pos;
    //
    // faceAndPixelPosition (dir, dw, f, pif);
    // pos = pixelPosition (f, dw, pif);
    //
    //--------------------------------------------------------------
    void		faceAndPixelPosition (const Imath::V3f &direction,
 					      const Imath::Box2i &dataWindow,
 					      CubeMapFace &face,
 					      Imath::V2f &positionInFace);
    // --------------------------------------------------------
    // Given a cube face and a pixel position within that face,
    // compute the corresponding 3D direction.
    // --------------------------------------------------------
    Imath::V3f		direction (CubeMapFace face,
 				   const Imath::Box2i &dataWindow,
 				   const Imath::V2f &positionInFace);
 }
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfEnvmapAttribute.cpp
+++ b/3rdparty/openexr/IlmImf/ImfEnvmapAttribute.cpp
@ -0,0 +1,75 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class EnvmapAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfEnvmapAttribute.h>
 namespace Imf {
 template <>
 const char *
 EnvmapAttribute::staticTypeName ()
 {
    return "envmap";
 }
 template <>
 void
 EnvmapAttribute::writeValueTo (OStream &os, int version) const
 {
    unsigned char tmp = _value;
    Xdr::write <StreamIO> (os, tmp);
 }
 template <>
 void
 EnvmapAttribute::readValueFrom (IStream &is, int size, int version)
 {
    unsigned char tmp;
    Xdr::read <StreamIO> (is, tmp);
    _value = Envmap (tmp);
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfEnvmapAttribute.h
+++ b/3rdparty/openexr/IlmImf/ImfEnvmapAttribute.h
@ -0,0 +1,65 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_ENVMAP_ATTRIBUTE_H
 #define INCLUDED_IMF_ENVMAP_ATTRIBUTE_H
 //-----------------------------------------------------------------------------
 //
 //	class EnvmapAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfAttribute.h>
 #include <ImfEnvmap.h>
 namespace Imf {
 typedef TypedAttribute<Envmap> EnvmapAttribute;
 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
--- a/3rdparty/openexr/IlmImf/ImfFloatAttribute.cpp
+++ b/3rdparty/openexr/IlmImf/ImfFloatAttribute.cpp
@ -0,0 +1,57 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class FloatAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfFloatAttribute.h>
 namespace Imf {
 template <>
 const char *
 FloatAttribute::staticTypeName ()
 {
    return "float";
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfFloatAttribute.h
+++ b/3rdparty/openexr/IlmImf/ImfFloatAttribute.h
@ -0,0 +1,63 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_FLOAT_ATTRIBUTE_H
 #define INCLUDED_IMF_FLOAT_ATTRIBUTE_H
 //-----------------------------------------------------------------------------
 //
 //	class FloatAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfAttribute.h>
 namespace Imf {
 typedef TypedAttribute<float> FloatAttribute;
 template <> const char *FloatAttribute::staticTypeName ();
 } // namespace Imf
 // Metrowerks compiler wants the .cpp file inlined, too
 #ifdef __MWERKS__
 #include <ImfFloatAttribute.cpp>
 #endif
 #endif
--- a/3rdparty/openexr/IlmImf/ImfFrameBuffer.cpp
+++ b/3rdparty/openexr/IlmImf/ImfFrameBuffer.cpp
@ -0,0 +1,226 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class Slice
 //	class FrameBuffer
 //
 //-----------------------------------------------------------------------------
 #include <ImfFrameBuffer.h>
 #include "Iex.h"
 using namespace std;
 namespace Imf {
 Slice::Slice (PixelType t,
 	      char *b,
 	      size_t xst,
 	      size_t yst,
 	      int xsm,
 	      int ysm,
 	      double fv,
              bool xtc,
              bool ytc)
 :
    type (t),
    base (b),
    xStride (xst),
    yStride (yst),
    xSampling (xsm),
    ySampling (ysm),
    fillValue (fv),
    xTileCoords (xtc),
    yTileCoords (ytc)
 {
    // empty
 }
 void	
 FrameBuffer::insert (const char name[], const Slice &slice)
 {
    if (name[0] == 0)
    {
 	THROW (Iex::ArgExc,
 	       "Frame buffer slice name cannot be an empty string.");
    }
    _map[name] = slice;
 }
 void	
 FrameBuffer::insert (const string &name, const Slice &slice)
 {
    insert (name.c_str(), slice);
 }
 Slice &
 FrameBuffer::operator [] (const char name[])
 {
    SliceMap::iterator i = _map.find (name);
    if (i == _map.end())
    {
 	THROW (Iex::ArgExc,
 	       "Cannot find frame buffer slice \"" << name << "\".");
    }
    return i->second;
 }
 const Slice &
 FrameBuffer::operator [] (const char name[]) const
 {
    SliceMap::const_iterator i = _map.find (name);
    if (i == _map.end())
    {
 	THROW (Iex::ArgExc,
 	       "Cannot find frame buffer slice \"" << name << "\".");
    }
    return i->second;
 }
 Slice &
 FrameBuffer::operator [] (const string &name)
 {
    return this->operator[] (name.c_str());
 }
 const Slice &
 FrameBuffer::operator [] (const string &name) const
 {
    return this->operator[] (name.c_str());
 }
 Slice *
 FrameBuffer::findSlice (const char name[])
 {
    SliceMap::iterator i = _map.find (name);
    return (i == _map.end())? 0: &i->second;
 }
 const Slice *
 FrameBuffer::findSlice (const char name[]) const
 {
    SliceMap::const_iterator i = _map.find (name);
    return (i == _map.end())? 0: &i->second;
 }
 Slice *
 FrameBuffer::findSlice (const string &name)
 {
    return findSlice (name.c_str());
 }
 const Slice *
 FrameBuffer::findSlice (const string &name) const
 {
    return findSlice (name.c_str());
 }
 FrameBuffer::Iterator		
 FrameBuffer::begin ()
 {
    return _map.begin();
 }
 FrameBuffer::ConstIterator	
 FrameBuffer::begin () const
 {
    return _map.begin();
 }
 FrameBuffer::Iterator
 FrameBuffer::end ()
 {
    return _map.end();
 }
 FrameBuffer::ConstIterator	
 FrameBuffer::end () const
 {
    return _map.end();
 }
 FrameBuffer::Iterator
 FrameBuffer::find (const char name[])
 {
    return _map.find (name);
 }
 FrameBuffer::ConstIterator
 FrameBuffer::find (const char name[]) const
 {
    return _map.find (name);
 }
 FrameBuffer::Iterator
 FrameBuffer::find (const string &name)
 {
    return find (name.c_str());
 }
 FrameBuffer::ConstIterator
 FrameBuffer::find (const string &name) const
 {
    return find (name.c_str());
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfFrameBuffer.h
+++ b/3rdparty/openexr/IlmImf/ImfFrameBuffer.h
@ -0,0 +1,383 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_FRAME_BUFFER_H
 #define INCLUDED_IMF_FRAME_BUFFER_H
 //-----------------------------------------------------------------------------
 //
 //	class Slice
 //	class FrameBuffer
 //
 //-----------------------------------------------------------------------------
 #include <ImfName.h>
 #include <ImfPixelType.h>
 #include <map>
 #include <string>
 namespace Imf {
 //-------------------------------------------------------
 // Description of a single slice of the frame buffer:
 //
 // Note -- terminology: as part of a file, a component of
 // an image (e.g. red, green, blue, depth etc.) is called
 // a "channel".  As part of a frame buffer, an image
 // component is called a "slice".
 //-------------------------------------------------------
 struct Slice
 {
    //------------------------------
    // Data type; see ImfPixelType.h
    //------------------------------
    PixelType		type;
    //---------------------------------------------------------------------
    // Memory layout:  The address of pixel (x, y) is
    //
    //	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:
    //
    //	    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
    //
    //---------------------------------------------------------------------
    char *		base;
    size_t		xStride;
    size_t		yStride;
    //--------------------------------------------
    // Subsampling: pixel (x, y) is present in the
    // slice only if 
    //
    //  x % xSampling == 0 && y % ySampling == 0
    //
    //--------------------------------------------
    int			xSampling;
    int			ySampling;
    //----------------------------------------------------------
    // Default value, used to fill the slice when a file without
    // a channel that corresponds to this slice is read.
    //----------------------------------------------------------
    double		fillValue;
    //-------------------------------------------------------
    // For tiled files, the xTileCoords and yTileCoords flags
    // determine whether pixel addressing is performed using
    // absolute coordinates or coordinates relative to a
    // tile's upper left corner.  (See the comment on base,
    // xStride and yStride, above.)
    //
    // For scanline-based files these flags have no effect;
    // pixel addressing is always done using absolute
    // coordinates.
    //-------------------------------------------------------
    bool                xTileCoords;
    bool                yTileCoords;
    //------------
    // Constructor
    //------------
    Slice (PixelType type = HALF,
 	   char * base = 0,
 	   size_t xStride = 0,
 	   size_t yStride = 0,
 	   int xSampling = 1,
 	   int ySampling = 1,
 	   double fillValue = 0.0,
           bool xTileCoords = false,
           bool yTileCoords = false);
 };
 class FrameBuffer
 {
  public:
    //------------
    // Add a slice
    //------------
    void			insert (const char name[],
 					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.
    //			If no slice with name n exists, an Iex::ArgExc
    //			is thrown.
    //
    // findSlice(n)	Returns a pointer to the slice with name n,
    //			or 0 if no slice with name n exists.
    //
    //----------------------------------------------------------------
    Slice &			operator [] (const char name[]);
    const Slice &		operator [] (const char name[]) const;
    Slice &			operator [] (const std::string &name);
    const Slice &		operator [] (const std::string &name) const;
    Slice *			findSlice (const char name[]);
    const Slice *		findSlice (const char name[]) const;
    Slice *			findSlice (const std::string &name);
    const Slice *		findSlice (const std::string &name) const;
    //-----------------------------------------
    // Iterator-style access to existing slices
    //-----------------------------------------
    typedef std::map <Name, Slice> SliceMap;
    class Iterator;
    class ConstIterator;
    Iterator			begin ();
    ConstIterator		begin () const;
    Iterator			end ();
    ConstIterator		end () const;
    Iterator			find (const char name[]);
    ConstIterator		find (const char name[]) const;
    Iterator			find (const std::string &name);
    ConstIterator		find (const std::string &name) const;
  private:
    SliceMap			_map;
 };
 //----------
 // Iterators
 //----------
 class FrameBuffer::Iterator
 {
  public:
    Iterator ();
    Iterator (const FrameBuffer::SliceMap::iterator &i);
    Iterator &			operator ++ ();
    Iterator 			operator ++ (int);
    const char *		name () const;
    Slice &			slice () const;
  private:
    friend class FrameBuffer::ConstIterator;
    FrameBuffer::SliceMap::iterator _i;
 };
 class FrameBuffer::ConstIterator
 {
  public:
    ConstIterator ();
    ConstIterator (const FrameBuffer::SliceMap::const_iterator &i);
    ConstIterator (const FrameBuffer::Iterator &other);
    ConstIterator &		operator ++ ();
    ConstIterator 		operator ++ (int);
    const char *		name () const;
    const Slice &		slice () const;
  private:
    friend bool operator == (const ConstIterator &, const ConstIterator &);
    friend bool operator != (const ConstIterator &, const ConstIterator &);
    FrameBuffer::SliceMap::const_iterator _i;
 };
 //-----------------
 // Inline Functions
 //-----------------
 inline
 FrameBuffer::Iterator::Iterator (): _i()
 {
    // empty
 }
 inline
 FrameBuffer::Iterator::Iterator (const FrameBuffer::SliceMap::iterator &i):
    _i (i)
 {
    // empty
 }
 inline FrameBuffer::Iterator &		
 FrameBuffer::Iterator::operator ++ ()
 {
    ++_i;
    return *this;
 }
 inline FrameBuffer::Iterator 	
 FrameBuffer::Iterator::operator ++ (int)
 {
    Iterator tmp = *this;
    ++_i;
    return tmp;
 }
 inline const char *
 FrameBuffer::Iterator::name () const
 {
    return *_i->first;
 }
 inline Slice &	
 FrameBuffer::Iterator::slice () const
 {
    return _i->second;
 }
 inline
 FrameBuffer::ConstIterator::ConstIterator (): _i()
 {
    // empty
 }
 inline
 FrameBuffer::ConstIterator::ConstIterator
    (const FrameBuffer::SliceMap::const_iterator &i): _i (i)
 {
    // empty
 }
 inline
 FrameBuffer::ConstIterator::ConstIterator (const FrameBuffer::Iterator &other):
    _i (other._i)
 {
    // empty
 }
 inline FrameBuffer::ConstIterator &
 FrameBuffer::ConstIterator::operator ++ ()
 {
    ++_i;
    return *this;
 }
 inline FrameBuffer::ConstIterator 		
 FrameBuffer::ConstIterator::operator ++ (int)
 {
    ConstIterator tmp = *this;
    ++_i;
    return tmp;
 }
 inline const char *
 FrameBuffer::ConstIterator::name () const
 {
    return *_i->first;
 }
 inline const Slice &	
 FrameBuffer::ConstIterator::slice () const
 {
    return _i->second;
 }
 inline bool
 operator == (const FrameBuffer::ConstIterator &x,
 	     const FrameBuffer::ConstIterator &y)
 {
    return x._i == y._i;
 }
 inline bool
 operator != (const FrameBuffer::ConstIterator &x,
 	     const FrameBuffer::ConstIterator &y)
 {
    return !(x == y);
 }
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfFramesPerSecond.cpp
+++ b/3rdparty/openexr/IlmImf/ImfFramesPerSecond.cpp
@ -0,0 +1,75 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2006, 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	Convenience functions related to the framesPerSecond attribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfFramesPerSecond.h>
 #include "ImathFun.h"
 using namespace Imath;
 namespace Imf {
 Rational
 guessExactFps (double fps)
 {
    return guessExactFps (Rational (fps));
 }
 Rational
 guessExactFps (const Rational &fps)
 {
    const double e = 0.002;
    if (abs (double (fps) - double (fps_23_976())) < e)
 	return fps_23_976();
    if (abs (double (fps) - double (fps_29_97())) < e)
 	return fps_29_97();
    if (abs (double (fps) - double (fps_47_952())) < e)
 	return fps_47_952();
    if (abs (double (fps) - double (fps_59_94())) < e)
 	return fps_59_94();
    return fps;
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfFramesPerSecond.h
+++ b/3rdparty/openexr/IlmImf/ImfFramesPerSecond.h
@ -0,0 +1,88 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2006, 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_FRAMES_PER_SECOND_H
 #define INCLUDED_IMF_FRAMES_PER_SECOND_H
 //-----------------------------------------------------------------------------
 //
 //	Convenience functions related to the framesPerSecond attribute
 //
 //	Functions that return the exact values for commonly used frame rates:
 //
 //	    name		frames per second
 //
 //	    fps_23_976()	23.976023...
 //	    fps_24()		24.0		35mm film frames
 //	    fps_25()		25.0		PAL video frames
 //	    fps_29_97()		29.970029...	NTSC video frames
 //	    fps_30()		30.0		60Hz HDTV frames
 //	    fps_47_952()	47.952047...
 //	    fps_48()		48.0
 //	    fps_50()		50.0		PAL video fields
 //	    fps_59_94()		59.940059...	NTSC video fields
 //	    fps_60()		60.0		60Hz HDTV fields
 //
 //	Functions that try to convert inexact frame rates into exact ones:
 //
 //	    Given a frame rate, fps, that is close to one of the pre-defined
 //	    frame rates fps_23_976(), fps_29_97(), fps_47_952() or fps_59_94(),
 //	    guessExactFps(fps) returns the corresponding pre-defined frame
 //	    rate.  If fps is not close to one of the pre-defined frame rates,
 //	    then guessExactFps(fps) returns Rational(fps).
 //
 //-----------------------------------------------------------------------------
 #include <ImfRational.h>
 namespace Imf {
 inline Rational	fps_23_976 ()	{return Rational (24000, 1001);}
 inline Rational	fps_24 ()	{return Rational (24, 1);}
 inline Rational	fps_25 ()	{return Rational (25, 1);}
 inline Rational	fps_29_97 ()	{return Rational (30000, 1001);}
 inline Rational	fps_30 ()	{return Rational (30, 1);}
 inline Rational	fps_47_952 ()	{return Rational (48000, 1001);}
 inline Rational	fps_48 ()	{return Rational (48, 1);}
 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);
 Rational	guessExactFps (const Rational &fps);
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfHeader.cpp
+++ b/3rdparty/openexr/IlmImf/ImfHeader.cpp
--- a/3rdparty/openexr/IlmImf/ImfHeader.h
+++ b/3rdparty/openexr/IlmImf/ImfHeader.h
@ -0,0 +1,627 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_HEADER_H
 #define INCLUDED_IMF_HEADER_H
 //-----------------------------------------------------------------------------
 //
 //	class Header
 //
 //-----------------------------------------------------------------------------
 #include <ImfLineOrder.h>
 #include <ImfCompression.h>
 #include <ImfName.h>
 #include <ImfTileDescription.h>
 #include <ImfInt64.h>
 #include "ImathVec.h"
 #include "ImathBox.h"
 #include "IexBaseExc.h"
 #include <map>
 #include <iosfwd>
 #include <string>
 namespace Imf {
 class Attribute;
 class ChannelList;
 class IStream;
 class OStream;
 class PreviewImage;
 class Header
 {
  public:
    //----------------------------------------------------------------
    // Default constructor -- the display window and the data window
    // are both set to Box2i (V2i (0, 0), V2i (width-1, height-1).
    //----------------------------------------------------------------
    Header (int width = 64,
 	    int height = 64,
 	    float pixelAspectRatio = 1,
 	    const Imath::V2f &screenWindowCenter = Imath::V2f (0, 0),
 	    float screenWindowWidth = 1,
 	    LineOrder lineOrder = INCREASING_Y,
 	    Compression = ZIP_COMPRESSION);
    //--------------------------------------------------------------------
    // Constructor -- the data window is specified explicitly; the display
    // window is set to Box2i (V2i (0, 0), V2i (width-1, height-1).
    //--------------------------------------------------------------------
    Header (int width,
 	    int height,
 	    const Imath::Box2i &dataWindow,
 	    float pixelAspectRatio = 1,
 	    const Imath::V2f &screenWindowCenter = Imath::V2f (0, 0),
 	    float screenWindowWidth = 1,
 	    LineOrder lineOrder = INCREASING_Y,
 	    Compression = ZIP_COMPRESSION);
    //----------------------------------------------------------
    // Constructor -- the display window and the data window are
    // both specified explicitly.
    //----------------------------------------------------------
    Header (const Imath::Box2i &displayWindow,
 	    const Imath::Box2i &dataWindow,
 	    float pixelAspectRatio = 1,
 	    const Imath::V2f &screenWindowCenter = Imath::V2f (0, 0),
 	    float screenWindowWidth = 1,
 	    LineOrder lineOrder = INCREASING_Y,
 	    Compression = ZIP_COMPRESSION);
    //-----------------
    // Copy constructor
    //-----------------
    Header (const Header &other);
    //-----------
    // Destructor
    //-----------
    ~Header ();
    //-----------
    // Assignment
    //-----------
    Header &			operator = (const Header &other);
    //---------------------------------------------------------------
    // Add an attribute:
    //
    // insert(n,attr)	If no attribute with name n exists, a new
    //			attribute with name n, and the same type as
    //			attr, is added, and the value of attr is
    //			copied into the new attribute.
    //
    //			If an attribute with name n exists, and its
    //			type is the same as attr, the value of attr
    //			is copied into this attribute.
    //
    //			If an attribute with name n exists, and its
    //			type is different from attr, an Iex::TypeExc
    //			is thrown.
    //
    //---------------------------------------------------------------
    void			insert (const char name[],
 				        const Attribute &attribute);
    void			insert (const std::string &name,
 				        const Attribute &attribute);
    //------------------------------------------------------------------
    // Access to existing attributes:
    //
    // [n]			Returns a reference to the attribute
    //				with name n.  If no attribute with
    //				name n exists, an Iex::ArgExc is thrown.
    //
    // typedAttribute<T>(n)	Returns a reference to the attribute
    //				with name n and type T.  If no attribute
    //				with name n exists, an Iex::ArgExc is
    //				thrown.  If an attribute with name n
    //				exists, but its type is not T, an
    //				Iex::TypeExc is thrown.
    //
    // findTypedAttribute<T>(n)	Returns a pointer to the attribute with
    //				name n and type T, or 0 if no attribute
    //				with name n and type T exists.
    //
    //------------------------------------------------------------------
    Attribute &			operator [] (const char name[]);
    const Attribute &		operator [] (const char name[]) const;
    Attribute &			operator [] (const std::string &name);
    const Attribute &		operator [] (const std::string &name) const;
    template <class T> T&	typedAttribute (const char name[]);
    template <class T> const T&	typedAttribute (const char name[]) const;
    template <class T> T&	typedAttribute (const std::string &name);
    template <class T> const T&	typedAttribute (const std::string &name) const;
    template <class T> T*	findTypedAttribute (const char name[]);
    template <class T> const T*	findTypedAttribute (const char name[]) const;
    template <class T> T*	findTypedAttribute (const std::string &name);
    template <class T> const T*	findTypedAttribute (const std::string &name)
 								       const;
    //---------------------------------------------
    // Iterator-style access to existing attributes
    //---------------------------------------------
    typedef std::map <Name, Attribute *> AttributeMap;
    class Iterator;
    class ConstIterator;
    Iterator			begin ();
    ConstIterator		begin () const;
    Iterator			end ();
    ConstIterator		end () const;
    Iterator			find (const char name[]);
    ConstIterator		find (const char name[]) const;
    Iterator			find (const std::string &name);
    ConstIterator		find (const std::string &name) const;
    //--------------------------------
    // Access to predefined attributes
    //--------------------------------
    Imath::Box2i &		displayWindow ();
    const Imath::Box2i &	displayWindow () const;
    Imath::Box2i &		dataWindow ();
    const Imath::Box2i &	dataWindow () const;
    float &			pixelAspectRatio ();
    const float &		pixelAspectRatio () const;
    Imath::V2f &		screenWindowCenter ();
    const Imath::V2f &		screenWindowCenter () const;
    float &			screenWindowWidth ();
    const float &		screenWindowWidth () const;
    ChannelList &		channels ();
    const ChannelList &		channels () const;
    LineOrder &			lineOrder ();
    const LineOrder &		lineOrder () const;
    Compression &		compression ();
    const Compression &		compression () const;
    //----------------------------------------------------------------------
    // Tile Description:
    //
    // The tile description is a TileDescriptionAttribute whose name
    // is "tiles".  The "tiles" attribute must be present in any tiled
    // image file. When present, it describes various properties of the
    // tiles that make up the file.
    //
    // Convenience functions:
    //
    // setTileDescription(td)
    //     calls insert ("tiles", TileDescriptionAttribute (td))
    //
    // tileDescription()
    //     returns typedAttribute<TileDescriptionAttribute>("tiles").value()
    //
    // hasTileDescription()
    //     return findTypedAttribute<TileDescriptionAttribute>("tiles") != 0
    //
    //----------------------------------------------------------------------
    void			setTileDescription (const TileDescription & td);
    TileDescription &		tileDescription ();
    const TileDescription &	tileDescription () const;
    bool			hasTileDescription() const;
    //----------------------------------------------------------------------
    // Preview image:
    //
    // The preview image is a PreviewImageAttribute whose name is "preview".
    // This attribute is special -- while an image file is being written,
    // the pixels of the preview image can be changed repeatedly by calling
    // OutputFile::updatePreviewImage().
    //
    // Convenience functions:
    //
    // setPreviewImage(p)
    //     calls insert ("preview", PreviewImageAttribute (p))
    //
    // previewImage()
    //     returns typedAttribute<PreviewImageAttribute>("preview").value()
    //
    // hasPreviewImage()
    //     return findTypedAttribute<PreviewImageAttribute>("preview") != 0
    //
    //----------------------------------------------------------------------
    void			setPreviewImage (const PreviewImage &p);
    PreviewImage &		previewImage ();
    const PreviewImage &	previewImage () const;
    bool			hasPreviewImage () const;
    //-------------------------------------------------------------
    // Sanity check -- examines the header, and throws an exception
    // if it finds something wrong (empty display window, negative
    // pixel aspect ratio, unknown compression sceme etc.)
    //
    // set isTiled to true if you are checking a tiled/multi-res
    // header
    //-------------------------------------------------------------
    void			sanityCheck (bool isTiled = false) const;
    //----------------------------------------------------------------
    // Maximum image size and maximim tile size:
    //
    // sanityCheck() will throw an exception if the width or height of
    // the data window exceeds the maximum image width or height, or
    // if the size of a tile exceeds the maximum tile width or height.
    // 
    // At program startup the maximum image and tile width and height
    // are set to zero, meaning that width and height are unlimited.
    //
    // Limiting image and tile width and height limits how much memory
    // will be allocated when a file is opened.  This can help protect
    // applications from running out of memory while trying to read
    // a damaged image file.
    //----------------------------------------------------------------
    static void			setMaxImageSize (int maxWidth, int maxHeight);
    static void			setMaxTileSize (int maxWidth, int maxHeight);
    //------------------------------------------------------------------
    // Input and output:
    //
    // If the header contains a preview image attribute, then writeTo()
    // returns the position of that attribute in the output stream; this
    // information is used by OutputFile::updatePreviewImage().
    // If the header contains no preview image attribute, then writeTo()
    // returns 0.
    //------------------------------------------------------------------
    Int64			writeTo (OStream &os,
 					 bool isTiled = false) const;
    void			readFrom (IStream &is, int &version);
  private:
    AttributeMap		_map;
 };
 //----------
 // Iterators
 //----------
 class Header::Iterator
 {
  public:
    Iterator ();
    Iterator (const Header::AttributeMap::iterator &i);
    Iterator &			operator ++ ();
    Iterator 			operator ++ (int);
    const char *		name () const;
    Attribute &			attribute () const;
  private:
    friend class Header::ConstIterator;
    Header::AttributeMap::iterator _i;
 };
 class Header::ConstIterator
 {
  public:
    ConstIterator ();
    ConstIterator (const Header::AttributeMap::const_iterator &i);
    ConstIterator (const Header::Iterator &other);
    ConstIterator &		operator ++ ();
    ConstIterator 		operator ++ (int);
    const char *		name () const;
    const Attribute &		attribute () const;
  private:
    friend bool operator == (const ConstIterator &, const ConstIterator &);
    friend bool operator != (const ConstIterator &, const ConstIterator &);
    Header::AttributeMap::const_iterator _i;
 };
 //------------------------------------------------------------------------
 // Library initialization:
 //
 // In a multithreaded program, staticInitialize() must be called once
 // during startup, before the program accesses any other functions or
 // classes in the IlmImf library.  Calling staticInitialize() in this
 // way avoids races during initialization of the library's global
 // variables.
 //
 // Single-threaded programs are not required to call staticInitialize();
 // initialization of the library's global variables happens automatically.
 //
 //------------------------------------------------------------------------
 void staticInitialize ();
 //-----------------
 // Inline Functions
 //-----------------
 inline
 Header::Iterator::Iterator (): _i()
 {
    // empty
 }
 inline
 Header::Iterator::Iterator (const Header::AttributeMap::iterator &i): _i (i)
 {
    // empty
 }
 inline Header::Iterator &		
 Header::Iterator::operator ++ ()
 {
    ++_i;
    return *this;
 }
 inline Header::Iterator 	
 Header::Iterator::operator ++ (int)
 {
    Iterator tmp = *this;
    ++_i;
    return tmp;
 }
 inline const char *
 Header::Iterator::name () const
 {
    return *_i->first;
 }
 inline Attribute &	
 Header::Iterator::attribute () const
 {
    return *_i->second;
 }
 inline
 Header::ConstIterator::ConstIterator (): _i()
 {
    // empty
 }
 inline
 Header::ConstIterator::ConstIterator
    (const Header::AttributeMap::const_iterator &i): _i (i)
 {
    // empty
 }
 inline
 Header::ConstIterator::ConstIterator (const Header::Iterator &other):
    _i (other._i)
 {
    // empty
 }
 inline Header::ConstIterator &
 Header::ConstIterator::operator ++ ()
 {
    ++_i;
    return *this;
 }
 inline Header::ConstIterator 		
 Header::ConstIterator::operator ++ (int)
 {
    ConstIterator tmp = *this;
    ++_i;
    return tmp;
 }
 inline const char *
 Header::ConstIterator::name () const
 {
    return *_i->first;
 }
 inline const Attribute &	
 Header::ConstIterator::attribute () const
 {
    return *_i->second;
 }
 inline bool
 operator == (const Header::ConstIterator &x, const Header::ConstIterator &y)
 {
    return x._i == y._i;
 }
 inline bool
 operator != (const Header::ConstIterator &x, const Header::ConstIterator &y)
 {
    return !(x == y);
 }
 //---------------------
 // Template definitions
 //---------------------
 template <class T>
 T &
 Header::typedAttribute (const char name[])
 {
    Attribute *attr = &(*this)[name];
    T *tattr = dynamic_cast <T*> (attr);
    if (tattr == 0)
 	throw Iex::TypeExc ("Unexpected attribute type.");
    return *tattr;
 }
 template <class T>
 const T &
 Header::typedAttribute (const char name[]) const
 {
    const Attribute *attr = &(*this)[name];
    const T *tattr = dynamic_cast <const T*> (attr);
    if (tattr == 0)
 	throw Iex::TypeExc ("Unexpected attribute type.");
    return *tattr;
 }
 template <class T>
 T &
 Header::typedAttribute (const std::string &name)
 {
    return typedAttribute<T> (name.c_str());
 }
 template <class T>
 const T &
 Header::typedAttribute (const std::string &name) const
 {
    return typedAttribute<T> (name.c_str());
 }
 template <class T>
 T *
 Header::findTypedAttribute (const char name[])
 {
    AttributeMap::iterator i = _map.find (name);
    return (i == _map.end())? 0: dynamic_cast <T*> (i->second);
 }
 template <class T>
 const T *
 Header::findTypedAttribute (const char name[]) const
 {
    AttributeMap::const_iterator i = _map.find (name);
    return (i == _map.end())? 0: dynamic_cast <const T*> (i->second);
 }
 template <class T>
 T *
 Header::findTypedAttribute (const std::string &name)
 {
    return findTypedAttribute<T> (name.c_str());
 }
 template <class T>
 const T *
 Header::findTypedAttribute (const std::string &name) const
 {
    return findTypedAttribute<T> (name.c_str());
 }
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfHuf.cpp
+++ b/3rdparty/openexr/IlmImf/ImfHuf.cpp
--- a/3rdparty/openexr/IlmImf/ImfHuf.h
+++ b/3rdparty/openexr/IlmImf/ImfHuf.h
@ -0,0 +1,79 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_HUF_H
 #define INCLUDED_IMF_HUF_H
 //-----------------------------------------------------------------------------
 //
 //	16-bit Huffman compression and decompression:
 //
 //	hufCompress (r, nr, c)
 //
 //		Compresses the contents of array r (of length nr),
 //		stores the compressed data in array c, and returns
 //		the size of the compressed data (in bytes).
 //
 //		To avoid buffer overflows, the size of array c should
 //		be at least 2 * nr + 65536.
 //
 //	hufUncompress (c, nc, r, nr)
 //
 //		Uncompresses the data in array c (with length nc),
 //		and stores the results in array r (with length nr).
 //
 //-----------------------------------------------------------------------------
 namespace Imf {
 int
 hufCompress (const unsigned short raw[/*nRaw*/],
 	     int nRaw,
 	     char compressed[/*2 * nRaw + 65536*/]);
 void
 hufUncompress (const char compressed[/*nCompressed*/],
 	       int nCompressed,
 	       unsigned short raw[/*nRaw*/],
 	       int nRaw);
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfIO.cpp
+++ b/3rdparty/openexr/IlmImf/ImfIO.cpp
@ -0,0 +1,109 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	Low-level file input and output for OpenEXR.
 //
 //-----------------------------------------------------------------------------
 #include <ImfIO.h>
 #include "Iex.h"
 namespace Imf {
 IStream::IStream (const char fileName[]): _fileName (fileName)
 {
    // empty
 }
 IStream::~IStream ()
 {
    // empty
 }
 bool
 IStream::isMemoryMapped () const
 {
    return false;
 }
 char *
 IStream::readMemoryMapped (int n)
 {
    throw Iex::InputExc ("Attempt to perform a memory-mapped read "
 			 "on a file that is not memory mapped.");
    return 0;
 }
 void
 IStream::clear ()
 {
    // empty
 }
 const char *
 IStream::fileName () const
 {
    return _fileName.c_str();
 }
 OStream::OStream (const char fileName[]): _fileName (fileName)
 {
    // empty
 }
 OStream::~OStream ()
 {
    // empty
 }
 const char *
 OStream::fileName () const
 {
    return _fileName.c_str();
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfIO.h
+++ b/3rdparty/openexr/IlmImf/ImfIO.h
@ -0,0 +1,252 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_IO_H
 #define INCLUDED_IMF_IO_H
 //-----------------------------------------------------------------------------
 //
 //	Low-level file input and output for OpenEXR.
 //
 //-----------------------------------------------------------------------------
 #include <ImfInt64.h>
 #include <string>
 namespace Imf {
 //-----------------------------------------------------------
 // class IStream -- an abstract base class for input streams.
 //-----------------------------------------------------------
 class IStream
 {
  public:
    //-----------
    // Destructor
    //-----------
    virtual ~IStream ();
    //-------------------------------------------------
    // Does this input stream support memory-mapped IO?
    //
    // Memory-mapped streams can avoid an extra copy;
    // memory-mapped read operations return a pointer
    // to an internal buffer instead of copying data
    // into a buffer supplied by the caller.
    //-------------------------------------------------
    virtual bool        isMemoryMapped () const;
    //------------------------------------------------------
    // Read from the stream:
    //
    // read(c,n) reads n bytes from the stream, and stores
    // them in array c.  If the stream contains less than n
    // bytes, or if an I/O error occurs, read(c,n) throws
    // an exception.  If read(c,n) reads the last byte from
    // the file it returns false, otherwise it returns true.
    //------------------------------------------------------
    virtual bool	read (char c[/*n*/], int n) = 0;
    //---------------------------------------------------
    // Read from a memory-mapped stream:
    //
    // readMemoryMapped(n) reads n bytes from the stream
    // and returns a pointer to the first byte.  The
    // returned pointer remains valid until the stream
    // is closed.  If there are less than n byte left to
    // read in the stream or if the stream is not memory-
    // mapped, readMemoryMapped(n) throws an exception.  
    //---------------------------------------------------
    virtual char *	readMemoryMapped (int n);
    //--------------------------------------------------------
    // Get the current reading position, in bytes from the
    // beginning of the file.  If the next call to read() will
    // read the first byte in the file, tellg() returns 0.
    //--------------------------------------------------------
    virtual Int64	tellg () = 0;
    //-------------------------------------------
    // Set the current reading position.
    // After calling seekg(i), tellg() returns i.
    //-------------------------------------------
    virtual void	seekg (Int64 pos) = 0;
    //------------------------------------------------------
    // Clear error conditions after an operation has failed.
    //------------------------------------------------------
    virtual void	clear ();
    //------------------------------------------------------
    // Get the name of the file associated with this stream.
    //------------------------------------------------------
    const char *	fileName () const;
  protected:
    IStream (const char fileName[]);
  private:
    IStream (const IStream &);			// not implemented
    IStream & operator = (const IStream &);	// not implemented
    std::string		_fileName;
 };
 //-----------------------------------------------------------
 // class OStream -- an abstract base class for output streams
 //-----------------------------------------------------------
 class OStream
 {
  public:
    //-----------
    // Destructor
    //-----------
    virtual ~OStream ();
    //----------------------------------------------------------
    // Write to the stream:
    //
    // write(c,n) takes n bytes from array c, and stores them
    // in the stream.  If an I/O error occurs, write(c,n) throws
    // an exception.
    //----------------------------------------------------------
    virtual void	write (const char c[/*n*/], int n) = 0;
    //---------------------------------------------------------
    // Get the current writing position, in bytes from the
    // beginning of the file.  If the next call to write() will
    // start writing at the beginning of the file, tellp()
    // returns 0.
    //---------------------------------------------------------
    virtual Int64	tellp () = 0;
    //-------------------------------------------
    // Set the current writing position.
    // After calling seekp(i), tellp() returns i.
    //-------------------------------------------
    virtual void	seekp (Int64 pos) = 0;
    //------------------------------------------------------
    // Get the name of the file associated with this stream.
    //------------------------------------------------------
    const char *	fileName () const;
  protected:
    OStream (const char fileName[]);
  private:
    OStream (const OStream &);			// not implemented
    OStream & operator = (const OStream &);	// not implemented
    std::string		_fileName;
 };
 //-----------------------
 // Helper classes for Xdr
 //-----------------------
 struct StreamIO
 {
    static void
    writeChars (OStream &os, const char c[/*n*/], int n)
    {
 	os.write (c, n);
    }
    static bool
    readChars (IStream &is, char c[/*n*/], int n)
    {
 	return is.read (c, n);
    }
 };
 struct CharPtrIO
 {
    static void
    writeChars (char *&op, const char c[/*n*/], int n)
    {
 	while (n--)
 	    *op++ = *c++;
    }
    static bool
    readChars (const char *&ip, char c[/*n*/], int n)
    {
 	while (n--)
 	    *c++ = *ip++;
 	return true;
    }
 };
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfInputFile.cpp
+++ b/3rdparty/openexr/IlmImf/ImfInputFile.cpp
@ -0,0 +1,648 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class InputFile
 //
 //-----------------------------------------------------------------------------
 #include <ImfInputFile.h>
 #include <ImfScanLineInputFile.h>
 #include <ImfTiledInputFile.h>
 #include <ImfChannelList.h>
 #include <ImfMisc.h>
 #include <ImfStdIO.h>
 #include <ImfVersion.h>
 #include "ImathFun.h"
 #include "IlmThreadMutex.h"
 #include "Iex.h"
 #include "half.h"
 #include <fstream>
 #include <algorithm>
 namespace Imf {
 using Imath::Box2i;
 using Imath::divp;
 using Imath::modp;
 using IlmThread::Mutex;
 using IlmThread::Lock;
 //
 // Struct InputFile::Data stores things that will be
 // needed between calls to readPixels
 //
 struct InputFile::Data: public Mutex
 {
    Header              header;
    int                 version;
    IStream *		is;
    bool		deleteStream;
    TiledInputFile *	tFile;
    ScanLineInputFile *	sFile;
    LineOrder		lineOrder;      // the file's lineorder
    int			minY;           // data window's min y coord
    int			maxY;           // data window's max x coord
    FrameBuffer		tFileBuffer;
    FrameBuffer *	cachedBuffer;
    int			cachedTileY;
    int                 offset;
    int                 numThreads;
     Data (bool del, int numThreads);
    ~Data ();
    void		deleteCachedBuffer();
 };
 InputFile::Data::Data (bool del, int numThreads):
    is (0),
    deleteStream (del),
    tFile (0),
    sFile (0),
    cachedBuffer (0),
    cachedTileY (-1),
    numThreads (numThreads)
 {
    // empty
 }
 InputFile::Data::~Data ()
 {
    delete tFile;
    delete sFile;
    if (deleteStream)
 	delete is;
    deleteCachedBuffer();
 }
 void	
 InputFile::Data::deleteCachedBuffer()
 {
    //
    // Delete the cached frame buffer, and all memory
    // allocated for the slices in the cached frameBuffer.
    //
    if (cachedBuffer)
    {
 	for (FrameBuffer::Iterator k = cachedBuffer->begin();
 	     k != cachedBuffer->end();
 	     ++k)
 	{
 	    Slice &s = k.slice();
 	    switch (s.type)
 	    {
 	      case UINT:
 		delete [] (((unsigned int *)s.base) + offset);
 		break;
 	      case HALF:
 		delete [] ((half *)s.base + offset);
 		break;
 	      case FLOAT:
 		delete [] (((float *)s.base) + offset);
 		break;
 	    }                
 	}
 	//
 	// delete the cached frame buffer
 	//
 	delete cachedBuffer;        
 	cachedBuffer = 0;
    }
 }
 namespace {
 void
 bufferedReadPixels (InputFile::Data* ifd, int scanLine1, int scanLine2)
 {
    //
    // bufferedReadPixels reads each row of tiles that intersect the
    // scan-line range (scanLine1 to scanLine2). The previous row of
    // tiles is cached in order to prevent redundent tile reads when
    // accessing scanlines sequentially.
    //
    int minY = std::min (scanLine1, scanLine2);
    int maxY = std::max (scanLine1, scanLine2);
    if (minY < ifd->minY || maxY >  ifd->maxY)
    {
        throw Iex::ArgExc ("Tried to read scan line outside "
 			   "the image file's data window.");
    }
    //
    // The minimum and maximum y tile coordinates that intersect this
    // scanline range
    //
    int minDy = (minY - ifd->minY) / ifd->tFile->tileYSize();
    int maxDy = (maxY - ifd->minY) / ifd->tFile->tileYSize();
    //
    // Figure out which one is first in the file so we can read without seeking
    //
    int yStart, yEnd, yStep;
    if (ifd->lineOrder == DECREASING_Y)
    {
        yStart = maxDy;
        yEnd = minDy - 1;
        yStep = -1;
    }
    else
    {
        yStart = minDy;
        yEnd = maxDy + 1;
        yStep = 1;
    }
    //
    // the number of pixels in a row of tiles
    //
    Box2i levelRange = ifd->tFile->dataWindowForLevel(0);
    //
    // Read the tiles into our temporary framebuffer and copy them into
    // the user's buffer
    //
    for (int j = yStart; j != yEnd; j += yStep)
    {
        Box2i tileRange = ifd->tFile->dataWindowForTile (0, j, 0);
        int minYThisRow = std::max (minY, tileRange.min.y);
        int maxYThisRow = std::min (maxY, tileRange.max.y);
        if (j != ifd->cachedTileY)
        {
            //
            // We don't have any valid buffered info, so we need to read in
            // from the file.
            //
            ifd->tFile->readTiles (0, ifd->tFile->numXTiles (0) - 1, j, j);
            ifd->cachedTileY = j;
        }
        //
        // Copy the data from our cached framebuffer into the user's
        // framebuffer.
        //
        for (FrameBuffer::ConstIterator k = ifd->cachedBuffer->begin();
             k != ifd->cachedBuffer->end();
             ++k)
        {
            Slice fromSlice = k.slice();		// slice to write from
            Slice toSlice = ifd->tFileBuffer[k.name()];	// slice to write to
            char *fromPtr, *toPtr;
            int size = pixelTypeSize (toSlice.type);
 	    int xStart = levelRange.min.x;
 	    int yStart = minYThisRow;
 	    while (modp (xStart, toSlice.xSampling) != 0)
 		++xStart;
 	    while (modp (yStart, toSlice.ySampling) != 0)
 		++yStart;
            for (int y = yStart;
 		 y <= maxYThisRow;
 		 y += toSlice.ySampling)
            {
 		//
                // Set the pointers to the start of the y scanline in
                // this row of tiles
 		//
                fromPtr = fromSlice.base +
                          (y - tileRange.min.y) * fromSlice.yStride +
                          xStart * fromSlice.xStride;
                toPtr = toSlice.base +
                        divp (y, toSlice.ySampling) * toSlice.yStride +
                        divp (xStart, toSlice.xSampling) * toSlice.xStride;
 		//
                // Copy all pixels for the scanline in this row of tiles
 		//
                for (int x = xStart;
 		     x <= levelRange.max.x;
 		     x += toSlice.xSampling)
                {
 		    for (size_t i = 0; i < size; ++i)
 			toPtr[i] = fromPtr[i];
 		    fromPtr += fromSlice.xStride * toSlice.xSampling;
 		    toPtr += toSlice.xStride;
                }
            }
        }
    }
 }
 } // namespace
 InputFile::InputFile (const char fileName[], int numThreads):
    _data (new Data (true, numThreads))
 {
    try
    {
 	_data->is = new StdIFStream (fileName);
 	initialize();
    }
    catch (Iex::BaseExc &e)
    {
 	delete _data;
        REPLACE_EXC (e, "Cannot read image file "
 			"\"" << fileName << "\". " << e);
        throw;
    }
    catch (...)
    {
 	delete _data;
        throw;
    }
 }
 InputFile::InputFile (IStream &is, int numThreads):
    _data (new Data (false, numThreads))
 {
    try
    {
 	_data->is = &is;
 	initialize();
    }
    catch (Iex::BaseExc &e)
    {
 	delete _data;
        REPLACE_EXC (e, "Cannot read image file "
 			"\"" << is.fileName() << "\". " << e);
        throw;
    }
    catch (...)
    {
 	delete _data;
        throw;
    }
 }
 void
 InputFile::initialize ()
 {
    _data->header.readFrom (*_data->is, _data->version);
    _data->header.sanityCheck (isTiled (_data->version));
    if (isTiled (_data->version))
    {
 	_data->lineOrder = _data->header.lineOrder();
 	//
 	// Save the dataWindow information
 	//
 	const Box2i &dataWindow = _data->header.dataWindow();
 	_data->minY = dataWindow.min.y;
 	_data->maxY = dataWindow.max.y;
 	_data->tFile = new TiledInputFile (_data->header,
 					   _data->is,
 					   _data->version,
                                           _data->numThreads);
    }
    else
    {
 	_data->sFile = new ScanLineInputFile (_data->header,
 					      _data->is,
                                              _data->numThreads);
    }
 }
 InputFile::~InputFile ()
 {
    delete _data;
 }
 const char *
 InputFile::fileName () const
 {
    return _data->is->fileName();
 }
 const Header &
 InputFile::header () const
 {
    return _data->header;
 }
 int
 InputFile::version () const
 {
    return _data->version;
 }
 void
 InputFile::setFrameBuffer (const FrameBuffer &frameBuffer)
 {
    if (isTiled (_data->version))
    {
 	Lock lock (*_data);
 	//
        // We must invalidate the cached buffer if the new frame
 	// buffer has a different set of channels than the old
 	// frame buffer, or if the type of a channel has changed.
 	//
 	const FrameBuffer &oldFrameBuffer = _data->tFileBuffer;
 	FrameBuffer::ConstIterator i = oldFrameBuffer.begin();
 	FrameBuffer::ConstIterator j = frameBuffer.begin();
 	while (i != oldFrameBuffer.end() && j != frameBuffer.end())
 	{
 	    if (strcmp (i.name(), j.name()) || i.slice().type != j.slice().type)
 		break;
 	    ++i;
 	    ++j;
 	}
 	if (i != oldFrameBuffer.end() || j != frameBuffer.end())
        {
 	    //
 	    // Invalidate the cached buffer.
 	    //
            _data->deleteCachedBuffer ();
 	    _data->cachedTileY = -1;
 	    //
 	    // Create new a cached frame buffer.  It can hold a single
 	    // row of tiles.  The cached buffer can be reused for each
 	    // row of tiles because we set the yTileCoords parameter of
 	    // each Slice to true.
 	    //
 	    const Box2i &dataWindow = _data->header.dataWindow();
 	    _data->cachedBuffer = new FrameBuffer();
 	    _data->offset = dataWindow.min.x;
 	    int tileRowSize = (dataWindow.max.x - dataWindow.min.x + 1) *
 			      _data->tFile->tileYSize();
 	    for (FrameBuffer::ConstIterator k = frameBuffer.begin();
 		 k != frameBuffer.end();
 		 ++k)
 	    {
 		Slice s = k.slice();
 		switch (s.type)
 		{
 		  case UINT:
 		    _data->cachedBuffer->insert
 			(k.name(),
 			 Slice (UINT,
 				(char *)(new unsigned int[tileRowSize] - 
 					_data->offset),
 				sizeof (unsigned int),
 				sizeof (unsigned int) *
 				    _data->tFile->levelWidth(0),
 				1, 1,
 				s.fillValue,
 				false, true));
 		    break;
 		  case HALF:
 		    _data->cachedBuffer->insert
 			(k.name(),
 			 Slice (HALF,
 				(char *)(new half[tileRowSize] - 
 					_data->offset),
 				sizeof (half),
 				sizeof (half) *
 				    _data->tFile->levelWidth(0),
 				1, 1,
 				s.fillValue,
 				false, true));
 		    break;
 		  case FLOAT:
 		    _data->cachedBuffer->insert
 			(k.name(),
 			 Slice (FLOAT,
 				(char *)(new float[tileRowSize] - 
 					_data->offset),
 				sizeof(float),
 				sizeof(float) *
 				    _data->tFile->levelWidth(0),
 				1, 1,
 				s.fillValue,
 				false, true));
 		    break;
 		  default:
 		    throw Iex::ArgExc ("Unknown pixel data type.");
 		}
 	    }
 	    _data->tFile->setFrameBuffer (*_data->cachedBuffer);
        }
 	_data->tFileBuffer = frameBuffer;
    }
    else
    {
        _data->sFile->setFrameBuffer (frameBuffer);
    }
 }
 const FrameBuffer &
 InputFile::frameBuffer () const
 {
    if (isTiled (_data->version))
    {
 	Lock lock (*_data);
 	return _data->tFileBuffer;
    }
    else
    {
 	return _data->sFile->frameBuffer();
    }
 }
 bool
 InputFile::isComplete () const
 {
    if (isTiled (_data->version))
 	return _data->tFile->isComplete();
    else
 	return _data->sFile->isComplete();
 }
 void
 InputFile::readPixels (int scanLine1, int scanLine2)
 {
    if (isTiled (_data->version))
    {
 	Lock lock (*_data);
        bufferedReadPixels (_data, scanLine1, scanLine2);
    }
    else
    {
        _data->sFile->readPixels (scanLine1, scanLine2);
    }
 }
 void
 InputFile::readPixels (int scanLine)
 {
    readPixels (scanLine, scanLine);
 }
 void
 InputFile::rawPixelData (int firstScanLine,
 			 const char *&pixelData,
 			 int &pixelDataSize)
 {
    try
    {
 	if (isTiled (_data->version))
 	{
 	    throw Iex::ArgExc ("Tried to read a raw scanline "
 			       "from a tiled image.");
 	}
        _data->sFile->rawPixelData (firstScanLine, pixelData, pixelDataSize);
    }
    catch (Iex::BaseExc &e)
    {
 	REPLACE_EXC (e, "Error reading pixel data from image "
 		        "file \"" << fileName() << "\". " << e);
 	throw;
    }
 }
 void
 InputFile::rawTileData (int &dx, int &dy,
 			int &lx, int &ly,
 			const char *&pixelData,
 			int &pixelDataSize)
 {
    try
    {
 	if (!isTiled (_data->version))
 	{
 	    throw Iex::ArgExc ("Tried to read a raw tile "
 			       "from a scanline-based image.");
 	}
        _data->tFile->rawTileData (dx, dy, lx, ly, pixelData, pixelDataSize);
    }
    catch (Iex::BaseExc &e)
    {
 	REPLACE_EXC (e, "Error reading tile data from image "
 		        "file \"" << fileName() << "\". " << e);
 	throw;
    }
 }
 TiledInputFile*
 InputFile::tFile()
 {
    if (!isTiled (_data->version))
    {
 	throw Iex::ArgExc ("Cannot get a TiledInputFile pointer "
 			   "from an InputFile that is not tiled.");
    }
    return _data->tFile;
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfInputFile.h
+++ b/3rdparty/openexr/IlmImf/ImfInputFile.h
@ -0,0 +1,209 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_INPUT_FILE_H
 #define INCLUDED_IMF_INPUT_FILE_H
 //-----------------------------------------------------------------------------
 //
 //	class InputFile -- a scanline-based interface that can be used
 //	to read both scanline-based and tiled OpenEXR image files.
 //
 //-----------------------------------------------------------------------------
 #include <ImfHeader.h>
 #include <ImfFrameBuffer.h>
 #include <ImfTiledOutputFile.h>
 #include <string>
 #include <fstream>
 #include <ImfThreading.h>
 namespace Imf {
 class TiledInputFile;
 class ScanLineInputFile;
 class InputFile
 {
  public:
    //-----------------------------------------------------------
    // A constructor that opens the file with the specified name.
    // Destroying the InputFile object will close the file.
    //
    // numThreads determines the number of threads that will be
    // used to read the file (see ImfThreading.h).
    //-----------------------------------------------------------
    InputFile (const char fileName[], int numThreads = globalThreadCount());
    //-------------------------------------------------------------
    // A constructor that attaches the new InputFile object to a
    // file that has already been opened.  Destroying the InputFile
    // object will not close the file.
    //
    // numThreads determines the number of threads that will be
    // used to read the file (see ImfThreading.h).
    //-------------------------------------------------------------
    InputFile (IStream &is, int numThreads = globalThreadCount());
    //-----------
    // Destructor
    //-----------
    virtual ~InputFile ();
    //------------------------
    // Access to the file name
    //------------------------
    const char *	fileName () const;
    //--------------------------
    // Access to the file header
    //--------------------------
    const Header &	header () const;
    //----------------------------------
    // Access to the file format version
    //----------------------------------
    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().
    //-----------------------------------------------------------
    void		setFrameBuffer (const FrameBuffer &frameBuffer);
    //-----------------------------------
    // Access to the current frame buffer
    //-----------------------------------
    const FrameBuffer &	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.)
    //---------------------------------------------------------------
    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).
    //
    //---------------------------------------------------------------
    void		readPixels (int scanLine1, int scanLine2);
    void		readPixels (int scanLine);
    //----------------------------------------------
    // Read a block of raw pixel data from the file,
    // without uncompressing it (this function is
    // used to implement OutputFile::copyPixels()).
    //----------------------------------------------
    void		rawPixelData (int firstScanLine,
 				      const char *&pixelData,
 				      int &pixelDataSize);
    //--------------------------------------------------
    // Read a tile of raw pixel data from the file,
    // without uncompressing it (this function is
    // used to implement TiledOutputFile::copyPixels()).
    //--------------------------------------------------
    void		rawTileData (int &dx, int &dy,
 				     int &lx, int &ly,
 				     const char *&pixelData,
 				     int &pixelDataSize);
    struct Data;
  private:
    InputFile (const InputFile &);			// not implemented
    InputFile & operator = (const InputFile &);		// not implemented
    void		initialize ();
    TiledInputFile *	tFile ();
    friend void TiledOutputFile::copyPixels (InputFile &);
    Data *		_data;
 };
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfInt64.h
+++ b/3rdparty/openexr/IlmImf/ImfInt64.h
@ -0,0 +1,52 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2006, 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_INT64_H
 #define INCLUDED_IMF_INT64_H
 //----------------------------------------------------------------------------
 //
 //	Int64 -- unsigned 64-bit integers, imported from namespace Imath
 //
 //----------------------------------------------------------------------------
 #include "ImathInt64.h"
 namespace Imf {
 using Imath::Int64;
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfIntAttribute.cpp
+++ b/3rdparty/openexr/IlmImf/ImfIntAttribute.cpp
@ -0,0 +1,57 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class IntAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfIntAttribute.h>
 namespace Imf {
 template <>
 const char *
 IntAttribute::staticTypeName ()
 {
    return "int";
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfIntAttribute.h
+++ b/3rdparty/openexr/IlmImf/ImfIntAttribute.h
@ -0,0 +1,63 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_INT_ATTRIBUTE_H
 #define INCLUDED_IMF_INT_ATTRIBUTE_H
 //-----------------------------------------------------------------------------
 //
 //	class IntAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfAttribute.h>
 namespace Imf {
 typedef TypedAttribute<int> IntAttribute;
 template <> const char *IntAttribute::staticTypeName ();
 } // namespace Imf
 // Metrowerks compiler wants the .cpp file inlined, too
 #ifdef __MWERKS__
 #include <ImfIntAttribute.cpp>
 #endif
 #endif
--- a/3rdparty/openexr/IlmImf/ImfKeyCode.cpp
+++ b/3rdparty/openexr/IlmImf/ImfKeyCode.cpp
@ -0,0 +1,216 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class KeyCode
 //
 //-----------------------------------------------------------------------------
 #include <ImfKeyCode.h>
 #include "Iex.h"
 namespace Imf {
 KeyCode::KeyCode (int filmMfcCode,
 		  int filmType,
 		  int prefix,
 		  int count,
 		  int perfOffset,
 		  int perfsPerFrame,
 		  int perfsPerCount)
 {
    setFilmMfcCode (filmMfcCode);
    setFilmType (filmType);
    setPrefix (prefix);
    setCount (count);
    setPerfOffset (perfOffset);
    setPerfsPerFrame (perfsPerFrame);
    setPerfsPerCount (perfsPerCount);
 }
 KeyCode::KeyCode (const KeyCode &other)
 {
    _filmMfcCode = other._filmMfcCode;
    _filmType = other._filmType;
    _prefix = other._prefix;
    _count = other._count;
    _perfOffset = other._perfOffset;
    _perfsPerFrame = other._perfsPerFrame;
    _perfsPerCount = other._perfsPerCount;
 }
 KeyCode &
 KeyCode::operator = (const KeyCode &other)
 {
    _filmMfcCode = other._filmMfcCode;
    _filmType = other._filmType;
    _prefix = other._prefix;
    _count = other._count;
    _perfOffset = other._perfOffset;
    _perfsPerFrame = other._perfsPerFrame;
    _perfsPerCount = other._perfsPerCount;
    return *this;
 }
 int		
 KeyCode::filmMfcCode () const
 {
    return _filmMfcCode;
 }
 void	
 KeyCode::setFilmMfcCode (int filmMfcCode)
 {
    if (filmMfcCode < 0 || filmMfcCode > 99)
 	throw Iex::ArgExc ("Invalid key code film manufacturer code "
 			   "(must be between 0 and 99).");
    _filmMfcCode = filmMfcCode;
 }
 int		
 KeyCode::filmType () const
 {
    return _filmType;
 }
 void	
 KeyCode::setFilmType (int filmType)
 {
    if (filmType < 0 || filmType > 99)
 	throw Iex::ArgExc ("Invalid key code film type "
 			   "(must be between 0 and 99).");
    _filmType = filmType;
 }
 int		
 KeyCode::prefix () const
 {
    return _prefix;
 }
 void	
 KeyCode::setPrefix (int prefix)
 {
    if (prefix < 0 || prefix > 999999)
 	throw Iex::ArgExc ("Invalid key code prefix "
 			   "(must be between 0 and 999999).");
    _prefix = prefix;
 }
 int		
 KeyCode::count () const
 {
    return _count;
 }
 void	
 KeyCode::setCount (int count)
 {
    if (count < 0 || count > 9999)
 	throw Iex::ArgExc ("Invalid key code count "
 			   "(must be between 0 and 9999).");
    _count = count;
 }
 int		
 KeyCode::perfOffset () const
 {
    return _perfOffset;
 }
 void	
 KeyCode::setPerfOffset (int perfOffset)
 {
    if (perfOffset < 0 || perfOffset > 119)
 	throw Iex::ArgExc ("Invalid key code perforation offset "
 			   "(must be between 0 and 119).");
    _perfOffset = perfOffset;
 }
 int	
 KeyCode::perfsPerFrame () const
 {
    return _perfsPerFrame;
 }
 void
 KeyCode::setPerfsPerFrame (int perfsPerFrame)
 {
    if (perfsPerFrame < 1 || perfsPerFrame > 15)
 	throw Iex::ArgExc ("Invalid key code number of perforations per frame "
 			   "(must be between 1 and 15).");
    _perfsPerFrame = perfsPerFrame;
 }
 int	
 KeyCode::perfsPerCount () const
 {
    return _perfsPerCount;
 }
 void
 KeyCode::setPerfsPerCount (int perfsPerCount)
 {
    if (perfsPerCount < 20 || perfsPerCount > 120)
 	throw Iex::ArgExc ("Invalid key code number of perforations per count "
 			   "(must be between 20 and 120).");
    _perfsPerCount = perfsPerCount;
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfKeyCode.h
+++ b/3rdparty/openexr/IlmImf/ImfKeyCode.h
@ -0,0 +1,161 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_KEY_CODE_H
 #define INCLUDED_IMF_KEY_CODE_H
 //-----------------------------------------------------------------------------
 //
 //	class KeyCode
 // 	
 // 	A KeyCode object uniquely identifies a motion picture film frame.
 // 	The following fields specifiy film manufacturer, film type, film
 // 	roll and the frame's position within the roll:
 //
 //	    filmMfcCode		film manufacturer code
 //				range: 0 - 99
 //
 //	    filmType		film type code
 // 				range: 0 - 99
 //
 //	    prefix		prefix to identify film roll
 // 				range: 0 - 999999
 //
 //	    count		count, increments once every perfsPerCount
 // 				perforations (see below)
 // 				range: 0 - 9999
 //
 //	    perfOffset		offset of frame, in perforations from
 // 				zero-frame reference mark
 // 				range: 0 - 119
 //
 //	    perfsPerFrame	number of perforations per frame 
 // 				range: 1 - 15
 //
 //				typical values:
 //
 //				    1 for 16mm film
 //				    3, 4, or 8 for 35mm film
 //				    5, 8 or 15 for 65mm film
 //
 //	    perfsPerCount	number of perforations per count 
 // 				range: 20 - 120
 //
 //				typical values:
 //
 //				    20 for 16mm film
 //				    64 for 35mm film
 //				    80 or 120 for 65mm film
 //
 // 	For more information about the interpretation of those fields see
 // 	the following standards and recommended practice publications:
 //
 // 	    SMPTE 254	Motion-Picture Film (35-mm) - Manufacturer-Printed
 // 			Latent Image Identification Information
 //
 // 	    SMPTE 268M 	File Format for Digital Moving-Picture Exchange (DPX)
 // 			(section 6.1)
 //
 // 	    SMPTE 270	Motion-Picture Film (65-mm) - Manufacturer- Printed
 // 			Latent Image Identification Information
 //
 // 	    SMPTE 271	Motion-Picture Film (16-mm) - Manufacturer- Printed
 // 			Latent Image Identification Information
 //
 //-----------------------------------------------------------------------------
 namespace Imf {
 class KeyCode
 {
  public:
    //-------------------------------------
    // Constructors and assignment operator
    //-------------------------------------
    KeyCode (int filmMfcCode = 0,
 	     int filmType = 0,
 	     int prefix = 0,
 	     int count = 0,
 	     int perfOffset = 0,
 	     int perfsPerFrame = 4,
 	     int perfsPerCount = 64);
    KeyCode (const KeyCode &other);
    KeyCode & operator = (const KeyCode &other);
    //----------------------------
    // Access to individual fields
    //----------------------------
    int		filmMfcCode () const;
    void	setFilmMfcCode (int filmMfcCode);
    int		filmType () const;
    void	setFilmType (int filmType);
    int		prefix () const;
    void	setPrefix (int prefix);
    int		count () const;
    void	setCount (int count);
    int		perfOffset () const;
    void	setPerfOffset (int perfOffset);
    int		perfsPerFrame () const;
    void	setPerfsPerFrame (int perfsPerFrame);
    int		perfsPerCount () const;
    void	setPerfsPerCount (int perfsPerCount);
  private:
    int		_filmMfcCode;
    int		_filmType;
    int		_prefix;
    int		_count;
    int		_perfOffset;
    int		_perfsPerFrame;
    int		_perfsPerCount;
 };
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfKeyCodeAttribute.cpp
+++ b/3rdparty/openexr/IlmImf/ImfKeyCodeAttribute.cpp
@ -0,0 +1,98 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class KeyCodeAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfKeyCodeAttribute.h>
 namespace Imf {
 template <>
 const char *
 KeyCodeAttribute::staticTypeName ()
 {
    return "keycode";
 }
 template <>
 void
 KeyCodeAttribute::writeValueTo (OStream &os, int version) const
 {
    Xdr::write <StreamIO> (os, _value.filmMfcCode());
    Xdr::write <StreamIO> (os, _value.filmType());
    Xdr::write <StreamIO> (os, _value.prefix());
    Xdr::write <StreamIO> (os, _value.count());
    Xdr::write <StreamIO> (os, _value.perfOffset());
    Xdr::write <StreamIO> (os, _value.perfsPerFrame());
    Xdr::write <StreamIO> (os, _value.perfsPerCount());
 }
 template <>
 void
 KeyCodeAttribute::readValueFrom (IStream &is, int size, int version)
 {
    int tmp;
    Xdr::read <StreamIO> (is, tmp);
    _value.setFilmMfcCode (tmp);
    Xdr::read <StreamIO> (is, tmp);
    _value.setFilmType (tmp);
    Xdr::read <StreamIO> (is, tmp);
    _value.setPrefix (tmp);
    Xdr::read <StreamIO> (is, tmp);
    _value.setCount (tmp);
    Xdr::read <StreamIO> (is, tmp);
    _value.setPerfOffset (tmp);
    Xdr::read <StreamIO> (is, tmp);
    _value.setPerfsPerFrame (tmp);
    Xdr::read <StreamIO> (is, tmp);
    _value.setPerfsPerCount (tmp);
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfKeyCodeAttribute.h
+++ b/3rdparty/openexr/IlmImf/ImfKeyCodeAttribute.h
@ -0,0 +1,72 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_KEY_CODE_ATTRIBUTE_H
 #define INCLUDED_IMF_KEY_CODE_ATTRIBUTE_H
 //-----------------------------------------------------------------------------
 //
 //	class KeyCodeAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfAttribute.h>
 #include <ImfKeyCode.h>
 namespace Imf {
 typedef TypedAttribute<KeyCode> KeyCodeAttribute;
 template <>
 const char *KeyCodeAttribute::staticTypeName ();
 template <>
 void KeyCodeAttribute::writeValueTo (OStream &, int) const;
 template <>
 void KeyCodeAttribute::readValueFrom (IStream &, int, int);
 } // namespace Imf
 // Metrowerks compiler wants the .cpp file inlined, too
 #ifdef __MWERKS__
 #include <ImfKeyCodeAttribute.cpp>
 #endif
 #endif
--- a/3rdparty/openexr/IlmImf/ImfLineOrder.h
+++ b/3rdparty/openexr/IlmImf/ImfLineOrder.h
@ -0,0 +1,64 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_LINE_ORDER_H
 #define INCLUDED_IMF_LINE_ORDER_H
 //-----------------------------------------------------------------------------
 //
 //	enum LineOrder
 //
 //-----------------------------------------------------------------------------
 namespace Imf {
 enum LineOrder
 {
    INCREASING_Y = 0,	// first scan line has lowest y coordinate
    DECREASING_Y = 1,	// first scan line has highest y coordinate
    RANDOM_Y = 2,       // only for tiled files; tiles are written
    			// in random order
    NUM_LINEORDERS	// number of different line orders
 };
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfLineOrderAttribute.cpp
+++ b/3rdparty/openexr/IlmImf/ImfLineOrderAttribute.cpp
@ -0,0 +1,77 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class LineOrderAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfLineOrderAttribute.h>
 namespace Imf {
 template <>
 const char *
 LineOrderAttribute::staticTypeName ()
 {
    return "lineOrder";
 }
 template <>
 void
 LineOrderAttribute::writeValueTo (OStream &os, int version) const
 {
    unsigned char tmp = _value;
    Xdr::write <StreamIO> (os, tmp);
 }
 template <>
 void
 LineOrderAttribute::readValueFrom (IStream &is, int size, int version)
 {
    unsigned char tmp;
    Xdr::read <StreamIO> (is, tmp);
    _value = LineOrder (tmp);
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfLineOrderAttribute.h
+++ b/3rdparty/openexr/IlmImf/ImfLineOrderAttribute.h
@ -0,0 +1,66 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_LINE_ORDER_ATTRIBUTE_H
 #define INCLUDED_IMF_LINE_ORDER_ATTRIBUTE_H
 //-----------------------------------------------------------------------------
 //
 //	class LineOrderAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfAttribute.h>
 #include <ImfLineOrder.h>
 namespace Imf {
 typedef TypedAttribute<LineOrder> LineOrderAttribute;
 template <> const char *LineOrderAttribute::staticTypeName ();
 template <> void LineOrderAttribute::writeValueTo (OStream &, int) const;
 template <> void LineOrderAttribute::readValueFrom (IStream &, int, int);
 } // namespace Imf
 // Metrowerks compiler wants the .cpp file inlined, too
 #ifdef __MWERKS__
 #include <ImfLineOrderAttribute.cpp>
 #endif
 #endif
--- a/3rdparty/openexr/IlmImf/ImfLut.cpp
+++ b/3rdparty/openexr/IlmImf/ImfLut.cpp
@ -0,0 +1,176 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	Lookup tables for efficient application
 //	of half --> half functions to pixel data,
 //	and some commonly applied functions.
 //
 //-----------------------------------------------------------------------------
 #include <ImfLut.h>
 #include <math.h>
 #include <assert.h>
 namespace Imf {
 void
 HalfLut::apply (half *data, int nData, int stride) const
 {
    while (nData)
    {
 	*data = _lut (*data);
 	data += stride;
 	nData -= 1;
    }
 }
 void
 HalfLut::apply (const Slice &data, const Imath::Box2i &dataWindow) const
 {
    assert (data.type == HALF);
    assert (dataWindow.min.x % data.xSampling == 0);
    assert (dataWindow.min.y % data.ySampling == 0);
    assert ((dataWindow.max.x - dataWindow.min.x + 1) % data.xSampling == 0);
    assert ((dataWindow.max.y - dataWindow.min.y + 1) % data.ySampling == 0);
    char *base = data.base + data.yStride *
 		 (dataWindow.min.y / data.ySampling);
    for (int y = dataWindow.min.y;
 	 y <= dataWindow.max.y;
 	 y += data.ySampling)
    {
 	char *pixel = base + data.xStride *
 		      (dataWindow.min.x / data.xSampling);
 	for (int x = dataWindow.min.x;
 	     x <= dataWindow.max.x;
 	     x += data.xSampling)
 	{
 	    *(half *)pixel = _lut (*(half *)pixel);
 	    pixel += data.xStride;
 	}
 	base += data.yStride;
    }
 }
 void
 RgbaLut::apply (Rgba *data, int nData, int stride) const
 {
    while (nData)
    {
 	if (_chn & WRITE_R)
 	    data->r = _lut (data->r);
 	if (_chn & WRITE_G)
 	    data->g = _lut (data->g);
 	if (_chn & WRITE_B)
 	    data->b = _lut (data->b);
 	if (_chn & WRITE_A)
 	    data->a = _lut (data->a);
 	data += stride;
 	nData -= 1;
    }
 }
 void
 RgbaLut::apply (Rgba *base,
 		int xStride, int yStride,
 		const Imath::Box2i &dataWindow) const
 {
    base += dataWindow.min.y * yStride;
    for (int y = dataWindow.min.y; y <= dataWindow.max.y; ++y)
    {
 	Rgba *pixel = base + dataWindow.min.x * xStride;
 	for (int x = dataWindow.min.x; x <= dataWindow.max.x; ++x)
 	{
 	    if (_chn & WRITE_R)
 		pixel->r = _lut (pixel->r);
 	    if (_chn & WRITE_G)
 		pixel->g = _lut (pixel->g);
 	    if (_chn & WRITE_B)
 		pixel->b = _lut (pixel->b);
 	    if (_chn & WRITE_A)
 		pixel->a = _lut (pixel->a);
 	    pixel += xStride;
 	}
 	base += yStride;
    }
 }
 half
 round12log (half x)
 {
    const float middleval = pow (2.0, -2.5);
    int int12log;
    if (x <= 0)
    {
 	return 0;
    }
    else
    {
 	int12log = int (2000.5 + 200.0 * log (x / middleval) / log (2.0));
 	if (int12log > 4095)
 	    int12log = 4095;
 	if (int12log < 1)
 	    int12log = 1;
    }
    return middleval * pow (2.0, (int12log - 2000.0) / 200.0);
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfLut.h
+++ b/3rdparty/openexr/IlmImf/ImfLut.h
@ -0,0 +1,185 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_LUT_H
 #define INCLUDED_IMF_LUT_H
 //-----------------------------------------------------------------------------
 //
 //	Lookup tables for efficient application
 //	of half --> half functions to pixel data,
 //	and some commonly applied functions.
 //
 //-----------------------------------------------------------------------------
 #include <ImfRgbaFile.h>
 #include <ImfFrameBuffer.h>
 #include "ImathBox.h"
 #include "halfFunction.h"
 namespace Imf {
 //
 // Lookup table for individual half channels.
 //
 class HalfLut
 {
  public:
    //------------
    // Constructor
    //------------
    template <class Function>
    HalfLut (Function f);
    //----------------------------------------------------------------------
    // Apply the table to data[0], data[stride] ... data[(nData-1) * stride]
    //----------------------------------------------------------------------
    void apply (half *data,
 		int nData,
 		int stride = 1) const;
    //---------------------------------------------------------------
    // Apply the table to a frame buffer slice (see ImfFrameBuffer.h)
    //---------------------------------------------------------------
    void apply (const Slice &data,
 		const Imath::Box2i &dataWindow) const;
  private:
    halfFunction <half>	_lut;
 };
 //
 // Lookup table for combined RGBA data.
 //
 class RgbaLut
 {
  public:
    //------------
    // Constructor
    //------------
    template <class Function>
    RgbaLut (Function f, RgbaChannels chn = WRITE_RGB);
    //----------------------------------------------------------------------
    // Apply the table to data[0], data[stride] ... data[(nData-1) * stride]
    //----------------------------------------------------------------------
    void apply (Rgba *data,
 		int nData,
 		int stride = 1) const;
    //-----------------------------------------------------------------------
    // Apply the table to a frame buffer (see RgbaOutpuFile.setFrameBuffer())
    //-----------------------------------------------------------------------
    void apply (Rgba *base,
 		int xStride,
 		int yStride,
 		const Imath::Box2i &dataWindow) const;
  private:
    halfFunction <half>	_lut;
    RgbaChannels	_chn;
 };
 //
 // 12bit log rounding reduces data to 20 stops with 200 steps per stop.
 // That makes 4000 numbers.  An extra 96 just come along for the ride.
 // Zero explicitly remains zero.  The first non-zero half will map to 1
 // in the 0-4095 12log space.  A nice power of two number is placed at
 // the center [2000] and that number is near 0.18.
 //
 half round12log (half x);
 //
 // Round to n-bit precision (n should be between 0 and 10).
 // After rounding, the significand's 10-n least significant
 // bits will be zero.
 //
 struct roundNBit
 {
    roundNBit (int n): n(n) {}
    half operator () (half x) {return x.round(n);}
    int n;
 };
 //
 // Template definitions
 //
 template <class Function>
 HalfLut::HalfLut (Function f):
    _lut(f, -HALF_MAX, HALF_MAX, half (0),
 	 half::posInf(), half::negInf(), half::qNan())
 {
    // empty
 }
 template <class Function>
 RgbaLut::RgbaLut (Function f, RgbaChannels chn):
    _lut(f, -HALF_MAX, HALF_MAX, half (0),
 	 half::posInf(), half::negInf(), half::qNan()),
    _chn(chn)
 {
    // empty
 }
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfMatrixAttribute.cpp
+++ b/3rdparty/openexr/IlmImf/ImfMatrixAttribute.cpp
@ -0,0 +1,260 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class M33fAttribute
 //	class M33dAttribute
 //	class M44fAttribute
 //	class M44dAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfMatrixAttribute.h>
 namespace Imf {
 template <>
 const char *
 M33fAttribute::staticTypeName ()
 {
    return "m33f";
 }
 template <>
 void
 M33fAttribute::writeValueTo (OStream &os, int version) const
 {
    Xdr::write <StreamIO> (os, _value[0][0]);
    Xdr::write <StreamIO> (os, _value[0][1]);
    Xdr::write <StreamIO> (os, _value[0][2]);
    Xdr::write <StreamIO> (os, _value[1][0]);
    Xdr::write <StreamIO> (os, _value[1][1]);
    Xdr::write <StreamIO> (os, _value[1][2]);
    Xdr::write <StreamIO> (os, _value[2][0]);
    Xdr::write <StreamIO> (os, _value[2][1]);
    Xdr::write <StreamIO> (os, _value[2][2]);
 }
 template <>
 void
 M33fAttribute::readValueFrom (IStream &is, int size, int version)
 {
    Xdr::read <StreamIO> (is, _value[0][0]);
    Xdr::read <StreamIO> (is, _value[0][1]);
    Xdr::read <StreamIO> (is, _value[0][2]);
    Xdr::read <StreamIO> (is, _value[1][0]);
    Xdr::read <StreamIO> (is, _value[1][1]);
    Xdr::read <StreamIO> (is, _value[1][2]);
    Xdr::read <StreamIO> (is, _value[2][0]);
    Xdr::read <StreamIO> (is, _value[2][1]);
    Xdr::read <StreamIO> (is, _value[2][2]);
 }
 template <>
 const char *
 M33dAttribute::staticTypeName ()
 {
    return "m33d";
 }
 template <>
 void
 M33dAttribute::writeValueTo (OStream &os, int version) const
 {
    Xdr::write <StreamIO> (os, _value[0][0]);
    Xdr::write <StreamIO> (os, _value[0][1]);
    Xdr::write <StreamIO> (os, _value[0][2]);
    Xdr::write <StreamIO> (os, _value[1][0]);
    Xdr::write <StreamIO> (os, _value[1][1]);
    Xdr::write <StreamIO> (os, _value[1][2]);
    Xdr::write <StreamIO> (os, _value[2][0]);
    Xdr::write <StreamIO> (os, _value[2][1]);
    Xdr::write <StreamIO> (os, _value[2][2]);
 }
 template <>
 void
 M33dAttribute::readValueFrom (IStream &is, int size, int version)
 {
    Xdr::read <StreamIO> (is, _value[0][0]);
    Xdr::read <StreamIO> (is, _value[0][1]);
    Xdr::read <StreamIO> (is, _value[0][2]);
    Xdr::read <StreamIO> (is, _value[1][0]);
    Xdr::read <StreamIO> (is, _value[1][1]);
    Xdr::read <StreamIO> (is, _value[1][2]);
    Xdr::read <StreamIO> (is, _value[2][0]);
    Xdr::read <StreamIO> (is, _value[2][1]);
    Xdr::read <StreamIO> (is, _value[2][2]);
 }
 template <>
 const char *
 M44fAttribute::staticTypeName ()
 {
    return "m44f";
 }
 template <>
 void
 M44fAttribute::writeValueTo (OStream &os, int version) const
 {
    Xdr::write <StreamIO> (os, _value[0][0]);
    Xdr::write <StreamIO> (os, _value[0][1]);
    Xdr::write <StreamIO> (os, _value[0][2]);
    Xdr::write <StreamIO> (os, _value[0][3]);
    Xdr::write <StreamIO> (os, _value[1][0]);
    Xdr::write <StreamIO> (os, _value[1][1]);
    Xdr::write <StreamIO> (os, _value[1][2]);
    Xdr::write <StreamIO> (os, _value[1][3]);
    Xdr::write <StreamIO> (os, _value[2][0]);
    Xdr::write <StreamIO> (os, _value[2][1]);
    Xdr::write <StreamIO> (os, _value[2][2]);
    Xdr::write <StreamIO> (os, _value[2][3]);
    Xdr::write <StreamIO> (os, _value[3][0]);
    Xdr::write <StreamIO> (os, _value[3][1]);
    Xdr::write <StreamIO> (os, _value[3][2]);
    Xdr::write <StreamIO> (os, _value[3][3]);
 }
 template <>
 void
 M44fAttribute::readValueFrom (IStream &is, int size, int version)
 {
    Xdr::read <StreamIO> (is, _value[0][0]);
    Xdr::read <StreamIO> (is, _value[0][1]);
    Xdr::read <StreamIO> (is, _value[0][2]);
    Xdr::read <StreamIO> (is, _value[0][3]);
    Xdr::read <StreamIO> (is, _value[1][0]);
    Xdr::read <StreamIO> (is, _value[1][1]);
    Xdr::read <StreamIO> (is, _value[1][2]);
    Xdr::read <StreamIO> (is, _value[1][3]);
    Xdr::read <StreamIO> (is, _value[2][0]);
    Xdr::read <StreamIO> (is, _value[2][1]);
    Xdr::read <StreamIO> (is, _value[2][2]);
    Xdr::read <StreamIO> (is, _value[2][3]);
    Xdr::read <StreamIO> (is, _value[3][0]);
    Xdr::read <StreamIO> (is, _value[3][1]);
    Xdr::read <StreamIO> (is, _value[3][2]);
    Xdr::read <StreamIO> (is, _value[3][3]);
 }
 template <>
 const char *
 M44dAttribute::staticTypeName ()
 {
    return "m44d";
 }
 template <>
 void
 M44dAttribute::writeValueTo (OStream &os, int version) const
 {
    Xdr::write <StreamIO> (os, _value[0][0]);
    Xdr::write <StreamIO> (os, _value[0][1]);
    Xdr::write <StreamIO> (os, _value[0][2]);
    Xdr::write <StreamIO> (os, _value[0][3]);
    Xdr::write <StreamIO> (os, _value[1][0]);
    Xdr::write <StreamIO> (os, _value[1][1]);
    Xdr::write <StreamIO> (os, _value[1][2]);
    Xdr::write <StreamIO> (os, _value[1][3]);
    Xdr::write <StreamIO> (os, _value[2][0]);
    Xdr::write <StreamIO> (os, _value[2][1]);
    Xdr::write <StreamIO> (os, _value[2][2]);
    Xdr::write <StreamIO> (os, _value[2][3]);
    Xdr::write <StreamIO> (os, _value[3][0]);
    Xdr::write <StreamIO> (os, _value[3][1]);
    Xdr::write <StreamIO> (os, _value[3][2]);
    Xdr::write <StreamIO> (os, _value[3][3]);
 }
 template <>
 void
 M44dAttribute::readValueFrom (IStream &is, int size, int version)
 {
    Xdr::read <StreamIO> (is, _value[0][0]);
    Xdr::read <StreamIO> (is, _value[0][1]);
    Xdr::read <StreamIO> (is, _value[0][2]);
    Xdr::read <StreamIO> (is, _value[0][3]);
    Xdr::read <StreamIO> (is, _value[1][0]);
    Xdr::read <StreamIO> (is, _value[1][1]);
    Xdr::read <StreamIO> (is, _value[1][2]);
    Xdr::read <StreamIO> (is, _value[1][3]);
    Xdr::read <StreamIO> (is, _value[2][0]);
    Xdr::read <StreamIO> (is, _value[2][1]);
    Xdr::read <StreamIO> (is, _value[2][2]);
    Xdr::read <StreamIO> (is, _value[2][3]);
    Xdr::read <StreamIO> (is, _value[3][0]);
    Xdr::read <StreamIO> (is, _value[3][1]);
    Xdr::read <StreamIO> (is, _value[3][2]);
    Xdr::read <StreamIO> (is, _value[3][3]);
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfMatrixAttribute.h
+++ b/3rdparty/openexr/IlmImf/ImfMatrixAttribute.h
@ -0,0 +1,87 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_MATRIX_ATTRIBUTE_H
 #define INCLUDED_IMF_MATRIX_ATTRIBUTE_H
 //-----------------------------------------------------------------------------
 //
 //	class M33fAttribute
 //	class M33dAttribute
 //	class M44fAttribute
 //	class M44dAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfAttribute.h>
 #include "ImathMatrix.h"
 namespace Imf {
 typedef TypedAttribute<Imath::M33f> M33fAttribute;
 template <> const char *M33fAttribute::staticTypeName ();
 template <> void M33fAttribute::writeValueTo (OStream &, int) const;
 template <> void M33fAttribute::readValueFrom (IStream &, int, int);
 typedef TypedAttribute<Imath::M33d> M33dAttribute;
 template <> const char *M33dAttribute::staticTypeName ();
 template <> void M33dAttribute::writeValueTo (OStream &, int) const;
 template <> void M33dAttribute::readValueFrom (IStream &, int, int);
 typedef TypedAttribute<Imath::M44f> M44fAttribute;
 template <> const char *M44fAttribute::staticTypeName ();
 template <> void M44fAttribute::writeValueTo (OStream &, int) const;
 template <> void M44fAttribute::readValueFrom (IStream &, int, int);
 typedef TypedAttribute<Imath::M44d> M44dAttribute;
 template <> const char *M44dAttribute::staticTypeName ();
 template <> void M44dAttribute::writeValueTo (OStream &, int) const;
 template <> void M44dAttribute::readValueFrom (IStream &, int, int);
 } // namespace Imf
 // Metrowerks compiler wants the .cpp file inlined, too
 #ifdef __MWERKS__
 #include <ImfMatrixAttribute.cpp>
 #endif
 #endif
--- a/3rdparty/openexr/IlmImf/ImfMisc.cpp
+++ b/3rdparty/openexr/IlmImf/ImfMisc.cpp
@ -0,0 +1,787 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	Miscellaneous helper functions for OpenEXR image file I/O
 //
 //-----------------------------------------------------------------------------
 #include <ImfMisc.h>
 #include <ImfHeader.h>
 #include <ImfCompressor.h>
 #include <ImfChannelList.h>
 #include <ImfXdr.h>
 #include <ImathFun.h>
 #include <Iex.h>
 #include <ImfStdIO.h>
 #include <ImfConvert.h>
 namespace Imf {
 using Imath::Box2i;
 using Imath::divp;
 using Imath::modp;
 using std::vector;
 int
 pixelTypeSize (PixelType type)
 {
    int size;
    switch (type)
    {
      case UINT:
 	size = Xdr::size <unsigned int> ();
 	break;
      case HALF:
 	size = Xdr::size <half> ();
 	break;
      case FLOAT:
 	size = Xdr::size <float> ();
 	break;
      default:
 	throw Iex::ArgExc ("Unknown pixel type.");
    }
    return size;
 }
 int
 numSamples (int s, int a, int b)
 {
    int a1 = divp (a, s);
    int b1 = divp (b, s);
    return  b1 - a1 + ((a1 * s < a)? 0: 1);
 }
 size_t
 bytesPerLineTable (const Header &header,
 		   vector<size_t> &bytesPerLine)
 {
    const Box2i &dataWindow = header.dataWindow();
    const ChannelList &channels = header.channels();
    bytesPerLine.resize (dataWindow.max.y - dataWindow.min.y + 1);
    for (ChannelList::ConstIterator c = channels.begin();
 	 c != channels.end();
 	 ++c)
    {
 	int nBytes = pixelTypeSize (c.channel().type) *
 		     (dataWindow.max.x - dataWindow.min.x + 1) /
 		     c.channel().xSampling;
 	for (int y = dataWindow.min.y, i = 0; y <= dataWindow.max.y; ++y, ++i)
 	    if (modp (y, c.channel().ySampling) == 0)
 		bytesPerLine[i] += nBytes;
    }
    size_t maxBytesPerLine = 0;
    for (int y = dataWindow.min.y, i = 0; y <= dataWindow.max.y; ++y, ++i)
 	if (maxBytesPerLine < bytesPerLine[i])
 	    maxBytesPerLine = bytesPerLine[i];
    return maxBytesPerLine;
 }
 void
 offsetInLineBufferTable (const vector<size_t> &bytesPerLine,
 			 int linesInLineBuffer,
 			 vector<size_t> &offsetInLineBuffer)
 {
    offsetInLineBuffer.resize (bytesPerLine.size());
    size_t offset = 0;
    for (int i = 0; i < bytesPerLine.size(); ++i)
    {
 	if (i % linesInLineBuffer == 0)
 	    offset = 0;
 	offsetInLineBuffer[i] = offset;
 	offset += bytesPerLine[i];
    }
 }
 int
 lineBufferMinY (int y, int minY, int linesInLineBuffer)
 {
    return ((y - minY) / linesInLineBuffer) * linesInLineBuffer + minY;
 }
 int
 lineBufferMaxY (int y, int minY, int linesInLineBuffer)
 {
    return lineBufferMinY (y, minY, linesInLineBuffer) + linesInLineBuffer - 1;
 }
 Compressor::Format
 defaultFormat (Compressor * compressor)
 {
    return compressor? compressor->format(): Compressor::XDR;
 }
 int
 numLinesInBuffer (Compressor * compressor)
 {
    return compressor? compressor->numScanLines(): 1;
 }
 void
 copyIntoFrameBuffer (const char *& readPtr,
 		     char * writePtr,
 		     char * endPtr,
                     size_t xStride,
 		     bool fill,
 		     double fillValue,
                     Compressor::Format format,
                     PixelType typeInFrameBuffer,
                     PixelType typeInFile)
 {
    //
    // Copy a horizontal row of pixels from an input
    // file's line or tile buffer to a frame buffer.
    //
    if (fill)
    {
        //
        // The file contains no data for this channel.
        // Store a default value in the frame buffer.
        //
        switch (typeInFrameBuffer)
        {
 	  case UINT:
            {
                unsigned int fillVal = (unsigned int) (fillValue);
                while (writePtr <= endPtr)
                {
                    *(unsigned int *) writePtr = fillVal;
                    writePtr += xStride;
                }
            }
            break;
          case HALF:
            {
                half fillVal = half (fillValue);
                while (writePtr <= endPtr)
                {
                    *(half *) writePtr = fillVal;
                    writePtr += xStride;
                }
            }
            break;
          case FLOAT:
            {
                float fillVal = float (fillValue);
                while (writePtr <= endPtr)
                {
                    *(float *) writePtr = fillVal;
                    writePtr += xStride;
                }
            }
            break;
          default:
            throw Iex::ArgExc ("Unknown pixel data type.");
        }
    }
    else if (format == Compressor::XDR)
    {
        //
        // The the line or tile buffer is in XDR format.
        //
        // Convert the pixels from the file's machine-
        // independent representation, and store the
        // results in the frame buffer.
        //
        switch (typeInFrameBuffer)
        {
          case UINT:
            switch (typeInFile)
            {
              case UINT:
                while (writePtr <= endPtr)
                {
                    Xdr::read <CharPtrIO> (readPtr, *(unsigned int *) writePtr);
                    writePtr += xStride;
                }
                break;
              case HALF:
                while (writePtr <= endPtr)
                {
                    half h;
                    Xdr::read <CharPtrIO> (readPtr, h);
                    *(unsigned int *) writePtr = halfToUint (h);
                    writePtr += xStride;
                }
                break;
              case FLOAT:
                while (writePtr <= endPtr)
                {
                    float f;
                    Xdr::read <CharPtrIO> (readPtr, f);
                    *(unsigned int *)writePtr = floatToUint (f);
                    writePtr += xStride;
                }
                break;
            }
            break;
          case HALF:
            switch (typeInFile)
            {
              case UINT:
                while (writePtr <= endPtr)
                {
                    unsigned int ui;
                    Xdr::read <CharPtrIO> (readPtr, ui);
                    *(half *) writePtr = uintToHalf (ui);
                    writePtr += xStride;
                }
                break;
              case HALF:
                while (writePtr <= endPtr)
                {
                    Xdr::read <CharPtrIO> (readPtr, *(half *) writePtr);
                    writePtr += xStride;
                }
                break;
              case FLOAT:
                while (writePtr <= endPtr)
                {
                    float f;
                    Xdr::read <CharPtrIO> (readPtr, f);
                    *(half *) writePtr = floatToHalf (f);
                    writePtr += xStride;
                }
                break;
            }
            break;
          case FLOAT:
            switch (typeInFile)
            {
              case UINT:
                while (writePtr <= endPtr)
                {
                    unsigned int ui;
                    Xdr::read <CharPtrIO> (readPtr, ui);
                    *(float *) writePtr = float (ui);
                    writePtr += xStride;
                }
                break;
              case HALF:
                while (writePtr <= endPtr)
                {
                    half h;
                    Xdr::read <CharPtrIO> (readPtr, h);
                    *(float *) writePtr = float (h);
                    writePtr += xStride;
                }
                break;
              case FLOAT:
                while (writePtr <= endPtr)
                {
                    Xdr::read <CharPtrIO> (readPtr, *(float *) writePtr);
                    writePtr += xStride;
                }
                break;
            }
            break;
          default:
            throw Iex::ArgExc ("Unknown pixel data type.");
        }
    }
    else
    {
        //
        // The the line or tile buffer is in NATIVE format.
        // Copy the results into the frame buffer.
        //
        switch (typeInFrameBuffer)
        {
          case UINT:
            switch (typeInFile)
            {
              case UINT:
                while (writePtr <= endPtr)
                {
                    for (size_t i = 0; i < sizeof (unsigned int); ++i)
                        writePtr[i] = readPtr[i];
                    readPtr += sizeof (unsigned int);
                    writePtr += xStride;
                }
                break;
              case HALF:
                while (writePtr <= endPtr)
                {
                    half h = *(half *) readPtr;
                    *(unsigned int *) writePtr = halfToUint (h);
                    readPtr += sizeof (half);
                    writePtr += xStride;
                }
                break;
              case FLOAT:
                while (writePtr <= endPtr)
                {
                    float f;
                    for (size_t i = 0; i < sizeof (float); ++i)
                        ((char *)&f)[i] = readPtr[i];
                    *(unsigned int *)writePtr = floatToUint (f);
                    readPtr += sizeof (float);
                    writePtr += xStride;
                }
                break;
            }
            break;
          case HALF:
            switch (typeInFile)
            {
              case UINT:
                while (writePtr <= endPtr)
                {
                    unsigned int ui;
                    for (size_t i = 0; i < sizeof (unsigned int); ++i)
                        ((char *)&ui)[i] = readPtr[i];
                    *(half *) writePtr = uintToHalf (ui);
                    readPtr += sizeof (unsigned int);
                    writePtr += xStride;
                }
                break;
              case HALF:
                while (writePtr <= endPtr)
                {
                    *(half *) writePtr = *(half *)readPtr;
                    readPtr += sizeof (half);
                    writePtr += xStride;
                }
                break;
              case FLOAT:
                while (writePtr <= endPtr)
                {
                    float f;
                    for (size_t i = 0; i < sizeof (float); ++i)
                        ((char *)&f)[i] = readPtr[i];
                    *(half *) writePtr = floatToHalf (f);
                    readPtr += sizeof (float);
                    writePtr += xStride;
                }
                break;
            }
            break;
          case FLOAT:
            switch (typeInFile)
            {
              case UINT:
                while (writePtr <= endPtr)
                {
                    unsigned int ui;
                    for (size_t i = 0; i < sizeof (unsigned int); ++i)
                        ((char *)&ui)[i] = readPtr[i];
                    *(float *) writePtr = float (ui);
                    readPtr += sizeof (unsigned int);
                    writePtr += xStride;
                }
                break;
              case HALF:
                while (writePtr <= endPtr)
                {
                    half h = *(half *) readPtr;
                    *(float *) writePtr = float (h);
                    readPtr += sizeof (half);
                    writePtr += xStride;
                }
                break;
              case FLOAT:
                while (writePtr <= endPtr)
                {
                    for (size_t i = 0; i < sizeof (float); ++i)
                        writePtr[i] = readPtr[i];
                    readPtr += sizeof (float);
                    writePtr += xStride;
                }
                break;
            }
            break;
          default:
            throw Iex::ArgExc ("Unknown pixel data type.");
        }
    }
 }
 void
 skipChannel (const char *& readPtr,
             PixelType typeInFile,
 	     size_t xSize)
 {
    switch (typeInFile)
    {
      case UINT:
        Xdr::skip <CharPtrIO> (readPtr, Xdr::size <unsigned int> () * xSize);
        break;
      case HALF:
        Xdr::skip <CharPtrIO> (readPtr, Xdr::size <half> () * xSize);
        break;
      case FLOAT:
        Xdr::skip <CharPtrIO> (readPtr, Xdr::size <float> () * xSize);
        break;
      default:
        throw Iex::ArgExc ("Unknown pixel data type.");
    }
 }
 void
 convertInPlace (char *& writePtr,
                const char *& readPtr,
 		PixelType type,
                size_t numPixels)
 {
    switch (type)
    {
      case UINT:
        for (int j = 0; j < numPixels; ++j)
        {
            Xdr::write <CharPtrIO> (writePtr, *(const unsigned int *) readPtr);
            readPtr += sizeof(unsigned int);
        }
        break;
      case HALF:
        for (int j = 0; j < numPixels; ++j)
        {               
            Xdr::write <CharPtrIO> (writePtr, *(const half *) readPtr);
            readPtr += sizeof(half);
        }
        break;
      case FLOAT:
        for (int j = 0; j < numPixels; ++j)
        {
            Xdr::write <CharPtrIO> (writePtr, *(const float *) readPtr);
            readPtr += sizeof(float);
        }
        break;
      default:
        throw Iex::ArgExc ("Unknown pixel data type.");
    }
 }
 void
 copyFromFrameBuffer (char *& writePtr,
 		     const char *& readPtr,
                     const char * endPtr,
 		     size_t xStride,
                     Compressor::Format format,
 		     PixelType type)
 {
    //
    // Copy a horizontal row of pixels from a frame
    // buffer to an output file's line or tile buffer.
    //
    if (format == Compressor::XDR)
    {
        //
        // The the line or tile buffer is in XDR format.
        //
        switch (type)
        {
          case UINT:
            while (readPtr <= endPtr)
            {
                Xdr::write <CharPtrIO> (writePtr,
                                        *(const unsigned int *) readPtr);
                readPtr += xStride;
            }
            break;
          case HALF:
            while (readPtr <= endPtr)
            {
                Xdr::write <CharPtrIO> (writePtr, *(const half *) readPtr);
                readPtr += xStride;
            }
            break;
          case FLOAT:
            while (readPtr <= endPtr)
            {
                Xdr::write <CharPtrIO> (writePtr, *(const float *) readPtr);
                readPtr += xStride;
            }
            break;
          default:
            throw Iex::ArgExc ("Unknown pixel data type.");
        }
    }
    else
    {
        //
        // The the line or tile buffer is in NATIVE format.
        //
        switch (type)
        {
          case UINT:
            while (readPtr <= endPtr)
            {
                for (size_t i = 0; i < sizeof (unsigned int); ++i)
                    *writePtr++ = readPtr[i];
                readPtr += xStride;
            }
            break;
          case HALF:
            while (readPtr <= endPtr)
            {
                *(half *) writePtr = *(const half *) readPtr;
                writePtr += sizeof (half);
                readPtr += xStride;
            }
            break;
          case FLOAT:
            while (readPtr <= endPtr)
            {
                for (size_t i = 0; i < sizeof (float); ++i)
                    *writePtr++ = readPtr[i];
                readPtr += xStride;
            }
            break;
          default:
            throw Iex::ArgExc ("Unknown pixel data type.");
        }
    }
 }
 void
 fillChannelWithZeroes (char *& writePtr,
 		       Compressor::Format format,
 		       PixelType type,
 		       size_t xSize)
 {
    if (format == Compressor::XDR)
    {
        //
        // Fill with data in XDR format.
        //
        switch (type)
        {
          case UINT:
            for (int j = 0; j < xSize; ++j)
                Xdr::write <CharPtrIO> (writePtr, (unsigned int) 0);
            break;
          case HALF:
            for (int j = 0; j < xSize; ++j)
                Xdr::write <CharPtrIO> (writePtr, (half) 0);
            break;
          case FLOAT:
            for (int j = 0; j < xSize; ++j)
                Xdr::write <CharPtrIO> (writePtr, (float) 0);
            break;
          default:
            throw Iex::ArgExc ("Unknown pixel data type.");
        }
    }
    else
    {
        //
        // Fill with data in NATIVE format.
        //
        switch (type)
        {
          case UINT:
            for (int j = 0; j < xSize; ++j)
            {
                static const unsigned int ui = 0;
                for (size_t i = 0; i < sizeof (ui); ++i)
                    *writePtr++ = ((char *) &ui)[i];
            }
            break;
          case HALF:
            for (int j = 0; j < xSize; ++j)
            {
                *(half *) writePtr = half (0);
                writePtr += sizeof (half);
            }
            break;
          case FLOAT:
            for (int j = 0; j < xSize; ++j)
            {
                static const float f = 0;
                for (size_t i = 0; i < sizeof (f); ++i)
                    *writePtr++ = ((char *) &f)[i];
            }
            break;
          default:
            throw Iex::ArgExc ("Unknown pixel data type.");
        }
    }
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfMisc.h
+++ b/3rdparty/openexr/IlmImf/ImfMisc.h
@ -0,0 +1,255 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_MISC_H
 #define INCLUDED_IMF_MISC_H
 //-----------------------------------------------------------------------------
 //
 //	Miscellaneous helper functions for OpenEXR image file I/O
 //
 //-----------------------------------------------------------------------------
 #include <ImfPixelType.h>
 #include <vector>
 #include <ImfCompressor.h>
 namespace Imf {
 class Header;
 //
 // Return the size of a single value of the indicated type,
 // in the machine's native format.
 //
 int	pixelTypeSize (PixelType type);
 //
 // Return the number of samples a channel with subsampling rate
 // s has in the interval [a, b].  For example, a channel with
 // subsampling rate 2 (and samples at 0, 2, 4, 6, 8, etc.) has
 // 2 samples in the interval [1, 5] and three samples in the
 // interval [2, 6].
 //
 int	numSamples (int s, int a, int b);
 //
 // Build a table that lists, for each scanline in a file's
 // data window, how many bytes are required to store all
 // pixels in all channels in that scanline (assuming that
 // the pixel data are tightly packed).
 //
 size_t	bytesPerLineTable (const Header &header,
 		           std::vector<size_t> &bytesPerLine);
 //
 // For scanline-based files, pixels are read or written in
 // in multi-scanline blocks.  Internally, class OutputFile
 // and class ScanLineInputFile store a block of scan lines
 // in a "line buffer".  Function offsetInLineBufferTable()
 // builds a table that lists, for each scan line in a file's
 // data window, the location of the pixel data for the scanline
 // relative to the beginning of the line buffer.
 //
 void	offsetInLineBufferTable (const std::vector<size_t> &bytesPerLine,
 				 int linesInLineBuffer,
 				 std::vector<size_t> &offsetInLineBuffer);
 //
 // For a scanline-based file, compute the range of scanlines
 // that occupy the same line buffer as a given scanline, y.
 // (minY is the minimum y coordinate of the file's data window.)
 //
 int	lineBufferMinY (int y, int minY, int linesInLineBuffer);
 int	lineBufferMaxY (int y, int minY, int linesInLineBuffer);
 //
 // Return a compressor's data format (Compressor::NATIVE or Compressor::XDR).
 // If compressor is 0, return Compressor::XDR.
 //
 Compressor::Format defaultFormat (Compressor *compressor);
 //
 // Return the number of scan lines a compressor wants to compress
 // or uncompress at once.  If compressor is 0, return 1.
 //
 int     numLinesInBuffer (Compressor *compressor);
 //
 // Copy a single channel of a horizontal row of pixels from an
 // input file's internal line buffer or tile buffer into a
 // frame buffer slice.  If necessary, perform on-the-fly data
 // type conversion.
 //
 //    readPtr		initially points to the beginning of the
 //			data in the line or tile buffer. readPtr
 //			is advanced as the pixel data are copied;
 //			when copyIntoFrameBuffer() returns,
 //			readPtr points just past the end of the
 //			copied data.
 //
 //    writePtr, endPtr	point to the lefmost and rightmost pixels
 //			in the frame buffer slice
 //
 //    xStride		the xStride for the frame buffer slice
 //
 //    format		indicates if the line or tile buffer is
 //			in NATIVE or XDR format.
 //
 //    typeInFrameBuffer the pixel data type of the frame buffer slice
 //
 //    typeInFile        the pixel data type in the input file's channel
 //
 void    copyIntoFrameBuffer (const char *&readPtr,
 			     char *writePtr,
                             char *endPtr,
 			     size_t xStride,
 			     bool fill,
                             double fillValue,
 			     Compressor::Format format,
                             PixelType typeInFrameBuffer,
                             PixelType typeInFile);
 //
 // Given a pointer into a an input file's line buffer or tile buffer,
 // skip over the data for xSize pixels of type typeInFile.
 // readPtr initially points to the beginning of the data to be skipped;
 // when skipChannel() returns, readPtr points just past the end of the
 // skipped data.
 //
 void    skipChannel (const char *&readPtr,
 		     PixelType typeInFile,
 		     size_t xSize);
 //
 // Convert an array of pixel data from the machine's native
 // representation to XDR format.
 //
 //    toPtr, fromPtr	initially point to the beginning of the input
 //			and output pixel data arrays; when convertInPlace()
 //			returns, toPtr and fromPtr point just past the
 //			end of the input and output arrays.
 // 			If the native representation of the data has the
 //			same size as the XDR data, then the conversion
 //			can take in place, without an intermediate
 //			temporary buffer (toPtr and fromPtr can point
 //			to the same location).
 //
 //    type		the pixel data type
 //
 //    numPixels		number of pixels in the input and output arrays
 // 
 void    convertInPlace (char *&toPtr,
 			const char *&fromPtr,
 			PixelType type,
                        size_t numPixels);
 //
 // Copy a single channel of a horizontal row of pixels from a
 // a frame buffer into an output file's internal line buffer or
 // tile buffer.
 //
 //    writePtr		initially points to the beginning of the
 //			data in the line or tile buffer. writePtr
 //			is advanced as the pixel data are copied;
 //			when copyFromFrameBuffer() returns,
 //			writePtr points just past the end of the
 //			copied data.
 //
 //    readPtr, endPtr	point to the lefmost and rightmost pixels
 //			in the frame buffer slice
 //
 //    xStride		the xStride for the frame buffer slice
 //
 //    format		indicates if the line or tile buffer is
 //			in NATIVE or XDR format.
 //
 //    type              the pixel data type in the frame buffer
 //			and in the output file's channel (function
 //			copyFromFrameBuffer() doesn't do on-the-fly
 //			data type conversion)
 //
 void    copyFromFrameBuffer (char *&writePtr,
 			     const char *&readPtr,
                             const char *endPtr,
 			     size_t xStride,
                             Compressor::Format format,
 			     PixelType type);
 //
 // Fill part of an output file's line buffer or tile buffer with
 // zeroes.  This routine is called when an output file contains
 // a channel for which the frame buffer contains no corresponding
 // slice.
 //
 //    writePtr		initially points to the beginning of the
 //			data in the line or tile buffer.  When
 //			fillChannelWithZeroes() returns, writePtr
 //			points just past the end of the zeroed
 //			data.
 //
 //    format		indicates if the line or tile buffer is
 //			in NATIVE or XDR format.
 //
 //    type              the pixel data type in the line or frame buffer.
 //
 //    xSize             number of pixels to be filled with zeroes.
 //
 void    fillChannelWithZeroes (char *&writePtr,
 			       Compressor::Format format,
 			       PixelType type,
 			       size_t xSize);
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfMultiView.cpp
+++ b/3rdparty/openexr/IlmImf/ImfMultiView.cpp
@ -0,0 +1,396 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	Functions related to accessing channels
 //	and views in multi-view OpenEXR files.
 //
 //-----------------------------------------------------------------------------
 #include <ImfMultiView.h>
 using namespace std;
 namespace Imf {
 namespace {
 StringVector
 parseString (string name, char c = '.')
 {
    //
    // Turn name into a list of strings, separating
    // on char 'c' with whitespace stripped.
    //
    StringVector r;
    while (name.size() > 0)
    {  
 	size_t s = name.find (c);
 	string sec = name.substr (0, s);
 	//
 	// Strip spaces from beginning
 	//
 	while (sec.size() > 0 && sec[0] == ' ')
 	    sec.erase (0, 1);
 	//
 	// Strip spaces from end
 	//
 	while (sec.size() > 0 && sec[sec.size() - 1] == ' ')
 	    sec.erase (sec.size() - 1);
 	r.push_back (sec);
 	//
 	// Strip off name including ending 'c'
 	//
 	if (s == name.npos)
 	    name = "";
 	else
 	    name = name.substr (s + 1);
    } 
    return r;
 }
 int
 viewNum (const string &view, const StringVector &multiView)
 {
    //
    // returns which view number is called 'view'
    // returns -1 if no member of multiView is 'view'
    // (i.e. if viewNum() returns -1, 'view' isn't a view name
    //       if viewNum() returns 0, 'view' is the default view
    // otherwise, it's some other (valid) view
    //
    for (int i = 0; i < multiView.size(); ++i)
    {
 	if (multiView[i] == view)
 	    return i;
    }
    return -1;
 }
 } // namespace
 string
 defaultViewName (const StringVector &multiView)
 {
    if (multiView.size() > 0)
 	return multiView[0];
    else
 	return "";
 }
 string
 viewFromChannelName (const string &channel,
 		     const StringVector &multiView)
 {
    //
    // Given the name of a channel, return the name of the view to
    // which it belongs.
    //
    //
    // View name is penultimate section of name separated by periods ('.'s)
    //
    StringVector s = parseString (channel, '.');
    if (s.size() == 0)
 	return ""; // nothing in, nothing out
    if (s.size() == 1)
    {
 	//
 	// Return default view name.
 	// The rules say ALL channels with no periods
 	// in the name belong to the default view.
 	//
 	return multiView[0];
    }
    else
    { 
 	//
 	// size >= 2 - the last part is the channel name,
 	// the next-to-last part is the view name.
 	// Check if that part of the name really is
 	// a valid view and, if it is, return it.
 	//
 	const string &viewName = s[s.size() - 2];
 	if (viewNum (viewName, multiView) >= 0)
 	    return viewName;
 	else
 	    return ""; // not associated with any particular view
    }
 }
 ChannelList
 channelsInView (const string & viewName,
 	        const ChannelList & channelList,
 		const StringVector & multiView)
 {
    //
    // Return a list of all channels belonging to view viewName.
    //
    ChannelList q;
    for (ChannelList::ConstIterator i = channelList.begin();
 	 i != channelList.end();
 	 ++i)
    {
 	//
 	// Get view name for this channel
 	//
 	string view = viewFromChannelName (i.name(), multiView);
 	//
 	// Insert channel into q if it's a member of view viewName
 	//
 	if (view == viewName)
 	   q.insert (i.name(), i.channel());
    }
    return q;
 }
 ChannelList
 channelsInNoView (const ChannelList &channelList,
 		  const StringVector &multiView)
 {
    //
    // Return a list of channels not associated with any named view.
    //
    return channelsInView ("", channelList, multiView); 
 }
 bool
 areCounterparts (const string &channel1, 
 	         const string &channel2,
 		 const StringVector &multiView)
 {
    //
    // Given two channels, return true if they are the same
    // channel in two different views.
    //
    StringVector chan1 = parseString (channel1);
    unsigned int size1 = chan1.size();	// number of SECTIONS in string
    					// name (not string length)
    StringVector chan2 = parseString (channel2);
    unsigned int size2 = chan2.size();
    if (size1 == 0 || size2 == 0)
 	return false;
    //
    // channel1 and channel2 can't be counterparts
    // if either channel is in no view.
    //
    if (size1 > 1 && viewNum (chan1[size1 - 2], multiView) == -1)
 	return false;
    if (size2 > 1 && viewNum (chan2[size2 - 2], multiView) == -1)
 	return false; 
    if (viewFromChannelName (channel1, multiView) ==
 	viewFromChannelName (channel2, multiView))
    {
 	//
 	// channel1 and channel2 are not counterparts
 	// if they are in the same view.
 	//
 	return false;
    }
    if (size1 == 1)
    { 
 	//
 	// channel1 is a default channel - the channels will only be
 	// counterparts if channel2 is of the form <view>.<channel1>
 	//
 	return size2 == 2 && chan1[0] == chan2[1];
    }
    if (size2 == 1)
    {
 	//
 	// channel2 is a default channel - the channels will only be
 	// counterparts if channel1 is of the form <view>.<channel2>
 	//
 	return size1 == 2 && chan2[0] == chan1[1];
    }
    //
    // Neither channel is a default channel.  To be counterparts both
    // channel names must have the same number of components, and
    // all components except the penultimate one must be the same.
    //
    if (size1 != size2)
 	return false;
    for(int i = 0; i < size1; ++i)
    {
 	if (i != size1 - 2 && chan1[i] != chan2[i])
 	    return false;
    }
    return true;
 }
 ChannelList
 channelInAllViews (const string &channelName,
 		   const ChannelList &channelList,
 		   const StringVector &multiView)
 {
    //
    // Given the name of a channel, return a
    // list of the same channel in all views.
    //
    ChannelList q;
    for (ChannelList::ConstIterator i=channelList.begin();
 	 i != channelList.end();
 	 ++i)
    {
 	if (i.name() == channelName ||
 	    areCounterparts (i.name(), channelName, multiView))
 	{
 	    q.insert (i.name(), i.channel());
 	}
    }
    return q;
 }
 string
 channelInOtherView (const string &channelName,
 		    const ChannelList &channelList,
 		    const StringVector &multiView,
 		    const string &otherViewName)
 {
    //
    // Given the name of a channel in one view, return the
    // corresponding channel name for view otherViewName.
    //
    for (ChannelList::ConstIterator i=channelList.begin();
 	 i != channelList.end();
 	 ++i)
    {
 	if (viewFromChannelName (i.name(), multiView) == otherViewName &&
 	    areCounterparts (i.name(), channelName, multiView))
 	{
 	    return i.name(); 
 	}
    }
    return "";
 }
 string
 insertViewName (const string &channel,
 		const StringVector &multiView,
 		int i)
 {
    //
    // Insert multiView[i] into the channel name if appropriate.
    //
    StringVector s = parseString (channel, '.');
    if (s.size() == 0)
 	return ""; // nothing in, nothing out
    if (s.size() == 1 && i == 0)
    {
 	//
 	// Channel in the default view, with no periods in its name.
 	// Do not insert view name.
 	//
 	return channel;
    }
    //
    // View name becomes penultimate section of new channel name.
    //
    string newName;
    for (int j = 0; j < s.size(); ++j)
    {
 	if (j < s.size() - 1)
 	    newName += s[j] + ".";
 	else
 	    newName += multiView[i] + "." + s[j];
    }
    return newName;
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfMultiView.h
+++ b/3rdparty/openexr/IlmImf/ImfMultiView.h
@ -0,0 +1,164 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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_MULTIVIEW_H
 #define INCLUDED_IMF_MULTIVIEW_H
 #include <ImfChannelList.h>
 #include <ImfStringVectorAttribute.h>
 //-----------------------------------------------------------------------------
 //
 //	Functions related to accessing channels and views in multi-view
 //	OpenEXR files.
 //
 //	A multi-view image file contains two or more views of the same
 //	scene, as seen from different viewpoints, for example, a left-eye
 //	and a right-eye view for stereo displays.  Each view has its own
 //	set of image channels.  A naming convention identifies the channels
 //	that belong to a given view.
 //
 //	A "multiView" attribute in the file header lists the names of the
 //	views in an image (see ImfStandardAttributes.h), and channel names
 //	of the form
 //
 //		layer.view.channel
 //
 //	allow channels to be matched with views.
 //
 //	For compatibility with singe-view images, the first view listed in
 //	the multiView attribute is the "default view", and channels that
 //	have no periods in their names are considered part of the default
 //	view.
 //
 //	For example, if a file's multiView attribute lists the views
 //	"left" and "right", in that order, then "left" is the default
 //	view.  Channels
 //
 //		"R", "left.Z", "diffuse.left.R"
 //
 //	are part of the "left" view; channels
 //
 //		"right.R", "right.Z", "diffuse.right.R"
 //
 //	are part of the "right" view; and channels
 //
 //		"tmp.R", "right.diffuse.R", "diffuse.tmp.R"
 //
 //	belong to no view at all.
 //
 //-----------------------------------------------------------------------------
 namespace Imf {
 //
 // Return the name of the default view given a multi-view string vector,
 // that is, return the first element of the string vector.  If the string
 // vector is empty, return "".
 //
 std::string defaultViewName (const StringVector &multiView);
 //
 // Given the name of a channel, return the name of the view to
 // which it belongs.  Returns the empty string ("") if the channel
 // is not a member of any named view.
 //
 std::string viewFromChannelName (const std::string &channel,
                                 const StringVector &multiView);
 //
 // Return whether channel1 and channel2 are the same channel but
 // viewed in different views.  (Return false if either channel
 // belongs to no view or if both channels belong to the same view.)
 //
 bool areCounterparts (const std::string &channel1,
                      const std::string &channel2,
                      const StringVector &multiView);
 //
 // Return a list of all channels belonging to view viewName.
 //
 ChannelList channelsInView (const std::string &viewName,
                            const ChannelList &channelList,
                            const StringVector &multiView);
 //
 // Return a list of channels not associated with any view.
 //
 ChannelList channelsInNoView (const ChannelList &channelList,
                              const StringVector &multiView);
 //
 // Given the name of a channel, return a list of the same channel
 // in all views (for example, given X.left.Y return X.left.Y,
 // X.right.Y, X.centre.Y, etc.).
 //
 ChannelList channelInAllViews (const std::string &channame,
                               const ChannelList &channelList,
                               const StringVector &multiView);
 //
 // Given the name of a channel in one view, return the corresponding
 // channel name for view otherViewName.  Return "" if no corresponding
 // channel exists in view otherViewName, or if view otherViewName doesn't
 // exist.
 //
 std::string channelInOtherView (const std::string &channel,
                                const ChannelList &channelList,
                                const StringVector &multiView,
                                const std::string &otherViewName);
 //
 // Given a channel name that does not include a view name, insert
 // multiView[i] into the channel name at the appropriate location.
 // If i is zero and the channel name contains no periods, then do
 // not insert the view name.
 //
 std::string insertViewName (const std::string &channel,
 			    const StringVector &multiView,
 			    int i);
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfName.h
+++ b/3rdparty/openexr/IlmImf/ImfName.h
@ -0,0 +1,146 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_NAME_H
 #define INCLUDED_IMF_NAME_H
 //-----------------------------------------------------------------------------
 //
 //	class ImfName -- a zero-terminated string
 //	with a fixed, small maximum length
 //
 //-----------------------------------------------------------------------------
 #include <string.h>
 namespace Imf {
 class Name
 {
  public:
    //-------------
    // Constructors
    //-------------
    Name ();
    Name (const char text[]);
    //--------------------
    // Assignment operator
    //--------------------
    Name &		operator = (const char text[]);
    //---------------------
    // Access to the string
    //---------------------
    const char *	text () const		{return _text;}
    const char *	operator * () const	{return _text;}
    //---------------
    // Maximum length
    //---------------
    static const int	SIZE = 256;
    static const int	MAX_LENGTH = SIZE - 1;
  private:
    char		_text[SIZE];
 };
 bool operator == (const Name &x, const Name &y);
 bool operator != (const Name &x, const Name &y);
 bool operator < (const Name &x, const Name &y);
 //-----------------
 // Inline functions
 //-----------------
 inline Name &
 Name::operator = (const char text[])
 {
    strncpy (_text, text, MAX_LENGTH);
    return *this;
 }
 inline
 Name::Name ()
 {
    _text[0] = 0;
 }
 inline
 Name::Name (const char text[])
 {
    *this = text;
    _text [MAX_LENGTH] = 0;
 }
 inline bool
 operator == (const Name &x, const Name &y)
 {
    return strcmp (*x, *y) == 0;
 }
 inline bool
 operator != (const Name &x, const Name &y)
 {
    return !(x == y);
 }
 inline bool
 operator < (const Name &x, const Name &y)
 {
    return strcmp (*x, *y) < 0;
 }
 } // namespace IMF
 #endif
--- a/3rdparty/openexr/IlmImf/ImfOpaqueAttribute.cpp
+++ b/3rdparty/openexr/IlmImf/ImfOpaqueAttribute.cpp
@ -0,0 +1,125 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class OpaqueAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfOpaqueAttribute.h>
 #include "Iex.h"
 #include <string.h>
 namespace Imf {
 OpaqueAttribute::OpaqueAttribute (const char typeName[]):
    _typeName (strlen (typeName) + 1),
    _dataSize (0)
 {
    strcpy (_typeName, typeName);
 }
 OpaqueAttribute::OpaqueAttribute (const OpaqueAttribute &other):
    _typeName (strlen (other._typeName) + 1),
    _dataSize (other._dataSize),
    _data (other._dataSize)
 {
    strcpy (_typeName, other._typeName);
    _data.resizeErase (other._dataSize);
    memcpy ((char *) _data, (const char *) other._data, other._dataSize);
 }
 OpaqueAttribute::~OpaqueAttribute ()
 {
    // empty
 }
 const char *
 OpaqueAttribute::typeName () const
 {
    return _typeName;
 }
 Attribute *	
 OpaqueAttribute::copy () const
 {
    return new OpaqueAttribute (*this);
 }
 void	
 OpaqueAttribute::writeValueTo (OStream &os, int version) const
 {
    Xdr::write <StreamIO> (os, _data, _dataSize);
 }
 void	
 OpaqueAttribute::readValueFrom (IStream &is, int size, int version)
 {
    _data.resizeErase (size);
    _dataSize = size;
    Xdr::read <StreamIO> (is, _data, size);
 }
 void	
 OpaqueAttribute::copyValueFrom (const Attribute &other)
 {
    const OpaqueAttribute *oa = dynamic_cast <const OpaqueAttribute *> (&other);
    if (oa == 0 || strcmp (_typeName, oa->_typeName))
    {
 	THROW (Iex::TypeExc, "Cannot copy the value of an "
 			     "image file attribute of type "
 			     "\"" << other.typeName() << "\" "
 			     "to an attribute of type "
 			     "\"" << _typeName << "\".");
    }
    _data.resizeErase (oa->_dataSize);
    _dataSize = oa->_dataSize;
    memcpy ((char *) _data, (const char *) oa->_data, oa->_dataSize);
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfOpaqueAttribute.h
+++ b/3rdparty/openexr/IlmImf/ImfOpaqueAttribute.h
@ -0,0 +1,114 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_OPAQUE_ATTRIBUTE_H
 #define INCLUDED_IMF_OPAQUE_ATTRIBUTE_H
 //-----------------------------------------------------------------------------
 //
 //	class OpaqueAttribute
 //
 //	When an image file is read, OpqaqueAttribute objects are used
 //	to hold the values of attributes whose types are not recognized
 //	by the reading program.  OpaqueAttribute objects can be read
 //	from an image file, copied, and written back to to another image
 //	file, but their values are inaccessible.
 //
 //-----------------------------------------------------------------------------
 #include <ImfAttribute.h>
 #include <ImfArray.h>
 namespace Imf {
 class OpaqueAttribute: public Attribute
 {
  public:
    //----------------------------
    // Constructors and destructor
    //----------------------------
    OpaqueAttribute (const char typeName[]);
    OpaqueAttribute (const OpaqueAttribute &other);
    virtual ~OpaqueAttribute ();
    //-------------------------------
    // Get this attribute's type name
    //-------------------------------
    virtual const char *	typeName () const;
    //------------------------------
    // Make a copy of this attribute
    //------------------------------
    virtual Attribute *		copy () const;
    //----------------
    // I/O and copying
    //----------------
    virtual void		writeValueTo (OStream &os,
 					      int version) const;
    virtual void		readValueFrom (IStream &is,
 					       int size,
 					       int version);
    virtual void		copyValueFrom (const Attribute &other);
  private:
    Array<char>			_typeName;
    long			_dataSize;
    Array<char>			_data;
 };
 } // namespace Imf
 // Metrowerks compiler wants the .cpp file inlined, too
 #ifdef __MWERKS__
 #include <ImfOpaqueAttribute.cpp>
 #endif
 #endif
--- a/3rdparty/openexr/IlmImf/ImfOutputFile.cpp
+++ b/3rdparty/openexr/IlmImf/ImfOutputFile.cpp
--- a/3rdparty/openexr/IlmImf/ImfOutputFile.h
+++ b/3rdparty/openexr/IlmImf/ImfOutputFile.h
@ -0,0 +1,241 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_OUTPUT_FILE_H
 #define INCLUDED_IMF_OUTPUT_FILE_H
 //-----------------------------------------------------------------------------
 //
 //	class OutputFile
 //
 //-----------------------------------------------------------------------------
 #include <ImfHeader.h>
 #include <ImfFrameBuffer.h>
 #include <ImfThreading.h>
 namespace Imf {
 class InputFile;
 struct PreviewRgba;
 class OutputFile
 {
  public:
    //-----------------------------------------------------------
    // Constructor -- opens the file and writes the file header.
    // The file header is also copied into the OutputFile object,
    // and can later be accessed via the header() method.
    // Destroying this OutputFile object automatically closes
    // the file.
    //
    // numThreads determines the number of threads that will be
    // used to write the file (see ImfThreading.h).
    //-----------------------------------------------------------
    OutputFile (const char fileName[], const Header &header,
                int numThreads = globalThreadCount());
    //------------------------------------------------------------
    // Constructor -- attaches the new OutputFile object to a file
    // that has already been opened, and writes the file header.
    // The file header is also copied into the OutputFile object,
    // and can later be accessed via the header() method.
    // Destroying this OutputFile object does not automatically
    // close the file.
    //
    // numThreads determines the number of threads that will be
    // used to write the file (see ImfThreading.h).
    //------------------------------------------------------------
    OutputFile (OStream &os, const Header &header,
                int numThreads = globalThreadCount());
    //-------------------------------------------------
    // Destructor
    //
    // Destroying the OutputFile object before writing
    // all scan lines within the data window results in
    // an incomplete file.
    //-------------------------------------------------
    virtual ~OutputFile ();
    //------------------------
    // Access to the file name
    //------------------------
    const char *	fileName () const;
    //--------------------------
    // Access to the file header
    //--------------------------
    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.
    //-------------------------------------------------------
    void		setFrameBuffer (const FrameBuffer &frameBuffer);
    //-----------------------------------
    // Access to the current frame buffer
    //-----------------------------------
    const FrameBuffer &	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.
    //-------------------------------------------------------------------
    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.
    //
    //------------------------------------------------------------------
    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.
    //--------------------------------------------------------------
    void		copyPixels (InputFile &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::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.
    //
    //--------------------------------------------------------------
    void		updatePreviewImage (const PreviewRgba newPixels[]);
    //---------------------------------------------------------
    // Break a scan line -- for testing and debugging only:
    // 
    // breakScanLine(y,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 pixel data block that
    // contains scan line y.
    //
    // 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.
    //
    //---------------------------------------------------------
    void		breakScanLine  (int y, int offset, int length, char c);
    struct Data;
  private:
    OutputFile (const OutputFile &);			// not implemented
    OutputFile & operator = (const OutputFile &);	// not implemented
    void		initialize (const Header &header);
    Data *		_data;
 };
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfPixelType.h
+++ b/3rdparty/openexr/IlmImf/ImfPixelType.h
@ -0,0 +1,61 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_PIXEL_TYPE_H
 #define INCLUDED_IMF_PIXEL_TYPE_H
 //-----------------------------------------------------------------------------
 //
 //	enum PixelType
 //
 //-----------------------------------------------------------------------------
 namespace Imf {
 enum PixelType
 {
    UINT  = 0,		// unsigned int (32 bit)
    HALF  = 1,		// half (16 bit floating point)
    FLOAT = 2,		// float (32 bit floating point)
    NUM_PIXELTYPES	// number of different pixel types
 };
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfPizCompressor.cpp
+++ b/3rdparty/openexr/IlmImf/ImfPizCompressor.cpp
@ -0,0 +1,666 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class PizCompressor
 //
 //-----------------------------------------------------------------------------
 #include <ImfPizCompressor.h>
 #include <ImfHeader.h>
 #include <ImfChannelList.h>
 #include <ImfHuf.h>
 #include <ImfWav.h>
 #include <ImfMisc.h>
 #include <ImfCheckedArithmetic.h>
 #include <ImathFun.h>
 #include <ImathBox.h>
 #include <Iex.h>
 #include <ImfIO.h>
 #include <ImfXdr.h>
 #include <ImfAutoArray.h>
 #include <string.h>
 #include <assert.h>
 namespace Imf {
 using Imath::divp;
 using Imath::modp;
 using Imath::Box2i;
 using Imath::V2i;
 using Iex::InputExc;
 namespace {
 //
 // Functions to compress the range of values in the pixel data
 //
 const int USHORT_RANGE = (1 << 16);
 const int BITMAP_SIZE  = (USHORT_RANGE >> 3);
 void
 bitmapFromData (const unsigned short data[/*nData*/],
 		int nData,
 		unsigned char bitmap[BITMAP_SIZE],
 		unsigned short &minNonZero,
 		unsigned short &maxNonZero)
 {
    for (int i = 0; i < BITMAP_SIZE; ++i)
 	bitmap[i] = 0;
    for (int i = 0; i < nData; ++i)
 	bitmap[data[i] >> 3] |= (1 << (data[i] & 7));
    bitmap[0] &= ~1;			// zero is not explicitly stored in
 					// the bitmap; we assume that the
 					// data always contain zeroes
    minNonZero = BITMAP_SIZE - 1;
    maxNonZero = 0;
    for (int i = 0; i < BITMAP_SIZE; ++i)
    {
 	if (bitmap[i])
 	{
 	    if (minNonZero > i)
 		minNonZero = i;
 	    if (maxNonZero < i)
 		maxNonZero = i;
 	}
    }
 }
 unsigned short
 forwardLutFromBitmap (const unsigned char bitmap[BITMAP_SIZE],
 		      unsigned short lut[USHORT_RANGE])
 {
    int k = 0;
    for (int i = 0; i < USHORT_RANGE; ++i)
    {
 	if ((i == 0) || (bitmap[i >> 3] & (1 << (i & 7))))
 	    lut[i] = k++;
 	else
 	    lut[i] = 0;
    }
    return k - 1;	// maximum value stored in lut[],
 }			// i.e. number of ones in bitmap minus 1
 unsigned short
 reverseLutFromBitmap (const unsigned char bitmap[BITMAP_SIZE],
 		      unsigned short lut[USHORT_RANGE])
 {
    int k = 0;
    for (int i = 0; i < USHORT_RANGE; ++i)
    {
 	if ((i == 0) || (bitmap[i >> 3] & (1 << (i & 7))))
 	    lut[k++] = i;
    }
    int n = k - 1;
    while (k < USHORT_RANGE)
 	lut[k++] = 0;
    return n;		// maximum k where lut[k] is non-zero,
 }			// i.e. number of ones in bitmap minus 1
 void
 applyLut (const unsigned short lut[USHORT_RANGE],
 	  unsigned short data[/*nData*/],
 	  int nData)
 {
    for (int i = 0; i < nData; ++i)
 	data[i] = lut[data[i]];
 }
 } // namespace
 struct PizCompressor::ChannelData
 {
    unsigned short *	start;
    unsigned short *	end;
    int			nx;
    int			ny;
    int			ys;
    int			size;
 };
 PizCompressor::PizCompressor
    (const Header &hdr,
     size_t maxScanLineSize,
     size_t numScanLines)
 :
    Compressor (hdr),
    _maxScanLineSize (maxScanLineSize),
    _format (XDR),
    _numScanLines (numScanLines),
    _tmpBuffer (0),
    _outBuffer (0),
    _numChans (0),
    _channels (hdr.channels()),
    _channelData (0)
 {
    size_t tmpBufferSize =
                uiMult (maxScanLineSize, numScanLines) / 2;
    size_t outBufferSize =
                uiAdd (uiMult (maxScanLineSize, numScanLines),
                       size_t (65536 + 8192));
    _tmpBuffer = new unsigned short
            [checkArraySize (tmpBufferSize, sizeof (unsigned short))];
    _outBuffer = new char [outBufferSize];
    const ChannelList &channels = header().channels();
    bool onlyHalfChannels = true;
    for (ChannelList::ConstIterator c = channels.begin();
 	 c != channels.end();
 	 ++c)
    {
 	_numChans++;
 	assert (pixelTypeSize (c.channel().type) % pixelTypeSize (HALF) == 0);
 	if (c.channel().type != HALF)
 	    onlyHalfChannels = false;
    }
    _channelData = new ChannelData[_numChans];
    const Box2i &dataWindow = hdr.dataWindow();
    _minX = dataWindow.min.x;
    _maxX = dataWindow.max.x;
    _maxY = dataWindow.max.y;
    //
    // We can support uncompressed data in the machine's native format
    // if all image channels are of type HALF, and if the Xdr and the
    // native represenations of a half have the same size.
    //
    if (onlyHalfChannels && (sizeof (half) == pixelTypeSize (HALF)))
 	_format = NATIVE;
 }
 PizCompressor::~PizCompressor ()
 {
    delete [] _tmpBuffer;
    delete [] _outBuffer;
    delete [] _channelData;
 }
 int
 PizCompressor::numScanLines () const
 {
    return _numScanLines;
 }
 Compressor::Format
 PizCompressor::format () const
 {
    return _format;
 }
 int
 PizCompressor::compress (const char *inPtr,
 			 int inSize,
 			 int minY,
 			 const char *&outPtr)
 {
    return compress (inPtr,
 		     inSize,
 		     Box2i (V2i (_minX, minY),
 			    V2i (_maxX, minY + numScanLines() - 1)),
 		     outPtr);
 }
 int
 PizCompressor::compressTile (const char *inPtr,
 			     int inSize,
 			     Imath::Box2i range,
 			     const char *&outPtr)
 {
    return compress (inPtr, inSize, range, outPtr);
 }
 int
 PizCompressor::uncompress (const char *inPtr,
 			   int inSize,
 			   int minY,
 			   const char *&outPtr)
 {
    return uncompress (inPtr,
 		       inSize,
 		       Box2i (V2i (_minX, minY),
 			      V2i (_maxX, minY + numScanLines() - 1)),
 		       outPtr);
 }
 int
 PizCompressor::uncompressTile (const char *inPtr,
 			       int inSize,
 			       Imath::Box2i range,
 			       const char *&outPtr)
 {
    return uncompress (inPtr, inSize, range, outPtr);
 }
 int
 PizCompressor::compress (const char *inPtr,
 			 int inSize,
 			 Imath::Box2i range,
 			 const char *&outPtr)
 {
    //
    // This is the compress function which is used by both the tiled and
    // scanline compression routines.
    //
    //
    // Special case - empty input buffer
    //
    if (inSize == 0)
    {
 	outPtr = _outBuffer;
 	return 0;
    }
    //
    // Rearrange the pixel data so that the wavelet
    // and Huffman encoders can process them easily.
    //
    // The wavelet and Huffman encoders both handle only
    // 16-bit data, so 32-bit data must be split into smaller
    // pieces.  We treat each 32-bit channel (UINT, FLOAT) as
    // two interleaved 16-bit channels.
    //
    int minX = range.min.x;
    int maxX = range.max.x;
    int minY = range.min.y;
    int maxY = range.max.y;
    if (maxY > _maxY)
        maxY = _maxY;
    if (maxX > _maxX)
        maxX = _maxX;
    unsigned short *tmpBufferEnd = _tmpBuffer;
    int i = 0;
    for (ChannelList::ConstIterator c = _channels.begin();
 	 c != _channels.end();
 	 ++c, ++i)
    {
 	ChannelData &cd = _channelData[i];
 	cd.start = tmpBufferEnd;
 	cd.end = cd.start;
 	cd.nx = numSamples (c.channel().xSampling, minX, maxX);
 	cd.ny = numSamples (c.channel().ySampling, minY, maxY);
 	cd.ys = c.channel().ySampling;
 	cd.size = pixelTypeSize (c.channel().type) / pixelTypeSize (HALF);
 	tmpBufferEnd += cd.nx * cd.ny * cd.size;
    }
    if (_format == XDR)
    {
 	//
 	// Machine-independent (Xdr) data format
 	//
 	for (int y = minY; y <= maxY; ++y)
 	{
 	    for (int i = 0; i < _numChans; ++i)
 	    {
 		ChannelData &cd = _channelData[i];
 		if (modp (y, cd.ys) != 0)
 		    continue;
 		for (int x = cd.nx * cd.size; x > 0; --x)
 		{
 		    Xdr::read <CharPtrIO> (inPtr, *cd.end);
 		    ++cd.end;
 		}
 	    }
 	}
    }
    else
    {
 	//
 	// Native, machine-dependent data format
 	//
 	for (int y = minY; y <= maxY; ++y)
 	{
 	    for (int i = 0; i < _numChans; ++i)
 	    {
 		ChannelData &cd = _channelData[i];
 		if (modp (y, cd.ys) != 0)
 		    continue;
 		int n = cd.nx * cd.size;
 		memcpy (cd.end, inPtr, n * sizeof (unsigned short));
 		inPtr  += n * sizeof (unsigned short);
 		cd.end += n;
 	    }
 	}
    }
    #if defined (DEBUG)
 	for (int i = 1; i < _numChans; ++i)
 	    assert (_channelData[i-1].end == _channelData[i].start);
 	assert (_channelData[_numChans-1].end == tmpBufferEnd);
    #endif
    //
    // Compress the range of the pixel data
    //
    AutoArray <unsigned char, BITMAP_SIZE> bitmap;
    unsigned short minNonZero;
    unsigned short maxNonZero;
    bitmapFromData (_tmpBuffer,
 		    tmpBufferEnd - _tmpBuffer,
 		    bitmap,
 		    minNonZero, maxNonZero);
    AutoArray <unsigned short, USHORT_RANGE> lut;
    unsigned short maxValue = forwardLutFromBitmap (bitmap, lut);
    applyLut (lut, _tmpBuffer, tmpBufferEnd - _tmpBuffer);
    //
    // Store range compression info in _outBuffer
    //
    char *buf = _outBuffer;
    Xdr::write <CharPtrIO> (buf, minNonZero);
    Xdr::write <CharPtrIO> (buf, maxNonZero);
    if (minNonZero <= maxNonZero)
    {
 	Xdr::write <CharPtrIO> (buf, (char *) &bitmap[0] + minNonZero,
 				maxNonZero - minNonZero + 1);
    }
    //
    // Apply wavelet encoding
    //
    for (int i = 0; i < _numChans; ++i)
    {
 	ChannelData &cd = _channelData[i];
 	for (int j = 0; j < cd.size; ++j)
 	{
 	    wav2Encode (cd.start + j,
 			cd.nx, cd.size,
 			cd.ny, cd.nx * cd.size,
 			maxValue);
 	}
    }
    //
    // Apply Huffman encoding; append the result to _outBuffer
    //
    char *lengthPtr = buf;
    Xdr::write <CharPtrIO> (buf, int(0));
    int length = hufCompress (_tmpBuffer, tmpBufferEnd - _tmpBuffer, buf);
    Xdr::write <CharPtrIO> (lengthPtr, length);
    outPtr = _outBuffer;
    return buf - _outBuffer + length;
 }
 int
 PizCompressor::uncompress (const char *inPtr,
 			   int inSize,
 			   Imath::Box2i range,
 			   const char *&outPtr)
 {
    //
    // This is the cunompress function which is used by both the tiled and
    // scanline decompression routines.
    //
    //
    // Special case - empty input buffer
    //
    if (inSize == 0)
    {
 	outPtr = _outBuffer;
 	return 0;
    }
    //
    // Determine the layout of the compressed pixel data
    //
    int minX = range.min.x;
    int maxX = range.max.x;
    int minY = range.min.y;
    int maxY = range.max.y;
    if (maxY > _maxY)
        maxY = _maxY;
    if (maxX > _maxX)
        maxX = _maxX;
    unsigned short *tmpBufferEnd = _tmpBuffer;
    int i = 0;
    for (ChannelList::ConstIterator c = _channels.begin();
 	 c != _channels.end();
 	 ++c, ++i)
    {
 	ChannelData &cd = _channelData[i];
 	cd.start = tmpBufferEnd;
 	cd.end = cd.start;
 	cd.nx = numSamples (c.channel().xSampling, minX, maxX);
 	cd.ny = numSamples (c.channel().ySampling, minY, maxY);
 	cd.ys = c.channel().ySampling;
 	cd.size = pixelTypeSize (c.channel().type) / pixelTypeSize (HALF);
 	tmpBufferEnd += cd.nx * cd.ny * cd.size;
    }
    //
    // Read range compression data
    //
    unsigned short minNonZero;
    unsigned short maxNonZero;
    AutoArray <unsigned char, BITMAP_SIZE> bitmap;
    memset (bitmap, 0, sizeof (unsigned char) * BITMAP_SIZE);
    Xdr::read <CharPtrIO> (inPtr, minNonZero);
    Xdr::read <CharPtrIO> (inPtr, maxNonZero);
    if (maxNonZero >= BITMAP_SIZE)
    {
 	throw InputExc ("Error in header for PIZ-compressed data "
 			"(invalid bitmap size).");
    }
    if (minNonZero <= maxNonZero)
    {
 	Xdr::read <CharPtrIO> (inPtr, (char *) &bitmap[0] + minNonZero,
 			       maxNonZero - minNonZero + 1);
    }
    AutoArray <unsigned short, USHORT_RANGE> lut;
    unsigned short maxValue = reverseLutFromBitmap (bitmap, lut);
    //
    // Huffman decoding
    //
    int length;
    Xdr::read <CharPtrIO> (inPtr, length);
    hufUncompress (inPtr, length, _tmpBuffer, tmpBufferEnd - _tmpBuffer);
    //
    // Wavelet decoding
    //
    for (int i = 0; i < _numChans; ++i)
    {
 	ChannelData &cd = _channelData[i];
 	for (int j = 0; j < cd.size; ++j)
 	{
 	    wav2Decode (cd.start + j,
 			cd.nx, cd.size,
 			cd.ny, cd.nx * cd.size,
 			maxValue);
 	}
    }
    //
    // Expand the pixel data to their original range
    //
    applyLut (lut, _tmpBuffer, tmpBufferEnd - _tmpBuffer);
    //
    // Rearrange the pixel data into the format expected by the caller.
    //
    char *outEnd = _outBuffer;
    if (_format == XDR)
    {
 	//
 	// Machine-independent (Xdr) data format
 	//
 	for (int y = minY; y <= maxY; ++y)
 	{
 	    for (int i = 0; i < _numChans; ++i)
 	    {
 		ChannelData &cd = _channelData[i];
 		if (modp (y, cd.ys) != 0)
 		    continue;
 		for (int x = cd.nx * cd.size; x > 0; --x)
 		{
 		    Xdr::write <CharPtrIO> (outEnd, *cd.end);
 		    ++cd.end;
 		}
 	    }
 	}
    }
    else
    {
 	//
 	// Native, machine-dependent data format
 	//
 	for (int y = minY; y <= maxY; ++y)
 	{
 	    for (int i = 0; i < _numChans; ++i)
 	    {
 		ChannelData &cd = _channelData[i];
 		if (modp (y, cd.ys) != 0)
 		    continue;
 		int n = cd.nx * cd.size;
 		memcpy (outEnd, cd.end, n * sizeof (unsigned short));
 		outEnd += n * sizeof (unsigned short);
 		cd.end += n;
 	    }
 	}
    }
    #if defined (DEBUG)
 	for (int i = 1; i < _numChans; ++i)
 	    assert (_channelData[i-1].end == _channelData[i].start);
 	assert (_channelData[_numChans-1].end == tmpBufferEnd);
    #endif
    outPtr = _outBuffer;
    return outEnd - _outBuffer;
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfPizCompressor.h
+++ b/3rdparty/openexr/IlmImf/ImfPizCompressor.h
@ -0,0 +1,115 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 #ifndef INCLUDED_IMF_PIZ_COMPRESSOR_H
 #define INCLUDED_IMF_PIZ_COMPRESSOR_H
 //-----------------------------------------------------------------------------
 //
 //	class PizCompressor -- uses Wavelet and Huffman encoding.
 //
 //-----------------------------------------------------------------------------
 #include <ImfCompressor.h>
 namespace Imf {
 class ChannelList;
 class PizCompressor: public Compressor
 {
  public:
    PizCompressor (const Header &hdr,
                   size_t maxScanLineSize,
                   size_t numScanLines);
    virtual ~PizCompressor ();
    virtual int		numScanLines () const;
    virtual Format	format () const;
    virtual int		compress (const char *inPtr,
 				  int inSize,
 				  int minY,
 				  const char *&outPtr);                  
    virtual int		compressTile (const char *inPtr,
 				      int inSize,
 				      Imath::Box2i range,
 				      const char *&outPtr);
    virtual int		uncompress (const char *inPtr,
 				    int inSize,
 				    int minY,
 				    const char *&outPtr);
    virtual int		uncompressTile (const char *inPtr,
 					int inSize,
 					Imath::Box2i range,
 					const char *&outPtr);
  private:
    struct ChannelData;
    int			compress (const char *inPtr,
 				  int inSize,
 				  Imath::Box2i range,
 				  const char *&outPtr);
    int			uncompress (const char *inPtr,
 				    int inSize,
 				    Imath::Box2i range,
 				    const char *&outPtr);
    int			_maxScanLineSize;
    Format		_format;
    int			_numScanLines;
    unsigned short *	_tmpBuffer;
    char *		_outBuffer;
    int			_numChans;
    const ChannelList &	_channels;
    ChannelData *	_channelData;
    int			_minX;
    int			_maxX;
    int			_maxY;
 };
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfPreviewImage.cpp
+++ b/3rdparty/openexr/IlmImf/ImfPreviewImage.cpp
@ -0,0 +1,103 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2003, 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 PreviewImage
 //
 //-----------------------------------------------------------------------------
 #include <ImfPreviewImage.h>
 #include <ImfCheckedArithmetic.h>
 #include "Iex.h"
 namespace Imf {
 PreviewImage::PreviewImage (unsigned int width,
 			    unsigned int height,
 			    const PreviewRgba pixels[])
 {
    _width = width;
    _height = height;
    _pixels = new PreviewRgba
        [checkArraySize (uiMult (_width, _height), sizeof (PreviewRgba))];
    if (pixels)
    {
 	for (unsigned int i = 0; i < _width * _height; ++i)
 	    _pixels[i] = pixels[i];
    }
    else
    {
 	for (unsigned int i = 0; i < _width * _height; ++i)
 	    _pixels[i] = PreviewRgba();
    }
 }
 PreviewImage::PreviewImage (const PreviewImage &other):
    _width (other._width),
    _height (other._height),
    _pixels (new PreviewRgba [other._width * other._height])
 {
    for (unsigned int i = 0; i < _width * _height; ++i)
 	_pixels[i] = other._pixels[i];
 }
 PreviewImage::~PreviewImage ()
 {
    delete [] _pixels;
 }
 PreviewImage &
 PreviewImage::operator = (const PreviewImage &other)
 {
    delete [] _pixels;
    _width = other._width;
    _height = other._height;
    _pixels = new PreviewRgba [other._width * other._height];
    for (unsigned int i = 0; i < _width * _height; ++i)
 	_pixels[i] = other._pixels[i];
    return *this;
 }
 } // namespace Imf
--- a/3rdparty/openexr/IlmImf/ImfPreviewImage.h
+++ b/3rdparty/openexr/IlmImf/ImfPreviewImage.h
@ -0,0 +1,131 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // Copyright (c) 2003, 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_PREVIEW_IMAGE_H
 #define INCLUDED_IMF_PREVIEW_IMAGE_H
 //-----------------------------------------------------------------------------
 //
 //	class PreviewImage -- a usually small, low-dynamic range image,
 //	that is intended to be stored in an image file's header.
 //
 //	struct PreviewRgba -- holds the value of a PreviewImage pixel.
 //
 //-----------------------------------------------------------------------------
 namespace Imf {
 struct PreviewRgba
 {
    unsigned char	r;	// Red, green and blue components of
    unsigned char	g;	// the pixel's color; intensity is
    unsigned char	b;	// proportional to pow (x/255, 2.2),
    				// where x is r, g, or b.
    unsigned char	a;	// The pixel's alpha; 0 == transparent,
 				// 255 == opaque.
    PreviewRgba (unsigned char r = 0,
 		 unsigned char g = 0,
 		 unsigned char b = 0,
 		 unsigned char a = 255)
 	: r(r), g(g), b(b), a(a) {}
 };
 class PreviewImage
 {
  public:
    //--------------------------------------------------------------------
    // Constructor:
    //
    // PreviewImage(w,h,p) constructs a preview image with w by h pixels
    // whose initial values are specified in pixel array p.  The x and y
    // coordinates of the pixels in p go from 0 to w-1, and from 0 to h-1.
    // The pixel with coordinates (x, y) is at address p + y*w + x.
    // Pixel (0, 0) is in the upper left corner of the preview image.
    // If p is zero, the pixels in the preview image are initialized with
    // (r = 0, b = 0, g = 0, a = 255).
    //
    //--------------------------------------------------------------------
     PreviewImage (unsigned int width = 0,
 		   unsigned int height = 0,
 		   const PreviewRgba pixels[] = 0);
    //-----------------------------------------------------
    // Copy constructor, destructor and assignment operator
    //-----------------------------------------------------
     PreviewImage (const PreviewImage &other);
    ~PreviewImage ();
    PreviewImage &	operator = (const PreviewImage &other);
    //-----------------------------------------------
    // Access to width, height and to the pixel array
    //-----------------------------------------------
    unsigned int	width () const	{return _width;}
    unsigned int	height () const	{return _height;}
    PreviewRgba *	pixels ()	{return _pixels;}
    const PreviewRgba *	pixels () const	{return _pixels;}
    //----------------------------
    // Access to individual pixels
    //----------------------------
    PreviewRgba &	pixel (unsigned int x, unsigned int y)
    					{return _pixels[y * _width + x];}
    const PreviewRgba &	pixel (unsigned int x, unsigned int y) const
    					{return _pixels[y * _width + x];}
  private:
    unsigned int	_width;
    unsigned int	_height;
    PreviewRgba *	_pixels;
 };
 } // namespace Imf
 #endif
--- a/3rdparty/openexr/IlmImf/ImfPreviewImageAttribute.cpp
+++ b/3rdparty/openexr/IlmImf/ImfPreviewImageAttribute.cpp
@ -0,0 +1,102 @@
 ///////////////////////////////////////////////////////////////////////////
 //
 // 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.
 //
 ///////////////////////////////////////////////////////////////////////////
 //-----------------------------------------------------------------------------
 //
 //	class PreviewImageAttribute
 //
 //-----------------------------------------------------------------------------
 #include <ImfPreviewImageAttribute.h>
 namespace Imf {
 template <>
 const char *
 PreviewImageAttribute::staticTypeName ()
 {
    return "preview";
 }
 template <>
 void
 PreviewImageAttribute::writeValueTo (OStream &os, int version) const
 {
    Xdr::write <StreamIO> (os, _value.width());
    Xdr::write <StreamIO> (os, _value.height());
    int numPixels = _value.width() * _value.height();
    const PreviewRgba *pixels = _value.pixels();
    for (int i = 0; i < numPixels; ++i)
    {
 	Xdr::write <StreamIO> (os, pixels[i].r);
 	Xdr::write <StreamIO> (os, pixels[i].g);
 	Xdr::write <StreamIO> (os, pixels[i].b);
 	Xdr::write <StreamIO> (os, pixels[i].a);
    }
 }
 template <>
 void
 PreviewImageAttribute::readValueFrom (IStream &is, int size, int version)
 {
    int width, height;
    Xdr::read <StreamIO> (is, width);
    Xdr::read <StreamIO> (is, height);
    PreviewImage p (width, height);
    int numPixels = p.width() * p.height();
    PreviewRgba *pixels = p.pixels();
    for (int i = 0; i < numPixels; ++i)
    {
 	Xdr::read <StreamIO> (is, pixels[i].r);
 	Xdr::read <StreamIO> (is, pixels[i].g);
 	Xdr::read <StreamIO> (is, pixels[i].b);
 	Xdr::read <StreamIO> (is, pixels[i].a);
    }
    _value = p;
 }
 } // namespace Imf
--- a/Show More
+++ b/Show More