Attachment #407748 for bug #536078

Lines 24-29 option(OCIO_BUILD_JNIGLUE "Specify whether to build java bindings" OFF) Link Here

(-)a/CMakeLists.txt (-23 / +56 lines)
24	option(OCIO_STATIC_JNIGLUE "Specify whether to statically link ocio to the java bindings" ON)	24	option(OCIO_STATIC_JNIGLUE "Specify whether to statically link ocio to the java bindings" ON)
25		25
26	option(OCIO_USE_SSE "Specify whether to enable SSE CPU performance optimizations" ON)	26	option(OCIO_USE_SSE "Specify whether to enable SSE CPU performance optimizations" ON)
		27	option(OCIO_INLINES_HIDDEN "Specify whether to build with -fvisibility-inlines-hidden" ON)
27		28
28	# Use boost's shared_ptr by default on Windows (as <VS2010 doesn't have it),	29	# Use boost's shared_ptr by default on Windows (as <VS2010 doesn't have it),
29	# Use std::tr1::shared_ptr by default on other platforms	30	# Use std::tr1::shared_ptr by default on other platforms
Lines 116-121 else() Link Here
116	set(OCIO_USE_BOOST_PTR 0)	117	set(OCIO_USE_BOOST_PTR 0)
117	endif()	118	endif()
118		119
		120	if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
		121	if(OCIO_INLINES_HIDDEN)
		122	execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion
		123	OUTPUT_VARIABLE GCC_VERSION)
		124	if (GCC_VERSION VERSION_LESS 4.2)
		125	message(STATUS "WARNING: GCC Version < 4.2 - disabling hidden inlines")
		126	set(OCIO_INLINES_HIDDEN OFF)
		127	endif()
		128	endif()
		129	endif()
		130
119	if(CMAKE_COMPILER_IS_GNUCXX)	131	if(CMAKE_COMPILER_IS_GNUCXX)
120	# Enable a bunch of compiler warnings...	132	# Enable a bunch of compiler warnings...
121	# http://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html	133	# http://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html
Lines 165-171 if(USE_EXTERNAL_TINYXML) Link Here
165		177
166	else(USE_EXTERNAL_TINYXML)	178	else(USE_EXTERNAL_TINYXML)
167	set(TINYXML_VERSION 2_6_1)	179	set(TINYXML_VERSION 2_6_1)
168	set(TINYXML_CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${PROJECT_BINARY_DIR}/ext/dist)	180	set(TINYXML_CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${PROJECT_BINARY_DIR}/ext/dist -DOCIO_INLINES_HIDDEN:BOOL=${OCIO_INLINES_HIDDEN})
169	if(CMAKE_TOOLCHAIN_FILE)	181	if(CMAKE_TOOLCHAIN_FILE)
170	set(TINYXML_CMAKE_ARGS ${TINYXML_CMAKE_ARGS} -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE})	182	set(TINYXML_CMAKE_ARGS ${TINYXML_CMAKE_ARGS} -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE})
171	endif()	183	endif()
Lines 190-210 if(USE_EXTERNAL_YAML) Link Here
190	# Set minimum yaml version for non-patched sources.	202	# Set minimum yaml version for non-patched sources.
191	set(YAML_VERSION_MIN "0.3.0")	203	set(YAML_VERSION_MIN "0.3.0")
192	include(FindPkgConfig)	204	include(FindPkgConfig)
193	pkg_check_modules(YAML_CPP yaml-cpp)	205	pkg_check_modules(PC_YAML_CPP REQUIRED QUIET yaml-cpp)
		206	find_path(YAML_CPP_INCLUDE_DIR yaml-cpp/yaml.h
		207	HINTS ${PC_YAML_CPP_INCLUDEDIR} ${PC_YAML_CPP_INCLUDE_DIRS} )
		208	find_library(YAML_CPP_LIBRARY LIBRARY_NAMES yaml-cpp libyaml-cpp
		209	HINTS ${PC_YAML_CPP_LIBRARY_DIRS} )
		210	set(YAML_CPP_LIBRARIES ${YAML_CPP_LIBRARY})
		211	set(YAML_CPP_INCLUDE_DIRS ${YAML_CPP_INCLUDE_DIR})
		212	set(YAML_CPP_VERSION ${PC_YAML_CPP_VERSION})
		213
		214	if(YAML_CPP_VERSION VERSION_LESS ${YAML_VERSION_MIN})
		215	message(FATAL_ERROR "ERROR: yaml-cpp ${YAML_VERSION_MIN} or greater is required.")
		216	endif()
		217
		218	find_package_handle_standard_args(yaml-cpp
		219	REQUIRED_VARS YAML_CPP_LIBRARIES YAML_CPP_INCLUDE_DIRS )
		220	set(YAML_CPP_FOUND ${YAML-CPP_FOUND})
		221	mark_as_advanced(YAML_CPP_INCLUDE_DIR YAML_CPP_LIBRARY YAML-CPP_FOUND)
		222
194	if(YAML_CPP_FOUND)	223	if(YAML_CPP_FOUND)
195	if(YAML_CPP_VERSION VERSION_EQUAL ${YAML_VERSION_MIN} OR	224	if(YAML_CPP_VERSION VERSION_GREATER "0.5.0")
196	YAML_CPP_VERSION VERSION_GREATER ${YAML_VERSION_MIN})	225	# Need to also get the boost headers here, as yaml-cpp 0.5.0+ requires them.
197	message(STATUS "System yaml-cpp library will be used.")	226	# Don't bother doing this step if we are already including the boost headers for shared_ptr
198	include_directories(BEFORE ${YAML_CPP_INCLUDE_DIRS})	227	if(NOT OCIO_USE_BOOST_PTR)
199	else()	228	set(Boost_ADDITIONAL_VERSIONS "1.49" "1.45" "1.44" "1.43" "1.43.0" "1.42"
200	message(FATAL_ERROR "ERROR: yaml-cpp ${YAML_VERSION_MIN} or greater is required.")	229	"1.42.0" "1.41" "1.41.0" "1.40"
		230	"1.40.0" "1.39" "1.39.0" "1.38"
		231	"1.38.0" "1.37" "1.37.0" "1.34.1"
		232	"1_34_1")
		233	set(Boost_USE_MULTITHREADED ON)
		234	find_package(Boost 1.34)
		235	if(NOT Boost_FOUND)
		236	message(FATAL_ERROR "Error: Detected system yaml-cpp version ${YAML_CPP_VERSION} is greater than 0.5.0, and therefore requires boost, but a boost installation could not be found.")
		237	endif()
		238
		239	set(EXTERNAL_INCLUDE_DIRS ${EXTERNAL_INCLUDE_DIRS} ${Boost_INCLUDE_DIR})
		240	endif()
201	endif()	241	endif()
		242	set(EXTERNAL_INCLUDE_DIRS ${EXTERNAL_INCLUDE_DIRS} ${YAML_CPP_INCLUDE_DIRS})
202	else(YAML_CPP_FOUND)	243	else(YAML_CPP_FOUND)
203	message(FATAL_ERROR "ERROR: System yaml-cpp library was not found. Make sure the library is installed and the pkg-config file exists.")	244	message(FATAL_ERROR "ERROR: System yaml-cpp library was not found. Make sure the library is installed and the pkg-config file exists.")
204	endif(YAML_CPP_FOUND)	245	endif(YAML_CPP_FOUND)
205	else(USE_EXTERNAL_YAML)	246	else(USE_EXTERNAL_YAML)
206	set(YAML_CPP_VERSION 0.3.0)	247	set(YAML_CPP_VERSION 0.3.0)
207	set(YAML_CPP_CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${PROJECT_BINARY_DIR}/ext/dist -DYAML_CPP_BUILD_TOOLS:BOOL=FALSE)	248	set(YAML_CPP_CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${PROJECT_BINARY_DIR}/ext/dist -DYAML_CPP_BUILD_TOOLS:BOOL=FALSE -DOCIO_INLINES_HIDDEN:BOOL=${OCIO_INLINES_HIDDEN})
208	if(CMAKE_TOOLCHAIN_FILE)	249	if(CMAKE_TOOLCHAIN_FILE)
209	set(YAML_CPP_CMAKE_ARGS ${YAML_CPP_CMAKE_ARGS} -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE})	250	set(YAML_CPP_CMAKE_ARGS ${YAML_CPP_CMAKE_ARGS} -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE})
210	endif()	251	endif()
Lines 225-249 else(USE_EXTERNAL_YAML) Link Here
225	endif()	266	endif()
226	endif(USE_EXTERNAL_YAML)	267	endif(USE_EXTERNAL_YAML)
227		268
228		269	if(YAML_CPP_VERSION VERSION_LESS "0.5.0")
		270	set(YAML_CPP_COMPILE_FLAGS "-DOLDYAML")
		271	endif()
229		272
230	###############################################################################	273	###############################################################################
231	### Externals ###	274	### Externals ###
232		275
233	set(EXTERNAL_INCLUDE_DIRS ${EXTERNAL_INCLUDE_DIRS} ${PROJECT_BINARY_DIR}/ext/dist/include)	276	set(EXTERNAL_INCLUDE_DIRS ${EXTERNAL_INCLUDE_DIRS} ${PROJECT_BINARY_DIR}/ext/dist/include)
234	set(EXTERNAL_COMPILE_FLAGS "-DTIXML_USE_STL")	277	set(EXTERNAL_COMPILE_FLAGS "-DTIXML_USE_STL ${YAML_CPP_COMPILE_FLAGS} -fPIC -fvisibility=hidden")
235		278	if(OCIO_INLINES_HIDDEN)
236	if(CMAKE_COMPILER_IS_GNUCXX)	279	set(EXTERNAL_COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS} -fvisibility-inlines-hidden")
237
238	execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion
239	OUTPUT_VARIABLE GCC_VERSION)
240
241	if (GCC_VERSION VERSION_LESS 4.2)
242	message(STATUS "GCC Version < 4.2 - symbol visibility hiding disabled")
243	set(EXTERNAL_COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS} -fPIC")
244	else()
245	set(EXTERNAL_COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS} -fPIC -fvisibility-inlines-hidden -fvisibility=hidden")
246	endif()
247	endif()	280	endif()
248		281
249	set(EXTERNAL_LINK_FLAGS "")	282	set(EXTERNAL_LINK_FLAGS "")

Lines 55-60 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Link Here

(-)a/export/OpenColorIO/OpenColorABI.h.in (+4 lines)
55	#include <boost/shared_ptr.hpp>	55	#include <boost/shared_ptr.hpp>
56	#define OCIO_SHARED_PTR boost::shared_ptr	56	#define OCIO_SHARED_PTR boost::shared_ptr
57	#define OCIO_DYNAMIC_POINTER_CAST boost::dynamic_pointer_cast	57	#define OCIO_DYNAMIC_POINTER_CAST boost::dynamic_pointer_cast
		58	#elif defined(_LIBCPP_VERSION)
		59	#include <memory>
		60	#define OCIO_SHARED_PTR std::shared_ptr
		61	#define OCIO_DYNAMIC_POINTER_CAST std::dynamic_pointer_cast
58	#elif __GNUC__ >= 4	62	#elif __GNUC__ >= 4
59	#include <tr1/memory>	63	#include <tr1/memory>
60	#define OCIO_SHARED_PTR std::tr1::shared_ptr	64	#define OCIO_SHARED_PTR std::tr1::shared_ptr

Lines 279-284 OCIO_NAMESPACE_ENTER Link Here

(-)a/export/OpenColorIO/OpenColorIO.h (+6 lines)
279	const char * getEnvironmentVarDefault(const char * name) const;	279	const char * getEnvironmentVarDefault(const char * name) const;
280	//!cpp:function::	280	//!cpp:function::
281	void clearEnvironmentVars();	281	void clearEnvironmentVars();
		282	//!cpp:function::
		283	void setEnvironmentMode(EnvironmentMode mode);
		284	//!cpp:function::
		285	EnvironmentMode getEnvironmentMode() const;
		286	//!cpp:function::
		287	void loadEnvironment();
282		288
283	//!cpp:function::	289	//!cpp:function::
284	const char * getSearchPath() const;	290	const char * getSearchPath() const;

Lines 1-7 Link Here

(-)a/ext/tinyxml_2_6_1.patch
1	diff -Naur tinyxml.orig/CMakeLists.txt tinyxml/CMakeLists.txt	1	diff -Naur tinyxml.orig/CMakeLists.txt tinyxml/CMakeLists.txt

Lines 13-20 diff -Naur tinyxml.orig/CMakeLists.txt tinyxml/CMakeLists.txt Link Here

(-)- tinyxml.orig/CMakeLists.txt (-1 / +6 lines)
13	+ tinyxmlerror.cpp	13	+ tinyxmlerror.cpp
14	+ tinyxmlparser.cpp)	14	+ tinyxmlparser.cpp)
15	+	15	+
		16	+set(TINYXML_COMPILE_FLAGS "-DTIXML_USE_STL -fPIC -fvisibility=hidden")
		17	+if(OCIO_INLINES_HIDDEN)
		18	+ set(TINYXML_COMPILE_FLAGS "${TINYXML_COMPILE_FLAGS} -fvisibility-inlines-hidden")
		19	+endif()
		20	+
