X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=core%2Fproducer%2Fscene%2Fxml_scene_producer.cpp;h=10c4aca6db751395504ac21c4bad8dc005423b86;hb=62c7da66319a85de98331bcf9dded7490ab62884;hp=8ad65fa249deed79e8caa8f519b0b0afaa29067c;hpb=d82b533b0954e77573d2dcc05e4055946790993b;p=casparcg

diff --git a/core/producer/scene/xml_scene_producer.cpp b/core/producer/scene/xml_scene_producer.cpp
index 8ad65fa24..10c4aca6d 100644
--- a/core/producer/scene/xml_scene_producer.cpp
+++ b/core/producer/scene/xml_scene_producer.cpp
@@ -31,11 +31,14 @@
 
 #include <common/env.h>
 #include <common/os/filesystem.h>
+#include <common/filesystem.h>
+#include <common/ptree.h>
 #include <core/producer/frame_producer.h>
 #include <core/help/help_repository.h>
 #include <core/help/help_sink.h>
 
 #include <future>
+#include <vector>
 
 #include "scene_producer.h"
 #include "scene_cg_proxy.h"
@@ -86,7 +89,10 @@ spl::shared_ptr<core::frame_producer> create_xml_scene_producer(
 	if (!found)
 		return core::frame_producer::empty();
 
-	std::wstring filename = *found;
+	auto filename		= *found;
+	auto template_name	= get_relative(filename, env::template_folder()).wstring();
+
+	CASPAR_SCOPED_CONTEXT_MSG(template_name + L": ");
 
 	boost::property_tree::wptree root;
 	boost::filesystem::wifstream file(filename);
@@ -96,17 +102,19 @@ spl::shared_ptr<core::frame_producer> create_xml_scene_producer(
 			boost::property_tree::xml_parser::trim_whitespace
 					| boost::property_tree::xml_parser::no_comments);
 
-	int width = root.get<int>(L"scene.<xmlattr>.width");
-	int height = root.get<int>(L"scene.<xmlattr>.height");
+	int width = ptree_get<int>(root, L"scene.<xmlattr>.width");
+	int height = ptree_get<int>(root, L"scene.<xmlattr>.height");
 
-	auto scene = spl::make_shared<scene_producer>(width, height, dependencies.format_desc);
+	auto scene = spl::make_shared<scene_producer>(L"scene", template_name, width, height, dependencies.format_desc);
 
-	for (auto elem : root.get_child(L"scene.variables"))
+	for (auto elem : root | witerate_children(L"scene.variables") | welement_context_iteration)
 	{
-		auto type = elem.second.get<std::wstring>(L"<xmlattr>.type");
-		auto id = elem.second.get<std::wstring>(L"<xmlattr>.id");
-		auto is_public = elem.second.get(L"<xmlattr>.public", false);
-		auto expr = elem.second.get_value<std::wstring>();
+		ptree_verify_element_name(elem, L"variable");
+
+		auto type		= ptree_get<std::wstring>(elem.second, L"<xmlattr>.type");
+		auto id			= ptree_get<std::wstring>(elem.second, L"<xmlattr>.id");
+		auto is_public	= elem.second.get(L"<xmlattr>.public", false);
+		auto expr		= ptree_get_value<std::wstring>(elem.second);
 
 		if (!is_public)
 			id = L"variable." + id;
@@ -119,43 +127,71 @@ spl::shared_ptr<core::frame_producer> create_xml_scene_producer(
 			scene->create_variable<bool>(id, is_public, expr);
 	}
 
-	for (auto& elem : root.get_child(L"scene.layers"))
+	for (auto& elem : root | witerate_children(L"scene.layers") | welement_context_iteration)
 	{
-		auto id = elem.second.get<std::wstring>(L"<xmlattr>.id");
-		auto producer = dependencies.producer_registry->create_producer(dependencies, elem.second.get<std::wstring>(L"producer"));
-		auto& layer = scene->create_layer(producer, 0, 0, id);
-		auto variable_prefix = L"layer." + id + L".";
-
-		layer.hidden = scene->create_variable<bool>(variable_prefix + L"hidden", false, elem.second.get(L"hidden", L"false"));
-		layer.position.x = scene->create_variable<double>(variable_prefix + L"x", false, elem.second.get<std::wstring>(L"x"));
-		layer.position.y = scene->create_variable<double>(variable_prefix + L"y", false, elem.second.get<std::wstring>(L"y"));
-		layer.anchor.x = scene->create_variable<double>(variable_prefix + L"anchor_x", false, elem.second.get<std::wstring>(L"anchor_x", L"0.0"));
-		layer.anchor.y = scene->create_variable<double>(variable_prefix + L"anchor_y", false, elem.second.get<std::wstring>(L"anchor_y", L"0.0"));
-		layer.rotation = scene->create_variable<double>(variable_prefix + L"rotation", false, elem.second.get<std::wstring>(L"rotation", L"0.0"));
-		layer.crop.upper_left.x = scene->create_variable<double>(variable_prefix + L"crop_upper_left_x", false, elem.second.get<std::wstring>(L"crop_upper_left_x", L"0.0"));
-		layer.crop.upper_left.y = scene->create_variable<double>(variable_prefix + L"crop_upper_left_y", false, elem.second.get<std::wstring>(L"crop_upper_left_y", L"0.0"));
-		layer.crop.lower_right.x = scene->create_variable<double>(variable_prefix + L"crop_lower_right_x", false, elem.second.get<std::wstring>(L"crop_lower_right_x", layer.producer.get()->pixel_constraints().width.as<std::wstring>().get()));
-		layer.crop.lower_right.y = scene->create_variable<double>(variable_prefix + L"crop_lower_right_y", false, elem.second.get<std::wstring>(L"crop_lower_right_y", layer.producer.get()->pixel_constraints().height.as<std::wstring>().get()));
-		layer.perspective.upper_left.x = scene->create_variable<double>(variable_prefix + L"perspective_upper_left_x", false, elem.second.get<std::wstring>(L"perspective_upper_left_x", L"0.0"));
-		layer.perspective.upper_left.y = scene->create_variable<double>(variable_prefix + L"perspective_upper_left_y", false, elem.second.get<std::wstring>(L"perspective_upper_left_y", L"0.0"));
-		layer.perspective.upper_right.x = scene->create_variable<double>(variable_prefix + L"perspective_upper_right_x", false, elem.second.get<std::wstring>(L"perspective_upper_right_x", layer.producer.get()->pixel_constraints().width.as<std::wstring>().get()));
-		layer.perspective.upper_right.y = scene->create_variable<double>(variable_prefix + L"perspective_upper_right_y", false, elem.second.get<std::wstring>(L"perspective_upper_right_y", L"0.0"));
-		layer.perspective.lower_right.x = scene->create_variable<double>(variable_prefix + L"perspective_lower_right_x", false, elem.second.get<std::wstring>(L"perspective_lower_right_x", layer.producer.get()->pixel_constraints().width.as<std::wstring>().get()));
-		layer.perspective.lower_right.y = scene->create_variable<double>(variable_prefix + L"perspective_lower_right_y", false, elem.second.get<std::wstring>(L"perspective_lower_right_y", layer.producer.get()->pixel_constraints().height.as<std::wstring>().get()));
-		layer.perspective.lower_left.x = scene->create_variable<double>(variable_prefix + L"perspective_lower_left_x", false, elem.second.get<std::wstring>(L"perspective_lower_left_x", L"0.0"));
-		layer.perspective.lower_left.y = scene->create_variable<double>(variable_prefix + L"perspective_lower_left_y", false, elem.second.get<std::wstring>(L"perspective_lower_left_y", layer.producer.get()->pixel_constraints().height.as<std::wstring>().get()));
-
-		layer.adjustments.opacity = scene->create_variable<double>(variable_prefix + L"adjustment.opacity", false, elem.second.get(L"adjustments.opacity", L"1.0"));
-		layer.is_key = scene->create_variable<bool>(variable_prefix + L"is_key", false, elem.second.get(L"is_key", L"false"));
-		layer.use_mipmap = scene->create_variable<bool>(variable_prefix + L"use_mipmap", false, elem.second.get(L"use_mipmap", L"false"));
-		layer.blend_mode = scene->create_variable<std::wstring>(variable_prefix + L"blend_mode", false, elem.second.get(L"blend_mode", L"normal")).transformed([](const std::wstring& b) { return get_blend_mode(b); });
-		layer.chroma_key.key = scene->create_variable<std::wstring>(variable_prefix + L"chroma_key.key", false, elem.second.get(L"chroma_key.key", L"none")).transformed([](const std::wstring& k) { return get_chroma_mode(k); });
-		layer.chroma_key.threshold = scene->create_variable<double>(variable_prefix + L"chroma_key.threshold", false, elem.second.get(L"chroma_key.threshold", L"0.0"));
-		layer.chroma_key.softness = scene->create_variable<double>(variable_prefix + L"chroma_key.softness", false, elem.second.get(L"chroma_key.softness", L"0.0"));
-		layer.chroma_key.spill = scene->create_variable<double>(variable_prefix + L"chroma_key.spill", false, elem.second.get(L"chroma_key.spill", L"0.0"));
-
-		scene->create_variable<double>(variable_prefix + L"width", false) = layer.producer.get()->pixel_constraints().width;
-		scene->create_variable<double>(variable_prefix + L"height", false) = layer.producer.get()->pixel_constraints().height;
+		ptree_verify_element_name(elem, L"layer");
+
+		auto id							= ptree_get<std::wstring>(elem.second, L"<xmlattr>.id");
+		auto producer_string			= ptree_get<std::wstring>(elem.second, L"producer");
+		auto producer					= [&]
+		{
+			CASPAR_SCOPED_CONTEXT_MSG(" -> ");
+			auto adjusted_dependencies = dependencies;
+			auto& adjusted_format_desc = adjusted_dependencies.format_desc;
+
+			adjusted_format_desc.field_mode		 = field_mode::progressive;
+			adjusted_format_desc.fps			*= adjusted_format_desc.field_count;
+			adjusted_format_desc.duration		/= adjusted_format_desc.field_count;
+			adjusted_format_desc.field_count	 = 1;
+
+			return dependencies.producer_registry->create_producer(adjusted_dependencies, producer_string);
+		}();
+		auto& layer						= scene->create_layer(producer, 0, 0, id);
+		auto variable_prefix			= L"layer." + id + L".";
+
+		auto overridden_width = elem.second.get<std::wstring>(L"width", L"");
+		if (!overridden_width.empty())
+			layer.producer.get()->pixel_constraints().width = scene->create_variable<double>(variable_prefix + L"width", false, overridden_width);
+		else
+			scene->create_variable<double>(variable_prefix + L"width", false) = layer.producer.get()->pixel_constraints().width;
+
+		auto overridden_height = elem.second.get<std::wstring>(L"height", L"");
+		if (!overridden_height.empty())
+			layer.producer.get()->pixel_constraints().height = scene->create_variable<double>(variable_prefix + L"height", false, overridden_height);
+		else
+			scene->create_variable<double>(variable_prefix + L"height", false) = layer.producer.get()->pixel_constraints().height;
+
+		layer.hidden					= scene->create_variable<bool>(variable_prefix + L"hidden", false, elem.second.get(L"hidden", L"false"));
+		layer.position.x				= scene->create_variable<double>(variable_prefix + L"x", false, ptree_get<std::wstring>(elem.second, L"x"));
+		layer.position.y				= scene->create_variable<double>(variable_prefix + L"y", false, ptree_get<std::wstring>(elem.second, L"y"));
+		layer.anchor.x					= scene->create_variable<double>(variable_prefix + L"anchor_x", false, elem.second.get<std::wstring>(L"anchor_x", L"0.0"));
+		layer.anchor.y					= scene->create_variable<double>(variable_prefix + L"anchor_y", false, elem.second.get<std::wstring>(L"anchor_y", L"0.0"));
+		layer.rotation					= scene->create_variable<double>(variable_prefix + L"rotation", false, elem.second.get<std::wstring>(L"rotation", L"0.0"));
+		layer.crop.upper_left.x			= scene->create_variable<double>(variable_prefix + L"crop_upper_left_x", false, elem.second.get<std::wstring>(L"crop_upper_left_x", L"0.0"));
+		layer.crop.upper_left.y			= scene->create_variable<double>(variable_prefix + L"crop_upper_left_y", false, elem.second.get<std::wstring>(L"crop_upper_left_y", L"0.0"));
+		layer.crop.lower_right.x		= scene->create_variable<double>(variable_prefix + L"crop_lower_right_x", false, elem.second.get<std::wstring>(L"crop_lower_right_x", L"${" + variable_prefix + L"width}"));
+		layer.crop.lower_right.y		= scene->create_variable<double>(variable_prefix + L"crop_lower_right_y", false, elem.second.get<std::wstring>(L"crop_lower_right_y", L"${" + variable_prefix + L"height}"));
+		layer.perspective.upper_left.x	= scene->create_variable<double>(variable_prefix + L"perspective_upper_left_x", false, elem.second.get<std::wstring>(L"perspective_upper_left_x", L"0.0"));
+		layer.perspective.upper_left.y	= scene->create_variable<double>(variable_prefix + L"perspective_upper_left_y", false, elem.second.get<std::wstring>(L"perspective_upper_left_y", L"0.0"));
+		layer.perspective.upper_right.x	= scene->create_variable<double>(variable_prefix + L"perspective_upper_right_x", false, elem.second.get<std::wstring>(L"perspective_upper_right_x", L"${" + variable_prefix + L"width}"));
+		layer.perspective.upper_right.y	= scene->create_variable<double>(variable_prefix + L"perspective_upper_right_y", false, elem.second.get<std::wstring>(L"perspective_upper_right_y", L"0.0"));
+		layer.perspective.lower_right.x	= scene->create_variable<double>(variable_prefix + L"perspective_lower_right_x", false, elem.second.get<std::wstring>(L"perspective_lower_right_x", L"${" + variable_prefix + L"width}"));
+		layer.perspective.lower_right.y	= scene->create_variable<double>(variable_prefix + L"perspective_lower_right_y", false, elem.second.get<std::wstring>(L"perspective_lower_right_y", L"${" + variable_prefix + L"height}"));
+		layer.perspective.lower_left.x	= scene->create_variable<double>(variable_prefix + L"perspective_lower_left_x", false, elem.second.get<std::wstring>(L"perspective_lower_left_x", L"0.0"));
+		layer.perspective.lower_left.y	= scene->create_variable<double>(variable_prefix + L"perspective_lower_left_y", false, elem.second.get<std::wstring>(L"perspective_lower_left_y", L"${" + variable_prefix + L"height}"));
+
+		layer.adjustments.opacity		= scene->create_variable<double>(variable_prefix + L"adjustment.opacity", false, elem.second.get(L"adjustments.opacity", L"1.0"));
+		layer.is_key					= scene->create_variable<bool>(variable_prefix + L"is_key", false, elem.second.get(L"is_key", L"false"));
+		layer.use_mipmap				= scene->create_variable<bool>(variable_prefix + L"use_mipmap", false, elem.second.get(L"use_mipmap", L"false"));
+		layer.blend_mode				= scene->create_variable<std::wstring>(variable_prefix + L"blend_mode", false, elem.second.get(L"blend_mode", L"normal")).transformed([](const std::wstring& b) { return get_blend_mode(b); });
+		layer.chroma_key.enable			= scene->create_variable<bool>(variable_prefix + L"chroma_key.enable", false, elem.second.get(L"chroma_key.enable", L"false"));
+		layer.chroma_key.target_hue		= scene->create_variable<double>(variable_prefix + L"chroma_key.target_hue", false, elem.second.get(L"chroma_key.target_hue", L"120.0"));
+		layer.chroma_key.hue_width		= scene->create_variable<double>(variable_prefix + L"chroma_key.hue_width", false, elem.second.get(L"chroma_key.hue_width", L"0.1"));
+		layer.chroma_key.min_saturation	= scene->create_variable<double>(variable_prefix + L"chroma_key.min_saturation", false, elem.second.get(L"chroma_key.min_saturation", L"0.0"));
+		layer.chroma_key.min_brightness	= scene->create_variable<double>(variable_prefix + L"chroma_key.min_brightness", false, elem.second.get(L"chroma_key.min_brightness", L"0.0"));
+		layer.chroma_key.softness		= scene->create_variable<double>(variable_prefix + L"chroma_key.softness", false, elem.second.get(L"chroma_key.softness", L"0.0"));
+		layer.chroma_key.spill			= scene->create_variable<double>(variable_prefix + L"chroma_key.spill", false, elem.second.get(L"chroma_key.spill", L"1.0"));
+		layer.chroma_key.spill_darken	= scene->create_variable<double>(variable_prefix + L"chroma_key.spill_darken", false, elem.second.get(L"chroma_key.spill_darken", L"2.0"));
 
 		for (auto& var_name : producer->get_variables())
 		{
@@ -173,42 +209,117 @@ spl::shared_ptr<core::frame_producer> create_xml_scene_producer(
 
 	if (root.get_child_optional(L"scene.marks"))
 	{
-		for (auto& mark : root.get_child(L"scene.marks"))
+		for (auto& mark : root | witerate_children(L"scene.marks") | welement_context_iteration)
 		{
-			auto at = mark.second.get<int64_t>(L"<xmlattr>.at");
-			auto type = get_mark_action(mark.second.get<std::wstring>(L"<xmlattr>.type"));
-			auto label = mark.second.get(L"<xmlattr>.label", L"");
+			ptree_verify_element_name(mark, L"mark");
+
+			auto at		= ptree_get<int64_t>(mark.second, L"<xmlattr>.at");
+			auto type	= get_mark_action(ptree_get<std::wstring>(mark.second, L"<xmlattr>.type"));
+			auto label	= mark.second.get(L"<xmlattr>.label", L"");
 
 			scene->add_mark(at, type, label);
 		}
 	}
 
-	for (auto& elem : root.get_child(L"scene.timelines"))
+	if (root.get_child_optional(L"scene.timelines"))
 	{
-		auto& variable = scene->get_variable(elem.second.get<std::wstring>(L"<xmlattr>.variable"));
-
-		for (auto& k : elem.second)
+		for (auto& elem : root | witerate_children(L"scene.timelines") | welement_context_iteration)
 		{
-			if (k.first == L"<xmlattr>")
-				continue;
+			ptree_verify_element_name(elem, L"timeline");
+
+			auto variable_name	= ptree_get<std::wstring>(elem.second, L"<xmlattr>.variable");
+			auto& variable		= scene->get_variable(variable_name);
 
-			auto easing = k.second.get(L"<xmlattr>.easing", L"");
-			auto at = k.second.get<int64_t>(L"<xmlattr>.at");
+			for (auto& k : elem.second)
+			{
+				if (k.first == L"<xmlattr>")
+					continue;
+
+				ptree_verify_element_name(k, L"keyframe");
+
+				auto easing	= k.second.get(L"<xmlattr>.easing", L"");
+				auto at		= ptree_get<int64_t>(k.second, L"<xmlattr>.at");
+
+				auto keyframe_variable_name = L"timeline." + variable_name + L"." + boost::lexical_cast<std::wstring>(at);
 
-			if (variable.is<double>())
-				scene->add_keyframe(variable.as<double>(), k.second.get_value<double>(), at, easing);
-			else if (variable.is<int>())
-				scene->add_keyframe(variable.as<int>(), k.second.get_value<int>(), at, easing);
+				if (variable.is<double>())
+					scene->add_keyframe(variable.as<double>(), scene->create_variable<double>(keyframe_variable_name, false, ptree_get_value<std::wstring>(k.second)), at, easing);
+				else if (variable.is<int>())
+					scene->add_keyframe(variable.as<int>(), scene->create_variable<int>(keyframe_variable_name, false, ptree_get_value<std::wstring>(k.second)), at, easing);
+			}
 		}
 	}
 
 	auto repo = [&scene](const std::wstring& name) -> variable&
 	{
-		return scene->get_variable(name); 
+		return scene->get_variable(name);
 	};
 
+	int task_id = 0;
+	if (root.get_child_optional(L"scene.tasks"))
+	{
+		for (auto& task : root | witerate_children(L"scene.tasks") | welement_context_iteration)
+		{
+			auto& element_name = task.first;
+
+			std::vector<std::wstring> call_params;
+
+			if (element_name == L"call")
+			{
+				for (auto& arg : task.second)
+				{
+					if (arg.first == L"<xmlattr>")
+						continue;
+
+					ptree_verify_element_name(arg, L"arg");
+					call_params.push_back(ptree_get_value<std::wstring>(arg.second));
+				}
+			}
+			else if (element_name == L"cg_play")
+				call_params.push_back(L"play()");
+			else if (element_name == L"cg_stop")
+				call_params.push_back(L"stop()");
+			else if (element_name == L"cg_next")
+				call_params.push_back(L"next()");
+			else if (element_name == L"cg_invoke")
+			{
+				call_params.push_back(L"invoke()");
+				call_params.push_back(ptree_get<std::wstring>(task.second, L"<xmlattr>.label"));
+			}
+			else
+				CASPAR_THROW_EXCEPTION(user_error() << msg_info(L"Only valid element names in <tasks /> are call, cg_play, cg_stop, cg_next and cg_invoke"));
+
+			auto at_frame	= task.second.get_optional<int64_t>(L"<xmlattr>.at");
+			auto when		= task.second.get_optional<std::wstring>(L"<xmlattr>.when");
+			auto to_layer	= ptree_get<std::wstring>(task.second, L"<xmlattr>.to_layer");
+			auto producer	= scene->get_layer(to_layer).producer.get();
+
+			binding<bool> condition;
+
+			if (at_frame)
+				condition = scene->timeline_frame() == *at_frame;
+			else if (when)
+				condition = scene->create_variable<bool>(L"tasks.task_" + boost::lexical_cast<std::wstring>(task_id), false, *when);
+			else
+				CASPAR_THROW_EXCEPTION(user_error() << msg_info(L"Task elements must have either an at attribute or a when attribute"));
+
+			auto weak_producer = static_cast<std::weak_ptr<frame_producer>>(producer);
+
+			scene->add_task(std::move(condition), [=]
+			{
+				auto strong = weak_producer.lock();
+
+				if (strong)
+					strong->call(call_params);
+			});
+
+			++task_id;
+		}
+	}
+
 	for (auto& var_name : scene->get_variables())
 	{
+		CASPAR_SCOPED_CONTEXT_MSG(L"/scene/variables/variable[@id=" + var_name + L"]/text()");
 		deduce_expression(scene->get_variable(var_name), repo);
 	}