rfreeimage 0.1.0

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

@@ -0,0 +1,436 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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 "ImfNamespace.h"
+#include "ImfExport.h"
+
+#include <map>
+#include <set>
+#include <string>
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+struct IMF_EXPORT 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 IMF_EXPORT 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_NAMESPACE::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);
+}
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+#endif

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

@@ -0,0 +1,150 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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>
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
+
+namespace {
+
+template <size_t N>
+void checkIsNullTerminated (const char (&str)[N], const char *what)
+{
+    for (size_t i = 0; i < N; ++i) {
+        if (str[i] == '\0')
+            return;
+   }
+    std::stringstream s;
+    s << "Invalid " << what << ": it is more than " << (N - 1) 
+      << " characters long.";
+    throw IEX_NAMESPACE::InputExc(s);
+}
+
+} // namespace
+
+
+template <>
+const char *
+ChannelListAttribute::staticTypeName ()
+{
+    return "chlist";
+}
+
+using namespace OPENEXR_IMF_INTERNAL_NAMESPACE;
+
+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));
+    }
+}
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT 

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

@@ -0,0 +1,74 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// 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"
+#include "ImfExport.h"
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER
+
+
+typedef TypedAttribute<OPENEXR_IMF_INTERNAL_NAMESPACE::ChannelList> ChannelListAttribute;
+
+template <>
+IMF_EXPORT
+const char *ChannelListAttribute::staticTypeName ();
+
+template <>
+IMF_EXPORT
+void ChannelListAttribute::writeValueTo (OPENEXR_IMF_INTERNAL_NAMESPACE::OStream &,
+                                         int) const;
+
+template <>
+IMF_EXPORT
+void ChannelListAttribute::readValueFrom (OPENEXR_IMF_INTERNAL_NAMESPACE::IStream &,
+                                          int, int);
+
+
+OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT
+
+
+#endif
+