16	+set_target_properties(tinyxml PROPERTIES	21	+set_target_properties(tinyxml PROPERTIES
17	+ COMPILE_FLAGS "-DTIXML_USE_STL -fPIC -fvisibility-inlines-hidden -fvisibility=hidden")	22	+ COMPILE_FLAGS "${TINYXML_COMPILE_FLAGS}")
18	+	23	+
19	+install(TARGETS	24	+install(TARGETS
20	+ tinyxml	25	+ tinyxml

Lines 1-11 Link Here

(-)a/ext/yaml-cpp-0.3.0.patch
1	diff -Naur yaml-cpp.orig/CMakeLists.txt yaml-cpp/CMakeLists.txt > yaml-cpp-0.3.0.patch	1	diff -Naur yaml-cpp.orig/CMakeLists.txt yaml-cpp/CMakeLists.txt > yaml-cpp-0.3.0.patch




diff -Naur yaml-cpp-0.5.1.orig/CMakeLists.txt yaml-cpp-0.5.1/CMakeLists.txt
--- yaml-cpp-0.5.1.orig/CMakeLists.txt	2014-01-30 09:45:54.000000000 +0000

#include "HashUtils.h"
#include "Logging.h"
#include "LookParse.h"
#include "Display.h"
#include "MathUtils.h"
#include "Mutex.h"
#include "OpBuilders.h"

        if(csname.empty()) return false;
        
        std::string csnamelower = pystring::lower(csname);
        
        for(unsigned int i = 0; i < colorspaces.size(); ++i)
        {
            if(csnamelower == pystring::lower(colorspaces[i]->getName()))

        
        return false;
    }
    
    
    // Displays
    struct View
    {
        std::string name;
        std::string colorspace;
        std::string looks;
        
        View() { }
        
        View(const std::string & name_,
             const std::string & colorspace_,
             const std::string & looksList_) :
                name(name_),
                colorspace(colorspace_),
                looks(looksList_)
        { }
    };
    
    typedef std::vector<View> ViewVec;
    typedef std::map<std::string, ViewVec> DisplayMap;  // (display name : ViewVec)
    
    void operator >> (const YAML::Node& node, View& v)
    {
        if(node.Tag() != "View")
            return;
        
        std::string key, stringval;
        
        for (YAML::Iterator iter = node.begin();
             iter != node.end();
             ++iter)
        {
            iter.first() >> key;
            
            if(key == "name")
            {
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<std::string>(stringval))
                    v.name = stringval;
            }
            else if(key == "colorspace")
            {
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<std::string>(stringval))
                    v.colorspace = stringval;
            }
            else if(key == "looks" || key == "look")
            {
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<std::string>(stringval))
                    v.looks = stringval;
            }
            else
            {
                LogUnknownKeyWarning(node.Tag(), iter.first());
            }
        }
        
        if(v.name.empty())
        {
            throw Exception("View does not specify 'name'.");
        }
        if(v.colorspace.empty())
        {
            std::ostringstream os;
            os << "View '" << v.name << "' ";
            os << "does not specify colorspace.";
            throw Exception(os.str().c_str());
        }
    }
    
    YAML::Emitter& operator << (YAML::Emitter& out, View view)
    {
        out << YAML::VerbatimTag("View");
        out << YAML::Flow;
        out << YAML::BeginMap;
        out << YAML::Key << "name" << YAML::Value << view.name;
        out << YAML::Key << "colorspace" << YAML::Value << view.colorspace;
        if(!view.looks.empty()) out << YAML::Key << "looks" << YAML::Value << view.looks;
        out << YAML::EndMap;
        return out;
    }
    
    DisplayMap::iterator find_display(DisplayMap & displays, const std::string & display)
    {
        for(DisplayMap::iterator iter = displays.begin();
            iter != displays.end();
            ++iter)
        {
            if(StrEqualsCaseIgnore(display, iter->first)) return iter;
        }
        return displays.end();
    }
    
    DisplayMap::const_iterator find_display_const(const DisplayMap & displays, const std::string & display)
    {
        for(DisplayMap::const_iterator iter = displays.begin();
            iter != displays.end();
            ++iter)
        {
            if(StrEqualsCaseIgnore(display, iter->first)) return iter;
        }
        return displays.end();
    }
    
    int find_view(const ViewVec & vec, const std::string & name)
    {
        for(unsigned int i=0; i<vec.size(); ++i)
        {
            if(StrEqualsCaseIgnore(name, vec[i].name)) return i;
        }
        return -1;
    }
    
    void AddDisplay(DisplayMap & displays,
                    const std::string & display,
                    const std::string & view,
                    const std::string & colorspace,
                    const std::string & looks)
    {
        DisplayMap::iterator iter = find_display(displays, display);
        if(iter == displays.end())
        {
            ViewVec views;
            views.push_back( View(view, colorspace, looks) );
            displays[display] = views;
        }
        else
        {
            ViewVec & views = iter->second;
            int index = find_view(views, view);
            if(index<0)
            {
                views.push_back( View(view, colorspace, looks) );
            }
            else
            {
                views[index].colorspace = colorspace;
                views[index].looks = looks;
            }
        }
    }
    
    void ComputeDisplays(StringVec & displayCache,
                         const DisplayMap & displays,
                         const StringVec & activeDisplays,
                         const StringVec & activeDisplaysEnvOverride)
    {
        displayCache.clear();
        
        StringVec displayMasterList;
        for(DisplayMap::const_iterator iter = displays.begin();
            iter != displays.end();
            ++iter)
        {
            displayMasterList.push_back(iter->first);
        }
        
        // Apply the env override if it's not empty.
        if(!activeDisplaysEnvOverride.empty())
        {
            displayCache = IntersectStringVecsCaseIgnore(displayMasterList, activeDisplaysEnvOverride);
            if(!displayCache.empty()) return;
        }
        // Otherwise, aApply the active displays if it's not empty.
        else if(!activeDisplays.empty())
        {
            displayCache = IntersectStringVecsCaseIgnore(displayMasterList, activeDisplays);
            if(!displayCache.empty()) return;
        }
        
        displayCache = displayMasterList;
    }
    
    
    
    } // namespace
    
    class Config::Impl

        mutable StringMap cacheids_;
        mutable std::string cacheidnocontext_;
        
        OCIOYaml io_;
        
        Impl() : 
            context_(Context::Create()),
            strictParsing_(true),

            return *this;
        }
        
        void load(std::istream & istream, const char * name);
        
        // Any time you modify the state of the config, you must call this
        // to reset internal cache states.  You also should do this in a
        // thread safe manner by acquiring the cacheidMutex_;

        istream.str(INTERNAL_RAW_PROFILE);
        
        ConfigRcPtr config = Config::Create();
        config->getImpl()->io_.open(istream, config);
        return config;
    }
    

        }
        
        ConfigRcPtr config = Config::Create();
        config->getImpl()->io_.open(istream, config, filename);
        return config;
    }
    
    ConstConfigRcPtr Config::CreateFromStream(std::istream & istream)
    {
        ConfigRcPtr config = Config::Create();
        config->getImpl()->io_.open(istream, config);
        return config;
    }
    

        getImpl()->resetCacheIDs();
    }
    
    void Config::setEnvironmentMode(EnvironmentMode mode)
    {
        getImpl()->context_->setEnvironmentMode(mode);
        
        AutoMutex lock(getImpl()->cacheidMutex_);
        getImpl()->resetCacheIDs();
    }
    
    EnvironmentMode Config::getEnvironmentMode() const
    {
        return getImpl()->context_->getEnvironmentMode();
    }
    
    void Config::loadEnvironment()
    {
        getImpl()->context_->loadEnvironment();
        
        AutoMutex lock(getImpl()->cacheidMutex_);
        getImpl()->resetCacheIDs();
    }
    
    const char * Config::getSearchPath() const
    {
        return getImpl()->context_->getSearchPath();

    {
        try
        {
            getImpl()->io_.write(os, this);
            out << YAML::Block;
            out << YAML::BeginMap;
            out << YAML::Key << "ocio_profile_version" << YAML::Value << 1;
            out << YAML::Newline;
            if(getImpl()->env_.size() > 0) {
                out << YAML::Key << "environment";
                out << YAML::Value << getImpl()->env_;
                out << YAML::Newline;
            }
            out << YAML::Key << "search_path" << YAML::Value << getImpl()->context_->getSearchPath();
            out << YAML::Key << "strictparsing" << YAML::Value << getImpl()->strictParsing_;
            out << YAML::Key << "luma" << YAML::Value << YAML::Flow << getImpl()->defaultLumaCoefs_;
            
            if(getImpl()->description_ != "")
            {
                out << YAML::Newline;
                out << YAML::Key << "description";
                out << YAML::Value << getImpl()->description_;
            }
            
            // Roles
            out << YAML::Newline;
            out << YAML::Key << "roles";
            out << YAML::Value << getImpl()->roles_;
            
            // Displays
            out << YAML::Newline;
            out << YAML::Key << "displays";
            out << YAML::Value << getImpl()->displays_;
            out << YAML::Newline;
            out << YAML::Key << "active_displays";
            out << YAML::Value << YAML::Flow << getImpl()->activeDisplays_;
            out << YAML::Key << "active_views";
            out << YAML::Value << YAML::Flow << getImpl()->activeViews_;
            
            // Looks
            if(!getImpl()->looksList_.empty())
            {
                out << YAML::Newline;
                out << YAML::Key << "looks";
                out << YAML::Value << getImpl()->looksList_;
            }
            
            // ColorSpaces
            {
                out << YAML::Newline;
                out << YAML::Key << "colorspaces";
                out << YAML::Value << getImpl()->colorspaces_;
            }
            
            out << YAML::EndMap;
            
            os << out.c_str();
        }
        catch( const std::exception & e)
        {

        }
    }
    
    void Config::Impl::load(std::istream & istream, const char * filename)
    {
        try
        {
            YAML::Parser parser(istream);
            YAML::Node node;
            parser.GetNextDocument(node);
            
            // check profile version
            int profile_version = 0;
            if(node.FindValue("ocio_profile_version") == NULL)
            {
                std::ostringstream os;
                os << "The specified file ";
                os << "does not appear to be an OCIO configuration.";
                throw Exception (os.str().c_str());
            }
            
            node["ocio_profile_version"] >> profile_version;
            if(profile_version > 1)
            {
                std::ostringstream os;
                os << "This .ocio config ";
                if(filename && *filename)
                {
                    os << " '" << filename << "' ";
                }
                os << "is version " << profile_version << ". ";
                os << "This version of the OpenColorIO library (" << OCIO_VERSION ") ";
                os << "is not known to be able to load this profile. ";
                os << "An attempt will be made, but there are no guarantees that the ";
                os << "results will be accurate. Continue at your own risk.";
                LogWarning(os.str());
            }
            
            
            std::string key, stringval;
            bool boolval = false;
            EnvironmentMode mode = ENV_ENVIRONMENT_LOAD_ALL;
            
            for (YAML::Iterator iter = node.begin();
                 iter != node.end();
                 ++iter)
            {
                iter.first() >> key;
                
                if(key == "ocio_profile_version") { } // Already handled above.
                else if(key == "environment")
                {
                    mode = ENV_ENVIRONMENT_LOAD_PREDEFINED;
                    const YAML::Node& environment = iter.second();
                    if(environment.Type() != YAML::NodeType::Map)
                    {
                        std::ostringstream os;
                        os << "'environment' field needs to be a (name: key) map.";
                        throw Exception(os.str().c_str());
                    }
                    for (YAML::Iterator it  = environment.begin();
                                        it != environment.end(); ++it)
                    {
                        std::string k, v;
                        it.first() >> k;
                        it.second() >> v;
                        env_[k] = v;
                        context_->setStringVar(k.c_str(), v.c_str());
                    }
                }
                else if(key == "search_path" || key == "resource_path")
                {
                    if (iter.second().Type() != YAML::NodeType::Null && 
                        iter.second().Read<std::string>(stringval))
                        context_->setSearchPath(stringval.c_str());
                }
                else if(key == "strictparsing")
                {
                    if (iter.second().Type() != YAML::NodeType::Null && 
                        iter.second().Read<bool>(boolval))
                        strictParsing_ = boolval;
                }
                else if(key == "description")
                {
                    if (iter.second().Type() != YAML::NodeType::Null && 
                        iter.second().Read<std::string>(stringval))
                        description_ = stringval;
                }
                else if(key == "luma")
                {
                    std::vector<float> val;
                    if (iter.second().Type() != YAML::NodeType::Null)
                    {
                        iter.second() >> val;
                        if(val.size() != 3)
                        {
                            std::ostringstream os;
                            os << "'luma' field must be 3 ";
                            os << "floats. Found '" << val.size() << "'.";
                            throw Exception(os.str().c_str());
                        }
                        defaultLumaCoefs_ = val;
                    }
                }
                else if(key == "roles")
                {
                    const YAML::Node& roles = iter.second();
                    if(roles.Type() != YAML::NodeType::Map)
                    {
                        std::ostringstream os;
                        os << "'roles' field needs to be a (name: key) map.";
                        throw Exception(os.str().c_str());
                    }
                    for (YAML::Iterator it  = roles.begin();
                                        it != roles.end(); ++it)
                    {
                        std::string k, v;
                        it.first() >> k;
                        it.second() >> v;
                        roles_[pystring::lower(k)] = v;
                    }
                }
                else if(key == "displays")
                {
                    if (iter.second().Type() != YAML::NodeType::Null)
                    {
                        iter.second() >> displays_;
                    }
                }
                else if(key == "active_displays")
                {
                    if (iter.second().Type() != YAML::NodeType::Null)
                    {
                        iter.second() >> activeDisplays_;
                    }
                }
                else if(key == "active_views")
                {
                    if (iter.second().Type() != YAML::NodeType::Null)
                    {
                        iter.second() >> activeViews_;
                    }
                }
                else if(key == "colorspaces")
                {
                    const YAML::Node& colorspaces = iter.second();
                    
                    if(colorspaces.Type() != YAML::NodeType::Sequence)
                    {
                        std::ostringstream os;
                        os << "'colorspaces' field needs to be a (- !<ColorSpace>) list.";
                        throw Exception(os.str().c_str());
                    }
                    
                    for(unsigned i = 0; i < colorspaces.size(); ++i)
                    {
                        if(colorspaces[i].Tag() == "ColorSpace")
                        {
                            ColorSpaceRcPtr cs = ColorSpace::Create();
                            colorspaces[i] >> cs;
                            colorspaces_.push_back( cs );
                        }
                        else
                        {
                            std::ostringstream os;
                            os << "Unknown element found in colorspaces:";
                            os << colorspaces[i].Tag() << ". Only ColorSpace(s)";
                            os << " currently handled.";
                            LogWarning(os.str());
                        }
                    }
                }
                else if(key == "looks")
                {
                    const YAML::Node& looks = iter.second();
                    
                    if(looks.Type() != YAML::NodeType::Sequence)
                    {
                        std::ostringstream os;
                        os << "'looks' field needs to be a (- !<Look>) list.";
                        throw Exception(os.str().c_str());
                    }
                    
                    for(unsigned i = 0; i < looks.size(); ++i)
                    {
                        if(looks[i].Tag() == "Look")
                        {
                            LookRcPtr look = Look::Create();
                            looks[i] >> look;
                            looksList_.push_back( look );
                        }
                        else
                        {
                            std::ostringstream os;
                            os << "Unknown element found in looks:";
                            os << looks[i].Tag() << ". Only Look(s)";
                            os << " currently handled.";
                            LogWarning(os.str());
                        }
                    }
                }
                else
                {
                    LogUnknownKeyWarning("profile", iter.first());
                }
            }
            
            if(filename)
            {
                std::string realfilename = pystring::os::path::abspath(filename);
                std::string configrootdir = pystring::os::path::dirname(realfilename);
                context_->setWorkingDir(configrootdir.c_str());
            }
            
            context_->setEnvironmentMode(mode);
            context_->loadEnvironment();
            
            if(mode == ENV_ENVIRONMENT_LOAD_ALL)
            {
                std::ostringstream os;
                os << "This .ocio config ";
                if(filename && *filename)
                {
                    os << " '" << filename << "' ";
                }
                os << "has no environment section defined. The default behaviour is to ";
                os << "load all environment variables (" << context_->getNumStringVars() << ")";
                os << ", which reduces the efficiency of OCIO's caching. Considering ";
                os << "predefining the environment variables used.";
                LogDebug(os.str());
            }
            
        }
        catch( const std::exception & e)
        {
            std::ostringstream os;
            os << "Error: Loading the OCIO profile ";
            if(filename) os << "'" << filename << "' ";
            os << "failed. " << e.what();
            throw Exception(os.str().c_str());
        }
    }
    
    void Config::Impl::resetCacheIDs()
    {
        cacheids_.clear();

    std::istringstream is;
    is.str(SIMPLE_PROFILE);
    OCIO::ConstConfigRcPtr config;
    OIIO_CHECK_THOW(config = OCIO::Config::CreateFromStream(is), OCIO::Exception);
    
    OIIO_CHECK_THOW(config->sanityCheck(), OCIO::Exception);
    }
    
    {

    "colorspaces:\n"
    "  - !<ColorSpace>\n"
    "      name: raw\n"
    "  - !<ColorSpace>\n"
    "      name: raw\n"
    "strictparsing: false\n"
    "roles:\n"
    "  default: raw\n"

    "colorspaces:\n"
    "  - !<ColorSpace>\n"
    "      name: raw\n"
    "  - !<ColorSpace>\n"
    "      name: raw\n"
    "strictparsing: false\n"
    "roles:\n"
    "  default: raw\n"

        "testbarchedder") == 0);
    OIIO_CHECK_ASSERT(strcmp(config->getCurrentContext()->resolveStringVar("${SHOW}"),
        "bar") == 0);
    OIIO_CHECK_THOW(config->sanityCheck(), OCIO::Exception);
    OIIO_CHECK_ASSERT(strcmp(config->getEnvironmentVarDefault("SHOW"), "super") == 0);
    
    OCIO::ConfigRcPtr edit = config->createEditableCopy();

        "lighting") == 0);
    OCIO::SetLoggingLevel(loglevel);
    
    OIIO_CHECK_EQUAL(edit->getEnvironmentMode(), OCIO::ENV_ENVIRONMENT_LOAD_PREDEFINED);
    edit->setEnvironmentMode(OCIO::ENV_ENVIRONMENT_LOAD_ALL);
    OIIO_CHECK_EQUAL(edit->getEnvironmentMode(), OCIO::ENV_ENVIRONMENT_LOAD_ALL);
    
    }
}





