X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=protocol%2Famcp%2FAMCPCommandsImpl.cpp;h=5eedd32f13a8d1fcb72b9c5666903bd4badf9a99;hb=3cfeb882a742d67080e60b2686421b4d862e9e9c;hp=0b06c546fccc577b5ce8c7affbcaf41306e0b1f2;hpb=f0ee6c6addebce6dfbe10ab969463ba448726fd8;p=casparcg

diff --git a/protocol/amcp/AMCPCommandsImpl.cpp b/protocol/amcp/AMCPCommandsImpl.cpp
index 0b06c546f..5eedd32f1 100644
--- a/protocol/amcp/AMCPCommandsImpl.cpp
+++ b/protocol/amcp/AMCPCommandsImpl.cpp
@@ -20,21 +20,29 @@
 
 #include "../StdAfx.h"
 
+#if defined(_MSC_VER)
+#pragma warning (push, 1) // TODO: Legacy code, just disable warnings
+#endif
+
 #include "AMCPCommandsImpl.h"
 #include "AMCPProtocolStrategy.h"
 
-#include "../media.h"
-
 #include <common/env.h>
 
+#include <common/log/log.h>
+
 #include <core/producer/frame_producer.h>
 #include <core/video_format.h>
-#include <core/producer/flash/flash_producer.h>
 #include <core/producer/transition/transition_producer.h>
-#include <core/producer/flash/cg_producer.h>
+#include <core/producer/frame/frame_transform.h>
+#include <core/producer/stage.h>
+#include <core/producer/layer.h>
+#include <core/mixer/mixer.h>
+#include <core/consumer/output.h>
 
-#include <mixer/image/image_transform.h>
-#include <mixer/audio/audio_transform.h>
+#include <modules/flash/flash.h>
+#include <modules/flash/producer/flash_producer.h>
+#include <modules/flash/producer/cg_producer.h>
 
 #include <algorithm>
 #include <locale>
@@ -46,10 +54,7 @@
 #include <boost/lexical_cast.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/filesystem.hpp>
