Attachment #373564 for bug #471366

Lines 225-237 else(USE_EXTERNAL_YAML) Link Here

(-)a/CMakeLists.txt (-2 / +4 lines)
225	endif()	225	endif()
226	endif(USE_EXTERNAL_YAML)	226	endif(USE_EXTERNAL_YAML)
227		227
228		228	if(YAML_CPP_VERSION VERSION_LESS "0.5.0")
		229	set(YAML_CPP_COMPILE_FLAGS "-DOLDYAML")
		230	endif()
229		231
230	###############################################################################	232	###############################################################################
231	### Externals ###	233	### Externals ###
232		234
233	set(EXTERNAL_INCLUDE_DIRS ${EXTERNAL_INCLUDE_DIRS} ${PROJECT_BINARY_DIR}/ext/dist/include)	235	set(EXTERNAL_INCLUDE_DIRS ${EXTERNAL_INCLUDE_DIRS} ${PROJECT_BINARY_DIR}/ext/dist/include)
234	set(EXTERNAL_COMPILE_FLAGS "-DTIXML_USE_STL")	236	set(EXTERNAL_COMPILE_FLAGS "-DTIXML_USE_STL ${YAML_CPP_COMPILE_FLAGS}")
235		237
236	if(CMAKE_COMPILER_IS_GNUCXX)	238	if(CMAKE_COMPILER_IS_GNUCXX)
237		239

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;




#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





#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
        bool boolval;
        
        inline const YAML::Node& get_first(const Iterator it)
             iter != node.end();
             ++iter)
        {
            iter.first() >> key;
            
            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());
            }
        }
    }
    
    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)
        {
#ifdef OLDYAML
            return it.first();
#else
            return it->first;
#endif
        }
        out << YAML::Key << "isdata" << YAML::Value << cs->isData();
        
        inline const YAML::Node& get_second(const Iterator it)
        if(cs->getAllocationNumVars() > 0)
        {
#ifdef OLDYAML
            return it.second();
#else
            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);
        
        out << YAML::Key << "children";
        out << YAML::Value;
        
        inline void save(YAML::Emitter& out, View view)
        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();
        
        std::string key, stringval;
        
        inline void save(YAML::Emitter& out, ConstAllocationTransformRcPtr t)
             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")
            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, ConstExponentTransformRcPtr t)
    {
        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;
        return out;
    }
    
    void operator >> (const YAML::Node& node, LogTransformRcPtr& t)
    {
        t = LogTransform::Create();
        
        std::string key;
        
        for (YAML::Iterator iter = node.begin();
             iter != node.end();
             ++iter)
        {
            iter.first() >> key;
            
            if(key == "base")
            {
                float val = 0.0f;
                if (iter.second().Type() != YAML::NodeType::Null && 
                    iter.second().Read<float>(val))
                  t->setBase(val);
            }
            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, 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();
        
        std::string key;
        
        for (YAML::Iterator iter = node.begin();
             iter != node.end();
             ++iter)
        {
            iter.first() >> key;
            
            if(key == "matrix")
            {
                std::vector<float> val;
                if (iter.second().Type() != YAML::NodeType::Null)
                {
                    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")
            else if(key == "offset")
            {
                std::vector<float> val;
                if (iter.second().Type() != YAML::NodeType::Null)
                {
                    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;
            }
            
            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, ConstMatrixTransformRcPtr t)
    {
        out << YAML::VerbatimTag("MatrixTransform");
        out << YAML::Flow << YAML::BeginMap;
        
        // ColorSpaceTransform
        
        inline void load(const YAML::Node& node, ColorSpaceTransformRcPtr& t)
        {
            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)
        t->getOffset(&offset[0]);
        if(!IsVecEqualToZero(&offset[0],4))
        {
            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
        out << YAML::EndMap;
        return out;
    }
    
    void operator >> (const YAML::Node& node, CDLTransformRcPtr& t)
    {
        t = CDLTransform::Create();
        
        inline void load(const YAML::Node& node, ExponentTransformRcPtr& t)
        std::vector<float> floatvecval;
        
        for (YAML::Iterator iter = node.begin();
             iter != node.end();
             ++iter)
        {
            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);
                }
            }
        }
        
        inline void save(YAML::Emitter& out, ConstExponentTransformRcPtr t)
        {
            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)
        {
            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);
                    }
                }
                else if(key == "direction")
                {
                    TransformDirection val;
                    load(second, val);
                    t->setDirection(val);
                }
                else
                {
                    LogUnknownKeyWarning(node.Tag(), first);
                }
            }
        }
        
        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);
                    const char* displays = JoinStringEnvStyle(display).c_str();
                    c->setActiveDisplays(displays);
                }
                else if(key == "active_views")
                {
                    std::vector<std::string> view;
                    load(second, view);
                    const char* views = JoinStringEnvStyle(view).c_str();
                    c->setActiveViews(views);
                }
                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

- 

Return to bug 471366

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

(-)a/src/core/Config.cpp (-485 / +33 lines)
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 (-85 / +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
125	-