/*
Copyright (c) 2003-2010 Sony Pictures Imageworks Inc., et al.
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 Sony Pictures Imageworks 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 <string>

#include <OpenColorIO/OpenColorIO.h>

#include "Display.h"
#include "ParseUtils.h"

OCIO_NAMESPACE_ENTER
{
    
    DisplayMap::iterator find_display(DisplayMap & displays, const std::string & display)
    {
        for(DisplayMap::iterator iter = displays.begin();
            iter != displays.end();
            ++iter)
        {
            if(StrEqualsCaseIgnore(display, iter->first)) return iter;
        }
        return displays.end();
    }
    
    DisplayMap::const_iterator find_display_const(const DisplayMap & displays, const std::string & display)
    {
        for(DisplayMap::const_iterator iter = displays.begin();
            iter != displays.end();
            ++iter)
        {
            if(StrEqualsCaseIgnore(display, iter->first)) return iter;
        }
        return displays.end();
    }
    
    int find_view(const ViewVec & vec, const std::string & name)
    {
        for(unsigned int i=0; i<vec.size(); ++i)
        {
            if(StrEqualsCaseIgnore(name, vec[i].name)) return i;
        }
        return -1;
    }
    
    void AddDisplay(DisplayMap & displays,
                    const std::string & display,
                    const std::string & view,
                    const std::string & colorspace,
                    const std::string & looks)
    {
        DisplayMap::iterator iter = find_display(displays, display);
        if(iter == displays.end())
        {
            ViewVec views;
            views.push_back( View(view, colorspace, looks) );
            displays[display] = views;
        }
        else
        {
            ViewVec & views = iter->second;
            int index = find_view(views, view);
            if(index<0)
            {
                views.push_back( View(view, colorspace, looks) );
            }
            else
            {
                views[index].colorspace = colorspace;
                views[index].looks = looks;
            }
        }
    }
    
    void ComputeDisplays(StringVec & displayCache,
                         const DisplayMap & displays,
                         const StringVec & activeDisplays,
                         const StringVec & activeDisplaysEnvOverride)
    {
        displayCache.clear();
        
        StringVec displayMasterList;
        for(DisplayMap::const_iterator iter = displays.begin();
            iter != displays.end();
            ++iter)
        {
            displayMasterList.push_back(iter->first);
        }
        
        // Apply the env override if it's not empty.
        if(!activeDisplaysEnvOverride.empty())
        {
            displayCache = IntersectStringVecsCaseIgnore(displayMasterList, activeDisplaysEnvOverride);
            if(!displayCache.empty()) return;
        }
        // Otherwise, aApply the active displays if it's not empty.
        else if(!activeDisplays.empty())
        {
            displayCache = IntersectStringVecsCaseIgnore(displayMasterList, activeDisplays);
            if(!displayCache.empty()) return;
        }
        
        displayCache = displayMasterList;
    }

}
OCIO_NAMESPACE_EXIT

///////////////////////////////////////////////////////////////////////////////

#ifdef OCIO_UNIT_TEST

namespace OCIO = OCIO_NAMESPACE;
#include "UnitTest.h"

OIIO_ADD_TEST(Display, Basic)
{
    
}

#endif // OCIO_UNIT_TEST




/*
Copyright (c) 2003-2010 Sony Pictures Imageworks Inc., et al.
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 Sony Pictures Imageworks 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_OCIO_DISPLAY_H
#define INCLUDED_OCIO_DISPLAY_H

#include <OpenColorIO/OpenColorIO.h>

#include <string>
#include <vector>
#include <map>

#include "PrivateTypes.h"

OCIO_NAMESPACE_ENTER
{
    
    // Displays
    struct View
    {
        std::string name;
        std::string colorspace;
        std::string looks;
        
        View() { }
        
        View(const std::string & name_,
             const std::string & colorspace_,
             const std::string & looksList_) :
                name(name_),
                colorspace(colorspace_),
                looks(looksList_)
        { }
    };
    
    typedef std::vector<View> ViewVec;
    typedef std::map<std::string, ViewVec> DisplayMap;  // (display name : ViewVec)
    
    DisplayMap::iterator find_display(DisplayMap & displays, const std::string & display);
    
    DisplayMap::const_iterator find_display_const(const DisplayMap & displays, const std::string & display);
    
    int find_view(const ViewVec & vec, const std::string & name);
    
    void AddDisplay(DisplayMap & displays,
                    const std::string & display,
                    const std::string & view,
                    const std::string & colorspace,
                    const std::string & looks);
    
    void ComputeDisplays(StringVec & displayCache,
                         const DisplayMap & displays,
                         const StringVec & activeDisplays,
                         const StringVec & activeDisplaysEnvOverride);
    
}
OCIO_NAMESPACE_EXIT

#endif

Lines 28-33 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Link Here

(-)a/src/core/FileFormatTruelight.cpp (-1 / +69 lines)
28		28
29	#include <cstdio>	29	#include <cstdio>
30	#include <iostream>	30	#include <iostream>
		31	#include <iomanip>
31	#include <iterator>	32	#include <iterator>
32		33
33	#include <OpenColorIO/OpenColorIO.h>	34	#include <OpenColorIO/OpenColorIO.h>
Lines 90-95 OCIO_NAMESPACE_ENTER Link Here
90		91
91	virtual CachedFileRcPtr Read(std::istream & istream) const;	92	virtual CachedFileRcPtr Read(std::istream & istream) const;
92		93
		94	virtual void Write(const Baker & baker,
		95	const std::string & formatName,
		96	std::ostream & ostream) const;
		97
93	virtual void BuildFileOps(OpRcPtrVec & ops,	98	virtual void BuildFileOps(OpRcPtrVec & ops,
94	const Config& config,	99	const Config& config,
95	const ConstContextRcPtr & context,	100	const ConstContextRcPtr & context,
Lines 103-109 OCIO_NAMESPACE_ENTER Link Here
103	FormatInfo info;	108	FormatInfo info;
104	info.name = "truelight";	109	info.name = "truelight";
105	info.extension = "cub";	110	info.extension = "cub";
106	info.capabilities = FORMAT_CAPABILITY_READ;	111	info.capabilities = (FORMAT_CAPABILITY_READ \| FORMAT_CAPABILITY_WRITE);
107	formatInfoVec.push_back(info);	112	formatInfoVec.push_back(info);
108	}	113	}
109		114
Lines 287-292 OCIO_NAMESPACE_ENTER Link Here
287		292
288	return cachedFile;	293	return cachedFile;
289	}	294	}
		295
		296
		297	void
		298	LocalFileFormat::Write(const Baker & baker,
		299	const std::string & /formatName/,
		300	std::ostream & ostream) const
		301	{
		302	const int DEFAULT_CUBE_SIZE = 32;
		303	const int DEFAULT_SHAPER_SIZE = 1024;
		304
		305	ConstConfigRcPtr config = baker.getConfig();
		306
		307	int cubeSize = baker.getCubeSize();
		308	if (cubeSize==-1) cubeSize = DEFAULT_CUBE_SIZE;
		309	cubeSize = std::max(2, cubeSize); // smallest cube is 2x2x2
		310
		311	std::vector<float> cubeData;
		312	cubeData.resize(cubeSizecubeSizecubeSize*3);
		313	GenerateIdentityLut3D(&cubeData[0], cubeSize, 3, LUT3DORDER_FAST_RED);
		314	PackedImageDesc cubeImg(&cubeData[0], cubeSizecubeSizecubeSize, 1, 3);
		315
		316	// Apply processor to lut data
		317	ConstProcessorRcPtr inputToTarget;
		318	inputToTarget = config->getProcessor(baker.getInputSpace(), baker.getTargetSpace());
		319	inputToTarget->apply(cubeImg);
		320
		321	int shaperSize = baker.getShaperSize();
		322	if (shaperSize==-1) shaperSize = DEFAULT_SHAPER_SIZE;
		323	shaperSize = std::max(2, shaperSize); // smallest shaper is 2x2x2
		324
		325
		326	// Write the header
		327	ostream << "# Truelight Cube v2.0\n";
		328	ostream << "# lutLength " << shaperSize << "\n";
		329	ostream << "# iDims 3\n";
		330	ostream << "# oDims 3\n";
		331	ostream << "# width " << cubeSize << " " << cubeSize << " " << cubeSize << "\n";
		332	ostream << "\n";
		333
		334
		335	// Write the shaper lut
		336	// (We are just going to use a unity lut)
		337	ostream << "# InputLUT\n";
		338	ostream << std::setprecision(6) << std::fixed;
		339	float v = 0.0f;
		340	for (int i=0; i < shaperSize-1; i++)
		341	{
		342	v = ((float)i / (float)(shaperSize-1)) * (float)(cubeSize-1);
		343	ostream << v << " " << v << " " << v << "\n";
		344	}
		345	v = (float) (cubeSize-1);
		346	ostream << v << " " << v << " " << v << "\n"; // ensure that the last value is spot on
		347	ostream << "\n";
		348
		349	// Write the cube
		350	ostream << "# Cube\n";
		351	for (int i=0; i<cubeSizecubeSizecubeSize; ++i)
		352	{
		353	ostream << cubeData[3i+0] << " " << cubeData[3i+1] << " " << cubeData[3*i+2] << "\n";
		354	}
		355
		356	ostream << "# end\n";
		357	}
290		358
291	void	359	void
292	LocalFileFormat::BuildFileOps(OpRcPtrVec & ops,	360	LocalFileFormat::BuildFileOps(OpRcPtrVec & ops,




        
        OpRcPtr LookNoOp::clone() const
        {
            OpRcPtr op = OpRcPtr(new LookNoOp(m_look));
            return op;
        }
        
        bool LookNoOp::isSameType(const OpRcPtr & op) const
        {
            LookNoOpRcPtr typedRcPtr = DynamicPtrCast<LookNoOp>(op);
            if(!typedRcPtr) return false;
            return true;
        }





#include <OpenColorIO/OpenColorIO.h>

#ifndef WINDOWS

// fwd declare yaml-cpp visibility
#pragma GCC visibility push(hidden)
namespace YAML {
    class Exception;
    class BadDereference;
    class RepresentationException;
    class EmitterException;
    class ParserException;
    class InvalidScalar;
    class KeyNotFound;
    template <typename T> class TypedKeyNotFound;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::ColorSpace>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::Config>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::Exception>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::GpuShaderDesc>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::ImageDesc>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::Look>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::Processor>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::Transform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::AllocationTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::CDLTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::ColorSpaceTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::DisplayTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::ExponentTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::FileTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::GroupTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::LogTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::LookTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::MatrixTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::TruelightTransform>;
}
#pragma GCC visibility pop

#endif

#include <yaml-cpp/yaml.h>

#include "Logging.h"
#include "MathUtils.h"
#include "pystring/pystring.h"
#include "PathUtils.h"
#include "ParseUtils.h"
#include "Display.h"
#include "OCIOYaml.h"

OCIO_NAMESPACE_ENTER
{
    ///////////////////////////////////////////////////////////////////////////
    //  Core
    
    namespace
    {
        std::string key;
        tag >> key;
        
        std::ostringstream os;
        os << "Unknown key in " << name << ": ";
        os << "'" << key << "'. (line ";
        os << (tag.GetMark().line+1) << ", column "; // (yaml line numbers start at 0)
        os << tag.GetMark().column << ")";
        LogWarning(os.str());
    }
    
#ifdef OLDYAML
        typedef YAML::Iterator Iterator;
#else
        typedef YAML::const_iterator Iterator;
#endif

        // Iterator access
        // Note: The ownership semantics have changed between yaml-cpp 0.3.x and 0.5.x .
        // Returning a const reference to a yaml node screws with the internal yaml-cpp smart ptr 
        // implementation in the newer version. Luckily, the compiler does not care if we maintain
        // const YAML::Node & = get_first(iter) syntax at the call site even when returning an actual object
        // (instead of the reference as expected).
#ifdef OLDYAML
        inline const YAML::Node& get_first(const Iterator &it)
        {
            return it.first();
            
            if(key == "name")
            {
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<std::string>(stringval))
                    cs->setName(stringval.c_str());
            }
            else if(key == "description")
            {
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<std::string>(stringval))
                    cs->setDescription(stringval.c_str());
            }
            else if(key == "family")
            {
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<std::string>(stringval))
                    cs->setFamily(stringval.c_str());
            }
            else if(key == "equalitygroup")
            {
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<std::string>(stringval))
                    cs->setEqualityGroup(stringval.c_str());
            }
            else if(key == "bitdepth")
            {
                BitDepth ret;
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<BitDepth>(ret))
                    cs->setBitDepth(ret);
            }
            else if(key == "isdata")
            {
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<bool>(boolval))
                    cs->setIsData(boolval);
            }
            else if(key == "allocation")
            {
                Allocation val;
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<Allocation>(val))
                    cs->setAllocation(val);
            }
            else if(key == "allocationvars")
            {
                std::vector<float> val;
                if (iter.second().Type() != YAML::NodeType::Null)
                {
                    iter.second() >> val;
                    if(!val.empty())
                    {
                        cs->setAllocationVars(static_cast<int>(val.size()), &val[0]);
                    }
                }
            }
            else if(key == "to_reference")
            {
                TransformRcPtr val;
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<TransformRcPtr>(val))
                  cs->setTransform(val, COLORSPACE_DIR_TO_REFERENCE);
            }
            else if(key == "from_reference")
            {
                TransformRcPtr val;
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<TransformRcPtr>(val))
                  cs->setTransform(val, COLORSPACE_DIR_FROM_REFERENCE);
            }
            else
            {
                LogUnknownKeyWarning(node.Tag(), iter.first());
            }
        }
#else
        inline YAML::Node get_first(const Iterator &it)
    YAML::Emitter& operator << (YAML::Emitter& out, ColorSpaceRcPtr cs)
    {
        out << YAML::VerbatimTag("ColorSpace");
        out << YAML::BeginMap;
        
        out << YAML::Key << "name" << YAML::Value << cs->getName();
        out << YAML::Key << "family" << YAML::Value << cs->getFamily();
        out << YAML::Key << "equalitygroup" << YAML::Value << cs->getEqualityGroup();
        out << YAML::Key << "bitdepth" << YAML::Value << cs->getBitDepth();
        if(strlen(cs->getDescription()) > 0)
        {
            return it->first;
            out << YAML::Value << YAML::Literal << cs->getDescription();
        }
#endif
        
#ifdef OLDYAML
        inline const YAML::Node& get_second(const Iterator &it)
        {
            return it.second();
            cs->getAllocationVars(&allocationvars[0]);
            out << YAML::Key << "allocationvars";
            out << YAML::Flow << YAML::Value << allocationvars;
        }
#else
        inline YAML::Node get_second(const Iterator &it)
        {
            return it->second;
        }
#endif
        
        // Basic types
            cs->getTransform(COLORSPACE_DIR_TO_REFERENCE);
        if(toref)
            out << YAML::Key << "to_reference" << YAML::Value << toref;
        
        ConstTransformRcPtr fromref = \
            cs->getTransform(COLORSPACE_DIR_FROM_REFERENCE);
        if(fromref)
            out << YAML::Key << "from_reference" << YAML::Value << fromref;
        
        out << YAML::EndMap;
        out << YAML::Newline;
        
        return out;
    }
    
    
    ///////////////////////////////////////////////////////////////////////////
    
    // Look. (not the transform, the top-level class)
    
    void operator >> (const YAML::Node& node, LookRcPtr& look)
    {
        if(node.Tag() != "Look")
            return;
        
        std::string key, stringval;
        
        inline void load(const YAML::Node& node, bool& x)
             iter != node.end();
             ++iter)
        {
#ifdef OLDYAML
            node.Read<bool>(x);
#else
            x = node.as<bool>();
#endif
                    iter.second().Read<std::string>(stringval))
                    look->setName(stringval.c_str());
            }
            else if(key == "process_space")
            {
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<std::string>(stringval))
                    look->setProcessSpace(stringval.c_str());
            }
            else if(key == "transform")
            {
                TransformRcPtr val;
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<TransformRcPtr>(val))
                    look->setTransform(val);
            }
            else if(key == "inverse_transform")
            {
                TransformRcPtr val;
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<TransformRcPtr>(val))
                    look->setInverseTransform(val);
            }
            else
            {
                LogUnknownKeyWarning(node.Tag(), iter.first());
            }
        }
    }
    
    YAML::Emitter& operator << (YAML::Emitter& out, LookRcPtr look)
    {
        out << YAML::VerbatimTag("Look");
        out << YAML::BeginMap;
        out << YAML::Key << "name" << YAML::Value << look->getName();
        out << YAML::Key << "process_space" << YAML::Value << look->getProcessSpace();
        
        inline void load(const YAML::Node& node, int& x)
        {
#ifdef OLDYAML
            node.Read<int>(x);
#else
            x = node.as<int>();
#endif
        }
        
        inline void load(const YAML::Node& node, float& x)
        {
#ifdef OLDYAML
            node.Read<float>(x);
#else
            x = node.as<float>();
#endif
        }
        
        inline void load(const YAML::Node& node, std::string& x)
        {
#ifdef OLDYAML
            node.Read<std::string>(x);
#else
            x = node.as<std::string>();
#endif
        }
        
        inline void load(const YAML::Node& node, std::vector<std::string>& x)
    }
    
    
    
    ///////////////////////////////////////////////////////////////////////////
    
    
    namespace
    {
        void EmitBaseTransformKeyValues(YAML::Emitter & out,
                                        const ConstTransformRcPtr & t)
        {
#ifdef OLDYAML
            node >> x;
#else
            x = node.as<std::vector<std::string> >();
#endif
        }
        
        inline void load(const YAML::Node& node, std::vector<float>& x)
    void operator >> (const YAML::Node& node, TransformRcPtr& t)
    {
        if(node.Type() != YAML::NodeType::Map)
        {
#ifdef OLDYAML
            node >> x;
#else
            x = node.as<std::vector<float> >();
#endif
            throw Exception(os.str().c_str());
        }
        
        // Enums
        
        inline void load(const YAML::Node& node, BitDepth& depth)
        {
            std::string str;
            load(node, str);
            depth = BitDepthFromString(str.c_str());
        }
        
        inline void save(YAML::Emitter& out, BitDepth depth)
        {
            out << BitDepthToString(depth);
        }
        
        inline void load(const YAML::Node& node, Allocation& alloc)
        {
            std::string str;
            load(node, str);
            alloc = AllocationFromString(str.c_str());
        }
        
        inline void save(YAML::Emitter& out, Allocation alloc)
        {
            out << AllocationToString(alloc);
            t = temp;
        }
        
        inline void load(const YAML::Node& node, ColorSpaceDirection& dir)
        {
            std::string str;
            load(node, str);
            dir = ColorSpaceDirectionFromString(str.c_str());
        }
        
        inline void save(YAML::Emitter& out, ColorSpaceDirection dir)
        {
            out << ColorSpaceDirectionToString(dir);
        }
        
        inline void load(const YAML::Node& node, TransformDirection& dir)
        {
            std::string str;
            load(node, str);
            dir = TransformDirectionFromString(str.c_str());
        }
        
        inline void save(YAML::Emitter& out, TransformDirection dir)
        {
            out << TransformDirectionToString(dir);
        }
        
        inline void load(const YAML::Node& node, Interpolation& interp)
        {
            std::string str;
            load(node, str);
            interp = InterpolationFromString(str.c_str());
        }
        
        inline void save(YAML::Emitter& out, Interpolation interp)
        {
            out << InterpolationToString(interp);
        }
        
        //
        
        inline void LogUnknownKeyWarning(const std::string & name,
                                         const YAML::Node& tag)
        {
            std::string key;
            load(tag, key);
        
            // GroupTransformRcPtr >> operator with some type of
            // supported_tag() method
            
            // TODO: consider the forwards-compatibility implication of
            // throwing an exception.  Should this be a warning, instead?
            
            //  t = EmptyTransformRcPtr(new EmptyTransform(), &deleter);
            std::ostringstream os;
            os << "Unknown key in " << name << ": '" << key << "'.";
            LogWarning(os.str());
            os << (node.GetMark().line+1) << ", column "; // (yaml line numbers start at 0)
            os << node.GetMark().column << ")";
            throw Exception(os.str().c_str());
        }
    }
    
    YAML::Emitter& operator << (YAML::Emitter& out, ConstTransformRcPtr t)
    {
        if(ConstAllocationTransformRcPtr Allocation_tran = \
            DynamicPtrCast<const AllocationTransform>(t))
            out << Allocation_tran;
        else if(ConstCDLTransformRcPtr CDL_tran = \
            DynamicPtrCast<const CDLTransform>(t))
            out << CDL_tran;
        else if(ConstColorSpaceTransformRcPtr ColorSpace_tran = \
            DynamicPtrCast<const ColorSpaceTransform>(t))
            out << ColorSpace_tran;
        else if(ConstExponentTransformRcPtr Exponent_tran = \
            DynamicPtrCast<const ExponentTransform>(t))
            out << Exponent_tran;
        else if(ConstFileTransformRcPtr File_tran = \
            DynamicPtrCast<const FileTransform>(t))
            out << File_tran;
        else if(ConstGroupTransformRcPtr Group_tran = \
            DynamicPtrCast<const GroupTransform>(t))
            out << Group_tran;
        else if(ConstLogTransformRcPtr Log_tran = \
            DynamicPtrCast<const LogTransform>(t))
            out << Log_tran;
        else if(ConstLookTransformRcPtr Look_tran = \
            DynamicPtrCast<const LookTransform>(t))
            out << Look_tran;
        else if(ConstMatrixTransformRcPtr Matrix_tran = \
            DynamicPtrCast<const MatrixTransform>(t))
            out << Matrix_tran;
        else if(ConstTruelightTransformRcPtr Truelight_tran = \
            DynamicPtrCast<const TruelightTransform>(t))
            out << Truelight_tran;
        else
            throw Exception("Unsupported Transform() type for serialization.");
        
        return out;
    }
    
    
    ///////////////////////////////////////////////////////////////////////////
    //  Transforms
    
    void operator >> (const YAML::Node& node, GroupTransformRcPtr& t)
    {
        t = GroupTransform::Create();
        
        // View
        
        inline void load(const YAML::Node& node, View& v)
             iter != node.end();
             ++iter)
        {
            if(node.Tag() != "View")
                return;
            
            std::string key, stringval;
            
            for (Iterator iter = node.begin();
                 iter != node.end();
                 ++iter)
            {
                const YAML::Node& first = get_first(iter);
                const YAML::Node& second = get_second(iter);
                
                load(first, key);
                
                if (second.Type() == YAML::NodeType::Null) continue;
                
                if(key == "name")
                {
                    load(second, stringval);
                    v.name = stringval;
                }
                else if(key == "colorspace")
                {
                    load(second, stringval);
                    v.colorspace = stringval;
                }
                else if(key == "looks" || key == "look")
                {
                    load(second, stringval);
                    v.looks = stringval;
                }
                else
                {
                    LogUnknownKeyWarning(node.Tag(), first);
                }
            }
            
            if(v.name.empty())
            {
                throw Exception("View does not specify 'name'.");
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<TransformDirection>(val))
                  t->setDirection(val);
            }
            if(v.colorspace.empty())
            {
                std::ostringstream os;
                os << "View '" << v.name << "' ";
                os << "does not specify colorspace.";
                throw Exception(os.str().c_str());
            }
        }
    }
    
    YAML::Emitter& operator << (YAML::Emitter& out, ConstGroupTransformRcPtr t)
    {
        out << YAML::VerbatimTag("GroupTransform");
        out << YAML::BeginMap;
        EmitBaseTransformKeyValues(out, t);
        
        inline void save(YAML::Emitter& out, View view)
        out << YAML::Value;
        
        out << YAML::BeginSeq;
        for(int i = 0; i < t->size(); ++i)
        {
            out << YAML::VerbatimTag("View");
            out << YAML::Flow;
            out << YAML::BeginMap;
            out << YAML::Key << "name" << YAML::Value << view.name;
            out << YAML::Key << "colorspace" << YAML::Value << view.colorspace;
            if(!view.looks.empty()) out << YAML::Key << "looks" << YAML::Value << view.looks;
            out << YAML::EndMap;
        }
        out << YAML::EndSeq;
        
        out << YAML::EndMap;
        
        return out;
    }
    
    
    
    void operator >> (const YAML::Node& node, FileTransformRcPtr& t)
    {
        t = FileTransform::Create();
        
        // Common Transform
        
        inline void EmitBaseTransformKeyValues(YAML::Emitter & out,
                                               const ConstTransformRcPtr & t)
             ++iter)
        {
            if(t->getDirection() != TRANSFORM_DIR_FORWARD)
            
            if(key == "src")
            {
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<std::string>(stringval))
                  t->setSrc(stringval.c_str());
            }
            else if(key == "cccid")
            {
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<std::string>(stringval))
                  t->setCCCId(stringval.c_str());
            }
            else if(key == "interpolation")
            {
                Interpolation val;
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<Interpolation>(val))
                  t->setInterpolation(val);
            }
            else if(key == "direction")
            {
                TransformDirection val;
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<TransformDirection>(val))
                  t->setDirection(val);
            }
            else
            {
                out << YAML::Key << "direction";
                out << YAML::Value << YAML::Flow;
                save(out, t->getDirection());
            }
        }
    }
    
    YAML::Emitter& operator << (YAML::Emitter& out, ConstFileTransformRcPtr t)
    {
        out << YAML::VerbatimTag("FileTransform");
        out << YAML::Flow << YAML::BeginMap;
        out << YAML::Key << "src" << YAML::Value << t->getSrc();
        const char * cccid = t->getCCCId();
        if(cccid && *cccid)
        {
            out << YAML::Key << "cccid" << YAML::Value << t->getCCCId();
        }
        out << YAML::Key << "interpolation";
        out << YAML::Value << t->getInterpolation();
        
        EmitBaseTransformKeyValues(out, t);
        out << YAML::EndMap;
        return out;
    }
    
    void operator >> (const YAML::Node& node, ColorSpaceTransformRcPtr& t)
    {
        t = ColorSpaceTransform::Create();
        
        // AllocationTransform
        
        inline void load(const YAML::Node& node, AllocationTransformRcPtr& t)
             iter != node.end();
             ++iter)
        {
            t = AllocationTransform::Create();
            
            std::string key;
            
            for (Iterator iter = node.begin();
                 iter != node.end();
                 ++iter)
            {
                const YAML::Node& first = get_first(iter);
                const YAML::Node& second = get_second(iter);
                
                load(first, key);
                
                if (second.Type() == YAML::NodeType::Null) continue;
                
                if(key == "allocation")
                {
                    Allocation val;
                    load(second, val);
                    t->setAllocation(val);
                }
                else if(key == "vars")
                {
                    std::vector<float> val;
                    load(second, val);
                    if(!val.empty())
                    {
                        t->setVars(static_cast<int>(val.size()), &val[0]);
                    }
                }
                else if(key == "direction")
                {
                    TransformDirection val;
                    load(second, val);
                    t->setDirection(val);
                }
                else
                {
                    LogUnknownKeyWarning(node.Tag(), first);
                }
            }
        }
    }
    
    YAML::Emitter& operator << (YAML::Emitter& out, ConstColorSpaceTransformRcPtr t)
    {
        out << YAML::VerbatimTag("ColorSpaceTransform");
        out << YAML::Flow << YAML::BeginMap;
        out << YAML::Key << "src" << YAML::Value << t->getSrc();
        out << YAML::Key << "dst" << YAML::Value << t->getDst();
        EmitBaseTransformKeyValues(out, t);
        out << YAML::EndMap;
        return out;
    }
    
    void operator >> (const YAML::Node& node, LookTransformRcPtr& t)
    {
        t = LookTransform::Create();
        
        inline void save(YAML::Emitter& out, ConstAllocationTransformRcPtr t)
        
        for (YAML::Iterator iter = node.begin();
             iter != node.end();
             ++iter)
        {
            out << YAML::VerbatimTag("AllocationTransform");
            out << YAML::Flow << YAML::BeginMap;
            
            out << YAML::Key << "allocation";
            out << YAML::Value << YAML::Flow;
            save(out, t->getAllocation());
            
            if(t->getNumVars() > 0)
            }
            else if(key == "dst")
            {
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<std::string>(stringval))
                  t->setDst(stringval.c_str());
            }
            else if(key == "looks")
            {
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<std::string>(stringval))
                  t->setLooks(stringval.c_str());
            }
            else if(key == "direction")
            {
                TransformDirection val;
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<TransformDirection>(val))
                  t->setDirection(val);
            }
            else
            {
                std::vector<float> vars(t->getNumVars());
                t->getVars(&vars[0]);
                out << YAML::Key << "vars";
                out << YAML::Flow << YAML::Value << vars;
            }
            
            EmitBaseTransformKeyValues(out, t);
            out << YAML::EndMap;
        }
    }
    
    YAML::Emitter& operator << (YAML::Emitter& out, ConstLookTransformRcPtr t)
    {
        out << YAML::VerbatimTag("LookTransform");
        out << YAML::Flow << YAML::BeginMap;
        out << YAML::Key << "src" << YAML::Value << t->getSrc();
        out << YAML::Key << "dst" << YAML::Value << t->getDst();
        out << YAML::Key << "looks" << YAML::Value << t->getLooks();
        EmitBaseTransformKeyValues(out, t);
        out << YAML::EndMap;
        return out;
    }
    
    void operator >> (const YAML::Node& node, ExponentTransformRcPtr& t)
    {
        t = ExponentTransform::Create();
        
        // CDLTransform
        
        inline void load(const YAML::Node& node, CDLTransformRcPtr& t)
             iter != node.end();
             ++iter)
        {
            t = CDLTransform::Create();
            
            std::string key;
            std::vector<float> floatvecval;
            
            for (Iterator iter = node.begin();
                 iter != node.end();
                 ++iter)
            {
                const YAML::Node& first = get_first(iter);
                const YAML::Node& second = get_second(iter);
                
                load(first, key);
                
                if (second.Type() == YAML::NodeType::Null) continue;
                
                if(key == "slope")
                {
                    load(second, floatvecval);
                    if(floatvecval.size() != 3)
                    {
                        std::ostringstream os;
                        os << "CDLTransform parse error, 'slope' field must be 3 ";
                        os << "floats. Found '" << floatvecval.size() << "'.";
                        throw Exception(os.str().c_str());
                    }
                    t->setSlope(&floatvecval[0]);
                }
                else if(key == "offset")
                {
                    load(second, floatvecval);
                    if(floatvecval.size() != 3)
                    {
                        std::ostringstream os;
                        os << "CDLTransform parse error, 'offset' field must be 3 ";
                        os << "floats. Found '" << floatvecval.size() << "'.";
                        throw Exception(os.str().c_str());
                    }
                    t->setOffset(&floatvecval[0]);
                }
                else if(key == "power")
                {
                    load(second, floatvecval);
                    if(floatvecval.size() != 3)
                    {
                        std::ostringstream os;
                        os << "CDLTransform parse error, 'power' field must be 3 ";
                        os << "floats. Found '" << floatvecval.size() << "'.";
                        throw Exception(os.str().c_str());
                    }
                    t->setPower(&floatvecval[0]);
                }
                else if(key == "saturation" || key == "sat")
                {
                    float val = 0.0f;
                    load(second, val);
                    t->setSat(val);
                }
                else if(key == "direction")
                {
                    TransformDirection val;
                    load(second, val);
                    t->setDirection(val);
                }
                else
                {
                    LogUnknownKeyWarning(node.Tag(), first);
                }
            }
        }
        
        inline void save(YAML::Emitter& out, ConstCDLTransformRcPtr t)
        {
            out << YAML::VerbatimTag("CDLTransform");
            out << YAML::Flow << YAML::BeginMap;
            
            std::vector<float> slope(3);
            t->getSlope(&slope[0]);
            if(!IsVecEqualToOne(&slope[0], 3))
            {
                out << YAML::Key << "slope";
                out << YAML::Value << YAML::Flow << slope;
                    iter.second().Read<float>(val))
                  t->setBase(val);
            }
            
            std::vector<float> offset(3);
            t->getOffset(&offset[0]);
            if(!IsVecEqualToZero(&offset[0], 3))
            {
                out << YAML::Key << "offset";
                out << YAML::Value << YAML::Flow << offset;
                    iter.second().Read<TransformDirection>(val))
                  t->setDirection(val);
            }
            
            std::vector<float> power(3);
            t->getPower(&power[0]);
            if(!IsVecEqualToOne(&power[0], 3))
            {
                out << YAML::Key << "power";
                out << YAML::Value << YAML::Flow << power;
            }
            
            if(!IsScalarEqualToOne(t->getSat()))
            {
                out << YAML::Key << "sat" << YAML::Value << t->getSat();
            }
            
            EmitBaseTransformKeyValues(out, t);
            out << YAML::EndMap;
        }
    }
    
    YAML::Emitter& operator << (YAML::Emitter& out, ConstLogTransformRcPtr t)
    {
        out << YAML::VerbatimTag("LogTransform");
        out << YAML::Flow << YAML::BeginMap;
        out << YAML::Key << "base" << YAML::Value << t->getBase();
        EmitBaseTransformKeyValues(out, t);
        out << YAML::EndMap;
        return out;
    }
    
    void operator >> (const YAML::Node& node, MatrixTransformRcPtr& t)
    {
        t = MatrixTransform::Create();
        
        // ColorSpaceTransform
        
        inline void load(const YAML::Node& node, ColorSpaceTransformRcPtr& t)
             iter != node.end();
             ++iter)
        {
            t = ColorSpaceTransform::Create();
            
            std::string key, stringval;
            
            for (Iterator iter = node.begin();
                 iter != node.end();
                 ++iter)
            {
                const YAML::Node& first = get_first(iter);
                const YAML::Node& second = get_second(iter);
                
                load(first, key);
                
                if (second.Type() == YAML::NodeType::Null) continue;
                
                if(key == "src")
                {
                    load(second, stringval);
                    t->setSrc(stringval.c_str());
                }
                else if(key == "dst")
                {
                    load(second, stringval);
                    t->setDst(stringval.c_str());
                }
                else if(key == "direction")
                {
                    TransformDirection val;
                    load(second, val);
                    t->setDirection(val);
                }
                else
                {
                    LogUnknownKeyWarning(node.Tag(), first);
                }
            }
        }
        
        inline void save(YAML::Emitter& out, ConstColorSpaceTransformRcPtr t)
        {
            out << YAML::VerbatimTag("ColorSpaceTransform");
            out << YAML::Flow << YAML::BeginMap;
            out << YAML::Key << "src" << YAML::Value << t->getSrc();
            out << YAML::Key << "dst" << YAML::Value << t->getDst();
            EmitBaseTransformKeyValues(out, t);
            out << YAML::EndMap;
        }
        
        // ExponentTransform
        
        inline void load(const YAML::Node& node, ExponentTransformRcPtr& t)
        {
            t = ExponentTransform::Create();
            
            std::string key;
            
            for (Iterator iter = node.begin();
                 iter != node.end();
                 ++iter)
            {
                const YAML::Node& first = get_first(iter);
                const YAML::Node& second = get_second(iter);
                
                load(first, key);
                
                if (second.Type() == YAML::NodeType::Null) continue;
                
                if(key == "value")
                {
                    std::vector<float> val;
                    load(second, val);
                    if(val.size() != 4)
                    {
                        std::ostringstream os;
                        os << "ExponentTransform parse error, value field must be 4 ";
                        os << "floats. Found '" << val.size() << "'.";
                        throw Exception(os.str().c_str());
                    }
                    t->setValue(&val[0]);
                }
                else if(key == "direction")
                {
                    TransformDirection val;
                    load(second, val);
                    t->setDirection(val);
                }
                else
                {
                    LogUnknownKeyWarning(node.Tag(), first);
                }
            }
            else if(key == "direction")
            {
                TransformDirection val;
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<TransformDirection>(val))
                  t->setDirection(val);
            }
            else
            {
                LogUnknownKeyWarning(node.Tag(), iter.first());
            }
        }
    }
    
    YAML::Emitter& operator << (YAML::Emitter& out, ConstMatrixTransformRcPtr t)
    {
        out << YAML::VerbatimTag("MatrixTransform");
        out << YAML::Flow << YAML::BeginMap;
        
        inline void save(YAML::Emitter& out, ConstExponentTransformRcPtr t)
        t->getMatrix(&matrix[0]);
        if(!IsM44Identity(&matrix[0]))
        {
            out << YAML::VerbatimTag("ExponentTransform");
            out << YAML::Flow << YAML::BeginMap;
            
            std::vector<float> value(4, 0.0);
            t->getValue(&value[0]);
            out << YAML::Key << "value";
            out << YAML::Value << YAML::Flow << value;
            EmitBaseTransformKeyValues(out, t);
            out << YAML::EndMap;
        }
        
        // FileTransform
        
        inline void load(const YAML::Node& node, FileTransformRcPtr& t)
        {
            t = FileTransform::Create();
            
            std::string key, stringval;
            
            for (Iterator iter = node.begin();
                 iter != node.end();
                 ++iter)
            {
                const YAML::Node& first = get_first(iter);
                const YAML::Node& second = get_second(iter);
                
                load(first, key);
                
                if (second.Type() == YAML::NodeType::Null) continue;
                
                if(key == "src")
                {
                    load(second, stringval);
                    t->setSrc(stringval.c_str());
                }
                else if(key == "cccid")
                {
                    load(second, stringval);
                    t->setCCCId(stringval.c_str());
                }
                else if(key == "interpolation")
                {
                    Interpolation val;
                    load(second, val);
                    t->setInterpolation(val);
                }
                else if(key == "direction")
                {
                    TransformDirection val;
                    load(second, val);
                    t->setDirection(val);
                }
                else
                {
                    LogUnknownKeyWarning(node.Tag(), first);
                }
            }
        }
        
        inline void save(YAML::Emitter& out, ConstFileTransformRcPtr t)
        {
            out << YAML::VerbatimTag("FileTransform");
            out << YAML::Flow << YAML::BeginMap;
            out << YAML::Key << "src" << YAML::Value << t->getSrc();
            const char * cccid = t->getCCCId();
            if(cccid && *cccid)
            {
                out << YAML::Key << "cccid" << YAML::Value << t->getCCCId();
            }
            out << YAML::Key << "interpolation";
            out << YAML::Value;
            save(out, t->getInterpolation());
            
            EmitBaseTransformKeyValues(out, t);
            out << YAML::EndMap;
        }
        
        // GroupTransform
        
        void load(const YAML::Node& node, TransformRcPtr& t);
        void save(YAML::Emitter& out, ConstTransformRcPtr t);
        
        inline void load(const YAML::Node& node, GroupTransformRcPtr& t)
             iter != node.end();
             ++iter)
        {
            t = GroupTransform::Create();
            
            std::string key;
            
            for (Iterator iter = node.begin();
                 iter != node.end();
                 ++iter)
            {
                const YAML::Node& first = get_first(iter);
                const YAML::Node& second = get_second(iter);
                
                load(first, key);
                
                if (second.Type() == YAML::NodeType::Null) continue;
                
                if(key == "children")
                {
                    for(unsigned i = 0; i < second.size(); ++i)
                    if(floatvecval.size() != 3)
                    {
                        TransformRcPtr childTransform;
                        load(second[i], childTransform);
                        
                        // TODO: consider the forwards-compatibility implication of
                        // throwing an exception.  Should this be a warning, instead?
                        if(!childTransform)
                        {
                            throw Exception("Child transform could not be parsed.");
                        }
                        
                        t->push_back(childTransform);
                    }
                    t->setSlope(&floatvecval[0]);
                }
                else if(key == "direction")
            else if(key == "offset")
            {
                if (iter.second().Type() != YAML::NodeType::Null)
                {
                    TransformDirection val;
                    load(second, val);
                    t->setDirection(val);
                        std::ostringstream os;
                        os << "CDLTransform parse error, 'offset' field must be 3 ";
                        os << "floats. Found '" << floatvecval.size() << "'.";
                        throw Exception(os.str().c_str());
                    }
                    t->setOffset(&floatvecval[0]);
                }
                else
            else if(key == "power")
            {
                if (iter.second().Type() != YAML::NodeType::Null)
                {
                    LogUnknownKeyWarning(node.Tag(), first);
                    if(floatvecval.size() != 3)
                    {
                        std::ostringstream os;
                        os << "CDLTransform parse error, 'power' field must be 3 ";
                        os << "floats. Found '" << floatvecval.size() << "'.";
                        throw Exception(os.str().c_str());
                    }
                    t->setPower(&floatvecval[0]);
                }
            }
        }
        
        inline void save(YAML::Emitter& out, ConstGroupTransformRcPtr t)
        {
            out << YAML::VerbatimTag("GroupTransform");
            out << YAML::BeginMap;
            EmitBaseTransformKeyValues(out, t);
            
            out << YAML::Key << "children";
            out << YAML::Value;
            
            out << YAML::BeginSeq;
            for(int i = 0; i < t->size(); ++i)
            }
            else
            {
                save(out, t->getTransform(i));
            }
            out << YAML::EndSeq;
            
            out << YAML::EndMap;
        }
    }
    
    YAML::Emitter& operator << (YAML::Emitter& out, ConstCDLTransformRcPtr t)
    {
        out << YAML::VerbatimTag("CDLTransform");
        out << YAML::Flow << YAML::BeginMap;
        
        // LogTransform
        
        inline void load(const YAML::Node& node, LogTransformRcPtr& t)
        {
            t = LogTransform::Create();
            
            std::string key;
            
            for (Iterator iter = node.begin();
                 iter != node.end();
                 ++iter)
            {
                const YAML::Node& first = get_first(iter);
                const YAML::Node& second = get_second(iter);
                
                load(first, key);
                
                if (second.Type() == YAML::NodeType::Null) continue;
                
                if(key == "base")
                {
                    float val = 0.0f;
                    load(second, val);
                    t->setBase(val);
                }
                else if(key == "direction")
                {
                    TransformDirection val;
                    load(second, val);
                    t->setDirection(val);
                }
                else
                {
                    LogUnknownKeyWarning(node.Tag(), first);
                }
            }
        }
        
        inline void save(YAML::Emitter& out, ConstLogTransformRcPtr t)
        t->getOffset(&offset[0]);
        if(!IsVecEqualToZero(&offset[0], 3))
        {
            out << YAML::VerbatimTag("LogTransform");
            out << YAML::Flow << YAML::BeginMap;
            out << YAML::Key << "base" << YAML::Value << t->getBase();
            EmitBaseTransformKeyValues(out, t);
            out << YAML::EndMap;
        }
        
        // LookTransform
        
        inline void load(const YAML::Node& node, LookTransformRcPtr& t)
        {
            t = LookTransform::Create();
            
            std::string key, stringval;
            
            for (Iterator iter = node.begin();
                 iter != node.end();
                 ++iter)
            {
                const YAML::Node& first = get_first(iter);
                const YAML::Node& second = get_second(iter);
                
                load(first, key);
                
                if (second.Type() == YAML::NodeType::Null) continue;
                
                if(key == "src")
                {
                    load(second, stringval);
                    t->setSrc(stringval.c_str());
                }
                else if(key == "dst")
                {
                    load(second, stringval);
                    t->setDst(stringval.c_str());
                }
                else if(key == "looks")
                {
                    load(second, stringval);
                    t->setLooks(stringval.c_str());
                }
                else if(key == "direction")
                {
                    TransformDirection val;
                    load(second, val);
                    t->setDirection(val);
                }
                else
                {
                    LogUnknownKeyWarning(node.Tag(), first);
                }
            }
        }
        
        inline void save(YAML::Emitter& out, ConstLookTransformRcPtr t)
        {
            out << YAML::VerbatimTag("LookTransform");
            out << YAML::Flow << YAML::BeginMap;
            out << YAML::Key << "src" << YAML::Value << t->getSrc();
            out << YAML::Key << "dst" << YAML::Value << t->getDst();
            out << YAML::Key << "looks" << YAML::Value << t->getLooks();
            EmitBaseTransformKeyValues(out, t);
            out << YAML::EndMap;
        }
        
        // MatrixTransform
        out << YAML::EndMap;
        return out;
    }
    
    void operator >> (const YAML::Node& node, AllocationTransformRcPtr& t)
    {
        t = AllocationTransform::Create();
        
        std::string key;
        
        inline void load(const YAML::Node& node, MatrixTransformRcPtr& t)
             iter != node.end();
             ++iter)
        {
            t = MatrixTransform::Create();
            
            std::string key;
            
            for (Iterator iter = node.begin();
                 iter != node.end();
                 ++iter)
            {
                const YAML::Node& first = get_first(iter);
                const YAML::Node& second = get_second(iter);
                
                load(first, key);
                
                if (second.Type() == YAML::NodeType::Null) continue;
                
                if(key == "matrix")
                {
                    std::vector<float> val;
                    load(second, val);
                    if(val.size() != 16)
                    {
                        std::ostringstream os;
                        os << "MatrixTransform parse error, matrix field must be 16 ";
                        os << "floats. Found '" << val.size() << "'.";
                        throw Exception(os.str().c_str());
                    }
                    t->setMatrix(&val[0]);
                }
                else if(key == "offset")
                {
                    std::vector<float> val;
                    load(second, val);
                    if(val.size() != 4)
                    {
                        std::ostringstream os;
                        os << "MatrixTransform parse error, offset field must be 4 ";
                        os << "floats. Found '" << val.size() << "'.";
                        throw Exception(os.str().c_str());
                    }
                    t->setOffset(&val[0]);
                }
                else if(key == "direction")
                {
                    TransformDirection val;
                    load(second, val);
                    t->setDirection(val);
                }
                else
                {
                    LogUnknownKeyWarning(node.Tag(), first);
                }
            }
        }
        
        inline void save(YAML::Emitter& out, ConstMatrixTransformRcPtr t)
        {
            out << YAML::VerbatimTag("MatrixTransform");
            out << YAML::Flow << YAML::BeginMap;
            
            std::vector<float> matrix(16, 0.0);
            t->getMatrix(&matrix[0]);
            if(!IsM44Identity(&matrix[0]))
            {
                out << YAML::Key << "matrix";
                out << YAML::Value << YAML::Flow << matrix;
                    iter.second().Read<TransformDirection>(val))
                  t->setDirection(val);
            }
            
            std::vector<float> offset(4, 0.0);
            t->getOffset(&offset[0]);
            if(!IsVecEqualToZero(&offset[0],4))
            {
                out << YAML::Key << "offset";
                out << YAML::Value << YAML::Flow << offset;
            }
            
            EmitBaseTransformKeyValues(out, t);
            out << YAML::EndMap;
        }
    }
    
    YAML::Emitter& operator << (YAML::Emitter& out, ConstAllocationTransformRcPtr t)
    {
        out << YAML::VerbatimTag("AllocationTransform");
        out << YAML::Flow << YAML::BeginMap;
        
        // TruelightTransform
        out << YAML::Value << YAML::Flow << t->getAllocation();
        
        inline void load(const YAML::Node& node, TruelightTransformRcPtr& t)
        {
            t = TruelightTransform::Create();
            
            std::string key, stringval;
            
            for (Iterator iter = node.begin();
                 iter != node.end();
                 ++iter)
            {
                const YAML::Node& first = get_first(iter);
                const YAML::Node& second = get_second(iter);
                
                load(first, key);
                
                if (second.Type() == YAML::NodeType::Null) continue;
                
                if(key == "config_root")
                {
                    load(second, stringval);
                    t->setConfigRoot(stringval.c_str());
                }
                else if(key == "profile")
                {
                    load(second, stringval);
                    t->setProfile(stringval.c_str());
                }
                else if(key == "camera")
                {
                    load(second, stringval);
                    t->setCamera(stringval.c_str());
                }
                else if(key == "input_display")
                {
                    load(second, stringval);
                    t->setInputDisplay(stringval.c_str());
                }
                else if(key == "recorder")
                {
                    load(second, stringval);
                    t->setRecorder(stringval.c_str());
                }
                else if(key == "print")
                {
                    load(second, stringval);
                    t->setPrint(stringval.c_str());
                }
                else if(key == "lamp")
                {
                    load(second, stringval);
                    t->setLamp(stringval.c_str());
                }
                else if(key == "output_camera")
                {
                    load(second, stringval);
                    t->setOutputCamera(stringval.c_str());
                }
                else if(key == "display")
                {
                    load(second, stringval);
                    t->setDisplay(stringval.c_str());
                }
                else if(key == "cube_input")
                {
                    load(second, stringval);
                     t->setCubeInput(stringval.c_str());
                }
                else if(key == "direction")
                {
                    TransformDirection val;
                    load(second, val);
                    t->setDirection(val);
                }
                else
                {
                    LogUnknownKeyWarning(node.Tag(), first);
                }
            }
        }
        
        inline void save(YAML::Emitter& out, ConstTruelightTransformRcPtr t)
        out << YAML::EndMap;
        return out;
    }
    
    void operator >> (const YAML::Node& node, TruelightTransformRcPtr& t)
    {
        t = TruelightTransform::Create();
        
        std::string key, stringval;
        
        for (YAML::Iterator iter = node.begin();
             iter != node.end();
             ++iter)
        {
            iter.first() >> key;
            
            out << YAML::VerbatimTag("TruelightTransform");
            out << YAML::Flow << YAML::BeginMap;
            if(strcmp(t->getConfigRoot(), "") != 0)
            {
                out << YAML::Key << "config_root";
                out << YAML::Value << YAML::Flow << t->getConfigRoot();
                  t->setConfigRoot(stringval.c_str());
            }
            if(strcmp(t->getProfile(), "") != 0)
            {
                out << YAML::Key << "profile";
                out << YAML::Value << YAML::Flow << t->getProfile();
                  t->setProfile(stringval.c_str());
            }
            if(strcmp(t->getCamera(), "") != 0)
            {
                out << YAML::Key << "camera";
                out << YAML::Value << YAML::Flow << t->getCamera();
                  t->setCamera(stringval.c_str());
            }
            if(strcmp(t->getInputDisplay(), "") != 0)
            {
                out << YAML::Key << "input_display";
                out << YAML::Value << YAML::Flow << t->getInputDisplay();
                  t->setInputDisplay(stringval.c_str());
            }
            if(strcmp(t->getRecorder(), "") != 0)
            {
                out << YAML::Key << "recorder";
                out << YAML::Value << YAML::Flow << t->getRecorder();
                  t->setRecorder(stringval.c_str());
            }
            if(strcmp(t->getPrint(), "") != 0)
            {
                out << YAML::Key << "print";
                out << YAML::Value << YAML::Flow << t->getPrint();
                  t->setPrint(stringval.c_str());
            }
            if(strcmp(t->getLamp(), "") != 0)
            {
                out << YAML::Key << "lamp";
                out << YAML::Value << YAML::Flow << t->getLamp();
                  t->setLamp(stringval.c_str());
            }
            if(strcmp(t->getOutputCamera(), "") != 0)
            {
                out << YAML::Key << "output_camera";
                out << YAML::Value << YAML::Flow << t->getOutputCamera();
                  t->setOutputCamera(stringval.c_str());
            }
            if(strcmp(t->getDisplay(), "") != 0)
            {
                out << YAML::Key << "display";
                out << YAML::Value << YAML::Flow << t->getDisplay();
                  t->setDisplay(stringval.c_str());
            }
            if(strcmp(t->getCubeInput(), "") != 0)
            {
                out << YAML::Key << "cube_input";
                out << YAML::Value << YAML::Flow << t->getCubeInput();
                  t->setCubeInput(stringval.c_str());
            }
            
            EmitBaseTransformKeyValues(out, t);
            
            out << YAML::EndMap;
        }
        
        // Transform
        
        void load(const YAML::Node& node, TransformRcPtr& t)
        {
            if(node.Type() != YAML::NodeType::Map)
            {
                std::ostringstream os;
                os << "Unsupported Transform type encountered: (" << node.Type() << ") in OCIO profile. ";
                os << "Only Mapping types supported.";
                throw Exception(os.str().c_str());
            }
            
            std::string type = node.Tag();
            
            if(type == "AllocationTransform") {
                AllocationTransformRcPtr temp;
                load(node, temp);
                t = temp;
            }
            else if(type == "CDLTransform") {
                CDLTransformRcPtr temp;
                load(node, temp);
                t = temp;
            }
            else if(type == "ColorSpaceTransform")  {
                ColorSpaceTransformRcPtr temp;
                load(node, temp);
                t = temp;
            }
            // TODO: DisplayTransform
            else if(type == "ExponentTransform")  {
                ExponentTransformRcPtr temp;
                load(node, temp);
                t = temp;
            }
            else if(type == "FileTransform")  {
                FileTransformRcPtr temp;
                load(node, temp);
                t = temp;
            }
            else if(type == "GroupTransform") {
                GroupTransformRcPtr temp;
                load(node, temp);
                t = temp;
            }
            else if(type == "LogTransform") {
                LogTransformRcPtr temp;
                load(node, temp);
                t = temp;
            }
            else if(type == "LookTransform") {
                LookTransformRcPtr temp;
                load(node, temp);
                t = temp;
            }
            else if(type == "MatrixTransform")  {
                MatrixTransformRcPtr temp;
                load(node, temp);
                t = temp;
            }
            else if(type == "TruelightTransform")  {
                TruelightTransformRcPtr temp;
                load(node, temp);
                t = temp;
            }
            else
            {
                // TODO: add a new empty (better name?) aka passthru Transform()
                // which does nothing. This is so upsupported !<tag> types don't
                // throw an exception. Alternativly this could be caught in the
                // GroupTransformRcPtr >> operator with some type of
                // supported_tag() method
                
                // TODO: consider the forwards-compatibility implication of
                // throwing an exception.  Should this be a warning, instead?
                
                //  t = EmptyTransformRcPtr(new EmptyTransform(), &deleter);
                std::ostringstream os;
                os << "Unsupported transform type !<" << type << "> in OCIO profile. ";
                throw Exception(os.str().c_str());
            }
        }
    }
    
    YAML::Emitter& operator << (YAML::Emitter& out, ConstTruelightTransformRcPtr t)
    {
        
        void save(YAML::Emitter& out, ConstTransformRcPtr t)
        out << YAML::Flow << YAML::BeginMap;
        if(strcmp(t->getConfigRoot(), "") != 0)
        {
            out << YAML::Key << "config_root";
            out << YAML::Value << YAML::Flow << t->getConfigRoot();
        }
        if(strcmp(t->getProfile(), "") != 0)
        {
            if(ConstAllocationTransformRcPtr Allocation_tran = \
                DynamicPtrCast<const AllocationTransform>(t))
                save(out, Allocation_tran);
            else if(ConstCDLTransformRcPtr CDL_tran = \
                DynamicPtrCast<const CDLTransform>(t))
                save(out, CDL_tran);
            else if(ConstColorSpaceTransformRcPtr ColorSpace_tran = \
                DynamicPtrCast<const ColorSpaceTransform>(t))
                save(out, ColorSpace_tran);
            else if(ConstExponentTransformRcPtr Exponent_tran = \
                DynamicPtrCast<const ExponentTransform>(t))
                save(out, Exponent_tran);
            else if(ConstFileTransformRcPtr File_tran = \
                DynamicPtrCast<const FileTransform>(t))
                save(out, File_tran);
            else if(ConstGroupTransformRcPtr Group_tran = \
                DynamicPtrCast<const GroupTransform>(t))
                save(out, Group_tran);
            else if(ConstLogTransformRcPtr Log_tran = \
                DynamicPtrCast<const LogTransform>(t))
                save(out, Log_tran);
            else if(ConstLookTransformRcPtr Look_tran = \
                DynamicPtrCast<const LookTransform>(t))
                save(out, Look_tran);
            else if(ConstMatrixTransformRcPtr Matrix_tran = \
                DynamicPtrCast<const MatrixTransform>(t))
                save(out, Matrix_tran);
            else if(ConstTruelightTransformRcPtr Truelight_tran = \
                DynamicPtrCast<const TruelightTransform>(t))
                save(out, Truelight_tran);
            else
                throw Exception("Unsupported Transform() type for serialization.");
        }
        
        // ColorSpace
        
        inline void load(const YAML::Node& node, ColorSpaceRcPtr& cs)
        {
            if(node.Tag() != "ColorSpace")
                return; // not a !<ColorSpace> tag
            
            std::string key, stringval;
            bool boolval;
            
            for (Iterator iter = node.begin();
                 iter != node.end();
                 ++iter)
            {
                const YAML::Node& first = get_first(iter);
                const YAML::Node& second = get_second(iter);
                
                load(first, key);
                
                if (second.Type() == YAML::NodeType::Null) continue;
                
                if(key == "name")
                {
                    load(second, stringval);
                    cs->setName(stringval.c_str());
                }
                else if(key == "description")
                {
                    load(second, stringval);
                    cs->setDescription(stringval.c_str());
                }
                else if(key == "family")
                {
                    load(second, stringval);
                    cs->setFamily(stringval.c_str());
                }
                else if(key == "equalitygroup")
                {
                    load(second, stringval);
                    cs->setEqualityGroup(stringval.c_str());
                }
                else if(key == "bitdepth")
                {
                    BitDepth ret;
                    load(second, ret);
                    cs->setBitDepth(ret);
                }
                else if(key == "isdata")
                {
                    load(second, boolval);
                    cs->setIsData(boolval);
                }
                else if(key == "allocation")
                {
                    Allocation val;
                    load(second, val);
                    cs->setAllocation(val);
                }
                else if(key == "allocationvars")
                {
                    std::vector<float> val;
                    load(second, val);
                    if(!val.empty())
                        cs->setAllocationVars(static_cast<int>(val.size()), &val[0]);
                }
                else if(key == "to_reference")
                {
                    TransformRcPtr val;
                    load(second, val);
                    cs->setTransform(val, COLORSPACE_DIR_TO_REFERENCE);
                }
                else if(key == "from_reference")
                {
                    TransformRcPtr val;
                    load(second, val);
                    cs->setTransform(val, COLORSPACE_DIR_FROM_REFERENCE);
                }
                else
                {
                    LogUnknownKeyWarning(node.Tag(), first);
                }
            }
        }
        
        inline void save(YAML::Emitter& out, ConstColorSpaceRcPtr cs)
        {
            out << YAML::VerbatimTag("ColorSpace");
            out << YAML::BeginMap;
            
            out << YAML::Key << "name" << YAML::Value << cs->getName();
            out << YAML::Key << "family" << YAML::Value << cs->getFamily();
            out << YAML::Key << "equalitygroup" << YAML::Value << cs->getEqualityGroup();
            out << YAML::Key << "bitdepth" << YAML::Value;
            save(out, cs->getBitDepth());
            if(cs->getDescription() != NULL && strlen(cs->getDescription()) > 0)
            {
                out << YAML::Key << "description";
                out << YAML::Value << YAML::Literal << cs->getDescription();
            }
            out << YAML::Key << "isdata" << YAML::Value << cs->isData();
            
            out << YAML::Key << "allocation" << YAML::Value;
            save(out, cs->getAllocation());
            if(cs->getAllocationNumVars() > 0)
            {
                std::vector<float> allocationvars(cs->getAllocationNumVars());
                cs->getAllocationVars(&allocationvars[0]);
                out << YAML::Key << "allocationvars";
                out << YAML::Flow << YAML::Value << allocationvars;
            }
            
            ConstTransformRcPtr toref = \
                cs->getTransform(COLORSPACE_DIR_TO_REFERENCE);
            if(toref)
            {
                out << YAML::Key << "to_reference" << YAML::Value;
                save(out, toref);
            }
            
            ConstTransformRcPtr fromref = \
                cs->getTransform(COLORSPACE_DIR_FROM_REFERENCE);
            if(fromref)
            {
                out << YAML::Key << "from_reference" << YAML::Value;
                save(out, fromref);
            }
            
            out << YAML::EndMap;
            out << YAML::Newline;
        }
        
        // Look
        
        inline void load(const YAML::Node& node, LookRcPtr& look)
        {
            if(node.Tag() != "Look")
                return;
            
            std::string key, stringval;
            
            for (Iterator iter = node.begin();
                 iter != node.end();
                 ++iter)
            {
                const YAML::Node& first = get_first(iter);
                const YAML::Node& second = get_second(iter);
                
                load(first, key);
                
                if (second.Type() == YAML::NodeType::Null) continue;
                
                if(key == "name")
                {
                    load(second, stringval);
                    look->setName(stringval.c_str());
                }
                else if(key == "process_space")
                {
                    load(second, stringval);
                    look->setProcessSpace(stringval.c_str());
                }
                else if(key == "transform")
                {
                    TransformRcPtr val;
                    load(second, val);
                    look->setTransform(val);
                }
                else if(key == "inverse_transform")
                {
                    TransformRcPtr val;
                    load(second, val);
                    look->setInverseTransform(val);
                }
                else
                {
                    LogUnknownKeyWarning(node.Tag(), first);
                }
            }
        }
        
        inline void save(YAML::Emitter& out, ConstLookRcPtr look)
        {
            out << YAML::VerbatimTag("Look");
            out << YAML::BeginMap;
            out << YAML::Key << "name" << YAML::Value << look->getName();
            out << YAML::Key << "process_space" << YAML::Value << look->getProcessSpace();
            
            if(look->getTransform())
            {
                out << YAML::Key << "transform";
                out << YAML::Value;
                save(out, look->getTransform());
            }
            
            if(look->getInverseTransform())
            {
                out << YAML::Key << "inverse_transform";
                out << YAML::Value;
                save(out, look->getInverseTransform());
            }
            
            out << YAML::EndMap;
            out << YAML::Newline;
        }
        
        // Config
        
        inline void load(const YAML::Node& node, ConfigRcPtr& c, const char* filename)
        {
            
            // check profile version
            int profile_version = 0;
#ifdef OLDYAML
            if(node.FindValue("ocio_profile_version") == NULL)
#else
            if(node["ocio_profile_version"] == NULL)
#endif
            {
                std::ostringstream os;
                os << "The specified file ";
                os << "does not appear to be an OCIO configuration.";
                throw Exception (os.str().c_str());
            }
            
            load(node["ocio_profile_version"], profile_version);
            if(profile_version > 1)
            {
                std::ostringstream os;
                os << "This .ocio config ";
                if(filename && *filename)
                {
                    os << " '" << filename << "' ";
                }
                os << "is version " << profile_version << ". ";
                os << "This version of the OpenColorIO library (" << OCIO_VERSION ") ";
                os << "is not known to be able to load this profile. ";
                os << "An attempt will be made, but there are no guarantees that the ";
                os << "results will be accurate. Continue at your own risk.";
                LogWarning(os.str());
            }
            
            std::string key, stringval;
            bool boolval = false;
            EnvironmentMode mode = ENV_ENVIRONMENT_LOAD_ALL;
            
            for (Iterator iter = node.begin();
                 iter != node.end();
                 ++iter)
            {
                const YAML::Node& first = get_first(iter);
                const YAML::Node& second = get_second(iter);
                
                load(first, key);
                
                if (second.Type() == YAML::NodeType::Null) continue;
                
                if(key == "ocio_profile_version") { } // Already handled above.
                else if(key == "environment")
                {
                    mode = ENV_ENVIRONMENT_LOAD_PREDEFINED;
                    if(second.Type() != YAML::NodeType::Map)
                    {
                        std::ostringstream os;
                        os << "'environment' field needs to be a (name: key) map.";
                        throw Exception(os.str().c_str());
                    }
                    for (Iterator it = second.begin();
                         it != second.end();
                         ++it)
                    {
                        std::string k, v;
                        load(get_first(it), k);
                        load(get_second(it), v);
                        c->addEnvironmentVar(k.c_str(), v.c_str());
                    }
                }
                else if(key == "search_path" || key == "resource_path")
                {
                    load(second, stringval);
                    c->setSearchPath(stringval.c_str());
                }
                else if(key == "strictparsing")
                {
                    load(second, boolval);
                    c->setStrictParsingEnabled(boolval);
                }
                else if(key == "description")
                {
                    load(second, stringval);
                    c->setDescription(stringval.c_str());
                }
                else if(key == "luma")
                {
                    std::vector<float> val;
                    load(second, val);
                    if(val.size() != 3)
                    {
                        std::ostringstream os;
                        os << "'luma' field must be 3 ";
                        os << "floats. Found '" << val.size() << "'.";
                        throw Exception(os.str().c_str());
                    }
                    c->setDefaultLumaCoefs(&val[0]);
                }
                else if(key == "roles")
                {
                    if(second.Type() != YAML::NodeType::Map)
                    {
                        std::ostringstream os;
                        os << "'roles' field needs to be a (name: key) map.";
                        throw Exception(os.str().c_str());
                    }
                    for (Iterator it = second.begin();
                         it != second.end();
                         ++it)
                    {
                        std::string k, v;
                        load(get_first(it), k);
                        load(get_second(it), v);
                        c->setRole(k.c_str(), v.c_str());
                    }
                }
                else if(key == "displays")
                {
                    if(second.Type() != YAML::NodeType::Map)
                    {
                        std::ostringstream os;
                        os << "'displays' field needs to be a (name: key) map.";
                        throw Exception(os.str().c_str());
                    }
                    for (Iterator it = second.begin();
                         it != second.end();
                         ++it)
                    {
                        std::string display;
                        load(get_first(it), display);
                        const YAML::Node& dsecond = get_second(it);
                        for(unsigned i = 0; i < dsecond.size(); ++i)
                        {
                            View view;
                            load(dsecond[i], view);
                            c->addDisplay(display.c_str(), view.name.c_str(),
                                          view.colorspace.c_str(), view.looks.c_str());
                        }
                    }
                }
                else if(key == "active_displays")
                {
                    std::vector<std::string> display;
                    load(second, display);
                    std::string displays = JoinStringEnvStyle(display);
                    c->setActiveDisplays(displays.c_str());
                }
                else if(key == "active_views")
                {
                    std::vector<std::string> view;
                    load(second, view);
                    std::string views = JoinStringEnvStyle(view);
                    c->setActiveViews(views.c_str());
                }
                else if(key == "colorspaces")
                {
                    if(second.Type() != YAML::NodeType::Sequence)
                    {
                        std::ostringstream os;
                        os << "'colorspaces' field needs to be a (- !<ColorSpace>) list.";
                        throw Exception(os.str().c_str());
                    }
                    for(unsigned i = 0; i < second.size(); ++i)
                    {
                        if(second[i].Tag() == "ColorSpace")
                        {
                            ColorSpaceRcPtr cs = ColorSpace::Create();
                            load(second[i], cs);
                            for(int ii = 0; ii < c->getNumColorSpaces(); ++ii)
                            {
                                if(strcmp(c->getColorSpaceNameByIndex(ii), cs->getName()) == 0)
                                {
                                    std::ostringstream os;
                                    os << "Colorspace with name '" << cs->getName() << "' already defined.";
                                    throw Exception(os.str().c_str());
                                }
                            }
                            c->addColorSpace(cs);
                        }
                        else
                        {
                            std::ostringstream os;
                            os << "Unknown element found in colorspaces:";
                            os << second[i].Tag() << ". Only ColorSpace(s)";
                            os << " currently handled.";
                            LogWarning(os.str());
                        }
                    }
                }
                else if(key == "looks")
                {
                    if(second.Type() != YAML::NodeType::Sequence)
                    {
                        std::ostringstream os;
                        os << "'looks' field needs to be a (- !<Look>) list.";
                        throw Exception(os.str().c_str());
                    }
                    
                    for(unsigned i = 0; i < second.size(); ++i)
                    {
                        if(second[i].Tag() == "Look")
                        {
                            LookRcPtr look = Look::Create();
                            load(second[i], look);
                            c->addLook(look);
                        }
                        else
                        {
                            std::ostringstream os;
                            os << "Unknown element found in looks:";
                            os << second[i].Tag() << ". Only Look(s)";
                            os << " currently handled.";
                            LogWarning(os.str());
                        }
                    }
                }
                else
                {
                    LogUnknownKeyWarning("profile", first);
                }
            }
            
            if(filename)
            {
                std::string realfilename = pystring::os::path::abspath(filename);
                std::string configrootdir = pystring::os::path::dirname(realfilename);
                c->setWorkingDir(configrootdir.c_str());
            }
            
            c->setEnvironmentMode(mode);
            c->loadEnvironment();
            
            if(mode == ENV_ENVIRONMENT_LOAD_ALL)
            {
                std::ostringstream os;
                os << "This .ocio config ";
                if(filename && *filename)
                {
                    os << " '" << filename << "' ";
                }
                os << "has no environment section defined. The default behaviour is to ";
                os << "load all environment variables (" << c->getNumEnvironmentVars() << ")";
                os << ", which reduces the efficiency of OCIO's caching. Considering ";
                os << "predefining the environment variables used.";
                LogDebug(os.str());
            }
            
        }
        
        inline void save(YAML::Emitter& out, const Config* c)
        {
            out << YAML::Block;
            out << YAML::BeginMap;
            out << YAML::Key << "ocio_profile_version" << YAML::Value << 1;
            out << YAML::Newline;
#ifndef OLDYAML
            out << YAML::Newline;
#endif
            
            if(c->getNumEnvironmentVars() > 0)
            {
                out << YAML::Key << "environment";
                out << YAML::Value << YAML::BeginMap;
                for(unsigned i = 0; i < c->getNumEnvironmentVars(); ++i)
                {   
                    const char* name = c->getEnvironmentVarNameByIndex(i);
                    out << YAML::Key << name;
                    out << YAML::Value << c->getEnvironmentVarDefault(name);
                }
                out << YAML::EndMap;
                out << YAML::Newline;
            }
            out << YAML::Key << "search_path" << YAML::Value << c->getSearchPath();
            out << YAML::Key << "strictparsing" << YAML::Value << c->isStrictParsingEnabled();
            
            std::vector<float> luma(3, 0.f);
            c->getDefaultLumaCoefs(&luma[0]);
            out << YAML::Key << "luma" << YAML::Value << YAML::Flow << luma;
            
            if(c->getDescription() != NULL && strlen(c->getDescription()) > 0)
            {
                out << YAML::Newline;
                out << YAML::Key << "description";
                out << YAML::Value << c->getDescription();
                out << YAML::Newline;
            }
            
            // Roles
            out << YAML::Newline;
#ifndef OLDYAML
            out << YAML::Newline;
#endif
            out << YAML::Key << "roles";
            out << YAML::Value << YAML::BeginMap;
            for(unsigned i = 0; i < c->getNumRoles(); ++i)
            {
                const char* role = c->getRoleName(i);
                out << YAML::Key << role;
                out << YAML::Value << c->getColorSpace(role)->getName();
            }
            out << YAML::EndMap;
#ifndef OLDYAML
            out << YAML::Newline;
#endif
            
            // Displays
            out << YAML::Newline;
            out << YAML::Key << "displays";
            out << YAML::Value << YAML::BeginMap;
            for(unsigned i = 0; i < c->getNumDisplays(); ++i)
            {
                const char* display = c->getDisplay(i);
                out << YAML::Key << display;
                out << YAML::Value << YAML::BeginSeq;
                for(unsigned v = 0; v < c->getNumViews(display); ++v)
                {
                    View dview;
                    dview.name = c->getView(display, v);
                    dview.colorspace = c->getDisplayColorSpaceName(display, dview.name.c_str());
                    if(c->getDisplayLooks(display, dview.name.c_str()) != NULL)
                        dview.looks = c->getDisplayLooks(display, dview.name.c_str());
                    save(out, dview);
                
                }
                out << YAML::EndSeq;
            }
            out << YAML::EndMap;
            
#ifndef OLDYAML
            out << YAML::Newline;
#endif
            out << YAML::Newline;
            out << YAML::Key << "active_displays";
            std::vector<std::string> active_displays;
            if(c->getActiveDisplays() != NULL && strlen(c->getActiveDisplays()) > 0)
                SplitStringEnvStyle(active_displays, c->getActiveDisplays());
            out << YAML::Value << YAML::Flow << active_displays;
            out << YAML::Key << "active_views";
            std::vector<std::string> active_views;
            if(c->getActiveViews() != NULL && strlen(c->getActiveViews()) > 0)
                SplitStringEnvStyle(active_views, c->getActiveViews());
            out << YAML::Value << YAML::Flow << active_views;
#ifndef OLDYAML
            out << YAML::Newline;
#endif
            
            // Looks
            if(c->getNumLooks() > 0)
            {
                out << YAML::Newline;
                out << YAML::Key << "looks";
                out << YAML::Value << YAML::BeginSeq;
                for(unsigned i = 0; i < c->getNumLooks(); ++i)
                {
                    const char* name = c->getLookNameByIndex(i);
                    save(out, c->getLook(name));
                }
                out << YAML::EndSeq;
                out << YAML::Newline;
            }
            
            // ColorSpaces
            {
                out << YAML::Newline;
                out << YAML::Key << "colorspaces";
                out << YAML::Value << YAML::BeginSeq;
                for(unsigned i = 0; i < c->getNumColorSpaces(); ++i)
                {
                    const char* name = c->getColorSpaceNameByIndex(i);
                    save(out, c->getColorSpace(name));
                }
                out << YAML::EndSeq;
            }
            
            out << YAML::EndMap;
        }
        
        EmitBaseTransformKeyValues(out, t);
        
        out << YAML::EndMap;
        return out;
    }
    
    ///////////////////////////////////////////////////////////////////////////
    //  Enums
    
    YAML::Emitter& operator << (YAML::Emitter& out, BitDepth depth) {
        out << BitDepthToString(depth);
        return out;
    }
    
    void operator >> (const YAML::Node& node, BitDepth& depth) {
        std::string str;
        node.Read<std::string>(str);
        depth = BitDepthFromString(str.c_str());
    }
    
    YAML::Emitter& operator << (YAML::Emitter& out, Allocation alloc) {
        out << AllocationToString(alloc);
        return out;
    }
    
    void operator >> (const YAML::Node& node, Allocation& alloc) {
        std::string str;
        node.Read<std::string>(str);
        alloc = AllocationFromString(str.c_str());
    }
    
    YAML::Emitter& operator << (YAML::Emitter& out, ColorSpaceDirection dir) {
        out << ColorSpaceDirectionToString(dir);
        return out;
    }
    
    void OCIOYaml::open(std::istream& istream, ConfigRcPtr& c, const char* filename) const
    {
        try
        {
#ifdef OLDYAML
            YAML::Parser parser(istream);
            YAML::Node node;
            parser.GetNextDocument(node);
#else
            YAML::Node node = YAML::Load(istream);
#endif
            load(node, c, filename);
        }
        catch(const std::exception & e)
        {
            std::ostringstream os;
            os << "Error: Loading the OCIO profile ";
            if(filename) os << "'" << filename << "' ";
            os << "failed. " << e.what();
            throw Exception(os.str().c_str());
        }
    }
    
    void OCIOYaml::write(std::ostream& ostream, const Config* c) const
    {
        YAML::Emitter out;
        save(out, c);
        ostream << out.c_str();
    }
    
}





#include <OpenColorIO/OpenColorIO.h>

#include "Platform.h"

#ifndef WINDOWS

// fwd declare yaml-cpp visibility
#pragma GCC visibility push(hidden)
namespace YAML {
    class Exception;
    class BadDereference;
    class RepresentationException;
    class EmitterException;
    class ParserException;
    class InvalidScalar;
    class KeyNotFound;
    template <typename T> class TypedKeyNotFound;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::ColorSpace>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::Config>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::Exception>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::GpuShaderDesc>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::ImageDesc>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::Look>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::Processor>;
    
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::Transform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::AllocationTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::CDLTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::ColorSpaceTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::DisplayTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::ExponentTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::FileTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::GroupTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::LogTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::LookTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::MatrixTransform>;
    template <> class TypedKeyNotFound<OCIO_NAMESPACE::TruelightTransform>;
}
#pragma GCC visibility pop

#endif 

#include <yaml-cpp/yaml.h>

#ifndef INCLUDED_OCIO_YAML_H
#define INCLUDED_OCIO_YAML_H

OCIO_NAMESPACE_ENTER
{
    
    class OCIOYaml
    {
    public:
        void open(std::istream& istream, ConfigRcPtr& c, const char* filename = NULL) const;
        void write(std::ostream& ostream, const Config* c) const;
    };
    OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstTransformRcPtr t);
    OCIOHIDDEN void operator >> (const YAML::Node& node, LookRcPtr& cs);
    OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, LookRcPtr cs);
    
    // Transforms
    OCIOHIDDEN void operator >> (const YAML::Node& node, AllocationTransformRcPtr& t);
    OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstAllocationTransformRcPtr t);
    OCIOHIDDEN void operator >> (const YAML::Node& node, CDLTransformRcPtr& t);
    OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstCDLTransformRcPtr t);
    OCIOHIDDEN void operator >> (const YAML::Node& node, ColorSpaceTransformRcPtr& t);
    OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstColorSpaceTransformRcPtr t);
    OCIOHIDDEN void operator >> (const YAML::Node& node, ExponentTransformRcPtr& t);
    OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstExponentTransformRcPtr t);
    OCIOHIDDEN void operator >> (const YAML::Node& node, FileTransformRcPtr& t);
    OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstFileTransformRcPtr t);
    OCIOHIDDEN void operator >> (const YAML::Node& node, LogTransformRcPtr& t);
    OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstLogTransformRcPtr t);
    OCIOHIDDEN void operator >> (const YAML::Node& node, LookTransformRcPtr& t);
    OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstLookTransformRcPtr t);
    OCIOHIDDEN void operator >> (const YAML::Node& node, MatrixTransformRcPtr& t);
    OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstMatrixTransformRcPtr t);
    OCIOHIDDEN void operator >> (const YAML::Node& node, TruelightTransformRcPtr& t);
    OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstTruelightTransformRcPtr t);
    
    // Enums
    OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, BitDepth depth);
    OCIOHIDDEN void operator >> (const YAML::Node& node, BitDepth& depth);
    OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, Allocation alloc);
    OCIOHIDDEN void operator >> (const YAML::Node& node, Allocation& alloc);
    OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ColorSpaceDirection dir);
    OCIOHIDDEN void operator >> (const YAML::Node& node, ColorSpaceDirection& dir);
    OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, TransformDirection dir);
    OCIOHIDDEN void operator >> (const YAML::Node& node, TransformDirection& dir);
    OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, Interpolation iterp);
    OCIOHIDDEN void operator >> (const YAML::Node& node, Interpolation& iterp);
    
    void LogUnknownKeyWarning(const std::string & name, const YAML::Node& tag);
}
OCIO_NAMESPACE_EXIT


Lines 359-364 OCIO_NAMESPACE_ENTER Link Here

(-)a/src/core/ParseUtils.cpp (+4 lines)
359	while ( istream.good() )	359	while ( istream.good() )
360	{	360	{
361	std::getline(istream, line);	361	std::getline(istream, line);
		362	if(line.size() > 0 && line[line.size() - 1] == '\r')
		363	{
		364	line.resize(line.size() - 1);
		365	}
362	if(!pystring::strip(line).empty())	366	if(!pystring::strip(line).empty())
363	{	367	{
364	return true;	368	return true;

Lines 48-53 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Link Here

(-)a/src/core/PathUtils.cpp (+1 lines)
48		48
49	#if defined(__APPLE__) && !defined(__IPHONE__)	49	#if defined(__APPLE__) && !defined(__IPHONE__)
50	#include <crt_externs.h> // _NSGetEnviron()	50	#include <crt_externs.h> // _NSGetEnviron()
		51	#include <unistd.h>
51	#elif !defined(WINDOWS)	52	#elif !defined(WINDOWS)
52	#include <unistd.h>	53	#include <unistd.h>
53	extern char **environ;	54	extern char **environ;

Lines 95-101 if(OCIO_PYGLUE_SONAME) Link Here

(-)a/src/pyglue/CMakeLists.txt (-1 / +2 lines)
95	endif()	95	endif()
96		96
97	if(APPLE)	97	if(APPLE)
98	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -undefined dynamic_lookup")	98	set_target_properties(PyOpenColorIO PROPERTIES
		99	LINK_FLAGS "-undefined dynamic_lookup")
99	endif()	100	endif()
100		101
101	add_subdirectory(tests)	102	add_subdirectory(tests)

Lines 150-156 OCIO_NAMESPACE_ENTER Link Here

(-)a/src/pyglue/PyMain.cpp (-1 lines)
150	}	150	}
151	OCIO_NAMESPACE_EXIT	151	OCIO_NAMESPACE_EXIT
152		152
153	extern "C"
154	MOD_INIT(PyOpenColorIO)	153	MOD_INIT(PyOpenColorIO)
155	{	154	{
156	PyObject * m;	155	PyObject * m;

Return to bug 536078

Lines 411-423 OCIO_NAMESPACE_ENTER Link Here

(-)a/src/core/NoOps.cpp (-2 / +2 lines)
411		411
412	OpRcPtr LookNoOp::clone() const	412	OpRcPtr LookNoOp::clone() const
413	{	413	{
414	OpRcPtr op = OpRcPtr(new FileNoOp(m_look));	414	OpRcPtr op = OpRcPtr(new LookNoOp(m_look));
415	return op;	415	return op;
416	}	416	}
417		417
418	bool LookNoOp::isSameType(const OpRcPtr & op) const	418	bool LookNoOp::isSameType(const OpRcPtr & op) const
419	{	419	{
420	FileNoOpRcPtr typedRcPtr = DynamicPtrCast<FileNoOp>(op);	420	LookNoOpRcPtr typedRcPtr = DynamicPtrCast<LookNoOp>(op);
421	if(!typedRcPtr) return false;	421	if(!typedRcPtr) return false;
422	return true;	422	return true;
423	}	423	}

Line 0 Link Here

(-)a/src/core/Config.cpp (-485 / +35 lines)
		1	diff -Naur yaml-cpp-0.5.1.orig/CMakeLists.txt yaml-cpp-0.5.1/CMakeLists.txt
		2	--- yaml-cpp-0.5.1.orig/CMakeLists.txt 2014-01-30 09:45:54.000000000 +0000
Lines 40-45 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Link Here
40	#include "HashUtils.h"	40	#include "HashUtils.h"
41	#include "Logging.h"	41	#include "Logging.h"
42	#include "LookParse.h"	42	#include "LookParse.h"
		43	#include "Display.h"
43	#include "MathUtils.h"	44	#include "MathUtils.h"
44	#include "Mutex.h"	45	#include "Mutex.h"
45	#include "OpBuilders.h"	46	#include "OpBuilders.h"
Lines 208-214 OCIO_NAMESPACE_ENTER Link Here
208	if(csname.empty()) return false;	209	if(csname.empty()) return false;
209		210
210	std::string csnamelower = pystring::lower(csname);	211	std::string csnamelower = pystring::lower(csname);
211
212	for(unsigned int i = 0; i < colorspaces.size(); ++i)	212	for(unsigned int i = 0; i < colorspaces.size(); ++i)
213	{	213	{
214	if(csnamelower == pystring::lower(colorspaces[i]->getName()))	214	if(csnamelower == pystring::lower(colorspaces[i]->getName()))
Lines 220-403 OCIO_NAMESPACE_ENTER Link Here
220		220
221	return false;	221	return false;
222	}	222	}
223
224
225	// Displays
226	struct View
227	{
228	std::string name;
229	std::string colorspace;
230	std::string looks;
231
232	View() { }
233
234	View(const std::string & name_,
235	const std::string & colorspace_,
236	const std::string & looksList_) :
237	name(name_),
238	colorspace(colorspace_),
239	looks(looksList_)
240	{ }
241	};
242
243	typedef std::vector<View> ViewVec;
244	typedef std::map<std::string, ViewVec> DisplayMap; // (display name : ViewVec)
245
246	void operator >> (const YAML::Node& node, View& v)
247	{
248	if(node.Tag() != "View")
249	return;
250
251	std::string key, stringval;
252
253	for (YAML::Iterator iter = node.begin();
254	iter != node.end();
255	++iter)
256	{
257	iter.first() >> key;
258
259	if(key == "name")
260	{
261	if (iter.second().Type() != YAML::NodeType::Null &&
262	iter.second().Read<std::string>(stringval))
263	v.name = stringval;
264	}
265	else if(key == "colorspace")
266	{
267	if (iter.second().Type() != YAML::NodeType::Null &&
268	iter.second().Read<std::string>(stringval))
269	v.colorspace = stringval;
270	}
271	else if(key == "looks" \|\| key == "look")
272	{
273	if (iter.second().Type() != YAML::NodeType::Null &&
274	iter.second().Read<std::string>(stringval))
275	v.looks = stringval;
276	}
277	else
278	{
279	LogUnknownKeyWarning(node.Tag(), iter.first());
280	}
281	}
282
283	if(v.name.empty())
284	{
285	throw Exception("View does not specify 'name'.");
286	}
287	if(v.colorspace.empty())
288	{
289	std::ostringstream os;
290	os << "View '" << v.name << "' ";
291	os << "does not specify colorspace.";
292	throw Exception(os.str().c_str());
293	}
294	}
295
296	YAML::Emitter& operator << (YAML::Emitter& out, View view)
297	{
298	out << YAML::VerbatimTag("View");
299	out << YAML::Flow;
300	out << YAML::BeginMap;
301	out << YAML::Key << "name" << YAML::Value << view.name;
302	out << YAML::Key << "colorspace" << YAML::Value << view.colorspace;
303	if(!view.looks.empty()) out << YAML::Key << "looks" << YAML::Value << view.looks;
304	out << YAML::EndMap;
305	return out;
306	}
307
308	DisplayMap::iterator find_display(DisplayMap & displays, const std::string & display)
309	{
310	for(DisplayMap::iterator iter = displays.begin();
311	iter != displays.end();
312	++iter)
313	{
314	if(StrEqualsCaseIgnore(display, iter->first)) return iter;
315	}
316	return displays.end();
317	}
318
319	DisplayMap::const_iterator find_display_const(const DisplayMap & displays, const std::string & display)
320	{
321	for(DisplayMap::const_iterator iter = displays.begin();
322	iter != displays.end();
323	++iter)
324	{
325	if(StrEqualsCaseIgnore(display, iter->first)) return iter;
326	}
327	return displays.end();
328	}
329
330	int find_view(const ViewVec & vec, const std::string & name)
331	{
332	for(unsigned int i=0; i<vec.size(); ++i)
333	{
334	if(StrEqualsCaseIgnore(name, vec[i].name)) return i;
335	}
336	return -1;
337	}
338
339	void AddDisplay(DisplayMap & displays,
340	const std::string & display,
341	const std::string & view,
342	const std::string & colorspace,
343	const std::string & looks)
344	{
345	DisplayMap::iterator iter = find_display(displays, display);
346	if(iter == displays.end())
347	{
348	ViewVec views;
349	views.push_back( View(view, colorspace, looks) );
350	displays[display] = views;
351	}
352	else
353	{
354	ViewVec & views = iter->second;
355	int index = find_view(views, view);
356	if(index<0)
357	{
358	views.push_back( View(view, colorspace, looks) );
359	}
360	else
361	{
362	views[index].colorspace = colorspace;
363	views[index].looks = looks;
364	}
365	}
366	}
367
368	void ComputeDisplays(StringVec & displayCache,
369	const DisplayMap & displays,
370	const StringVec & activeDisplays,
371	const StringVec & activeDisplaysEnvOverride)
372	{
373	displayCache.clear();
374		223
375	StringVec displayMasterList;
376	for(DisplayMap::const_iterator iter = displays.begin();
377	iter != displays.end();
378	++iter)
379	{
380	displayMasterList.push_back(iter->first);
381	}
382
383	// Apply the env override if it's not empty.
384	if(!activeDisplaysEnvOverride.empty())
385	{
386	displayCache = IntersectStringVecsCaseIgnore(displayMasterList, activeDisplaysEnvOverride);
387	if(!displayCache.empty()) return;
388	}
389	// Otherwise, aApply the active displays if it's not empty.
390	else if(!activeDisplays.empty())
391	{
392	displayCache = IntersectStringVecsCaseIgnore(displayMasterList, activeDisplays);
393	if(!displayCache.empty()) return;
394	}
395
396	displayCache = displayMasterList;
397	}
398
399
400
401	} // namespace	224	} // namespace
402		225
403	class Config::Impl	226	class Config::Impl
Lines 431-436 OCIO_NAMESPACE_ENTER Link Here
431	mutable StringMap cacheids_;	254	mutable StringMap cacheids_;
432	mutable std::string cacheidnocontext_;	255	mutable std::string cacheidnocontext_;
433		256
		257	OCIOYaml io_;
		258
434	Impl() :	259	Impl() :
435	context_(Context::Create()),	260	context_(Context::Create()),
436	strictParsing_(true),	261	strictParsing_(true),
Lines 497-504 OCIO_NAMESPACE_ENTER Link Here
497	return *this;	322	return *this;
498	}	323	}
499		324
500	void load(std::istream & istream, const char * name);
501
502	// Any time you modify the state of the config, you must call this	325	// Any time you modify the state of the config, you must call this
503	// to reset internal cache states. You also should do this in a	326	// to reset internal cache states. You also should do this in a
504	// thread safe manner by acquiring the cacheidMutex_;	327	// thread safe manner by acquiring the cacheidMutex_;
Lines 536-542 OCIO_NAMESPACE_ENTER Link Here
536	istream.str(INTERNAL_RAW_PROFILE);	359	istream.str(INTERNAL_RAW_PROFILE);
537		360
538	ConfigRcPtr config = Config::Create();	361	ConfigRcPtr config = Config::Create();
539	config->getImpl()->load(istream, "");	362	config->getImpl()->io_.open(istream, config);
540	return config;	363	return config;
541	}	364	}
542		365
Lines 551-564 OCIO_NAMESPACE_ENTER Link Here
551	}	374	}
552		375
553	ConfigRcPtr config = Config::Create();	376	ConfigRcPtr config = Config::Create();
554	config->getImpl()->load(istream, filename);	377	config->getImpl()->io_.open(istream, config, filename);
555	return config;	378	return config;
556	}	379	}
557		380
558	ConstConfigRcPtr Config::CreateFromStream(std::istream & istream)	381	ConstConfigRcPtr Config::CreateFromStream(std::istream & istream)
559	{	382	{
560	ConfigRcPtr config = Config::Create();	383	ConfigRcPtr config = Config::Create();
561	config->getImpl()->load(istream, "");	384	config->getImpl()->io_.open(istream, config);
562	return config;	385	return config;
563	}	386	}
564		387
Lines 893-898 OCIO_NAMESPACE_ENTER Link Here
893	getImpl()->resetCacheIDs();	716	getImpl()->resetCacheIDs();
894	}	717	}
895		718
		719	void Config::setEnvironmentMode(EnvironmentMode mode)
		720	{
		721	getImpl()->context_->setEnvironmentMode(mode);
		722
		723	AutoMutex lock(getImpl()->cacheidMutex_);
		724	getImpl()->resetCacheIDs();
		725	}
		726
		727	EnvironmentMode Config::getEnvironmentMode() const
		728	{
		729	return getImpl()->context_->getEnvironmentMode();
		730	}
		731
		732	void Config::loadEnvironment()
		733	{
		734	getImpl()->context_->loadEnvironment();
		735
		736	AutoMutex lock(getImpl()->cacheidMutex_);
		737	getImpl()->resetCacheIDs();
		738	}
		739
896	const char * Config::getSearchPath() const	740	const char * Config::getSearchPath() const
897	{	741	{
898	return getImpl()->context_->getSearchPath();	742	return getImpl()->context_->getSearchPath();
Lines 1647-1706 OCIO_NAMESPACE_ENTER Link Here
1647	{	1491	{
1648	try	1492	try
1649	{	1493	{
1650	YAML::Emitter out;	1494	getImpl()->io_.write(os, this);
1651	out << YAML::Block;
1652	out << YAML::BeginMap;
1653	out << YAML::Key << "ocio_profile_version" << YAML::Value << 1;
1654	out << YAML::Newline;
1655	if(getImpl()->env_.size() > 0) {
1656	out << YAML::Key << "environment";
1657	out << YAML::Value << getImpl()->env_;
1658	out << YAML::Newline;
1659	}
1660	out << YAML::Key << "search_path" << YAML::Value << getImpl()->context_->getSearchPath();
1661	out << YAML::Key << "strictparsing" << YAML::Value << getImpl()->strictParsing_;
1662	out << YAML::Key << "luma" << YAML::Value << YAML::Flow << getImpl()->defaultLumaCoefs_;
1663
1664	if(getImpl()->description_ != "")
1665	{
1666	out << YAML::Newline;
1667	out << YAML::Key << "description";
1668	out << YAML::Value << getImpl()->description_;
1669	}
1670
1671	// Roles
1672	out << YAML::Newline;
1673	out << YAML::Key << "roles";
1674	out << YAML::Value << getImpl()->roles_;
1675
1676	// Displays
1677	out << YAML::Newline;
1678	out << YAML::Key << "displays";
1679	out << YAML::Value << getImpl()->displays_;
1680	out << YAML::Newline;
1681	out << YAML::Key << "active_displays";
1682	out << YAML::Value << YAML::Flow << getImpl()->activeDisplays_;
1683	out << YAML::Key << "active_views";
1684	out << YAML::Value << YAML::Flow << getImpl()->activeViews_;
1685
1686	// Looks
1687	if(!getImpl()->looksList_.empty())
1688	{
1689	out << YAML::Newline;
1690	out << YAML::Key << "looks";
1691	out << YAML::Value << getImpl()->looksList_;
1692	}
1693
1694	// ColorSpaces
1695	{
1696	out << YAML::Newline;
1697	out << YAML::Key << "colorspaces";
1698	out << YAML::Value << getImpl()->colorspaces_;
1699	}
1700
1701	out << YAML::EndMap;
1702
1703	os << out.c_str();
1704	}	1495	}
1705	catch( const std::exception & e)	1496	catch( const std::exception & e)
1706	{	1497	{
Lines 1710-1955 OCIO_NAMESPACE_ENTER Link Here
1710	}	1501	}
1711	}	1502	}
1712		1503
1713	void Config::Impl::load(std::istream & istream, const char * filename)
1714	{
1715	try
1716	{
1717	YAML::Parser parser(istream);
1718	YAML::Node node;
1719	parser.GetNextDocument(node);
1720
1721	// check profile version
1722	int profile_version = 0;
1723	if(node.FindValue("ocio_profile_version") == NULL)
1724	{
1725	std::ostringstream os;
1726	os << "The specified file ";
1727	os << "does not appear to be an OCIO configuration.";
1728	throw Exception (os.str().c_str());
1729	}
1730
1731	node["ocio_profile_version"] >> profile_version;
1732	if(profile_version > 1)
1733	{
1734	std::ostringstream os;
1735	os << "This .ocio config ";
1736	if(filename && *filename)
1737	{
1738	os << " '" << filename << "' ";
1739	}
1740	os << "is version " << profile_version << ". ";
1741	os << "This version of the OpenColorIO library (" << OCIO_VERSION ") ";
1742	os << "is not known to be able to load this profile. ";
1743	os << "An attempt will be made, but there are no guarantees that the ";
1744	os << "results will be accurate. Continue at your own risk.";
1745	LogWarning(os.str());
1746	}
1747
1748
1749	std::string key, stringval;
1750	bool boolval = false;
1751	EnvironmentMode mode = ENV_ENVIRONMENT_LOAD_ALL;
1752
1753	for (YAML::Iterator iter = node.begin();
1754	iter != node.end();
1755	++iter)
1756	{
1757	iter.first() >> key;
1758
1759	if(key == "ocio_profile_version") { } // Already handled above.
1760	else if(key == "environment")
1761	{
1762	mode = ENV_ENVIRONMENT_LOAD_PREDEFINED;
1763	const YAML::Node& environment = iter.second();
1764	if(environment.Type() != YAML::NodeType::Map)
1765	{
1766	std::ostringstream os;
1767	os << "'environment' field needs to be a (name: key) map.";
1768	throw Exception(os.str().c_str());
1769	}
1770	for (YAML::Iterator it = environment.begin();
1771	it != environment.end(); ++it)
1772	{
1773	std::string k, v;
1774	it.first() >> k;
1775	it.second() >> v;
1776	env_[k] = v;
1777	context_->setStringVar(k.c_str(), v.c_str());
1778	}
1779	}
1780	else if(key == "search_path" \|\| key == "resource_path")
1781	{
1782	if (iter.second().Type() != YAML::NodeType::Null &&
1783	iter.second().Read<std::string>(stringval))
1784	context_->setSearchPath(stringval.c_str());
1785	}
1786	else if(key == "strictparsing")
1787	{
1788	if (iter.second().Type() != YAML::NodeType::Null &&
1789	iter.second().Read<bool>(boolval))
1790	strictParsing_ = boolval;
1791	}
1792	else if(key == "description")
1793	{
1794	if (iter.second().Type() != YAML::NodeType::Null &&
1795	iter.second().Read<std::string>(stringval))
1796	description_ = stringval;
1797	}
1798	else if(key == "luma")
1799	{
1800	std::vector<float> val;
1801	if (iter.second().Type() != YAML::NodeType::Null)
1802	{
1803	iter.second() >> val;
1804	if(val.size() != 3)
1805	{
1806	std::ostringstream os;
1807	os << "'luma' field must be 3 ";
1808	os << "floats. Found '" << val.size() << "'.";
1809	throw Exception(os.str().c_str());
1810	}
1811	defaultLumaCoefs_ = val;
1812	}
1813	}
1814	else if(key == "roles")
1815	{
1816	const YAML::Node& roles = iter.second();
1817	if(roles.Type() != YAML::NodeType::Map)
1818	{
1819	std::ostringstream os;
1820	os << "'roles' field needs to be a (name: key) map.";
1821	throw Exception(os.str().c_str());
1822	}
1823	for (YAML::Iterator it = roles.begin();
1824	it != roles.end(); ++it)
1825	{
1826	std::string k, v;
1827	it.first() >> k;
1828	it.second() >> v;
1829	roles_[pystring::lower(k)] = v;
1830	}
1831	}
1832	else if(key == "displays")
1833	{
1834	if (iter.second().Type() != YAML::NodeType::Null)
1835	{
1836	iter.second() >> displays_;
1837	}
1838	}
1839	else if(key == "active_displays")
1840	{
1841	if (iter.second().Type() != YAML::NodeType::Null)
1842	{
1843	iter.second() >> activeDisplays_;
1844	}
1845	}
1846	else if(key == "active_views")
1847	{
1848	if (iter.second().Type() != YAML::NodeType::Null)
1849	{
1850	iter.second() >> activeViews_;
1851	}
1852	}
1853	else if(key == "colorspaces")
1854	{
1855	const YAML::Node& colorspaces = iter.second();
1856
1857	if(colorspaces.Type() != YAML::NodeType::Sequence)
1858	{
1859	std::ostringstream os;
1860	os << "'colorspaces' field needs to be a (- !<ColorSpace>) list.";
1861	throw Exception(os.str().c_str());
1862	}
1863
1864	for(unsigned i = 0; i < colorspaces.size(); ++i)
1865	{
1866	if(colorspaces[i].Tag() == "ColorSpace")
1867	{
1868	ColorSpaceRcPtr cs = ColorSpace::Create();
1869	colorspaces[i] >> cs;
1870	colorspaces_.push_back( cs );
1871	}
1872	else
1873	{
1874	std::ostringstream os;
1875	os << "Unknown element found in colorspaces:";
1876	os << colorspaces[i].Tag() << ". Only ColorSpace(s)";
1877	os << " currently handled.";
1878	LogWarning(os.str());
1879	}
1880	}
1881	}
1882	else if(key == "looks")
1883	{
1884	const YAML::Node& looks = iter.second();
1885
1886	if(looks.Type() != YAML::NodeType::Sequence)
1887	{
1888	std::ostringstream os;
1889	os << "'looks' field needs to be a (- !<Look>) list.";
1890	throw Exception(os.str().c_str());
1891	}
1892
1893	for(unsigned i = 0; i < looks.size(); ++i)
1894	{
1895	if(looks[i].Tag() == "Look")
1896	{
1897	LookRcPtr look = Look::Create();
1898	looks[i] >> look;
1899	looksList_.push_back( look );
1900	}
1901	else
1902	{
1903	std::ostringstream os;
1904	os << "Unknown element found in looks:";
1905	os << looks[i].Tag() << ". Only Look(s)";
1906	os << " currently handled.";
1907	LogWarning(os.str());
1908	}
1909	}
1910	}
1911	else
1912	{
1913	LogUnknownKeyWarning("profile", iter.first());
1914	}
1915	}
1916
1917	if(filename)
1918	{
1919	std::string realfilename = pystring::os::path::abspath(filename);
1920	std::string configrootdir = pystring::os::path::dirname(realfilename);
1921	context_->setWorkingDir(configrootdir.c_str());
1922	}
1923
1924	context_->setEnvironmentMode(mode);
1925	context_->loadEnvironment();
1926
1927	if(mode == ENV_ENVIRONMENT_LOAD_ALL)
1928	{
1929	std::ostringstream os;
1930	os << "This .ocio config ";
1931	if(filename && *filename)
1932	{
1933	os << " '" << filename << "' ";
1934	}
1935	os << "has no environment section defined. The default behaviour is to ";
1936	os << "load all environment variables (" << context_->getNumStringVars() << ")";
1937	os << ", which reduces the efficiency of OCIO's caching. Considering ";
1938	os << "predefining the environment variables used.";
1939	LogDebug(os.str());
1940	}
1941
1942	}
1943	catch( const std::exception & e)
1944	{
1945	std::ostringstream os;
1946	os << "Error: Loading the OCIO profile ";
1947	if(filename) os << "'" << filename << "' ";
1948	os << "failed. " << e.what();
1949	throw Exception(os.str().c_str());
1950	}
1951	}
1952
1953	void Config::Impl::resetCacheIDs()	1504	void Config::Impl::resetCacheIDs()
1954	{	1505	{
1955	cacheids_.clear();	1506	cacheids_.clear();
Lines 2287-2295 OIIO_ADD_TEST(Config, SanityCheck) Link Here
2287	std::istringstream is;	1838	std::istringstream is;
2288	is.str(SIMPLE_PROFILE);	1839	is.str(SIMPLE_PROFILE);
2289	OCIO::ConstConfigRcPtr config;	1840	OCIO::ConstConfigRcPtr config;
2290	OIIO_CHECK_NO_THOW(config = OCIO::Config::CreateFromStream(is));	1841	OIIO_CHECK_THOW(config = OCIO::Config::CreateFromStream(is), OCIO::Exception);
2291
2292	OIIO_CHECK_THOW(config->sanityCheck(), OCIO::Exception);
2293	}	1842	}
2294		1843
2295	{	1844	{
Lines 2330-2337 OIIO_ADD_TEST(Config, EnvCheck) Link Here
2330	"colorspaces:\n"	1879	"colorspaces:\n"
2331	" - !<ColorSpace>\n"	1880	" - !<ColorSpace>\n"
2332	" name: raw\n"	1881	" name: raw\n"
2333	" - !<ColorSpace>\n"
2334	" name: raw\n"
2335	"strictparsing: false\n"	1882	"strictparsing: false\n"
2336	"roles:\n"	1883	"roles:\n"
2337	" default: raw\n"	1884	" default: raw\n"
Lines 2345-2352 OIIO_ADD_TEST(Config, EnvCheck) Link Here
2345	"colorspaces:\n"	1892	"colorspaces:\n"
2346	" - !<ColorSpace>\n"	1893	" - !<ColorSpace>\n"
2347	" name: raw\n"	1894	" name: raw\n"
2348	" - !<ColorSpace>\n"
2349	" name: raw\n"
2350	"strictparsing: false\n"	1895	"strictparsing: false\n"
2351	"roles:\n"	1896	"roles:\n"
2352	" default: raw\n"	1897	" default: raw\n"
Lines 2370-2376 OIIO_ADD_TEST(Config, EnvCheck) Link Here
2370	"testbarchedder") == 0);	1915	"testbarchedder") == 0);
2371	OIIO_CHECK_ASSERT(strcmp(config->getCurrentContext()->resolveStringVar("${SHOW}"),	1916	OIIO_CHECK_ASSERT(strcmp(config->getCurrentContext()->resolveStringVar("${SHOW}"),
2372	"bar") == 0);	1917	"bar") == 0);
2373	OIIO_CHECK_THOW(config->sanityCheck(), OCIO::Exception);
2374	OIIO_CHECK_ASSERT(strcmp(config->getEnvironmentVarDefault("SHOW"), "super") == 0);	1918	OIIO_CHECK_ASSERT(strcmp(config->getEnvironmentVarDefault("SHOW"), "super") == 0);
2375		1919
2376	OCIO::ConfigRcPtr edit = config->createEditableCopy();	1920	OCIO::ConfigRcPtr edit = config->createEditableCopy();
Lines 2403-2408 OIIO_ADD_TEST(Config, EnvCheck) Link Here
2403	"lighting") == 0);	1947	"lighting") == 0);
2404	OCIO::SetLoggingLevel(loglevel);	1948	OCIO::SetLoggingLevel(loglevel);
2405		1949
		1950	OIIO_CHECK_EQUAL(edit->getEnvironmentMode(), OCIO::ENV_ENVIRONMENT_LOAD_PREDEFINED);
		1951	edit->setEnvironmentMode(OCIO::ENV_ENVIRONMENT_LOAD_ALL);
		1952	OIIO_CHECK_EQUAL(edit->getEnvironmentMode(), OCIO::ENV_ENVIRONMENT_LOAD_ALL);
		1953
2406	}	1954	}
2407	}	1955	}
2408		1956

Line 0 Link Here

(-)a/src/core/Display.cpp (+145 lines)
		1	/*
		2	Copyright (c) 2003-2010 Sony Pictures Imageworks Inc., et al.
		3	All Rights Reserved.
		4
		5	Redistribution and use in source and binary forms, with or without
		6	modification, are permitted provided that the following conditions are
		7	met:
		8	* Redistributions of source code must retain the above copyright
		9	notice, this list of conditions and the following disclaimer.
		10	* Redistributions in binary form must reproduce the above copyright
		11	notice, this list of conditions and the following disclaimer in the
		12	documentation and/or other materials provided with the distribution.
		13	* Neither the name of Sony Pictures Imageworks nor the names of its
		14	contributors may be used to endorse or promote products derived from
		15	this software without specific prior written permission.
		16	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
		17	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
		18	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
		19	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
		20	OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
		21	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
		22	LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
		23	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
		24	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		25	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		26	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		27	*/
		28
		29	#include <string>
		30
		31	#include <OpenColorIO/OpenColorIO.h>
		32
		33	#include "Display.h"
		34	#include "ParseUtils.h"
		35
		36	OCIO_NAMESPACE_ENTER
		37	{
		38
		39	DisplayMap::iterator find_display(DisplayMap & displays, const std::string & display)
		40	{
		41	for(DisplayMap::iterator iter = displays.begin();
		42	iter != displays.end();
		43	++iter)
		44	{
		45	if(StrEqualsCaseIgnore(display, iter->first)) return iter;
		46	}
		47	return displays.end();
		48	}
		49
		50	DisplayMap::const_iterator find_display_const(const DisplayMap & displays, const std::string & display)
		51	{
		52	for(DisplayMap::const_iterator iter = displays.begin();
		53	iter != displays.end();
		54	++iter)
		55	{
		56	if(StrEqualsCaseIgnore(display, iter->first)) return iter;
		57	}
		58	return displays.end();
		59	}
		60
		61	int find_view(const ViewVec & vec, const std::string & name)
		62	{
		63	for(unsigned int i=0; i<vec.size(); ++i)
		64	{
65	if(StrEqualsCaseIgnore(name, vec[i].name)) return i;
66	}
67	return -1;
68	}
69
70	void AddDisplay(DisplayMap & displays,
71	const std::string & display,
72	const std::string & view,
73	const std::string & colorspace,
74	const std::string & looks)
75	{
76	DisplayMap::iterator iter = find_display(displays, display);
77	if(iter == displays.end())
78	{
79	ViewVec views;
80	views.push_back( View(view, colorspace, looks) );
81	displays[display] = views;
82	}
83	else
84	{
85	ViewVec & views = iter->second;
86	int index = find_view(views, view);
87	if(index<0)
88	{
89	views.push_back( View(view, colorspace, looks) );
90	}
91	else
92	{
93	views[index].colorspace = colorspace;
94	views[index].looks = looks;
95	}
96	}
97	}
98
99	void ComputeDisplays(StringVec & displayCache,
100	const DisplayMap & displays,
101	const StringVec & activeDisplays,
102	const StringVec & activeDisplaysEnvOverride)
103	{
104	displayCache.clear();
105
106	StringVec displayMasterList;
107	for(DisplayMap::const_iterator iter = displays.begin();
108	iter != displays.end();
109	++iter)
110	{
111	displayMasterList.push_back(iter->first);
112	}
113
114	// Apply the env override if it's not empty.
115	if(!activeDisplaysEnvOverride.empty())
116	{
117	displayCache = IntersectStringVecsCaseIgnore(displayMasterList, activeDisplaysEnvOverride);
118	if(!displayCache.empty()) return;
119	}
120	// Otherwise, aApply the active displays if it's not empty.
121	else if(!activeDisplays.empty())
122	{
123	displayCache = IntersectStringVecsCaseIgnore(displayMasterList, activeDisplays);
124	if(!displayCache.empty()) return;
125	}
126
127	displayCache = displayMasterList;
128	}
129
130	}
131	OCIO_NAMESPACE_EXIT
132
133	///////////////////////////////////////////////////////////////////////////////
134
135	#ifdef OCIO_UNIT_TEST
136
137	namespace OCIO = OCIO_NAMESPACE;
138	#include "UnitTest.h"
139
140	OIIO_ADD_TEST(Display, Basic)
141	{
142
143	}
144
145	#endif // OCIO_UNIT_TEST

