X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=protocol%2Famcp%2FAMCPCommandsImpl.cpp;h=5f917d04e31bb53fb438fff745e9ac5e359219ed;hb=3bea40d5c5ea42b42c9e983915013299be425749;hp=6b61b40e49eb74e4e802a39efee04f78f6f59cfa;hpb=261958466deb1a8b06fcf7b82f2207595b307deb;p=casparcg

diff --git a/protocol/amcp/AMCPCommandsImpl.cpp b/protocol/amcp/AMCPCommandsImpl.cpp
index 6b61b40e4..5f917d04e 100644
--- a/protocol/amcp/AMCPCommandsImpl.cpp
+++ b/protocol/amcp/AMCPCommandsImpl.cpp
@@ -23,18 +23,19 @@
 #include "AMCPCommandsImpl.h"
 #include "AMCPProtocolStrategy.h"
 
-#include "../media.h"
-
 #include <common/env.h>
 
 #include <core/producer/frame_producer.h>
 #include <core/video_format.h>
-#include <core/producer/flash/flash_producer.h>
+#include <modules/flash/flash.h>
+#include <modules/flash/producer/flash_producer.h>
+#include <modules/flash/producer/cg_producer.h>
 #include <core/producer/transition/transition_producer.h>
-#include <core/producer/flash/cg_producer.h>
 
-#include <mixer/image/image_transform.h>
-#include <mixer/audio/audio_transform.h>
+#include <core/producer/frame/image_transform.h>
+#include <core/producer/frame/audio_transform.h>
+#include <core/mixer/mixer.h>
+#include <core/consumer/output.h>
 
 #include <algorithm>
 #include <locale>
@@ -46,6 +47,7 @@
 #include <boost/lexical_cast.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/filesystem.hpp>
+#include <boost/regex.hpp>
 
 #if defined(_MSC_VER)
 #pragma warning (push, 1) // TODO: Legacy code, just disable warnings
@@ -86,10 +88,13 @@ std::wstring ListMedia()
 		{
 			std::wstring clipttype = TEXT(" N/A ");
 			std::wstring extension = boost::to_upper_copy(itr->path().extension());
-			if(extension == TEXT(".TGA") || extension == TEXT(".COL"))
+			if(extension == TEXT(".TGA") || extension == TEXT(".COL") || extension == L".PNG" || extension == L".JPEG" || extension == L".JPG" ||
+				extension == L"GIF" || extension == L"BMP")
 				clipttype = TEXT(" STILL ");
 			else if(extension == TEXT(".SWF") || extension == TEXT(".DV") || extension == TEXT(".MOV") || extension == TEXT(".MPG") || 
-					extension == TEXT(".AVI") || extension == TEXT(".FLV") || extension == TEXT(".F4V") || extension == TEXT(".MP4"))
+					extension == TEXT(".AVI") || extension == TEXT(".FLV") || extension == TEXT(".F4V") || extension == TEXT(".MP4") ||
+					extension == L".M2V" || extension == L".H264" || extension == L".MKV" || extension == L".WMV" || extension == L".DIVX" || 
+					extension == L".XVID" || extension == L".OGG")
 				clipttype = TEXT(" MOVIE ");
 			else if(extension == TEXT(".WAV") || extension == TEXT(".MP3"))
 				clipttype = TEXT(" STILL ");
@@ -107,12 +112,16 @@ std::wstring ListMedia()
 				auto sizeStr = boost::lexical_cast<std::wstring>(boost::filesystem::file_size(itr->path()));
 				sizeStr.erase(std::remove_if(sizeStr.begin(), sizeStr.end(), is_not_digit), sizeStr.end());
 				auto sizeWStr = std::wstring(sizeStr.begin(), sizeStr.end());
+				
+				auto str = relativePath.replace_extension(TEXT("")).external_file_string();
+				if(str[0] == '\\' || str[0] == '/')
+					str = std::wstring(str.begin() + 1, str.end());
 
-				replyString << TEXT("\"") << relativePath.replace_extension(TEXT(""))
+				replyString << TEXT("\"") << str
 							<< TEXT("\" ") << clipttype 
 							<< TEXT(" ") << sizeStr
 							<< TEXT(" ") << writeTimeWStr
-							<< TEXT("\r\n");
+							<< TEXT("\r\n"); 	
 			}	
 		}
 	}
@@ -137,14 +146,22 @@ std::wstring ListTemplates()
 			sizeStr.erase(std::remove_if(sizeStr.begin(), sizeStr.end(), [](char c){ return std::isdigit(c) == 0;}), sizeStr.end());
 
 			auto sizeWStr = std::wstring(sizeStr.begin(), sizeStr.end());
