X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=protocol%2Famcp%2FAMCPCommandsImpl.cpp;h=aec863e885ec6ee4b4b6d7612b635b8f9fdad627;hb=0629f3b9b79c8a5dcab3c6b082cd9ac95c119b68;hp=01477c88c6d66b917189ce1f95c77f1071bb71e7;hpb=745f022a44f0d347e56acbbd597ff71e06eab894;p=casparcg

diff --git a/protocol/amcp/AMCPCommandsImpl.cpp b/protocol/amcp/AMCPCommandsImpl.cpp
index 01477c88c..aec863e88 100644
--- a/protocol/amcp/AMCPCommandsImpl.cpp
+++ b/protocol/amcp/AMCPCommandsImpl.cpp
@@ -20,20 +20,30 @@
 
 #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 <common/env.h>
 
+#include <common/log/log.h>
+
 #include <core/producer/frame_producer.h>
 #include <core/video_format.h>
+#include <core/video_channel_context.h>
+#include <core/producer/transition/transition_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 <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 <mixer/image/image_transform.h>
-#include <mixer/audio/audio_transform.h>
 
 #include <algorithm>
 #include <locale>
@@ -45,10 +55,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
 
@@ -76,45 +83,57 @@ namespace caspar { namespace protocol {
 
 using namespace core;
 
+std::wstring MediaInfo(const boost::filesystem::wpath& path)
+{
+	if(boost::filesystem::is_regular_file(path))
+	{
+		std::wstring clipttype = TEXT(" N/A ");
+		std::wstring extension = boost::to_upper_copy(path.extension());
+		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 == 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 ");
+
+		if(clipttype != TEXT(" N/A "))
+		{		
+			auto is_not_digit = [](char c){ return std::isdigit(c) == 0; };
+
+			auto relativePath = boost::filesystem::wpath(path.file_string().substr(env::media_folder().size()-1, path.file_string().size()));
+
+			auto writeTimeStr = boost::posix_time::to_iso_string(boost::posix_time::from_time_t(boost::filesystem::last_write_time(path)));
+			writeTimeStr.erase(std::remove_if(writeTimeStr.begin(), writeTimeStr.end(), is_not_digit), writeTimeStr.end());
+			auto writeTimeWStr = std::wstring(writeTimeStr.begin(), writeTimeStr.end());
+
+			auto sizeStr = boost::lexical_cast<std::wstring>(boost::filesystem::file_size(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());
+
+			return std::wstring() + TEXT("\"") + str +
+					+ TEXT("\" ") + clipttype +
+					+ TEXT(" ") + sizeStr +
+					+ TEXT(" ") + writeTimeWStr +
+					+ TEXT("\r\n"); 	
+		}	
+	}
+	return L"";
+}
+
 std::wstring ListMedia()
 {	
 	std::wstringstream replyString;
-	for (boost::filesystem::wrecursive_directory_iterator itr(env::media_folder()), end; itr != end; ++itr)
-	{			
-		if(boost::filesystem::is_regular_file(itr->path()))
-		{
-			std::wstring clipttype = TEXT(" N/A ");
-			std::wstring extension = boost::to_upper_copy(itr->path().extension());
-			if(extension == TEXT(".TGA") || extension == TEXT(".COL"))
-				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"))
-				clipttype = TEXT(" MOVIE ");
-			else if(extension == TEXT(".WAV") || extension == TEXT(".MP3"))
-				clipttype = TEXT(" STILL ");
-
-			if(clipttype != TEXT(" N/A "))
-			{		
-				auto is_not_digit = [](char c){ return std::isdigit(c) == 0; };
-
-				auto relativePath = boost::filesystem::wpath(itr->path().file_string().substr(env::media_folder().size()-1, itr->path().file_string().size()));
-
-				auto writeTimeStr = boost::posix_time::to_iso_string(boost::posix_time::from_time_t(boost::filesystem::last_write_time(itr->path())));
-				writeTimeStr.erase(std::remove_if(writeTimeStr.begin(), writeTimeStr.end(), is_not_digit), writeTimeStr.end());
-				auto writeTimeWStr = std::wstring(writeTimeStr.begin(), writeTimeStr.end());
-
-				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());
-
-				replyString << TEXT("\"") << relativePath.replace_extension(TEXT(""))
-							<< TEXT("\" ") << clipttype 
-							<< TEXT(" ") << sizeStr
-							<< TEXT(" ") << writeTimeWStr
-							<< TEXT("\r\n");
-			}	
-		}
-	}
+	for (boost::filesystem::wrecursive_directory_iterator itr(env::media_folder()), end; itr != end; ++itr)	
+		replyString << MediaInfo(itr->path());
+	
 	return boost::to_upper_copy(replyString.str());
 }
 
@@ -136,14 +155,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 {
@@ -163,151 +190,239 @@ 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(0);
+
+		std::wstring param = _parameters2.at(1);
+		for(auto it = std::begin(_parameters2)+2; it != std::end(_parameters2); ++it)
+			param += L" " + *it;
+
+		if(what == L"B")
+			GetChannel()->stage()->background(GetLayerIndex()).get()->param(param);
+		else if(what == L"F")
+			GetChannel()->stage()->foreground(GetLayerIndex()).get()->param(param);
+	
+		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" || _parameters[0] == L"IS_KEY")
 		{
-			if(_parameters[1] == L"OPACITY")
+			bool value = lexical_cast_or_default(_parameters.at(1), false);
+			auto transform = [=](frame_transform transform) -> frame_transform
 			{
-				int duration = _parameters.size() > 3 ? lexical_cast_or_default(_parameters[3], 0) : 0;
-				double value = boost::lexical_cast<double>(_parameters.at(2));
+				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 = [=](image_transform transform) -> image_transform
-				{
-					transform.set_opacity(value);
-					return transform;					
-				};
-
-				int layer = GetLayerIndex(std::numeric_limits<int>::min());
-				if(layer != std::numeric_limits<int>::min())					
-					GetChannel()->mixer().apply_image_transform(GetLayerIndex(), transform, duration);
-				else
-					GetChannel()->mixer().apply_image_transform(transform, duration);
-			}
-			else if(_parameters[1] == L"GAIN")
+			auto transform = [=](frame_transform transform) -> frame_transform
 			{
-				int duration = _parameters.size() > 3 ? lexical_cast_or_default(_parameters[3], 0) : 0;
-				double value = boost::lexical_cast<double>(_parameters.at(2));
-				
-				auto transform = [=](image_transform transform) -> image_transform
-				{
-					transform.set_gain(value);
-					return transform;					
-				};
-
-				int layer = GetLayerIndex(std::numeric_limits<int>::min());
-				if(layer != std::numeric_limits<int>::min())
-					GetChannel()->mixer().apply_image_transform(GetLayerIndex(), transform, duration);
-				else
-					GetChannel()->mixer().apply_image_transform(transform, duration);
-			}
-			else if(_parameters[1] == L"FILL_RECT")
-			{
-				int duration = _parameters.size() > 6 ? lexical_cast_or_default(_parameters[6], 0) : 0;
-				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));
+				transform.opacity = value;
+				return transform;					
+			};
 
-				auto transform = [=](image_transform transform) -> image_transform
-				{
-					transform.set_fill_translation(x, y);
-					transform.set_fill_scale(x_s, y_s);
-					transform.set_key_translation(x, y);
-					transform.set_key_scale(x_s, y_s);
-					return transform;
-				};
-
-				int layer = GetLayerIndex(std::numeric_limits<int>::min());
-				if(layer != std::numeric_limits<int>::min())
-					GetChannel()->mixer().apply_image_transform(GetLayerIndex(), transform, duration);
-				else
-					GetChannel()->mixer().apply_image_transform(transform, duration);
-			}
-			else if(_parameters[1] == L"KEY_RECT")
+			int layer = GetLayerIndex();
+			GetChannel()->mixer()->apply_frame_transform(GetLayerIndex(), transform, duration, tween);
+		}
+		else if(_parameters[0] == L"FILL" || _parameters[0] == L"FILL_RECT")
+		{
+			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
 			{
-				int duration = _parameters.size() > 6 ? lexical_cast_or_default(_parameters[6], 0) : 0;
-				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 = [=](image_transform transform) -> image_transform
-				{
-					transform.set_key_translation(x, y);
-					transform.set_key_scale(x_s, y_s);
-					return transform;
-				};
-
-				int layer = GetLayerIndex(std::numeric_limits<int>::min());
-				if(layer != std::numeric_limits<int>::min())
-					GetChannel()->mixer().apply_image_transform(GetLayerIndex(), transform, duration);
-				else
-					GetChannel()->mixer().apply_image_transform(transform, duration);
-			}
-			else if(_parameters[1] == L"GRID")
+				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" || _parameters[0] == L"CLIP_RECT")
+		{
+			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
 			{
-				int n = boost::lexical_cast<int>(_parameters.at(2));
-				double delta = 1.0/static_cast<double>(n);
-				for(int x = 0; x < n; ++x)
+				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)
+			{
+				for(int y = 0; y < n; ++y)
 				{
-					for(int y = 0; y < n; ++y)
-					{
-						int index = x+y*n;
-						auto transform = [=](image_transform transform) -> image_transform
-						{				
-							transform.set_fill_translation(x*delta, y*delta);
-							transform.set_fill_scale(delta, delta);			
-							transform.set_key_translation(x*delta, y*delta);
-							transform.set_key_scale(delta, delta);
-							return transform;
-						};
-						GetChannel()->mixer().apply_image_transform(index, transform, 0);
-					}
+					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
 			{
-				int duration = _parameters.size() > 3 ? lexical_cast_or_default(_parameters[3], 0) : 0;
-				double value = boost::lexical_cast<double>(_parameters[2]);
-
-				auto transform = [=](audio_transform transform) -> audio_transform
-				{
-					transform.set_gain(value);
-					return transform;
-				};
+				transform.saturation = value;
+				return transform;
+			};
 				
-				int layer = GetLayerIndex(std::numeric_limits<int>::min());
-				if(layer != std::numeric_limits<int>::min())
-					GetChannel()->mixer().apply_audio_transform(GetLayerIndex(), transform, duration);
-				else
-					GetChannel()->mixer().apply_audio_transform(transform, duration);
-			}
-			else if(_parameters[1] == L"RESET")
+			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"));
@@ -344,13 +459,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";
@@ -378,7 +493,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");
 
@@ -405,7 +520,7 @@ bool RemoveCommand::DoExecute()
 	//Perform loading of the clip
 	try
 	{
-		GetChannel()->consumer().remove(GetLayerIndex());
+		GetChannel()->output()->remove(GetLayerIndex());
 
 		SetReplyString(TEXT("202 REMOVE OK\r\n"));
 
@@ -431,8 +546,8 @@ bool LoadCommand::DoExecute()
 	try
 	{
 		_parameters[0] = _parameters[0];
-		auto pFP = create_producer(_parameters);		
-		GetChannel()->producer().load(GetLayerIndex(), pFP, false, true);
+		auto pFP = create_producer(GetChannel()->mixer(), _parameters);		
+		GetChannel()->stage()->load(GetLayerIndex(), pFP, true);
 	
 		CASPAR_LOG(info) << "Loaded " <<  _parameters[0] << TEXT(" successfully");
 
@@ -443,76 +558,110 @@ bool LoadCommand::DoExecute()
 	catch(file_not_found&)
 	{
 		CASPAR_LOG_CURRENT_EXCEPTION();
-		SetReplyString(TEXT("404 LOADBG ERROR\r\n"));
+		SetReplyString(TEXT("404 LOAD ERROR\r\n"));
 		return false;
 	}
 	catch(...)
 	{
 		CASPAR_LOG_CURRENT_EXCEPTION();
-		SetReplyString(TEXT("502 LOADBG FAILED\r\n"));
+		SetReplyString(TEXT("502 LOAD FAILED\r\n"));
 		return false;
 	}
 }
 
+
+
+//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::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]) : ""));
 
-		auto pFP2 = make_safe<core::transition_producer>(pFP, transitionInfo);
-		bool autoPlay = std::find(_parameters.begin(), _parameters.end(), TEXT("AUTOPLAY")) != _parameters.end();
-		GetChannel()->producer().load(GetLayerIndex(), pFP2, 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, create_destroy_producer_proxy(GetChannel()->context().destruction(), 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"));
@@ -537,7 +686,7 @@ bool PauseCommand::DoExecute()
 {
 	try
 	{
-		GetChannel()->producer().pause(GetLayerIndex());
+		GetChannel()->stage()->pause(GetLayerIndex());
 		SetReplyString(TEXT("202 PAUSE OK\r\n"));
 		return true;
 	}
@@ -553,7 +702,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;
 	}
@@ -569,7 +734,7 @@ bool StopCommand::DoExecute()
 {
 	try
 	{
-		GetChannel()->producer().stop(GetLayerIndex());
+		GetChannel()->stage()->stop(GetLayerIndex());
 		SetReplyString(TEXT("202 STOP OK\r\n"));
 		return true;
 	}
@@ -585,15 +750,60 @@ bool ClearCommand::DoExecute()
 {
 	int index = GetLayerIndex(std::numeric_limits<int>::min());
 	if(index != std::numeric_limits<int>::min())
-		GetChannel()->producer().clear(index);
+		GetChannel()->stage()->clear(index);
 	else
-		GetChannel()->producer().clear();
+		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"200 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\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];
@@ -657,7 +867,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
@@ -682,7 +892,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();
@@ -708,14 +918,14 @@ bool CGCommand::DoExecuteAdd() {
 		}
 	}
 
-	std::wstring fullFilename = flash_producer::find_template(env::template_folder() + _parameters[2]);
+	std::wstring fullFilename = flash::find_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);
 
-		get_default_cg_producer(safe_ptr<core::channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->add(layer, filename, bDoStart, label, (pDataString!=0) ? pDataString : TEXT(""));
+		flash::get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->add(layer, filename, bDoStart, label, (pDataString!=0) ? pDataString : TEXT(""));
 		SetReplyString(TEXT("202 CG OK\r\n"));
 	}
 	else
@@ -736,7 +946,7 @@ bool CGCommand::DoExecutePlay()
 			return false;
 		}
 		int layer = _ttoi(_parameters[1].c_str());
-		get_default_cg_producer(safe_ptr<core::channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->play(layer);
+		flash::get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->play(layer);
 	}
 	else
 	{
@@ -758,7 +968,7 @@ bool CGCommand::DoExecuteStop()
 			return false;
 		}
 		int layer = _ttoi(_parameters[1].c_str());
-		get_default_cg_producer(safe_ptr<core::channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->stop(layer, 0);
+		flash::get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->stop(layer, 0);
 	}
 	else 
 	{
@@ -779,8 +989,9 @@ bool CGCommand::DoExecuteNext()
 			SetReplyString(TEXT("403 CG ERROR\r\n"));
 			return false;
 		}
+
 		int layer = _ttoi(_parameters[1].c_str());
-		get_default_cg_producer(safe_ptr<core::channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->next(layer);
+		flash::get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->next(layer);
 	}
 	else 
 	{
@@ -801,8 +1012,9 @@ bool CGCommand::DoExecuteRemove()
 			SetReplyString(TEXT("403 CG ERROR\r\n"));
 			return false;
 		}
+
 		int layer = _ttoi(_parameters[1].c_str());
-		get_default_cg_producer(safe_ptr<core::channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->remove(layer);
+		flash::get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->remove(layer);
 	}
 	else 
 	{
@@ -816,25 +1028,47 @@ bool CGCommand::DoExecuteRemove()
 
 bool CGCommand::DoExecuteClear() 
 {
-	get_default_cg_producer(safe_ptr<core::channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->clear();
+	GetChannel()->stage()->clear(GetLayerIndex(flash::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
-		get_default_cg_producer(safe_ptr<core::channel>(GetChannel()), GetLayerIndex(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());
+		flash::get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->update(layer, dataString);
 	}
-	else 
+	catch(...)
 	{
 		SetReplyString(TEXT("402 CG ERROR\r\n"));
 		return true;
@@ -854,7 +1088,7 @@ bool CGCommand::DoExecuteInvoke()
 			return false;
 		}
 		int layer = _ttoi(_parameters[1].c_str());
-		get_default_cg_producer(safe_ptr<core::channel>(GetChannel()), GetLayerIndex(cg_producer::DEFAULT_LAYER))->invoke(layer, _parameters[2]);
+		flash::get_default_cg_producer(safe_ptr<core::video_channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->invoke(layer, _parameters2[2]);
 	}
 	else 
 	{
@@ -869,7 +1103,7 @@ bool CGCommand::DoExecuteInvoke()
 bool CGCommand::DoExecuteInfo() 
 {
 	// TODO
-	//get_default_cg_producer(GetChannel())->Info();
+	//flash::get_default_cg_producer(GetChannel())->Info();
 	SetReplyString(TEXT("600 CG FAILED\r\n"));
 	return true;
 }
@@ -907,7 +1141,7 @@ bool DataCommand::DoExecuteStore()
 		return false;
 	}
 
-	datafile << _parameters[2];
+	datafile << _parameters2[2];
 	datafile.close();
 
 	std::wstring replyString = TEXT("202 DATA STORE OK\r\n");
@@ -957,7 +1191,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()));
@@ -967,65 +1218,67 @@ bool DataCommand::DoExecuteList()
 bool CinfCommand::DoExecute()
 {
 	std::wstringstream replyString;
+	
+	try
+	{
+		std::wstring info;
+		for (boost::filesystem::wrecursive_directory_iterator itr(env::media_folder()), end; itr != end; ++itr)
+		{
+			auto path = itr->path();
+			auto file = path.replace_extension(L"").filename();
+			if(boost::iequals(file, _parameters.at(0)))
+				info += MediaInfo(itr->path()) + L"\r\n";
+		}
 
-	std::wstring filename = _parameters[0];
-
-	// TODO:
-
-	//FileInfo fileInfo;
-
-	//MediaManagerPtr pMediaManager = GetApplication()->FindMediaFile(filename, &fileInfo);
-	//if(pMediaManager != 0 && fileInfo.filetype.length() >0)	//File was found
-	//{
-	//	if(pMediaManager->getFileInfo(&fileInfo))
-	//	{
-	//		TCHAR numBuffer[32];
-	//		_ui64tot_s(fileInfo.size, numBuffer, 32, 10);
-
-	//		replyString << TEXT("201 CINF OK\r\n\"") << fileInfo.filename << TEXT("\" ") << fileInfo.type << TEXT("/") << fileInfo.filetype << TEXT("/") << fileInfo.encoding << TEXT(" ") << numBuffer << TEXT("\r\n");
-
-	//		SetReplyString(replyString.str());
-	//		return true;
-	//	}
-	//}
-
-	SetReplyString(TEXT("404 CINF ERROR\r\n"));
-	return false;
+		if(info.empty())
+		{
+			SetReplyString(TEXT("404 CINF ERROR\r\n"));
+			return false;
+		}
+		replyString << TEXT("200 INFO OK\r\n");
+		replyString << info << "\r\n";
+	}
+	catch(...)
+	{
+		SetReplyString(TEXT("404 CINF ERROR\r\n"));
+		return false;
+	}
+	
+	SetReplyString(replyString.str());
+	return true;
 }
 
-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");
 }
 
 bool InfoCommand::DoExecute()
 {
-	std::wstringstream replyString;
-
-	if(_parameters.size() >= 1)
+	try
 	{
-		int channelIndex = _ttoi(_parameters[0].c_str())-1;
-
-		if(channelIndex < channels_.size())
+		std::wstringstream replyString;
+		if(_parameters.size() >= 1)
 		{
+			int channelIndex = _ttoi(_parameters.at(0).c_str())-1;
 			replyString << TEXT("201 INFO OK\r\n");
-			GenerateChannelInfo(channelIndex, channels_[channelIndex], replyString);
+			GenerateChannelInfo(channelIndex, channels_.at(channelIndex), replyString);
 		}
 		else
 		{
-			SetReplyString(TEXT("401 INFO ERROR\r\n"));
-			return false;
+			replyString << TEXT("200 INFO OK\r\n");
+			for(size_t n = 0; n < channels_.size(); ++n)
+				GenerateChannelInfo(n, channels_[n], replyString);
+			replyString << TEXT("\r\n");
 		}
+		SetReplyString(replyString.str());
 	}
-	else
+	catch(...)
 	{
-		replyString << TEXT("200 INFO OK\r\n");
-		for(size_t n = 0; n < channels_.size(); ++n)
-			GenerateChannelInfo(n, channels_[n], replyString);
-		replyString << TEXT("\r\n");
+		SetReplyString(TEXT("401 INFO ERROR\r\n"));
+		return false;
 	}
 
-	SetReplyString(replyString.str());
 	return true;
 }
 
@@ -1066,9 +1319,9 @@ bool VersionCommand::DoExecute()
 	if(_parameters.size() > 0)
 	{
 		if(_parameters[0] == L"FLASH")
-			replyString = TEXT("201 VERSION OK\r\n FLASH: ") + get_flash_version() + TEXT("\r\n");
+			replyString = TEXT("201 VERSION OK\r\n FLASH: ") + flash::get_version() + TEXT("\r\n");
 		else if(_parameters[0] == L"TEMPLATEHOST")
-			replyString = TEXT("201 VERSION OK\r\n TEMPLATEHOST: ") + get_cg_version() + TEXT("\r\n");
+			replyString = TEXT("201 VERSION OK\r\n TEMPLATEHOST: ") + flash::get_cg_version() + TEXT("\r\n");
 		else if(_parameters[0] != L"SERVER")
 			replyString = TEXT("403 VERSION ERROR\r\n");
 	}
@@ -1093,10 +1346,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
 	{