Line 0 Link Here

(-)a/src/core/Display.h (+85 lines)
		1	/*
		2	Copyright (c) 2003-2010 Sony Pictures Imageworks Inc., et al.
		3	All Rights Reserved.
		4
		5	Redistribution and use in source and binary forms, with or without
		6	modification, are permitted provided that the following conditions are
		7	met:
		8	* Redistributions of source code must retain the above copyright
		9	notice, this list of conditions and the following disclaimer.
		10	* Redistributions in binary form must reproduce the above copyright
		11	notice, this list of conditions and the following disclaimer in the
		12	documentation and/or other materials provided with the distribution.
		13	* Neither the name of Sony Pictures Imageworks nor the names of its
		14	contributors may be used to endorse or promote products derived from
		15	this software without specific prior written permission.
		16	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
		17	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
		18	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
		19	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
		20	OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
		21	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
		22	LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
		23	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
		24	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		25	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		26	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		27	*/
		28
		29
		30	#ifndef INCLUDED_OCIO_DISPLAY_H
		31	#define INCLUDED_OCIO_DISPLAY_H
		32
		33	#include <OpenColorIO/OpenColorIO.h>
		34
		35	#include <string>
		36	#include <vector>
		37	#include <map>
		38
		39	#include "PrivateTypes.h"
		40
		41	OCIO_NAMESPACE_ENTER
		42	{
		43
		44	// Displays
		45	struct View
		46	{
		47	std::string name;
		48	std::string colorspace;
		49	std::string looks;
		50
		51	View() { }
		52
		53	View(const std::string & name_,
		54	const std::string & colorspace_,
		55	const std::string & looksList_) :
		56	name(name_),
		57	colorspace(colorspace_),
		58	looks(looksList_)
		59	{ }
		60	};
		61
		62	typedef std::vector<View> ViewVec;
		63	typedef std::map<std::string, ViewVec> DisplayMap; // (display name : ViewVec)
		64
65	DisplayMap::iterator find_display(DisplayMap & displays, const std::string & display);
66
67	DisplayMap::const_iterator find_display_const(const DisplayMap & displays, const std::string & display);
68
69	int find_view(const ViewVec & vec, const std::string & name);
70
71	void AddDisplay(DisplayMap & displays,
72	const std::string & display,
73	const std::string & view,
74	const std::string & colorspace,
75	const std::string & looks);
76
77	void ComputeDisplays(StringVec & displayCache,
78	const DisplayMap & displays,
79	const StringVec & activeDisplays,
80	const StringVec & activeDisplaysEnvOverride);
81
82	}
83	OCIO_NAMESPACE_EXIT
84
85	#endif

