rfreeimage 0.1.0

data/vendor/FreeImage/Source/OpenEXR/IlmImf/ImfAttribute.cpp

@@ -0,0 +1,158 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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>
+
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER 
+
+
+using ILMTHREAD_NAMESPACE::Mutex;
+using ILMTHREAD_NAMESPACE::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_NAMESPACE::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_NAMESPACE::ArgExc, "Cannot create image file attribute of "
+			    "unknown type \"" << typeName << "\".");
+
+    return (i->second)();
+}
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT

data/vendor/FreeImage/Source/OpenEXR/IlmImf/ImfAttribute.h

@@ -0,0 +1,407 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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"
+#include "ImfForward.h"
+#include "ImfExport.h"
+#include "ImfNamespace.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+class IMF_EXPORT 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 (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os,
+					      int version) const = 0;
+
+    virtual void		readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::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 (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os,
+					      int version) const;
+
+    virtual void		readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::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 (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &os,
+                                    int version) const
+{
+    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::write <OPENEXR_IMF_INTERNAL_NAMESPACE::StreamIO> (os, _value);
+}
+
+
+template <class T>
+void		
+TypedAttribute<T>::readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &is,
+                                     int size,
+                                     int version)
+{
+    OPENEXR_IMF_INTERNAL_NAMESPACE::Xdr::read <OPENEXR_IMF_INTERNAL_NAMESPACE::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_NAMESPACE::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_NAMESPACE::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());
+}
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+
+#endif

data/vendor/FreeImage/Source/OpenEXR/IlmImf/ImfAutoArray.h

@@ -0,0 +1,95 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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 "ImfNamespace.h"
+#include <string.h>
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+#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
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+
+#endif