-			
-			replyString << TEXT("\"") << relativePath.replace_extension(TEXT(""))
+
+			std::wstring dir = relativePath.parent_path().external_directory_string();
+			std::wstring file = boost::to_upper_copy(relativePath.filename());
+			relativePath = boost::filesystem::wpath(dir + L"/" + file);
+						
+			auto str = relativePath.replace_extension(TEXT("")).external_file_string();
+			if(str[0] == '\\' || str[0] == '/')
+				str = std::wstring(str.begin() + 1, str.end());
+
+			replyString << TEXT("\"") << str
 						<< TEXT("\" ") << sizeWStr
 						<< TEXT(" ") << writeTimeWStr
 						<< TEXT("\r\n");		
 		}
 	}
-	return boost::to_upper_copy(replyString.str());
+	return replyString.str();
 }
 
 namespace amcp {
@@ -164,12 +181,37 @@ void AMCPCommand::SendReply()
 
 void AMCPCommand::Clear() 
 {
-	pChannel_->producer().clear();
+	pChannel_->stage()->clear();
 	pClientInfo_.reset();
 	channelIndex_ = 0;
 	_parameters.clear();
 }
 
+bool ParamCommand::DoExecute()
+{	
+	//Perform loading of the clip
+	try
+	{
+		auto what = _parameters.at(2);
+		if(what == L"B")
+			GetChannel()->stage()->background(GetLayerIndex()).get()->param(_parameters.at(3));
+		else if(what == L"F")
+			GetChannel()->stage()->foreground(GetLayerIndex()).get()->param(_parameters.at(3));
+	
+		CASPAR_LOG(info) << "Executed param: " <<  _parameters[0] << TEXT(" successfully");
+
+		SetReplyString(TEXT("202 PARAM OK\r\n"));
+
+		return true;
+	}
+	catch(...)
+	{
+		CASPAR_LOG_CURRENT_EXCEPTION();
+		SetReplyString(TEXT("502 PARAM FAILED\r\n"));
+		return false;
+	}
+}
+
 bool MixerCommand::DoExecute()
 {	
 	//Perform loading of the clip
@@ -177,87 +219,238 @@ bool MixerCommand::DoExecute()
 	{	
 		if(_parameters[0] == L"VIDEO")
 		{
-			if(_parameters[1] == L"OPACITY")
+			if(_parameters[1] == L"IS_KEY")
 			{
+				bool value = lexical_cast_or_default(_parameters.at(2), false);
+				auto transform = [=](image_transform transform) -> image_transform
+				{
+					transform.set_is_key(value);
+					return transform;					
+				};
+
+				int layer = GetLayerIndex();
+				GetChannel()->mixer()->apply_image_transform(GetLayerIndex(), transform);
+			}
+			else if(_parameters[1] == L"OPACITY")
+			{
+				int duration = _parameters.size() > 3 ? lexical_cast_or_default(_parameters[3], 0) : 0;
+				std::wstring tween = _parameters.size() > 4 ? _parameters[4] : L"linear";
+
 				double value = boost::lexical_cast<double>(_parameters.at(2));
-				auto transform = GetChannel()->mixer().get_image_transform(GetLayerIndex());
-				transform.set_opacity(value);
-				GetChannel()->mixer().set_image_transform(GetLayerIndex(), std::move(transform));
+			
+				auto transform = [=](image_transform transform) -> image_transform
+				{
+					transform.set_opacity(value);
+					return transform;					
+				};
+
+				int layer = GetLayerIndex();
+				GetChannel()->mixer()->apply_image_transform(GetLayerIndex(), transform, duration, tween);
 			}
 			else if(_parameters[1] == L"GAIN")
 			{
+				int duration = _parameters.size() > 3 ? lexical_cast_or_default(_parameters[3], 0) : 0;
+				std::wstring tween = _parameters.size() > 4 ? _parameters[4] : L"linear";
 				double value = boost::lexical_cast<double>(_parameters.at(2));
-				auto transform = GetChannel()->mixer().get_image_transform(GetLayerIndex());
-				transform.set_gain(value);
-				GetChannel()->mixer().set_image_transform(GetLayerIndex(), std::move(transform));
+				
+				auto transform = [=](image_transform transform) -> image_transform
+				{
+					transform.set_gain(value);
+					return transform;					
+				};
+
+				int layer = GetLayerIndex();
+				GetChannel()->mixer()->apply_image_transform(GetLayerIndex(), transform, duration, tween);
 			}
-			else if(_parameters[1] == L"FIX_RECT")
+			else if(_parameters[1] == L"FILL_RECT")
 			{
+				int duration = _parameters.size() > 6 ? lexical_cast_or_default(_parameters[6], 0) : 0;
+				std::wstring tween = _parameters.size() > 7 ? _parameters[7] : L"linear";
 				double x	= boost::lexical_cast<double>(_parameters.at(2));
 				double y	= boost::lexical_cast<double>(_parameters.at(3));
 				double x_s	= boost::lexical_cast<double>(_parameters.at(4));
 				double y_s	= boost::lexical_cast<double>(_parameters.at(5));
-				auto transform = GetChannel()->mixer().get_image_transform(GetLayerIndex());
-				transform.set_image_translation(x, y);
-				transform.set_image_scale(x_s, y_s);
-				transform.set_mask_translation(x, y);
-				transform.set_mask_scale(x_s, y_s);
-				GetChannel()->mixer().set_image_transform(GetLayerIndex(), std::move(transform));
+
+				auto transform = [=](image_transform transform) -> image_transform
+				{
+					transform.set_fill_translation(x, y);
+					transform.set_fill_scale(x_s, y_s);
+					transform.set_clip_translation(x, y);
+					transform.set_clip_scale(x_s, y_s);
+					return transform;
+				};
+				
+				int layer = GetLayerIndex();
+				GetChannel()->mixer()->apply_image_transform(GetLayerIndex(), transform, duration, tween);
 			}
 			else if(_parameters[1] == L"CLIP_RECT")
 			{
+				int duration = _parameters.size() > 6 ? lexical_cast_or_default(_parameters[6], 0) : 0;
+				std::wstring tween = _parameters.size() > 7 ? _parameters[7] : L"linear";
 				double x	= boost::lexical_cast<double>(_parameters.at(2));
 				double y	= boost::lexical_cast<double>(_parameters.at(3));
 				double x_s	= boost::lexical_cast<double>(_parameters.at(4));
 				double y_s	= boost::lexical_cast<double>(_parameters.at(5));
-				auto transform = GetChannel()->mixer().get_image_transform(GetLayerIndex());
-				transform.set_image_translation(0.0, 0.0);
-				transform.set_image_scale(1.0, 1.0);
-				transform.set_mask_translation(x, y);
-				transform.set_mask_scale(x_s, y_s);
-				GetChannel()->mixer().set_image_transform(GetLayerIndex(), std::move(transform));
+
+				auto transform = [=](image_transform transform) -> image_transform
+				{
+					transform.set_clip_translation(x, y);
+					transform.set_clip_scale(x_s, y_s);
+					return transform;
+				};
+				
+				int layer = GetLayerIndex();
+				GetChannel()->mixer()->apply_image_transform(GetLayerIndex(), transform, duration, tween);
 			}
 			else if(_parameters[1] == L"GRID")
 			{
+				int duration = _parameters.size() > 3 ? lexical_cast_or_default(_parameters[3], 0) : 0;
+				std::wstring tween = _parameters.size() > 4 ? _parameters[4] : L"linear";
 				int n = boost::lexical_cast<int>(_parameters.at(2));
 				double delta = 1.0/static_cast<double>(n);
 				for(int x = 0; x < n; ++x)
 				{
 					for(int y = 0; y < n; ++y)
 					{
-						int index = x+y*n;
-						auto transform = GetChannel()->mixer().get_image_transform(index);						
-						transform.set_image_translation(x*delta, y*delta);
-						transform.set_image_scale(delta, delta);			
-						transform.set_mask_translation(x*delta, y*delta);
-						transform.set_mask_scale(delta, delta);
-						GetChannel()->mixer().set_image_transform(index, std::move(transform));
+						int index = x+y*n+1;
+						auto transform = [=](image_transform transform) -> image_transform
+						{				
+							transform.set_fill_translation(x*delta, y*delta);
+							transform.set_fill_scale(delta, delta);			
+							transform.set_clip_translation(x*delta, y*delta);
+							transform.set_clip_scale(delta, delta);
+							return transform;
+						};
+						GetChannel()->mixer()->apply_image_transform(index, transform, duration, tween);
 					}
 				}
 			}
+			else if(_parameters[1] == L"BLEND")
+			{
+				auto blend_str = _parameters.at(2);
+
+				auto transform = [=](image_transform transform) -> image_transform
+				{
+					transform.set_blend_mode(get_blend_mode(blend_str));
+					return transform;
+				};
+				
+				int layer = GetLayerIndex();
+				GetChannel()->mixer()->apply_image_transform(GetLayerIndex(), transform);	
+			}
+			else if(_parameters[1] == L"ALPHA")
+			{
+				auto blend_str = _parameters.at(2);
+
+				auto transform = [=](image_transform transform) -> image_transform
+				{
+					transform.set_alpha_mode(get_alpha_mode(blend_str));
+					return transform;
+				};
+				
+				int layer = GetLayerIndex();
+				GetChannel()->mixer()->apply_image_transform(GetLayerIndex(), transform);	
+			}
+			else if(_parameters[1] == L"BRIGHTNESS")
+			{
+				auto value = boost::lexical_cast<double>(_parameters.at(2));
+				int duration = _parameters.size() > 3 ? lexical_cast_or_default(_parameters[3], 0) : 0;
+				std::wstring tween = _parameters.size() > 4 ? _parameters[4] : L"linear";
+				auto transform = [=](image_transform transform) -> image_transform
+				{
+					transform.set_brightness(value);
+					return transform;
+				};
+				
+				int layer = GetLayerIndex();
+				GetChannel()->mixer()->apply_image_transform(GetLayerIndex(), transform, duration, tween);	
+			}
+			else if(_parameters[1] == L"SATURATION")
+			{
+				auto value = boost::lexical_cast<double>(_parameters.at(2));
+				int duration = _parameters.size() > 3 ? lexical_cast_or_default(_parameters[3], 0) : 0;
+				std::wstring tween = _parameters.size() > 4 ? _parameters[4] : L"linear";
+				auto transform = [=](image_transform transform) -> image_transform
+				{
+					transform.set_saturation(value);
+					return transform;
+				};
+				
+				int layer = GetLayerIndex();
+				GetChannel()->mixer()->apply_image_transform(GetLayerIndex(), transform, duration, tween);	
+			}
+			else if(_parameters[1] == L"CONTRAST")
+			{
+				auto value = boost::lexical_cast<double>(_parameters.at(2));
+				int duration = _parameters.size() > 3 ? lexical_cast_or_default(_parameters[3], 0) : 0;
+				std::wstring tween = _parameters.size() > 4 ? _parameters[4] : L"linear";
+				auto transform = [=](image_transform transform) -> image_transform
+				{
+					transform.set_contrast(value);
+					return transform;
+				};
+				
+				int layer = GetLayerIndex();
+				GetChannel()->mixer()->apply_image_transform(GetLayerIndex(), transform, duration, tween);	
+			}
+			else if(_parameters[1] == L"LEVELS")
+			{
+				image_transform::levels value;
+				value.min_input  = boost::lexical_cast<double>(_parameters.at(2));
+				value.max_input  = boost::lexical_cast<double>(_parameters.at(3));
+				value.gamma		 = boost::lexical_cast<double>(_parameters.at(4));
+				value.min_output = boost::lexical_cast<double>(_parameters.at(5));
+				value.max_output = boost::lexical_cast<double>(_parameters.at(6));
+				int duration = _parameters.size() > 7 ? lexical_cast_or_default(_parameters[7], 0) : 0;
+				std::wstring tween = _parameters.size() > 8 ? _parameters[8] : L"linear";
+
+				auto transform = [=](image_transform transform) -> image_transform
+				{
+					transform.set_levels(value);
+					return transform;
+				};
+				
+				int layer = GetLayerIndex();
+				GetChannel()->mixer()->apply_image_transform(GetLayerIndex(), transform, duration, tween);	
+			}
 			else if(_parameters[1] == L"RESET")
 			{
-				GetChannel()->mixer().set_image_transform(GetLayerIndex(), image_transform());
+				int duration = _parameters.size() > 2 ? lexical_cast_or_default(_parameters[2], 0) : 0;
+				std::wstring tween = _parameters.size() > 3 ? _parameters[3] : L"linear";
+				
+				int layer = GetLayerIndex();
+				GetChannel()->mixer()->set_image_transform(GetLayerIndex(), image_transform(), duration, tween);
 			}
 		}
 		else if(_parameters[0] == L"AUDIO")
 		{
 			if(_parameters[1] == L"GAIN")
 			{
+				int duration = _parameters.size() > 3 ? lexical_cast_or_default(_parameters[3], 0) : 0;
+				std::wstring tween = _parameters.size() > 4 ? _parameters[4] : L"linear";
 				double value = boost::lexical_cast<double>(_parameters[2]);
-				auto transform = GetChannel()->mixer().get_audio_transform(GetLayerIndex());
-				transform.set_gain(value);
-				GetChannel()->mixer().set_audio_transform(GetLayerIndex(), std::move(transform));
+
+				auto transform = [=](audio_transform transform) -> audio_transform
+				{
+					transform.set_gain(value);
+					return transform;
+				};
+				
+				int layer = GetLayerIndex();
+				GetChannel()->mixer()->apply_audio_transform(GetLayerIndex(), transform, duration, tween);
 			}
 			else if(_parameters[1] == L"RESET")
 			{
-				GetChannel()->mixer().set_audio_transform(GetLayerIndex(), audio_transform());
+				int duration = _parameters.size() > 2 ? lexical_cast_or_default(_parameters[2], 0) : 0;
+				std::wstring tween = _parameters.size() > 3 ? _parameters[3] : L"linear";
+
+				int layer = GetLayerIndex();
+				GetChannel()->mixer()->set_audio_transform(GetLayerIndex(), audio_transform(), duration, tween);
 			}
 		}
 		else if(_parameters[0] == L"RESET")
 		{
-			GetChannel()->mixer().set_image_transform(GetLayerIndex(), image_transform());
-			GetChannel()->mixer().set_audio_transform(GetLayerIndex(), audio_transform());
+			GetChannel()->mixer()->reset_transforms();
 		}
 	
 		SetReplyString(TEXT("202 MIXER OK\r\n"));
@@ -294,13 +487,13 @@ bool SwapCommand::DoExecute()
 			int l1 = GetLayerIndex();
 			int l2 = boost::lexical_cast<int>(strs.at(1));
 
-			ch1->producer().swap_layer(l1, l2, ch2->producer());
+			ch1->stage()->swap_layer(l1, l2, *ch2->stage());
 		}
 		else
 		{
 			auto ch1 = GetChannel();
 			auto ch2 = GetChannels().at(boost::lexical_cast<int>(_parameters[0])-1);
-			ch1->producer().swap_output(ch2->producer());
+			ch1->stage()->swap(*ch2->stage());
 		}
 
 		CASPAR_LOG(info) << "Swapped successfully";
@@ -328,7 +521,7 @@ bool AddCommand::DoExecute()
 	//Perform loading of the clip
 	try
 	{
-		GetChannel()->consumer().add(GetLayerIndex(), create_consumer(_parameters));
+		GetChannel()->output()->add(GetLayerIndex(), create_consumer(_parameters));
 	
 		CASPAR_LOG(info) << "Added " <<  _parameters[0] << TEXT(" successfully");
 
@@ -355,9 +548,7 @@ bool RemoveCommand::DoExecute()
 	//Perform loading of the clip
 	try
 	{
-		GetChannel()->consumer().remove(GetLayerIndex());
-	
-		CASPAR_LOG(info) << "Removed " << TEXT(" successfully");
+		GetChannel()->output()->remove(GetLayerIndex());
 
 		SetReplyString(TEXT("202 REMOVE OK\r\n"));
 
@@ -383,8 +574,8 @@ bool LoadCommand::DoExecute()
 	try
 	{
 		_parameters[0] = _parameters[0];
-		auto pFP = create_producer(_parameters);		
-		GetChannel()->producer().preview(GetLayerIndex(), pFP);
+		auto pFP = create_producer(GetChannel()->mixer(), _parameters);		
+		GetChannel()->stage()->load(GetLayerIndex(), pFP, true);
 	
 		CASPAR_LOG(info) << "Loaded " <<  _parameters[0] << TEXT(" successfully");
 
@@ -406,65 +597,99 @@ bool LoadCommand::DoExecute()
 	}
 }
 
+
+
+//std::function<std::wstring()> channel_cg_add_command::parse(const std::wstring& message, const std::vector<renderer::render_device_ptr>& channels)
+//{
+//	static boost::wregex expr(L"^CG\\s(?<video_channel>\\d+)-?(?<LAYER>\\d+)?\\sADD\\s(?<FLASH_LAYER>\\d+)\\s(?<TEMPLATE>\\S+)\\s?(?<START_LABEL>\\S\\S+)?\\s?(?<PLAY_ON_LOAD>\\d)?\\s?(?<DATA>.*)?");
+//
+//	boost::wsmatch what;
+//	if(!boost::regex_match(message, what, expr))
+//		return nullptr;
+//
+//	auto info = channel_info::parse(what, channels);
+//
+//	int flash_layer_index = boost::lexical_cast<int>(what["FLASH_LAYER"].str());
+//
+//	std::wstring templatename = what["TEMPLATE"].str();
+//	bool play_on_load = what["PLAY_ON_LOAD"].matched ? what["PLAY_ON_LOAD"].str() != L"0" : 0;
+//	std::wstring start_label = what["START_LABEL"].str();	
+//	std::wstring data = get_data(what["DATA"].str());
+//	
+//	boost::replace_all(templatename, "\"", "");
+//
+//	return [=]() -> std::wstring
+//	{	
+//		std::wstring fullFilename = flash::flash_producer::find_template(server::template_folder() + templatename);
+//		if(fullFilename.empty())
+//			BOOST_THROW_EXCEPTION(file_not_found());
+//	
+//		std::wstring extension = boost::filesystem::wpath(fullFilename).extension();
+//		std::wstring filename = templatename;
+//		filename.append(extension);
+//
+//		flash::get_default_cg_producer(info.video_channel, std::max<int>(DEFAULT_CHANNEL_LAYER+1, info.layer_index))
+//			->add(flash_layer_index, filename, play_on_load, start_label, data);
+//
+//		CASPAR_LOG(info) << L"Executed [amcp_channel_cg_add]";
+//		return L"";
+//	};
+
 bool LoadbgCommand::DoExecute()
 {
 	transition_info transitionInfo;
 	
 	bool bLoop = false;
-	unsigned short transitionParameterIndex = 1;
 
-	if(_parameters.size() > 1 && _parameters[1] == TEXT("LOOP"))
-		++transitionParameterIndex;
+	// TRANSITION
 
-	//Setup transition info
-	if(_parameters.size() > transitionParameterIndex)	//type
+	std::wstring message;
+	for(size_t n = 0; n < _parameters.size(); ++n)
+		message += _parameters[n] + L" ";
+		
+	static const boost::wregex expr(L".*(?<TRANSITION>CUT|PUSH|SLIDE|WIPE|MIX)\\s*(?<DURATION>\\d+)\\s*(?<TWEEN>(LINEAR)|(EASE[^\\s]*))?\\s*(?<DIRECTION>FROMLEFT|FROMRIGHT|LEFT|RIGHT)?.*");
+	boost::wsmatch what;
+	if(boost::regex_match(message, what, expr))
 	{
-		std::wstring transitionType = _parameters[transitionParameterIndex];
+		auto transition = what["TRANSITION"].str();
+		transitionInfo.duration = lexical_cast_or_default<size_t>(what["DURATION"].str());
+		auto direction = what["DIRECTION"].matched ? what["DIRECTION"].str() : L"";
+		auto tween = what["TWEEN"].matched ? what["TWEEN"].str() : L"";
+		transitionInfo.tweener = get_tweener(tween);		
 
-		if(transitionType == TEXT("CUT"))
+		if(transition == TEXT("CUT"))
 			transitionInfo.type = transition::cut;
-		else if(transitionType == TEXT("MIX"))
+		else if(transition == TEXT("MIX"))
 			transitionInfo.type = transition::mix;
-		else if(transitionType == TEXT("PUSH"))
+		else if(transition == TEXT("PUSH"))
 			transitionInfo.type = transition::push;
-		else if(transitionType == TEXT("SLIDE"))
+		else if(transition == TEXT("SLIDE"))
 			transitionInfo.type = transition::slide;
-		else if(transitionType == TEXT("WIPE"))
+		else if(transition == TEXT("WIPE"))
 			transitionInfo.type = transition::wipe;
-
-		if(_parameters.size() > static_cast<unsigned short>(transitionParameterIndex+1))	//duration
-		{
-			int duration = _ttoi(_parameters[transitionParameterIndex+1].c_str());
-			if(duration > 0)
-				transitionInfo.duration = duration;
-
-			if(_parameters.size() > static_cast<unsigned short>(transitionParameterIndex+2))	//direction
-			{
-				std::wstring direction = _parameters[transitionParameterIndex+2];
-
-				if(direction == TEXT("FROMLEFT"))
-					transitionInfo.direction = transition_direction::from_left;
-				else if(direction == TEXT("FROMRIGHT"))
-					transitionInfo.direction = transition_direction::from_right;
-				else if(direction == TEXT("LEFT"))
-					transitionInfo.direction = transition_direction::from_right;
-				else if(direction == TEXT("RIGHT"))
-					transitionInfo.direction = transition_direction::from_left;
-			}
-		}
+		
+		if(direction == TEXT("FROMLEFT"))
+			transitionInfo.direction = transition_direction::from_left;
+		else if(direction == TEXT("FROMRIGHT"))
+			transitionInfo.direction = transition_direction::from_right;
+		else if(direction == TEXT("LEFT"))
+			transitionInfo.direction = transition_direction::from_right;
+		else if(direction == TEXT("RIGHT"))
+			transitionInfo.direction = transition_direction::from_left;
 	}
-
+	
 	//Perform loading of the clip
 	try
 	{
 		_parameters[0] = _parameters[0];
-		auto pFP = create_producer(_parameters);
+		auto pFP = create_producer(GetChannel()->mixer(), _parameters);
 		if(pFP == frame_producer::empty())
 			BOOST_THROW_EXCEPTION(file_not_found() << msg_info(_parameters.size() > 0 ? narrow(_parameters[0]) : ""));
 
-		pFP = safe_ptr<core::frame_producer>(transition_producer(pFP, transitionInfo));
-		bool autoPlay = std::find(_parameters.begin(), _parameters.end(), TEXT("AUTOPLAY")) != _parameters.end();
-		GetChannel()->producer().load(GetLayerIndex(), pFP, autoPlay); // TODO: LOOP
+		bool auto_play = std::find(_parameters.begin(), _parameters.end(), L"AUTO") != _parameters.end();
+
+		auto pFP2 = create_transition_producer(GetChannel()->get_video_format_desc().mode, pFP, transitionInfo);
+		GetChannel()->stage()->load(GetLayerIndex(), pFP2, false, auto_play ? transitionInfo.duration : -1); // TODO: LOOP
 	
 		CASPAR_LOG(info) << "Loaded " << _parameters[0] << TEXT(" successfully to background");
 		SetReplyString(TEXT("202 LOADBG OK\r\n"));
@@ -489,7 +714,7 @@ bool PauseCommand::DoExecute()
 {
 	try
 	{
-		GetChannel()->producer().pause(GetLayerIndex());
+		GetChannel()->stage()->pause(GetLayerIndex());
 		SetReplyString(TEXT("202 PAUSE OK\r\n"));
 		return true;
 	}
@@ -505,7 +730,23 @@ bool PlayCommand::DoExecute()
 {
 	try
 	{
-		GetChannel()->producer().play(GetLayerIndex());
+		if(!_parameters.empty())
+		{
+			LoadbgCommand lbg;
+			lbg.SetChannel(GetChannel());
+			lbg.SetChannelIndex(GetChannelIndex());
+			lbg.SetLayerIntex(GetLayerIndex());
+			lbg.SetClientInfo(GetClientInfo());
+			for(auto it = _parameters.begin(); it != _parameters.end(); ++it)
+				lbg.AddParameter(*it);
+			if(!lbg.Execute())
+				CASPAR_LOG(warning) << " Failed to play.";
+
+			CASPAR_LOG(info) << "Playing " << _parameters[0];
+		}
+
+		GetChannel()->stage()->play(GetLayerIndex());
+		
 		SetReplyString(TEXT("202 PLAY OK\r\n"));
 		return true;
 	}
@@ -521,7 +762,7 @@ bool StopCommand::DoExecute()
 {
 	try
 	{
-		GetChannel()->producer().stop(GetLayerIndex());
+		GetChannel()->stage()->stop(GetLayerIndex());
 		SetReplyString(TEXT("202 STOP OK\r\n"));
 		return true;
 	}
@@ -535,13 +776,26 @@ bool StopCommand::DoExecute()
 
 bool ClearCommand::DoExecute()
 {
-	GetChannel()->producer().clear(GetLayerIndex());
+	int index = GetLayerIndex(std::numeric_limits<int>::min());
+	if(index != std::numeric_limits<int>::min())
+		GetChannel()->stage()->clear(index);
+	else
+		GetChannel()->stage()->clear();
 		
 	SetReplyString(TEXT("202 CLEAR OK\r\n"));
 
 	return true;
 }
 
+bool PrintCommand::DoExecute()
+{
+	GetChannel()->output()->add(99978, create_consumer(boost::assign::list_of(L"IMAGE")));
+		
+	SetReplyString(TEXT("202 PRINT OK\r\n"));
+
+	return true;
+}
+
 bool CGCommand::DoExecute()
 {
 	std::wstring command = _parameters[0];
@@ -605,7 +859,7 @@ bool CGCommand::DoExecuteAdd() {
 
 	if(_parameters[3].length() > 1) 
 	{	//read label
-		label = _parameters[3];
+		label = _parameters2[3];
 		++dataIndex;
 
 		if(_parameters.size() > 4 && _parameters[4].length() > 0)	//read play-on-load-flag
@@ -630,7 +884,7 @@ bool CGCommand::DoExecuteAdd() {
 	std::wstring dataFromFile;
 	if(_parameters.size() > dataIndex) 
 	{	//read data
-		const std::wstring& dataString = _parameters[dataIndex];
+		const std::wstring& dataString = _parameters2[dataIndex];
 
 		if(dataString[0] == TEXT('<')) //the data is an XML-string
 			pDataString = dataString.c_str();
@@ -656,14 +910,14 @@ bool CGCommand::DoExecuteAdd() {
 		}
 	}
 
-	std::wstring fullFilename = core::flash::flash_producer::find_template(env::template_folder() + _parameters[2]);
+	std::wstring fullFilename = find_flash_template(env::template_folder() + _parameters[2]);
 	if(!fullFilename.empty())
 	{
 		std::wstring extension = boost::filesystem::wpath(fullFilename).extension();
 		std::wstring filename = _parameters[2];
 		filename.append(extension);
 
-		core::flash::get_default_cg_producer(safe_ptr<core::channel>(GetChannel()), GetLayerIndex(core::flash::cg_producer::DEFAULT_LAYER))->add(layer, filename, bDoStart, label, (pDataString!=0) ? pDataString : TEXT(""));
+		get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->add(layer, filename, bDoStart, label, (pDataString!=0) ? pDataString : TEXT(""));
 		SetReplyString(TEXT("202 CG OK\r\n"));
 	}
 	else
@@ -684,7 +938,7 @@ bool CGCommand::DoExecutePlay()
 			return false;
 		}
 		int layer = _ttoi(_parameters[1].c_str());
-		core::flash::get_default_cg_producer(safe_ptr<core::channel>(GetChannel()), GetLayerIndex(core::flash::cg_producer::DEFAULT_LAYER))->play(layer);
+		get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->play(layer);
 	}
 	else
 	{
@@ -706,7 +960,7 @@ bool CGCommand::DoExecuteStop()
 			return false;
 		}
 		int layer = _ttoi(_parameters[1].c_str());
-		core::flash::get_default_cg_producer(safe_ptr<core::channel>(GetChannel()), GetLayerIndex(core::flash::cg_producer::DEFAULT_LAYER))->stop(layer, 0);
+		get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->stop(layer, 0);
 	}
 	else 
 	{
@@ -728,7 +982,7 @@ bool CGCommand::DoExecuteNext()
 			return false;
 		}
 		int layer = _ttoi(_parameters[1].c_str());
-		core::flash::get_default_cg_producer(safe_ptr<core::channel>(GetChannel()), GetLayerIndex(core::flash::cg_producer::DEFAULT_LAYER))->next(layer);
+		get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->next(layer);
 	}
 	else 
 	{
@@ -750,7 +1004,7 @@ bool CGCommand::DoExecuteRemove()
 			return false;
 		}
 		int layer = _ttoi(_parameters[1].c_str());
-		core::flash::get_default_cg_producer(safe_ptr<core::channel>(GetChannel()), GetLayerIndex(core::flash::cg_producer::DEFAULT_LAYER))->remove(layer);
+		get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->remove(layer);
 	}
 	else 
 	{
@@ -764,7 +1018,7 @@ bool CGCommand::DoExecuteRemove()
 
 bool CGCommand::DoExecuteClear() 
 {
-	core::flash::get_default_cg_producer(safe_ptr<core::channel>(GetChannel()), GetLayerIndex(core::flash::cg_producer::DEFAULT_LAYER))->clear();
+	GetChannel()->stage()->clear(GetLayerIndex(cg_producer::DEFAULT_LAYER));
 	SetReplyString(TEXT("202 CG OK\r\n"));
 	return true;
 }
@@ -780,7 +1034,7 @@ bool CGCommand::DoExecuteUpdate()
 		}
 		int layer = _ttoi(_parameters[1].c_str());
 		//TODO: Implement indirect data loading from file. Same as in Add
-		core::flash::get_default_cg_producer(safe_ptr<core::channel>(GetChannel()), GetLayerIndex(core::flash::cg_producer::DEFAULT_LAYER))->update(layer, _parameters[2]);
+		get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->update(layer, _parameters2[2]);
 	}
 	else 
 	{
@@ -802,7 +1056,7 @@ bool CGCommand::DoExecuteInvoke()
 			return false;
 		}
 		int layer = _ttoi(_parameters[1].c_str());
-		core::flash::get_default_cg_producer(safe_ptr<core::channel>(GetChannel()), GetLayerIndex(core::flash::cg_producer::DEFAULT_LAYER))->invoke(layer, _parameters[2]);
+		get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->invoke(layer, _parameters2[2]);
 	}
 	else 
 	{
@@ -817,7 +1071,7 @@ bool CGCommand::DoExecuteInvoke()
 bool CGCommand::DoExecuteInfo() 
 {
 	// TODO
-	//core::flash::get_default_cg_producer(GetChannel())->Info();
+	//get_default_cg_producer(GetChannel())->Info();
 	SetReplyString(TEXT("600 CG FAILED\r\n"));
 	return true;
 }
@@ -941,7 +1195,7 @@ bool CinfCommand::DoExecute()
 	return false;
 }
 
-void GenerateChannelInfo(int index, const safe_ptr<core::channel>& pChannel, std::wstringstream& replyString)
+void GenerateChannelInfo(int index, const safe_ptr<core::video_channel>& pChannel, std::wstringstream& replyString)
 {
 	replyString << index+1 << TEXT(" ") << pChannel->get_video_format_desc().name << TEXT(" PLAYING") << TEXT("\r\n");
 }
@@ -1009,10 +1263,19 @@ bool TlsCommand::DoExecute()
 
 bool VersionCommand::DoExecute()
 {
-	std::wstringstream replyString;
-	replyString << TEXT("201 VERSION OK\r\n") << env::version() << TEXT("\r\n");
+	std::wstring replyString = TEXT("201 VERSION OK\r\n SERVER: ") + env::version() + TEXT("\r\n");
 
-	SetReplyString(replyString.str());
+	if(_parameters.size() > 0)
+	{
+		if(_parameters[0] == L"FLASH")
+			replyString = TEXT("201 VERSION OK\r\n FLASH: ") + get_flash_version() + TEXT("\r\n");
+		else if(_parameters[0] == L"TEMPLATEHOST")
+			replyString = TEXT("201 VERSION OK\r\n TEMPLATEHOST: ") + get_cg_version() + TEXT("\r\n");
+		else if(_parameters[0] != L"SERVER")
+			replyString = TEXT("403 VERSION ERROR\r\n");
+	}
+
+	SetReplyString(replyString);
 	return true;
 }
 
@@ -1032,10 +1295,14 @@ bool SetCommand::DoExecute()
 
 	if(name == TEXT("MODE"))
 	{
-		//if(this->GetChannel()->consumer().SetVideoFormat(value)) TODO
-		//	this->SetReplyString(TEXT("202 SET MODE OK\r\n"));
-		//else
-			this->SetReplyString(TEXT("501 SET MODE FAILED\r\n"));
+		auto format_desc = core::video_format_desc::get(value);
+		if(format_desc.format != core::video_format::invalid)
+		{
+			GetChannel()->set_video_format_desc(format_desc);
+			SetReplyString(TEXT("202 SET MODE OK\r\n"));
+		}
+		else
+			SetReplyString(TEXT("501 SET MODE FAILED\r\n"));
 	}
 	else
 	{