Lines 28-124 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Link Here

(-)a/src/core/OCIOYaml.h (-84 / +6 lines)
28		28
29	#include <OpenColorIO/OpenColorIO.h>	29	#include <OpenColorIO/OpenColorIO.h>
30		30
31	#include "Platform.h"
32
33	#ifndef WINDOWS
34
35	// fwd declare yaml-cpp visibility
36	#pragma GCC visibility push(hidden)
37	namespace YAML {
38	class Exception;
39	class BadDereference;
40	class RepresentationException;
41	class EmitterException;
42	class ParserException;
43	class InvalidScalar;
44	class KeyNotFound;
45	template <typename T> class TypedKeyNotFound;
46	template <> class TypedKeyNotFound<OCIO_NAMESPACE::ColorSpace>;
47	template <> class TypedKeyNotFound<OCIO_NAMESPACE::Config>;
48	template <> class TypedKeyNotFound<OCIO_NAMESPACE::Exception>;
49	template <> class TypedKeyNotFound<OCIO_NAMESPACE::GpuShaderDesc>;
50	template <> class TypedKeyNotFound<OCIO_NAMESPACE::ImageDesc>;
51	template <> class TypedKeyNotFound<OCIO_NAMESPACE::Look>;
52	template <> class TypedKeyNotFound<OCIO_NAMESPACE::Processor>;
53
54	template <> class TypedKeyNotFound<OCIO_NAMESPACE::Transform>;
55	template <> class TypedKeyNotFound<OCIO_NAMESPACE::AllocationTransform>;
56	template <> class TypedKeyNotFound<OCIO_NAMESPACE::CDLTransform>;
57	template <> class TypedKeyNotFound<OCIO_NAMESPACE::ColorSpaceTransform>;
58	template <> class TypedKeyNotFound<OCIO_NAMESPACE::DisplayTransform>;
59	template <> class TypedKeyNotFound<OCIO_NAMESPACE::ExponentTransform>;
60	template <> class TypedKeyNotFound<OCIO_NAMESPACE::FileTransform>;
61	template <> class TypedKeyNotFound<OCIO_NAMESPACE::GroupTransform>;
62	template <> class TypedKeyNotFound<OCIO_NAMESPACE::LogTransform>;
63	template <> class TypedKeyNotFound<OCIO_NAMESPACE::LookTransform>;
64	template <> class TypedKeyNotFound<OCIO_NAMESPACE::MatrixTransform>;
65	template <> class TypedKeyNotFound<OCIO_NAMESPACE::TruelightTransform>;
66	}
67	#pragma GCC visibility pop
68
69	#endif
70
71	#include <yaml-cpp/yaml.h>
72
73	#ifndef INCLUDED_OCIO_YAML_H	31	#ifndef INCLUDED_OCIO_YAML_H
74	#define INCLUDED_OCIO_YAML_H	32	#define INCLUDED_OCIO_YAML_H
75		33
76	OCIO_NAMESPACE_ENTER	34	OCIO_NAMESPACE_ENTER
77	{	35	{
78		36
79	// Core	37	class OCIOYaml
80	OCIOHIDDEN void operator >> (const YAML::Node& node, ColorSpaceRcPtr& cs);	38	{
81	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ColorSpaceRcPtr cs);	39	public:
82	OCIOHIDDEN void operator >> (const YAML::Node& node, GroupTransformRcPtr& t);	40	void open(std::istream& istream, ConfigRcPtr& c, const char* filename = NULL) const;
83	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstGroupTransformRcPtr t);	41	void write(std::ostream& ostream, const Config* c) const;
84	OCIOHIDDEN void operator >> (const YAML::Node& node, TransformRcPtr& t);	42	};
85	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstTransformRcPtr t);
86	OCIOHIDDEN void operator >> (const YAML::Node& node, LookRcPtr& cs);
87	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, LookRcPtr cs);
88
89	// Transforms
90	OCIOHIDDEN void operator >> (const YAML::Node& node, AllocationTransformRcPtr& t);
91	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstAllocationTransformRcPtr t);
92	OCIOHIDDEN void operator >> (const YAML::Node& node, CDLTransformRcPtr& t);
93	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstCDLTransformRcPtr t);
94	OCIOHIDDEN void operator >> (const YAML::Node& node, ColorSpaceTransformRcPtr& t);
95	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstColorSpaceTransformRcPtr t);
96	OCIOHIDDEN void operator >> (const YAML::Node& node, ExponentTransformRcPtr& t);
97	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstExponentTransformRcPtr t);
98	OCIOHIDDEN void operator >> (const YAML::Node& node, FileTransformRcPtr& t);
99	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstFileTransformRcPtr t);
100	OCIOHIDDEN void operator >> (const YAML::Node& node, LogTransformRcPtr& t);
101	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstLogTransformRcPtr t);
102	OCIOHIDDEN void operator >> (const YAML::Node& node, LookTransformRcPtr& t);
103	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstLookTransformRcPtr t);
104	OCIOHIDDEN void operator >> (const YAML::Node& node, MatrixTransformRcPtr& t);
105	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstMatrixTransformRcPtr t);
106	OCIOHIDDEN void operator >> (const YAML::Node& node, TruelightTransformRcPtr& t);
107	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ConstTruelightTransformRcPtr t);
108
109	// Enums
110	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, BitDepth depth);
111	OCIOHIDDEN void operator >> (const YAML::Node& node, BitDepth& depth);
112	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, Allocation alloc);
113	OCIOHIDDEN void operator >> (const YAML::Node& node, Allocation& alloc);
114	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, ColorSpaceDirection dir);
115	OCIOHIDDEN void operator >> (const YAML::Node& node, ColorSpaceDirection& dir);
116	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, TransformDirection dir);
117	OCIOHIDDEN void operator >> (const YAML::Node& node, TransformDirection& dir);
118	OCIOHIDDEN YAML::Emitter& operator << (YAML::Emitter& out, Interpolation iterp);
119	OCIOHIDDEN void operator >> (const YAML::Node& node, Interpolation& iterp);
120		43
121	void LogUnknownKeyWarning(const std::string & name, const YAML::Node& tag);
122	}	44	}
123	OCIO_NAMESPACE_EXIT	45	OCIO_NAMESPACE_EXIT
124		46