-
-#if defined(_MSC_VER)
-#pragma warning (push, 1) // TODO: Legacy code, just disable warnings
-#endif
+#include <boost/regex.hpp>
 
 /* Return codes
 
@@ -86,10 +91,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 +115,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 +149,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,100 +184,234 @@ 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
 	try
 	{	
-		if(_parameters[0] == L"VIDEO")
+		if(_parameters[0] == L"KEYER")
 		{
-			if(_parameters[1] == L"OPACITY")
+			bool value = lexical_cast_or_default(_parameters.at(1), false);
+			auto transform = [=](frame_transform transform) -> frame_transform
 			{
-				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));
-			}
-			else if(_parameters[1] == L"GAIN")
+				transform.is_key = value;
+				return transform;					
+			};
+
+			int layer = GetLayerIndex();
+			GetChannel()->mixer()->apply_frame_transform(GetLayerIndex(), transform);
+		}
+		else if(_parameters[0] == L"OPACITY")
+		{
+			int duration = _parameters.size() > 2 ? lexical_cast_or_default(_parameters[2], 0) : 0;
+			std::wstring tween = _parameters.size() > 3 ? _parameters[3] : L"linear";
+
+			double value = boost::lexical_cast<double>(_parameters.at(1));
+			
+			auto transform = [=](frame_transform transform) -> frame_transform
 			{
-				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));
-			}
-			else if(_parameters[1] == L"FIX_RECT")
+				transform.opacity = value;
+				return transform;					
+			};
+
+			int layer = GetLayerIndex();
+			GetChannel()->mixer()->apply_frame_transform(GetLayerIndex(), transform, duration, tween);
+		}
+		else if(_parameters[0] == L"FILL")
+		{
+			int duration = _parameters.size() > 5 ? lexical_cast_or_default(_parameters[5], 0) : 0;
+			std::wstring tween = _parameters.size() > 6 ? _parameters[6] : L"linear";
+			double x	= boost::lexical_cast<double>(_parameters.at(1));
+			double y	= boost::lexical_cast<double>(_parameters.at(2));
+			double x_s	= boost::lexical_cast<double>(_parameters.at(3));
+			double y_s	= boost::lexical_cast<double>(_parameters.at(4));
+
+			auto transform = [=](frame_transform transform) mutable -> frame_transform
 			{
-				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));
-			}
-			else if(_parameters[1] == L"CLIP_RECT")
+				transform.fill_translation[0]	= x;
+				transform.fill_translation[1]	= y;
+				transform.fill_scale[0]			= x_s;
+				transform.fill_scale[1]			= y_s;
+				transform.clip_translation[0]	= x;
+				transform.clip_translation[1]	= y;
+				transform.clip_scale[0]			= x_s;
+				transform.clip_scale[1]			= y_s;
+				return transform;
+			};
+				
+			int layer = GetLayerIndex();
+			GetChannel()->mixer()->apply_frame_transform(GetLayerIndex(), transform, duration, tween);
+		}
+		else if(_parameters[0] == L"CLIP")
+		{
+			int duration = _parameters.size() > 5 ? lexical_cast_or_default(_parameters[5], 0) : 0;
+			std::wstring tween = _parameters.size() > 6 ? _parameters[6] : L"linear";
+			double x	= boost::lexical_cast<double>(_parameters.at(1));
+			double y	= boost::lexical_cast<double>(_parameters.at(2));
+			double x_s	= boost::lexical_cast<double>(_parameters.at(3));
+			double y_s	= boost::lexical_cast<double>(_parameters.at(4));
+
+			auto transform = [=](frame_transform transform) -> frame_transform
 			{
-				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));
-			}
-			else if(_parameters[1] == L"GRID")
+				transform.clip_translation[0]	= x;
+				transform.clip_translation[1]	= y;
+				transform.clip_scale[0]			= x_s;
+				transform.clip_scale[1]			= y_s;
+				return transform;
+			};
+				
+			int layer = GetLayerIndex();
+			GetChannel()->mixer()->apply_frame_transform(GetLayerIndex(), transform, duration, tween);
+		}
+		else if(_parameters[0] == L"GRID")
+		{
+			int duration = _parameters.size() > 2 ? lexical_cast_or_default(_parameters[2], 0) : 0;
+			std::wstring tween = _parameters.size() > 3 ? _parameters[3] : L"linear";
+			int n = boost::lexical_cast<int>(_parameters.at(1));
+			double delta = 1.0/static_cast<double>(n);
+			for(int x = 0; x < n; ++x)
 			{
-				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)
 				{
-					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 = [=](frame_transform transform) -> frame_transform
+					{		
+						transform.fill_translation[0]	= x*delta;
+						transform.fill_translation[1]	= y*delta;
+						transform.fill_scale[0]			= delta;
+						transform.fill_scale[1]			= delta;
+						transform.clip_translation[0]	= x*delta;
+						transform.clip_translation[1]	= y*delta;
+						transform.clip_scale[0]			= delta;
+						transform.clip_scale[1]			= delta;			
+						return transform;
+					};
+					GetChannel()->mixer()->apply_frame_transform(index, transform, duration, tween);
 				}
 			}
-			else if(_parameters[1] == L"RESET")
+		}
+		else if(_parameters[0] == L"BLEND")
+		{
+			auto blend_str = _parameters.at(1);								
+			int layer = GetLayerIndex();
+			GetChannel()->mixer()->set_blend_mode(GetLayerIndex(), get_blend_mode(blend_str));	
+		}
+		else if(_parameters[0] == L"BRIGHTNESS")
+		{
+			auto value = boost::lexical_cast<double>(_parameters.at(1));
+			int duration = _parameters.size() > 2 ? lexical_cast_or_default(_parameters[2], 0) : 0;
+			std::wstring tween = _parameters.size() > 3 ? _parameters[3] : L"linear";
+			auto transform = [=](frame_transform transform) -> frame_transform
 			{
-				GetChannel()->mixer().set_image_transform(GetLayerIndex(), image_transform());
-			}
+				transform.brightness = value;
+				return transform;
+			};
+				
+			int layer = GetLayerIndex();
+			GetChannel()->mixer()->apply_frame_transform(GetLayerIndex(), transform, duration, tween);	
 		}
-		else if(_parameters[0] == L"AUDIO")
+		else if(_parameters[0] == L"SATURATION")
 		{
-			if(_parameters[1] == L"GAIN")
+			auto value = boost::lexical_cast<double>(_parameters.at(1));
+			int duration = _parameters.size() > 2 ? lexical_cast_or_default(_parameters[2], 0) : 0;
+			std::wstring tween = _parameters.size() > 3 ? _parameters[3] : L"linear";
+			auto transform = [=](frame_transform transform) -> frame_transform
 			{
-				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));
-			}
-			else if(_parameters[1] == L"RESET")
+				transform.saturation = value;
+				return transform;
+			};
+				
+			int layer = GetLayerIndex();
+			GetChannel()->mixer()->apply_frame_transform(GetLayerIndex(), transform, duration, tween);	
+		}
+		else if(_parameters[0] == L"CONTRAST")
+		{
+			auto value = boost::lexical_cast<double>(_parameters.at(1));
+			int duration = _parameters.size() > 2 ? lexical_cast_or_default(_parameters[2], 0) : 0;
+			std::wstring tween = _parameters.size() > 3 ? _parameters[3] : L"linear";
+			auto transform = [=](frame_transform transform) -> frame_transform
 			{
-				GetChannel()->mixer().set_audio_transform(GetLayerIndex(), audio_transform());
-			}
+				transform.contrast = value;
+				return transform;
+			};
+				
+			int layer = GetLayerIndex();
+			GetChannel()->mixer()->apply_frame_transform(GetLayerIndex(), transform, duration, tween);	
+		}
+		else if(_parameters[0] == L"LEVELS")
+		{
+			levels value;
+			value.min_input  = boost::lexical_cast<double>(_parameters.at(1));
+			value.max_input  = boost::lexical_cast<double>(_parameters.at(2));
+			value.gamma		 = boost::lexical_cast<double>(_parameters.at(3));
+			value.min_output = boost::lexical_cast<double>(_parameters.at(4));
+			value.max_output = boost::lexical_cast<double>(_parameters.at(5));
+			int duration = _parameters.size() > 6 ? lexical_cast_or_default(_parameters[6], 0) : 0;
+			std::wstring tween = _parameters.size() > 7 ? _parameters[7] : L"linear";
+
+			auto transform = [=](frame_transform transform) -> frame_transform
+			{
+				transform.levels = value;
+				return transform;
+			};
+				
+			int layer = GetLayerIndex();
+			GetChannel()->mixer()->apply_frame_transform(GetLayerIndex(), transform, duration, tween);	
+		}
+		else if(_parameters[0] == L"VOLUME")
+		{
+			int duration = _parameters.size() > 2 ? lexical_cast_or_default(_parameters[2], 0) : 0;
+			std::wstring tween = _parameters.size() > 3 ? _parameters[3] : L"linear";
+			double value = boost::lexical_cast<double>(_parameters[1]);
+
+			auto transform = [=](frame_transform transform) -> frame_transform
+			{
+				transform.volume = value;
+				return transform;
+			};
+				
+			int layer = GetLayerIndex();
+			GetChannel()->mixer()->apply_frame_transform(GetLayerIndex(), transform, duration, tween);
 		}
-		else if(_parameters[0] == L"RESET")
+		else if(_parameters[0] == L"CLEAR")
 		{
-			GetChannel()->mixer().set_image_transform(GetLayerIndex(), image_transform());
-			GetChannel()->mixer().set_audio_transform(GetLayerIndex(), audio_transform());
+			GetChannel()->mixer()->clear_transforms();
+		}
+		else
+		{
+			SetReplyString(TEXT("404 MIXER ERROR\r\n"));
+			return false;
 		}
 	
 		SetReplyString(TEXT("202 MIXER OK\r\n"));
@@ -294,13 +448,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(ch2->producer());
+			ch1->stage()->swap(*ch2->stage());
 		}
 
 		CASPAR_LOG(info) << "Swapped successfully";
@@ -328,7 +482,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 +509,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 +535,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 +558,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().field_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 +675,7 @@ bool PauseCommand::DoExecute()
 {
 	try
 	{
-		GetChannel()->producer().pause(GetLayerIndex());
+		GetChannel()->stage()->pause(GetLayerIndex());
 		SetReplyString(TEXT("202 PAUSE OK\r\n"));
 		return true;
 	}
@@ -505,7 +691,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 +723,7 @@ bool StopCommand::DoExecute()
 {
 	try
 	{
-		GetChannel()->producer().stop(GetLayerIndex());
+		GetChannel()->stage()->stop(GetLayerIndex());
 		SetReplyString(TEXT("202 STOP OK\r\n"));
 		return true;
 	}
@@ -535,13 +737,62 @@ 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 StatusCommand::DoExecute()
+{				
+	if (GetLayerIndex() > -1)
+	{
+		auto status = GetChannel()->stage()->get_status(GetLayerIndex());
+		std::wstringstream status_text;
+		status_text
+			<< L"202 STATUS OK\r\n"
+			<< L"FOREGROUND:"		<< status.foreground << L"\r\n"
+			<< L"BACKGROUND:"		<< status.background << L"\r\n"
+			<< L"STATUS:"			<< (status.is_paused ? L"PAUSED" : L"PLAYING") << L"\r\n"
+			<< L"TOTAL FRAMES:"		<< (status.total_frames == std::numeric_limits<int64_t>::max() ? 0 : status.total_frames) << L"\r\n"
+			<< L"CURRENT FRAME:"	<< status.current_frame << L"\r\n";
+
+		SetReplyString(status_text.str());
+		return true;
+	}
+	else
+	{
+		//NOTE: Possible to extend soo that "channel" status is returned when no layer is specified.
+
+		SetReplyString(TEXT("403 LAYER MUST BE SPECIFIED\r\n"));
+		return false;
+	}
+}
+
+bool LogCommand::DoExecute()
+{
+	if(_parameters.at(0) == L"LEVEL")
+		log::set_log_level(_parameters.at(1));
+
+	SetReplyString(TEXT("202 LOG OK\r\n"));
+
+	return true;
+}
+
 bool CGCommand::DoExecute()
 {
 	std::wstring command = _parameters[0];
@@ -605,7 +856,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 +881,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 +907,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 +935,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 +957,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 
 	{
@@ -727,8 +978,9 @@ bool CGCommand::DoExecuteNext()
 			SetReplyString(TEXT("403 CG ERROR\r\n"));
 			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 
 	{
@@ -749,8 +1001,9 @@ bool CGCommand::DoExecuteRemove()
 			SetReplyString(TEXT("403 CG ERROR\r\n"));
 			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,25 +1017,47 @@ 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;
 }
 
 bool CGCommand::DoExecuteUpdate() 
 {
-	if(_parameters.size() > 2) 
+	try
 	{
-		if(!ValidateLayer(_parameters[1]))
+		if(!ValidateLayer(_parameters.at(1)))
 		{
 			SetReplyString(TEXT("403 CG ERROR\r\n"));
 			return false;
 		}
-		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]);
+						
+		std::wstring dataString = _parameters2.at(2);				
+		if(dataString.at(0) != TEXT('<'))
+		{
+			//The data is not an XML-string, it must be a filename
+			std::wstring filename = env::data_folder();
+			filename.append(dataString);
+			filename.append(TEXT(".ftd"));
+
+			//open file
+			std::wifstream datafile(filename.c_str());
+			if(datafile) 
+			{
+				std::wstringstream data;
+				//read all data
+				data << datafile.rdbuf();
+				datafile.close();
+
+				//extract data to _parameters
+				dataString = data.str();
+			}
+		}		
+
+		int layer = _ttoi(_parameters.at(1).c_str());
+		get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->update(layer, dataString);
 	}
-	else 
+	catch(...)
 	{
 		SetReplyString(TEXT("402 CG ERROR\r\n"));
 		return true;
@@ -802,7 +1077,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 +1092,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;
 }
@@ -855,7 +1130,7 @@ bool DataCommand::DoExecuteStore()
 		return false;
 	}
 
-	datafile << _parameters[2];
+	datafile << _parameters2[2];
 	datafile.close();
 
 	std::wstring replyString = TEXT("202 DATA STORE OK\r\n");
@@ -905,7 +1180,24 @@ bool DataCommand::DoExecuteList()
 {
 	std::wstringstream replyString;
 	replyString << TEXT("200 DATA LIST OK\r\n");
-	replyString << ListMedia();
+
+	for (boost::filesystem::wrecursive_directory_iterator itr(env::data_folder()), end; itr != end; ++itr)
+	{			
+		if(boost::filesystem::is_regular_file(itr->path()))
+		{
+			if(!boost::iequals(itr->path().extension(), L".ftd"))
+				continue;
+			
+			auto relativePath = boost::filesystem::wpath(itr->path().file_string().substr(env::data_folder().size()-1, itr->path().file_string().size()));
+			
+			auto str = relativePath.replace_extension(TEXT("")).external_file_string();
+			if(str[0] == '\\' || str[0] == '/')
+				str = std::wstring(str.begin() + 1, str.end());
+
+			replyString << str << TEXT("\r\n"); 	
+		}
+	}
+	
 	replyString << TEXT("\r\n");
 
 	SetReplyString(boost::to_upper_copy(replyString.str()));
@@ -941,7 +1233,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 +1301,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 +1333,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
 	{