git.sesse.net Git - casparcg/blob - protocol/amcp/AMCPCommandsImpl.cpp

   1 /*
   2 * Copyright (c) 2011 Sveriges Television AB <info@casparcg.com>
   3 *
   4 * This file is part of CasparCG (www.casparcg.com).
   5 *
   6 * CasparCG is free software: you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation, either version 3 of the License, or
   9 * (at your option) any later version.
  10 *
  11 * CasparCG is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with CasparCG. If not, see <http://www.gnu.org/licenses/>.
  18 *
  19 * Author: Nicklas P Andersson
  20 */
  21
  22 #include "../StdAfx.h"
  23
  24 #if defined(_MSC_VER)
  25 #pragma warning (push, 1) // TODO: Legacy code, just disable warnings
  26 #endif
  27
  28 #include "AMCPCommandsImpl.h"
  29 #include "AMCPProtocolStrategy.h"
  30
  31 #include <common/env.h>
  32
  33 #include <common/log.h>
  34 #include <common/param.h>
  35 #include <common/diagnostics/graph.h>
  36 #include <common/os/windows/current_version.h>
  37 #include <common/os/windows/system_info.h>
  38
  39 #include <core/producer/frame_producer.h>
  40 #include <core/video_format.h>
  41 #include <core/producer/transition/transition_producer.h>
  42 #include <core/frame/frame_transform.h>
  43 #include <core/producer/stage.h>
  44 #include <core/producer/layer.h>
  45 #include <core/mixer/mixer.h>
  46 #include <core/consumer/output.h>
  47
  48 #include <modules/reroute/producer/reroute_producer.h>
  49 #include <modules/bluefish/bluefish.h>
  50 #include <modules/decklink/decklink.h>
  51 #include <modules/ffmpeg/ffmpeg.h>
  52 #include <modules/flash/flash.h>
  53 #include <modules/flash/util/swf.h>
  54 #include <modules/flash/producer/flash_producer.h>
  55 #include <modules/flash/producer/cg_proxy.h>
  56 #include <modules/ffmpeg/producer/util/util.h>
  57 #include <modules/image/image.h>
  58 #include <modules/screen/screen.h>
  59 #include <modules/reroute/producer/reroute_producer.h>
  60
  61 #include <algorithm>
  62 #include <locale>
  63 #include <fstream>
  64 #include <memory>
  65 #include <cctype>
  66 #include <io.h>
  67
  68 #include <boost/date_time/posix_time/posix_time.hpp>
  69 #include <boost/lexical_cast.hpp>
  70 #include <boost/algorithm/string.hpp>
  71 #include <boost/filesystem.hpp>
  72 #include <boost/filesystem/fstream.hpp>
  73 #include <boost/regex.hpp>
  74 #include <boost/property_tree/xml_parser.hpp>
  75 #include <boost/locale.hpp>
  76 #include <boost/range/adaptor/transformed.hpp>
  77 #include <boost/range/algorithm/copy.hpp>
  78
  79 #include <tbb/concurrent_unordered_map.h>
  80
  81 /* Return codes
  82
  83 100 [action]                    Information om att något har hänt
  84 101 [action]                    Information om att något har hänt, en rad data skickas
  85
  86 202 [kommando] OK               Kommandot har utförts
  87 201 [kommando] OK               Kommandot har utförts, och en rad data skickas tillbaka
  88 200 [kommando] OK               Kommandot har utförts, och flera rader data skickas tillbaka. Avslutas med tomrad
  89
  90 400 ERROR                               Kommandot kunde inte förstås
  91 401 [kommando] ERROR    Ogiltig kanal
  92 402 [kommando] ERROR    Parameter saknas
  93 403 [kommando] ERROR    Ogiltig parameter
  94 404 [kommando] ERROR    Mediafilen hittades inte
  95
  96 500 FAILED                              Internt configurationfel
  97 501 [kommando] FAILED   Internt configurationfel
  98 502 [kommando] FAILED   Oläslig mediafil
  99 503 [kommando] FAILED   access denied
 100
 101 600 [kommando] FAILED   funktion ej implementerad
 102 */
 103
 104 namespace caspar { namespace protocol {
 105
 106 using namespace core;
 107
 108 std::wstring read_utf8_file(const boost::filesystem::wpath& file)
 109 {
 110         std::wstringstream result;
 111         boost::filesystem::wifstream filestream(file);
 112
 113         if (filestream)
 114         {
 115                 // Consume BOM first
 116                 filestream.get();
 117                 // read all data
 118                 result << filestream.rdbuf();
 119         }
 120
 121         return result.str();
 122 }
 123
 124 std::wstring read_latin1_file(const boost::filesystem::wpath& file)
 125 {
 126         boost::locale::generator gen;
 127         gen.locale_cache_enabled(true);
 128         gen.categories(boost::locale::codepage_facet);
 129
 130         std::stringstream result_stream;
 131         boost::filesystem::ifstream filestream(file);
 132         filestream.imbue(gen("en_US.ISO8859-1"));
 133
 134         if (filestream)
 135         {
 136                 // read all data
 137                 result_stream << filestream.rdbuf();
 138         }
 139
 140         std::string result = result_stream.str();
 141         std::wstring widened_result;
 142
 143         // The first 255 codepoints in unicode is the same as in latin1
 144         auto from_signed_to_signed = std::function<unsigned char(char)>(
 145                 [] (char c) { return static_cast<unsigned char>(c); }
 146         );
 147         boost::copy(
 148                 result | boost::adaptors::transformed(from_signed_to_signed),
 149                 std::back_inserter(widened_result));
 150
 151         return widened_result;
 152 }
 153
 154 std::wstring read_file(const boost::filesystem::wpath& file)
 155 {
 156         static const uint8_t BOM[] = {0xef, 0xbb, 0xbf};
 157
 158         if (!boost::filesystem::exists(file))
 159         {
 160                 return L"";
 161         }
 162
 163         if (boost::filesystem::file_size(file) >= 3)
 164         {
 165                 boost::filesystem::ifstream bom_stream(file);
 166
 167                 char header[3];
 168                 bom_stream.read(header, 3);
 169                 bom_stream.close();
 170
 171                 if (std::memcmp(BOM, header, 3) == 0)
 172                         return read_utf8_file(file);
 173         }
 174
 175         return read_latin1_file(file);
 176 }
 177
 178 std::wstring MediaInfo(const boost::filesystem::path& path)
 179 {
 180         if(boost::filesystem::is_regular_file(path))
 181         {
 182                 std::wstring clipttype = TEXT("N/A");
 183                 std::wstring extension = boost::to_upper_copy(path.extension().wstring());
 184                 if(extension == TEXT(".TGA") || extension == TEXT(".COL") || extension == L".PNG" || extension == L".JPEG" || extension == L".JPG" ||
 185                         extension == L"GIF" || extension == L"BMP")
 186                         clipttype = TEXT("STILL");
 187                 else if(extension == TEXT(".WAV") || extension == TEXT(".MP3"))
 188                         clipttype = TEXT("AUDIO");
 189                 else if(extension == TEXT("SWF") || extension == TEXT("CT") || extension == TEXT("DV") || extension == TEXT("MOV") || extension == TEXT("MPG") || extension == TEXT("AVI") || caspar::ffmpeg::is_valid_file(path.wstring()))
 190                         clipttype = TEXT("MOVIE");
 191
 192                 if(clipttype != TEXT("N/A"))
 193                 {
 194                         auto is_not_digit = [](char c){ return std::isdigit(c) == 0; };
 195
 196                         auto relativePath = boost::filesystem::path(path.wstring().substr(env::media_folder().size()-1, path.wstring().size()));
 197
 198                         auto writeTimeStr = boost::posix_time::to_iso_string(boost::posix_time::from_time_t(boost::filesystem::last_write_time(path)));
 199                         writeTimeStr.erase(std::remove_if(writeTimeStr.begin(), writeTimeStr.end(), is_not_digit), writeTimeStr.end());
 200                         auto writeTimeWStr = std::wstring(writeTimeStr.begin(), writeTimeStr.end());
 201
 202                         auto sizeStr = boost::lexical_cast<std::wstring>(boost::filesystem::file_size(path));
 203                         sizeStr.erase(std::remove_if(sizeStr.begin(), sizeStr.end(), is_not_digit), sizeStr.end());
 204                         auto sizeWStr = std::wstring(sizeStr.begin(), sizeStr.end());
 205
 206                         auto str = relativePath.replace_extension(TEXT("")).native();
 207                         while(str.size() > 0 && (str[0] == '\\' || str[0] == '/'))
 208                                 str = std::wstring(str.begin() + 1, str.end());
 209
 210                         return std::wstring() + TEXT("\"") + str +
 211                                         + TEXT("\" ") + clipttype +
 212                                         + TEXT(" ") + sizeStr +
 213                                         + TEXT(" ") + writeTimeWStr +
 214                                         + TEXT("\r\n");
 215                 }
 216         }
 217         return L"";
 218 }
 219
 220 std::wstring ListMedia()
 221 {
 222         std::wstringstream replyString;
 223         for (boost::filesystem::recursive_directory_iterator itr(env::media_folder()), end; itr != end; ++itr)
 224                 replyString << MediaInfo(itr->path());
 225
 226         return boost::to_upper_copy(replyString.str());
 227 }
 228
 229 std::wstring ListTemplates()
 230 {
 231         std::wstringstream replyString;
 232
 233         for (boost::filesystem::recursive_directory_iterator itr(env::template_folder()), end; itr != end; ++itr)
 234         {
 235                 if(boost::filesystem::is_regular_file(itr->path()) && (itr->path().extension() == L".ft" || itr->path().extension() == L".ct"))
 236                 {
 237                         auto relativePath = boost::filesystem::wpath(itr->path().wstring().substr(env::template_folder().size()-1, itr->path().wstring().size()));
 238
 239                         auto writeTimeStr = boost::posix_time::to_iso_string(boost::posix_time::from_time_t(boost::filesystem::last_write_time(itr->path())));
 240                         writeTimeStr.erase(std::remove_if(writeTimeStr.begin(), writeTimeStr.end(), [](char c){ return std::isdigit(c) == 0;}), writeTimeStr.end());
 241                         auto writeTimeWStr = std::wstring(writeTimeStr.begin(), writeTimeStr.end());
 242
 243                         auto sizeStr = boost::lexical_cast<std::string>(boost::filesystem::file_size(itr->path()));
 244                         sizeStr.erase(std::remove_if(sizeStr.begin(), sizeStr.end(), [](char c){ return std::isdigit(c) == 0;}), sizeStr.end());
 245
 246                         auto sizeWStr = std::wstring(sizeStr.begin(), sizeStr.end());
 247
 248                         std::wstring dir = relativePath.parent_path().native();
 249                         std::wstring file = boost::to_upper_copy(relativePath.filename().wstring());
 250                         relativePath = boost::filesystem::wpath(dir + L"/" + file);
 251
 252                         auto str = relativePath.replace_extension(TEXT("")).native();
 253                         boost::trim_if(str, boost::is_any_of("\\/"));
 254
 255                         replyString << TEXT("\"") << str
 256                                                 << TEXT("\" ") << sizeWStr
 257                                                 << TEXT(" ") << writeTimeWStr
 258                                                 << TEXT("\r\n");
 259                 }
 260         }
 261         return replyString.str();
 262 }
 263
 264 namespace amcp {
 265
 266 void AMCPCommand::SendReply()
 267 {
 268         if(replyString_.empty())
 269                 return;
 270
 271         client_->send(std::move(replyString_));
 272 }
 273
 274 bool DiagnosticsCommand::DoExecute()
 275 {
 276         try
 277         {
 278                 diagnostics::show_graphs(true);
 279
 280                 SetReplyString(TEXT("202 DIAG OK\r\n"));
 281
 282                 return true;
 283         }
 284         catch(...)
 285         {
 286                 CASPAR_LOG_CURRENT_EXCEPTION();
 287                 SetReplyString(TEXT("502 DIAG FAILED\r\n"));
 288                 return false;
 289         }
 290 }
 291
 292 bool ChannelGridCommand::DoExecute()
 293 {
 294         CASPAR_THROW_EXCEPTION(not_implemented());
 295
 296         //int index = 1;
 297         //auto self = channels().back();
 298         //
 299         //std::vector<std::wstring> params;
 300         //params.push_back(L"SCREEN");
 301         //params.push_back(L"NAME");
 302         //params.push_back(L"Channel Grid Window");
 303         //auto screen = create_consumer(params);
 304
 305         //self->output().add(screen);
 306
 307         //BOOST_FOREACH(auto channel, channels())
 308         //{
 309         //      if(channel != self)
 310         //      {
 311         //              auto producer = reroute::create_producer(self->frame_factory(), *channel);
 312         //              self->stage().load(index, producer, false);
 313         //              self->stage().play(index);
 314         //              index++;
 315         //      }
 316         //}
 317
 318         //int n = channels().size()-1;
 319         //double delta = 1.0/static_cast<double>(n);
 320         //for(int x = 0; x < n; ++x)
 321         //{
 322         //      for(int y = 0; y < n; ++y)
 323         //      {
 324         //              int index = x+y*n+1;
 325         //              auto transform = [=](frame_transform transform) -> frame_transform
 326         //              {
 327         //                      transform.image_transform.fill_translation[0]   = x*delta;
 328         //                      transform.image_transform.fill_translation[1]   = y*delta;
 329         //                      transform.image_transform.fill_scale[0]                 = delta;
 330         //                      transform.image_transform.fill_scale[1]                 = delta;
 331         //                      transform.image_transform.clip_translation[0]   = x*delta;
 332         //                      transform.image_transform.clip_translation[1]   = y*delta;
 333         //                      transform.image_transform.clip_scale[0]                 = delta;
 334         //                      transform.image_transform.clip_scale[1]                 = delta;
 335         //                      return transform;
 336         //              };
 337         //              self->stage().apply_transform(index, transform);
 338         //      }
 339         //}
 340
 341         //return true;
 342 }
 343
 344 bool CallCommand::DoExecute()
 345 {
 346         //Perform loading of the clip
 347         try
 348         {
 349                 auto result = channel()->stage().call(layer_index(), parameters());
 350
 351                 if(!result.timed_wait(boost::posix_time::seconds(2)))
 352                         CASPAR_THROW_EXCEPTION(timed_out());
 353
 354                 std::wstringstream replyString;
 355                 if(result.get().empty())
 356                         replyString << TEXT("202 CALL OK\r\n");
 357                 else
 358                         replyString << TEXT("201 CALL OK\r\n") << result.get() << L"\r\n";
 359
 360                 SetReplyString(replyString.str());
 361
 362                 return true;
 363         }
 364         catch(...)
 365         {
 366                 CASPAR_LOG_CURRENT_EXCEPTION();
 367                 SetReplyString(TEXT("502 CALL FAILED\r\n"));
 368                 return false;
 369         }
 370 }
 371
 372 tbb::concurrent_unordered_map<int, std::vector<stage::transform_tuple_t>> deferred_transforms;
 373
 374 bool MixerCommand::DoExecute()
 375 {
 376         //Perform loading of the clip
 377         try
 378         {
 379                 bool defer = boost::iequals(parameters().back(), L"DEFER");
 380                 if(defer)
 381                         parameters().pop_back();
 382
 383                 std::vector<stage::transform_tuple_t> transforms;
 384
 385                 if(boost::iequals(parameters()[0], L"KEYER") || boost::iequals(parameters()[0], L"IS_KEY"))
 386                 {
 387                         bool value = boost::lexical_cast<int>(parameters().at(1));
 388                         transforms.push_back(stage::transform_tuple_t(layer_index(), [=](frame_transform transform) -> frame_transform
 389                         {
 390                                 transform.image_transform.is_key = value;
 391                                 return transform;
 392                         }, 0, L"linear"));
 393                 }
 394                 else if(boost::iequals(parameters()[0], L"OPACITY"))
 395                 {
 396                         int duration = parameters().size() > 2 ? boost::lexical_cast<int>(parameters()[2]) : 0;
 397                         std::wstring tween = parameters().size() > 3 ? parameters()[3] : L"linear";
 398
 399                         double value = boost::lexical_cast<double>(parameters().at(1));
 400
 401                         transforms.push_back(stage::transform_tuple_t(layer_index(), [=](frame_transform transform) -> frame_transform
 402                         {
 403                                 transform.image_transform.opacity = value;
 404                                 return transform;
 405                         }, duration, tween));
 406                 }
 407                 else if(boost::iequals(parameters()[0], L"FILL") || boost::iequals(parameters()[0], L"FILL_RECT"))
 408                 {
 409                         int duration = parameters().size() > 5 ? boost::lexical_cast<int>(parameters()[5]) : 0;
 410                         std::wstring tween = parameters().size() > 6 ? parameters()[6] : L"linear";
 411                         double x        = boost::lexical_cast<double>(parameters().at(1));
 412                         double y        = boost::lexical_cast<double>(parameters().at(2));
 413                         double x_s      = boost::lexical_cast<double>(parameters().at(3));
 414                         double y_s      = boost::lexical_cast<double>(parameters().at(4));
 415
 416                         transforms.push_back(stage::transform_tuple_t(layer_index(), [=](frame_transform transform) mutable -> frame_transform
 417                         {
 418                                 transform.image_transform.fill_translation[0]   = x;
 419                                 transform.image_transform.fill_translation[1]   = y;
 420                                 transform.image_transform.fill_scale[0]                 = x_s;
 421                                 transform.image_transform.fill_scale[1]                 = y_s;
 422                                 return transform;
 423                         }, duration, tween));
 424                 }
 425                 else if(boost::iequals(parameters()[0], L"CLIP") || boost::iequals(parameters()[0], L"CLIP_RECT"))
 426                 {
 427                         int duration = parameters().size() > 5 ? boost::lexical_cast<int>(parameters()[5]) : 0;
 428                         std::wstring tween = parameters().size() > 6 ? parameters()[6] : L"linear";
 429                         double x        = boost::lexical_cast<double>(parameters().at(1));
 430                         double y        = boost::lexical_cast<double>(parameters().at(2));
 431                         double x_s      = boost::lexical_cast<double>(parameters().at(3));
 432                         double y_s      = boost::lexical_cast<double>(parameters().at(4));
 433
 434                         transforms.push_back(stage::transform_tuple_t(layer_index(), [=](frame_transform transform) -> frame_transform
 435                         {
 436                                 transform.image_transform.clip_translation[0]   = x;
 437                                 transform.image_transform.clip_translation[1]   = y;
 438                                 transform.image_transform.clip_scale[0]                 = x_s;
 439                                 transform.image_transform.clip_scale[1]                 = y_s;
 440                                 return transform;
 441                         }, duration, tween));
 442                 }
 443                 else if(boost::iequals(parameters()[0], L"GRID"))
 444                 {
 445                         int duration = parameters().size() > 2 ? boost::lexical_cast<int>(parameters()[2]) : 0;
 446                         std::wstring tween = parameters().size() > 3 ? parameters()[3] : L"linear";
 447                         int n = boost::lexical_cast<int>(parameters().at(1));
 448                         double delta = 1.0/static_cast<double>(n);
 449                         for(int x = 0; x < n; ++x)
 450                         {
 451                                 for(int y = 0; y < n; ++y)
 452                                 {
 453                                         int index = x+y*n+1;
 454                                         transforms.push_back(stage::transform_tuple_t(index, [=](frame_transform transform) -> frame_transform
 455                                         {
 456                                                 transform.image_transform.fill_translation[0]   = x*delta;
 457                                                 transform.image_transform.fill_translation[1]   = y*delta;
 458                                                 transform.image_transform.fill_scale[0]                 = delta;
 459                                                 transform.image_transform.fill_scale[1]                 = delta;
 460                                                 transform.image_transform.clip_translation[0]   = x*delta;
 461                                                 transform.image_transform.clip_translation[1]   = y*delta;
 462                                                 transform.image_transform.clip_scale[0]                 = delta;
 463                                                 transform.image_transform.clip_scale[1]                 = delta;
 464                                                 return transform;
 465                                         }, duration, tween));
 466                                 }
 467                         }
 468                 }
 469                 else if(boost::iequals(parameters()[0], L"BLEND"))
 470                 {
 471                         auto blend_str = parameters().at(1);
 472                         int layer = layer_index();
 473                         channel()->mixer().set_blend_mode(layer_index(), get_blend_mode(blend_str));
 474                 }
 475                 else if(boost::iequals(parameters()[0], L"MASTERVOLUME"))
 476                 {
 477                         float master_volume = boost::lexical_cast<float>(parameters().at(1));
 478                         channel()->mixer().set_master_volume(master_volume);
 479                 }
 480                 else if(boost::iequals(parameters()[0], L"BRIGHTNESS"))
 481                 {
 482                         auto value = boost::lexical_cast<double>(parameters().at(1));
 483                         int duration = parameters().size() > 2 ? boost::lexical_cast<int>(parameters()[2]) : 0;
 484                         std::wstring tween = parameters().size() > 3 ? parameters()[3] : L"linear";
 485                         transforms.push_back(stage::transform_tuple_t(layer_index(), [=](frame_transform transform) -> frame_transform
 486                         {
 487                                 transform.image_transform.brightness = value;
 488                                 return transform;
 489                         }, duration, tween));
 490                 }
 491                 else if(boost::iequals(parameters()[0], L"SATURATION"))
 492                 {
 493                         auto value = boost::lexical_cast<double>(parameters().at(1));
 494                         int duration = parameters().size() > 2 ? boost::lexical_cast<int>(parameters()[2]) : 0;
 495                         std::wstring tween = parameters().size() > 3 ? parameters()[3] : L"linear";
 496                         transforms.push_back(stage::transform_tuple_t(layer_index(), [=](frame_transform transform) -> frame_transform
 497                         {
 498                                 transform.image_transform.saturation = value;
 499                                 return transform;
 500                         }, duration, tween));
 501                 }
 502                 else if(parameters()[0] == L"CONTRAST")
 503                 {
 504                         auto value = boost::lexical_cast<double>(parameters().at(1));
 505                         int duration = parameters().size() > 2 ? boost::lexical_cast<int>(parameters()[2]) : 0;
 506                         std::wstring tween = parameters().size() > 3 ? parameters()[3] : L"linear";
 507                         transforms.push_back(stage::transform_tuple_t(layer_index(), [=](frame_transform transform) -> frame_transform
 508                         {
 509                                 transform.image_transform.contrast = value;
 510                                 return transform;
 511                         }, duration, tween));
 512                 }
 513                 else if(boost::iequals(parameters()[0], L"LEVELS"))
 514                 {
 515                         levels value;
 516                         value.min_input  = boost::lexical_cast<double>(parameters().at(1));
 517                         value.max_input  = boost::lexical_cast<double>(parameters().at(2));
 518                         value.gamma              = boost::lexical_cast<double>(parameters().at(3));
 519                         value.min_output = boost::lexical_cast<double>(parameters().at(4));
 520                         value.max_output = boost::lexical_cast<double>(parameters().at(5));
 521                         int duration = parameters().size() > 6 ? boost::lexical_cast<int>(parameters()[6]) : 0;
 522                         std::wstring tween = parameters().size() > 7 ? parameters()[7] : L"linear";
 523
 524                         transforms.push_back(stage::transform_tuple_t(layer_index(), [=](frame_transform transform) -> frame_transform
 525                         {
 526                                 transform.image_transform.levels = value;
 527                                 return transform;
 528                         }, duration, tween));
 529                 }
 530                 else if(boost::iequals(parameters()[0], L"VOLUME"))
 531                 {
 532                         int duration = parameters().size() > 2 ? boost::lexical_cast<int>(parameters()[2]) : 0;
 533                         std::wstring tween = parameters().size() > 3 ? parameters()[3] : L"linear";
 534                         double value = boost::lexical_cast<double>(parameters()[1]);
 535
 536                         transforms.push_back(stage::transform_tuple_t(layer_index(), [=](frame_transform transform) -> frame_transform
 537                         {
 538                                 transform.audio_transform.volume = value;
 539                                 return transform;
 540                         }, duration, tween));
 541                 }
 542                 else if(boost::iequals(parameters()[0], L"CLEAR"))
 543                 {
 544                         int layer = layer_index(std::numeric_limits<int>::max());
 545
 546                         if (layer == std::numeric_limits<int>::max())
 547                         {
 548                                 channel()->stage().clear_transforms();
 549                                 channel()->mixer().clear_blend_modes();
 550                         }
 551                         else
 552                         {
 553                                 channel()->stage().clear_transforms(layer);
 554                                 channel()->mixer().clear_blend_mode(layer);
 555                         }
 556                 }
 557                 else if(boost::iequals(parameters()[0], L"COMMIT"))
 558                 {
 559                         transforms = std::move(deferred_transforms[channel_index()]);
 560                 }
 561                 else
 562                 {
 563                         SetReplyString(TEXT("404 MIXER ERROR\r\n"));
 564                         return false;
 565                 }
 566
 567                 if(defer)
 568                 {
 569                         auto& defer_tranforms = deferred_transforms[channel_index()];
 570                         defer_tranforms.insert(defer_tranforms.end(), transforms.begin(), transforms.end());
 571                 }
 572                 else
 573                         channel()->stage().apply_transforms(transforms);
 574
 575                 SetReplyString(TEXT("202 MIXER OK\r\n"));
 576
 577                 return true;
 578         }
 579         catch(file_not_found&)
 580         {
 581                 CASPAR_LOG_CURRENT_EXCEPTION();
 582                 SetReplyString(TEXT("404 MIXER ERROR\r\n"));
 583                 return false;
 584         }
 585         catch(...)
 586         {
 587                 CASPAR_LOG_CURRENT_EXCEPTION();
 588                 SetReplyString(TEXT("502 MIXER FAILED\r\n"));
 589                 return false;
 590         }
 591 }
 592
 593 bool SwapCommand::DoExecute()
 594 {
 595         //Perform loading of the clip
 596         try
 597         {
 598                 if(layer_index(-1) != -1)
 599                 {
 600                         std::vector<std::string> strs;
 601                         boost::split(strs, parameters()[0], boost::is_any_of("-"));
 602
 603                         auto ch1 = channel();
 604                         auto ch2 = channels().at(boost::lexical_cast<int>(strs.at(0))-1);
 605
 606                         int l1 = layer_index();
 607                         int l2 = boost::lexical_cast<int>(strs.at(1));
 608
 609                         ch1->stage().swap_layer(l1, l2, ch2.channel->stage());
 610                 }
 611                 else
 612                 {
 613                         auto ch1 = channel();
 614                         auto ch2 = channels().at(boost::lexical_cast<int>(parameters()[0])-1);
 615                         ch1->stage().swap_layers(ch2.channel->stage());
 616                 }
 617
 618                 SetReplyString(TEXT("202 SWAP OK\r\n"));
 619
 620                 return true;
 621         }
 622         catch(file_not_found&)
 623         {
 624                 CASPAR_LOG_CURRENT_EXCEPTION();
 625                 SetReplyString(TEXT("404 SWAP ERROR\r\n"));
 626                 return false;
 627         }
 628         catch(...)
 629         {
 630                 CASPAR_LOG_CURRENT_EXCEPTION();
 631                 SetReplyString(TEXT("502 SWAP FAILED\r\n"));
 632                 return false;
 633         }
 634 }
 635
 636 bool AddCommand::DoExecute()
 637 {
 638         //Perform loading of the clip
 639         try
 640         {
 641                 //create_consumer still expects all parameters to be uppercase
 642                 BOOST_FOREACH(std::wstring& str, parameters())
 643                 {
 644                         boost::to_upper(str);
 645                 }
 646
 647                 auto consumer = create_consumer(parameters());
 648                 channel()->output().add(layer_index(consumer->index()), consumer);
 649
 650                 SetReplyString(TEXT("202 ADD OK\r\n"));
 651
 652                 return true;
 653         }
 654         catch(file_not_found&)
 655         {
 656                 CASPAR_LOG_CURRENT_EXCEPTION();
 657                 SetReplyString(TEXT("404 ADD ERROR\r\n"));
 658                 return false;
 659         }
 660         catch(...)
 661         {
 662                 CASPAR_LOG_CURRENT_EXCEPTION();
 663                 SetReplyString(TEXT("502 ADD FAILED\r\n"));
 664                 return false;
 665         }
 666 }
 667
 668 bool RemoveCommand::DoExecute()
 669 {
 670         //Perform loading of the clip
 671         try
 672         {
 673                 auto index = layer_index(std::numeric_limits<int>::min());
 674                 if(index == std::numeric_limits<int>::min())
 675                 {
 676                         //create_consumer still expects all parameters to be uppercase
 677                         BOOST_FOREACH(std::wstring& str, parameters())
 678                         {
 679                                 boost::to_upper(str);
 680                         }
 681
 682                         index = create_consumer(parameters())->index();
 683                 }
 684
 685                 channel()->output().remove(index);
 686
 687                 SetReplyString(TEXT("202 REMOVE OK\r\n"));
 688
 689                 return true;
 690         }
 691         catch(file_not_found&)
 692         {
 693                 CASPAR_LOG_CURRENT_EXCEPTION();
 694                 SetReplyString(TEXT("404 REMOVE ERROR\r\n"));
 695                 return false;
 696         }
 697         catch(...)
 698         {
 699                 CASPAR_LOG_CURRENT_EXCEPTION();
 700                 SetReplyString(TEXT("502 REMOVE FAILED\r\n"));
 701                 return false;
 702         }
 703 }
 704
 705 bool LoadCommand::DoExecute()
 706 {
 707         //Perform loading of the clip
 708         try
 709         {
 710                 auto pFP = create_producer(channel()->frame_factory(), channel()->video_format_desc(), parameters());
 711                 channel()->stage().load(layer_index(), pFP, true);
 712
 713                 SetReplyString(TEXT("202 LOAD OK\r\n"));
 714
 715                 return true;
 716         }
 717         catch(file_not_found&)
 718         {
 719                 CASPAR_LOG_CURRENT_EXCEPTION();
 720                 SetReplyString(TEXT("404 LOAD ERROR\r\n"));
 721                 return false;
 722         }
 723         catch(...)
 724         {
 725                 CASPAR_LOG_CURRENT_EXCEPTION();
 726                 SetReplyString(TEXT("502 LOAD FAILED\r\n"));
 727                 return false;
 728         }
 729 }
 730
 731
 732
 733 //std::function<std::wstring()> channel_cg_add_command::parse(const std::wstring& message, const std::vector<renderer::render_device_ptr>& channels)
 734 //{
 735 //      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>.*)?");
 736 //
 737 //      boost::wsmatch what;
 738 //      if(!boost::regex_match(message, what, expr))
 739 //              return nullptr;
 740 //
 741 //      auto info = channel_info::parse(what, channels);
 742 //
 743 //      int flash_layer_index = boost::lexical_cast<int>(what["FLASH_LAYER"].str());
 744 //
 745 //      std::wstring templatename = what["TEMPLATE"].str();
 746 //      bool play_on_load = what["PLAY_ON_LOAD"].matched ? what["PLAY_ON_LOAD"].str() != L"0" : 0;
 747 //      std::wstring start_label = what["START_LABEL"].str();
 748 //      std::wstring data = get_data(what["DATA"].str());
 749 //
 750 //      boost::replace_all(templatename, "\"", "");
 751 //
 752 //      return [=]() -> std::wstring
 753 //      {
 754 //              std::wstring fullFilename = flash::flash_producer::find_template(server::template_folder() + templatename);
 755 //              if(fullFilename.empty())
 756 //                      CASPAR_THROW_EXCEPTION(file_not_found());
 757 //
 758 //              std::wstring extension = boost::filesystem::wpath(fullFilename).extension();
 759 //              std::wstring filename = templatename;
 760 //              filename.append(extension);
 761 //
 762 //              flash::flash::create_cg_proxy(info.video_channel, std::max<int>(DEFAULT_CHANNEL_LAYER+1, info.layer_index))
 763 //                      ->add(flash_layer_index, filename, play_on_load, start_label, data);
 764 //
 765 //              CASPAR_LOG(info) << L"Executed [amcp_channel_cg_add]";
 766 //              return L"";
 767 //      };
 768
 769 bool LoadbgCommand::DoExecute()
 770 {
 771         transition_info transitionInfo;
 772
 773         bool bLoop = false;
 774
 775         // TRANSITION
 776
 777         std::wstring message;
 778         for(size_t n = 0; n < parameters().size(); ++n)
 779                 message += boost::to_upper_copy(parameters()[n]) + L" ";
 780
 781         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)?.*");
 782         boost::wsmatch what;
 783         if(boost::regex_match(message, what, expr))
 784         {
 785                 auto transition = what["TRANSITION"].str();
 786                 transitionInfo.duration = boost::lexical_cast<size_t>(what["DURATION"].str());
 787                 auto direction = what["DIRECTION"].matched ? what["DIRECTION"].str() : L"";
 788                 auto tween = what["TWEEN"].matched ? what["TWEEN"].str() : L"";
 789                 transitionInfo.tweener = tween;
 790
 791                 if(transition == TEXT("CUT"))
 792                         transitionInfo.type = transition_type::cut;
 793                 else if(transition == TEXT("MIX"))
 794                         transitionInfo.type = transition_type::mix;
 795                 else if(transition == TEXT("PUSH"))
 796                         transitionInfo.type = transition_type::push;
 797                 else if(transition == TEXT("SLIDE"))
 798                         transitionInfo.type = transition_type::slide;
 799                 else if(transition == TEXT("WIPE"))
 800                         transitionInfo.type = transition_type::wipe;
 801
 802                 if(direction == TEXT("FROMLEFT"))
 803                         transitionInfo.direction = transition_direction::from_left;
 804                 else if(direction == TEXT("FROMRIGHT"))
 805                         transitionInfo.direction = transition_direction::from_right;
 806                 else if(direction == TEXT("LEFT"))
 807                         transitionInfo.direction = transition_direction::from_right;
 808                 else if(direction == TEXT("RIGHT"))
 809                         transitionInfo.direction = transition_direction::from_left;
 810         }
 811
 812         //Perform loading of the clip
 813         try
 814         {
 815                 std::shared_ptr<core::frame_producer> pFP;
 816
 817                 static boost::wregex expr(L"\\[(?<CHANNEL>\\d+)\\]", boost::regex::icase);
 818
 819                 boost::wsmatch what;
 820                 if(boost::regex_match(parameters().at(0), what, expr))
 821                 {
 822                         auto channel_index = boost::lexical_cast<int>(what["CHANNEL"].str());
 823                         pFP = reroute::create_producer(*channels().at(channel_index-1).channel);
 824                 }
 825                 else
 826                 {
 827                         pFP = create_producer(channel()->frame_factory(), channel()->video_format_desc(), parameters());
 828                 }
 829
 830                 if(pFP == frame_producer::empty())
 831                         CASPAR_THROW_EXCEPTION(file_not_found() << msg_info(parameters().size() > 0 ? parameters()[0] : L""));
 832
 833                 bool auto_play = contains_param(L"AUTO", parameters());
 834
 835                 auto pFP2 = create_transition_producer(channel()->video_format_desc().field_mode, spl::make_shared_ptr(pFP), transitionInfo);
 836                 if(auto_play)
 837                         channel()->stage().load(layer_index(), pFP2, false, transitionInfo.duration); // TODO: LOOP
 838                 else
 839                         channel()->stage().load(layer_index(), pFP2, false); // TODO: LOOP
 840
 841
 842                 SetReplyString(TEXT("202 LOADBG OK\r\n"));
 843
 844                 return true;
 845         }
 846         catch(file_not_found&)
 847         {
 848                 CASPAR_LOG(error) << L"File not found. No match found for parameters. Check syntax.";
 849                 SetReplyString(TEXT("404 LOADBG ERROR\r\n"));
 850                 return false;
 851         }
 852         catch(...)
 853         {
 854                 CASPAR_LOG_CURRENT_EXCEPTION();
 855                 SetReplyString(TEXT("502 LOADBG FAILED\r\n"));
 856                 return false;
 857         }
 858 }
 859
 860 bool PauseCommand::DoExecute()
 861 {
 862         try
 863         {
 864                 channel()->stage().pause(layer_index());
 865                 SetReplyString(TEXT("202 PAUSE OK\r\n"));
 866                 return true;
 867         }
 868         catch(...)
 869         {
 870                 SetReplyString(TEXT("501 PAUSE FAILED\r\n"));
 871         }
 872
 873         return false;
 874 }
 875
 876 bool PlayCommand::DoExecute()
 877 {
 878         try
 879         {
 880                 if(!parameters().empty())
 881                 {
 882                         LoadbgCommand lbg(*this);
 883
 884                         if(!lbg.Execute())
 885                                 throw std::exception();
 886                 }
 887
 888                 channel()->stage().play(layer_index());
 889
 890                 SetReplyString(TEXT("202 PLAY OK\r\n"));
 891                 return true;
 892         }
 893         catch(...)
 894         {
 895                 SetReplyString(TEXT("501 PLAY FAILED\r\n"));
 896         }
 897
 898         return false;
 899 }
 900
 901 bool StopCommand::DoExecute()
 902 {
 903         try
 904         {
 905                 channel()->stage().stop(layer_index());
 906                 SetReplyString(TEXT("202 STOP OK\r\n"));
 907                 return true;
 908         }
 909         catch(...)
 910         {
 911                 SetReplyString(TEXT("501 STOP FAILED\r\n"));
 912         }
 913
 914         return false;
 915 }
 916
 917 bool ClearCommand::DoExecute()
 918 {
 919         int index = layer_index(std::numeric_limits<int>::min());
 920         if(index != std::numeric_limits<int>::min())
 921                 channel()->stage().clear(index);
 922         else
 923                 channel()->stage().clear();
 924
 925         SetReplyString(TEXT("202 CLEAR OK\r\n"));
 926
 927         return true;
 928 }
 929
 930 bool PrintCommand::DoExecute()
 931 {
 932         channel()->output().add(create_consumer(boost::assign::list_of(L"IMAGE")));
 933
 934         SetReplyString(TEXT("202 PRINT OK\r\n"));
 935
 936         return true;
 937 }
 938
 939 bool LogCommand::DoExecute()
 940 {
 941         if(boost::iequals(parameters().at(0), L"LEVEL"))
 942                 log::set_log_level(parameters().at(1));
 943
 944         SetReplyString(TEXT("202 LOG OK\r\n"));
 945
 946         return true;
 947 }
 948
 949 bool CGCommand::DoExecute()
 950 {
 951         try
 952         {
 953                 std::wstring command = boost::to_upper_copy(parameters()[0]);
 954                 if(command == TEXT("ADD"))
 955                         return DoExecuteAdd();
 956                 else if(command == TEXT("PLAY"))
 957                         return DoExecutePlay();
 958                 else if(command == TEXT("STOP"))
 959                         return DoExecuteStop();
 960                 else if(command == TEXT("NEXT"))
 961                         return DoExecuteNext();
 962                 else if(command == TEXT("REMOVE"))
 963                         return DoExecuteRemove();
 964                 else if(command == TEXT("CLEAR"))
 965                         return DoExecuteClear();
 966                 else if(command == TEXT("UPDATE"))
 967                         return DoExecuteUpdate();
 968                 else if(command == TEXT("INVOKE"))
 969                         return DoExecuteInvoke();
 970                 else if(command == TEXT("INFO"))
 971                         return DoExecuteInfo();
 972         }
 973         catch(...)
 974         {
 975                 CASPAR_LOG_CURRENT_EXCEPTION();
 976         }
 977
 978         SetReplyString(TEXT("403 CG ERROR\r\n"));
 979         return false;
 980 }
 981
 982 bool CGCommand::ValidateLayer(const std::wstring& layerstring) {
 983         int length = layerstring.length();
 984         for(int i = 0; i < length; ++i) {
 985                 if(!_istdigit(layerstring[i])) {
 986                         return false;
 987                 }
 988         }
 989
 990         return true;
 991 }
 992
 993 bool CGCommand::DoExecuteAdd() {
 994         //CG 1 ADD 0 "template_folder/templatename" [STARTLABEL] 0/1 [DATA]
 995
 996         int layer = 0;                          //_parameters[1]
 997 //      std::wstring templateName;      //_parameters[2]
 998         std::wstring label;             //_parameters[3]
 999         bool bDoStart = false;          //_parameters[3] alt. _parameters[4]
1000 //      std::wstring data;                      //_parameters[4] alt. _parameters[5]
1001
1002         if(parameters().size() < 4)
1003         {
1004                 SetReplyString(TEXT("402 CG ERROR\r\n"));
1005                 return false;
1006         }
1007         unsigned int dataIndex = 4;
1008
1009         if(!ValidateLayer(parameters()[1]))
1010         {
1011                 SetReplyString(TEXT("403 CG ERROR\r\n"));
1012                 return false;
1013         }
1014
1015         layer = boost::lexical_cast<int>(parameters()[1]);
1016
1017         if(parameters()[3].length() > 1)
1018         {       //read label
1019                 label = parameters()[3];
1020                 ++dataIndex;
1021
1022                 if(parameters().size() > 4 && parameters()[4].length() > 0)     //read play-on-load-flag
1023                         bDoStart = (parameters()[4][0]==TEXT('1')) ? true : false;
1024                 else
1025                 {
1026                         SetReplyString(TEXT("402 CG ERROR\r\n"));
1027                         return false;
1028                 }
1029         }
1030         else if(parameters()[3].length() > 0) { //read play-on-load-flag
1031                 bDoStart = (parameters()[3][0]==TEXT('1')) ? true : false;
1032         }
1033         else
1034         {
1035                 SetReplyString(TEXT("403 CG ERROR\r\n"));
1036                 return false;
1037         }
1038
1039         const TCHAR* pDataString = 0;
1040         std::wstringstream data;
1041         std::wstring dataFromFile;
1042         if(parameters().size() > dataIndex)
1043         {       //read data
1044                 const std::wstring& dataString = parameters()[dataIndex];
1045
1046                 if(dataString[0] == TEXT('<')) //the data is an XML-string
1047                         pDataString = dataString.c_str();
1048                 else
1049                 {
1050                         //The data is not an XML-string, it must be a filename
1051                         std::wstring filename = env::data_folder();
1052                         filename.append(dataString);
1053                         filename.append(TEXT(".ftd"));
1054
1055                         dataFromFile = read_file(boost::filesystem::wpath(filename));
1056                         pDataString = dataFromFile.c_str();
1057                 }
1058         }
1059
1060         std::wstring fullFilename = flash::find_template(env::template_folder() + parameters()[2]);
1061         if(!fullFilename.empty())
1062         {
1063                 std::wstring extension = boost::filesystem::path(fullFilename).extension().wstring();
1064                 std::wstring filename = parameters()[2];
1065                 filename.append(extension);
1066
1067                 flash::create_cg_proxy(spl::shared_ptr<core::video_channel>(channel()), layer_index(flash::cg_proxy::DEFAULT_LAYER)).add(layer, filename, bDoStart, label, (pDataString!=0) ? pDataString : TEXT(""));
1068                 SetReplyString(TEXT("202 CG OK\r\n"));
1069         }
1070         else
1071         {
1072                 CASPAR_LOG(warning) << "Could not find template " << parameters()[2];
1073                 SetReplyString(TEXT("404 CG ERROR\r\n"));
1074         }
1075         return true;
1076 }
1077
1078 bool CGCommand::DoExecutePlay()
1079 {
1080         if(parameters().size() > 1)
1081         {
1082                 if(!ValidateLayer(parameters()[1]))
1083                 {
1084                         SetReplyString(TEXT("403 CG ERROR\r\n"));
1085                         return false;
1086                 }
1087                 int layer = boost::lexical_cast<int>(parameters()[1]);
1088                 flash::create_cg_proxy(spl::shared_ptr<core::video_channel>(channel()), layer_index(flash::cg_proxy::DEFAULT_LAYER)).play(layer);
1089         }
1090         else
1091         {
1092                 SetReplyString(TEXT("402 CG ERROR\r\n"));
1093                 return true;
1094         }
1095
1096         SetReplyString(TEXT("202 CG OK\r\n"));
1097         return true;
1098 }
1099
1100 bool CGCommand::DoExecuteStop()
1101 {
1102         if(parameters().size() > 1)
1103         {
1104                 if(!ValidateLayer(parameters()[1]))
1105                 {
1106                         SetReplyString(TEXT("403 CG ERROR\r\n"));
1107                         return false;
1108                 }
1109                 int layer = boost::lexical_cast<int>(parameters()[1]);
1110                 flash::create_cg_proxy(spl::shared_ptr<core::video_channel>(channel()), layer_index(flash::cg_proxy::DEFAULT_LAYER)).stop(layer, 0);
1111         }
1112         else
1113         {
1114                 SetReplyString(TEXT("402 CG ERROR\r\n"));
1115                 return true;
1116         }
1117
1118         SetReplyString(TEXT("202 CG OK\r\n"));
1119         return true;
1120 }
1121
1122 bool CGCommand::DoExecuteNext()
1123 {
1124         if(parameters().size() > 1)
1125         {
1126                 if(!ValidateLayer(parameters()[1]))
1127                 {
1128                         SetReplyString(TEXT("403 CG ERROR\r\n"));
1129                         return false;
1130                 }
1131
1132                 int layer = boost::lexical_cast<int>(parameters()[1]);
1133                 flash::create_cg_proxy(spl::shared_ptr<core::video_channel>(channel()), layer_index(flash::cg_proxy::DEFAULT_LAYER)).next(layer);
1134         }
1135         else
1136         {
1137                 SetReplyString(TEXT("402 CG ERROR\r\n"));
1138                 return true;
1139         }
1140
1141         SetReplyString(TEXT("202 CG OK\r\n"));
1142         return true;
1143 }
1144
1145 bool CGCommand::DoExecuteRemove()
1146 {
1147         if(parameters().size() > 1)
1148         {
1149                 if(!ValidateLayer(parameters()[1]))
1150                 {
1151                         SetReplyString(TEXT("403 CG ERROR\r\n"));
1152                         return false;
1153                 }
1154
1155                 int layer = boost::lexical_cast<int>(parameters()[1]);
1156                 flash::create_cg_proxy(spl::shared_ptr<core::video_channel>(channel()), layer_index(flash::cg_proxy::DEFAULT_LAYER)).remove(layer);
1157         }
1158         else
1159         {
1160                 SetReplyString(TEXT("402 CG ERROR\r\n"));
1161                 return true;
1162         }
1163
1164         SetReplyString(TEXT("202 CG OK\r\n"));
1165         return true;
1166 }
1167
1168 bool CGCommand::DoExecuteClear()
1169 {
1170         channel()->stage().clear(layer_index(flash::cg_proxy::DEFAULT_LAYER));
1171         SetReplyString(TEXT("202 CG OK\r\n"));
1172         return true;
1173 }
1174
1175 bool CGCommand::DoExecuteUpdate()
1176 {
1177         try
1178         {
1179                 if(!ValidateLayer(parameters().at(1)))
1180                 {
1181                         SetReplyString(TEXT("403 CG ERROR\r\n"));
1182                         return false;
1183                 }
1184
1185                 std::wstring dataString = parameters().at(2);
1186                 if(dataString.at(0) != TEXT('<'))
1187                 {
1188                         //The data is not an XML-string, it must be a filename
1189                         std::wstring filename = env::data_folder();
1190                         filename.append(dataString);
1191                         filename.append(TEXT(".ftd"));
1192
1193                         dataString = read_file(boost::filesystem::wpath(filename));
1194                 }
1195
1196                 int layer = boost::lexical_cast<int>(parameters()[1]);
1197                 flash::create_cg_proxy(spl::shared_ptr<core::video_channel>(channel()), layer_index(flash::cg_proxy::DEFAULT_LAYER)).update(layer, dataString);
1198         }
1199         catch(...)
1200         {
1201                 SetReplyString(TEXT("402 CG ERROR\r\n"));
1202                 return true;
1203         }
1204
1205         SetReplyString(TEXT("202 CG OK\r\n"));
1206         return true;
1207 }
1208
1209 bool CGCommand::DoExecuteInvoke()
1210 {
1211         std::wstringstream replyString;
1212         replyString << TEXT("201 CG OK\r\n");
1213
1214         if(parameters().size() > 2)
1215         {
1216                 if(!ValidateLayer(parameters()[1]))
1217                 {
1218                         SetReplyString(TEXT("403 CG ERROR\r\n"));
1219                         return false;
1220                 }
1221                 int layer = boost::lexical_cast<int>(parameters()[1]);
1222                 auto result = flash::create_cg_proxy(spl::shared_ptr<core::video_channel>(channel()), layer_index(flash::cg_proxy::DEFAULT_LAYER)).invoke(layer, parameters()[2]);
1223                 replyString << result << TEXT("\r\n");
1224         }
1225         else
1226         {
1227                 SetReplyString(TEXT("402 CG ERROR\r\n"));
1228                 return true;
1229         }
1230
1231         SetReplyString(replyString.str());
1232         return true;
1233 }
1234
1235 bool CGCommand::DoExecuteInfo()
1236 {
1237         std::wstringstream replyString;
1238         replyString << TEXT("201 CG OK\r\n");
1239
1240         if(parameters().size() > 1)
1241         {
1242                 if(!ValidateLayer(parameters()[1]))
1243                 {
1244                         SetReplyString(TEXT("403 CG ERROR\r\n"));
1245                         return false;
1246                 }
1247
1248                 int layer = boost::lexical_cast<int>(parameters()[1]);
1249                 auto desc = flash::create_cg_proxy(spl::shared_ptr<core::video_channel>(channel()), layer_index(flash::cg_proxy::DEFAULT_LAYER)).description(layer);
1250
1251                 replyString << desc << TEXT("\r\n");
1252         }
1253         else
1254         {
1255                 auto info = flash::create_cg_proxy(spl::shared_ptr<core::video_channel>(channel()), layer_index(flash::cg_proxy::DEFAULT_LAYER)).template_host_info();
1256                 replyString << info << TEXT("\r\n");
1257         }
1258
1259         SetReplyString(replyString.str());
1260         return true;
1261 }
1262
1263 bool DataCommand::DoExecute()
1264 {
1265         std::wstring command = boost::to_upper_copy(parameters()[0]);
1266         if(command == TEXT("STORE"))
1267                 return DoExecuteStore();
1268         else if(command == TEXT("RETRIEVE"))
1269                 return DoExecuteRetrieve();
1270         else if(command == TEXT("REMOVE"))
1271                 return DoExecuteRemove();
1272         else if(command == TEXT("LIST"))
1273                 return DoExecuteList();
1274
1275         SetReplyString(TEXT("403 DATA ERROR\r\n"));
1276         return false;
1277 }
1278
1279 bool DataCommand::DoExecuteStore()
1280 {
1281         if(parameters().size() < 3)
1282         {
1283                 SetReplyString(TEXT("402 DATA STORE ERROR\r\n"));
1284                 return false;
1285         }
1286
1287         std::wstring filename = env::data_folder();
1288         filename.append(parameters()[1]);
1289         filename.append(TEXT(".ftd"));
1290
1291         auto data_path = boost::filesystem::wpath(
1292                 boost::filesystem::wpath(filename).parent_path());
1293
1294         if(!boost::filesystem::exists(data_path))
1295                 boost::filesystem::create_directories(data_path);
1296
1297         std::wofstream datafile(filename.c_str());
1298         if(!datafile)
1299         {
1300                 SetReplyString(TEXT("501 DATA STORE FAILED\r\n"));
1301                 return false;
1302         }
1303
1304         datafile << static_cast<wchar_t>(65279); // UTF-8 BOM character
1305         datafile << parameters()[2] << std::flush;
1306         datafile.close();
1307
1308         std::wstring replyString = TEXT("202 DATA STORE OK\r\n");
1309         SetReplyString(replyString);
1310         return true;
1311 }
1312
1313 bool DataCommand::DoExecuteRetrieve()
1314 {
1315         if(parameters().size() < 2)
1316         {
1317                 SetReplyString(TEXT("402 DATA RETRIEVE ERROR\r\n"));
1318                 return false;
1319         }
1320
1321         std::wstring filename = env::data_folder();
1322         filename.append(parameters()[1]);
1323         filename.append(TEXT(".ftd"));
1324
1325         std::wstring file_contents = read_file(boost::filesystem::wpath(filename));
1326
1327         if (file_contents.empty())
1328         {
1329                 SetReplyString(TEXT("404 DATA RETRIEVE ERROR\r\n"));
1330                 return false;
1331         }
1332
1333         std::wstringstream reply(TEXT("201 DATA RETRIEVE OK\r\n"));
1334
1335         reply << file_contents;
1336         reply << "\r\n";
1337         SetReplyString(reply.str());
1338         return true;
1339 }
1340
1341 bool DataCommand::DoExecuteRemove()
1342 {
1343         if (parameters().size() < 2)
1344         {
1345                 SetReplyString(TEXT("402 DATA REMOVE ERROR\r\n"));
1346                 return false;
1347         }
1348
1349         std::wstring filename = env::data_folder();
1350         filename.append(parameters()[1]);
1351         filename.append(TEXT(".ftd"));
1352
1353         if (!boost::filesystem::exists(filename))
1354         {
1355                 SetReplyString(TEXT("404 DATA REMOVE ERROR\r\n"));
1356                 return false;
1357         }
1358
1359         if (!boost::filesystem::remove(filename))
1360         {
1361                 SetReplyString(TEXT("403 DATA REMOVE ERROR\r\n"));
1362                 return false;
1363         }
1364
1365         SetReplyString(TEXT("201 DATA REMOVE OK\r\n"));
1366
1367         return true;
1368 }
1369
1370 bool DataCommand::DoExecuteList()
1371 {
1372         std::wstringstream replyString;
1373         replyString << TEXT("200 DATA LIST OK\r\n");
1374
1375         for (boost::filesystem::recursive_directory_iterator itr(env::data_folder()), end; itr != end; ++itr)
1376         {
1377                 if(boost::filesystem::is_regular_file(itr->path()))
1378                 {
1379                         if(!boost::iequals(itr->path().extension().wstring(), L".ftd"))
1380                                 continue;
1381
1382                         auto relativePath = boost::filesystem::wpath(itr->path().wstring().substr(env::data_folder().size()-1, itr->path().wstring().size()));
1383
1384                         auto str = relativePath.replace_extension(TEXT("")).native();
1385                         if(str[0] == '\\' || str[0] == '/')
1386                                 str = std::wstring(str.begin() + 1, str.end());
1387
1388                         replyString << str << TEXT("\r\n");
1389                 }
1390         }
1391
1392         replyString << TEXT("\r\n");
1393
1394         SetReplyString(boost::to_upper_copy(replyString.str()));
1395         return true;
1396 }
1397
1398 bool CinfCommand::DoExecute()
1399 {
1400         std::wstringstream replyString;
1401
1402         try
1403         {
1404                 std::wstring info;
1405                 for (boost::filesystem::recursive_directory_iterator itr(env::media_folder()), end; itr != end && info.empty(); ++itr)
1406                 {
1407                         auto path = itr->path();
1408                         auto file = path.replace_extension(L"").filename();
1409                         if(boost::iequals(file.wstring(), parameters().at(0)))
1410                                 info += MediaInfo(itr->path()) + L"\r\n";
1411                 }
1412
1413                 if(info.empty())
1414                 {
1415                         SetReplyString(TEXT("404 CINF ERROR\r\n"));
1416                         return false;
1417                 }
1418                 replyString << TEXT("200 CINF OK\r\n");
1419                 replyString << info << "\r\n";
1420         }
1421         catch(...)
1422         {
1423                 CASPAR_LOG_CURRENT_EXCEPTION();
1424                 SetReplyString(TEXT("404 CINF ERROR\r\n"));
1425                 return false;
1426         }
1427
1428         SetReplyString(replyString.str());
1429         return true;
1430 }
1431
1432 void GenerateChannelInfo(int index, const spl::shared_ptr<core::video_channel>& pChannel, std::wstringstream& replyString)
1433 {
1434         replyString << index+1 << TEXT(" ") << pChannel->video_format_desc().name << TEXT(" PLAYING") << TEXT("\r\n");
1435 }
1436
1437 bool InfoCommand::DoExecute()
1438 {
1439         std::wstringstream replyString;
1440
1441         boost::property_tree::xml_writer_settings<wchar_t> w(' ', 3);
1442
1443         try
1444         {
1445                 if(parameters().size() >= 1 && boost::iequals(parameters()[0], L"TEMPLATE"))
1446                 {
1447                         replyString << L"201 INFO TEMPLATE OK\r\n";
1448
1449                         // Needs to be extended for any file, not just flash.
1450
1451                         auto filename = flash::find_template(env::template_folder() + parameters().at(1));
1452
1453                         std::wstringstream str;
1454                         str << u16(flash::read_template_meta_info(filename));
1455                         boost::property_tree::wptree info;
1456                         boost::property_tree::xml_parser::read_xml(str, info, boost::property_tree::xml_parser::trim_whitespace | boost::property_tree::xml_parser::no_comments);
1457
1458                         boost::property_tree::xml_parser::write_xml(replyString, info, w);
1459                 }
1460                 else if(parameters().size() >= 1 && boost::iequals(parameters()[0], L"CONFIG"))
1461                 {
1462                         replyString << L"201 INFO CONFIG OK\r\n";
1463
1464                         boost::property_tree::write_xml(replyString, caspar::env::properties(), w);
1465                 }
1466                 else if(parameters().size() >= 1 && boost::iequals(parameters()[0], L"PATHS"))
1467                 {
1468                         replyString << L"201 INFO PATHS OK\r\n";
1469
1470                         boost::property_tree::wptree info;
1471                         info.add_child(L"paths", caspar::env::properties().get_child(L"configuration.paths"));
1472                         info.add(L"paths.initial-path", boost::filesystem3::initial_path().wstring() + L"\\");
1473
1474                         boost::property_tree::write_xml(replyString, info, w);
1475                 }
1476                 else if(parameters().size() >= 1 && boost::iequals(parameters()[0], L"SYSTEM"))
1477                 {
1478                         replyString << L"201 INFO SYSTEM OK\r\n";
1479
1480                         boost::property_tree::wptree info;
1481
1482                         info.add(L"system.name",                                        caspar::system_product_name());
1483                         info.add(L"system.windows.name",                        caspar::win_product_name());
1484                         info.add(L"system.windows.service-pack",        caspar::win_sp_version());
1485                         info.add(L"system.cpu",                                         caspar::cpu_info());
1486
1487                         BOOST_FOREACH(auto device, caspar::decklink::device_list())
1488                                 info.add(L"system.decklink.device", device);
1489
1490                         BOOST_FOREACH(auto device, caspar::bluefish::device_list())
1491                                 info.add(L"system.bluefish.device", device);
1492
1493                         info.add(L"system.flash",                                       caspar::flash::version());
1494                         //info.add(L"system.free-image",                                caspar::image::version());
1495                         info.add(L"system.ffmpeg.avcodec",                      caspar::ffmpeg::avcodec_version());
1496                         info.add(L"system.ffmpeg.avformat",                     caspar::ffmpeg::avformat_version());
1497                         info.add(L"system.ffmpeg.avfilter",                     caspar::ffmpeg::avfilter_version());
1498                         info.add(L"system.ffmpeg.avutil",                       caspar::ffmpeg::avutil_version());
1499                         info.add(L"system.ffmpeg.swscale",                      caspar::ffmpeg::swscale_version());
1500
1501                         boost::property_tree::write_xml(replyString, info, w);
1502                 }
1503                 else if(parameters().size() >= 1 && boost::iequals(parameters()[0], L"SERVER"))
1504                 {
1505                         replyString << L"201 INFO SERVER OK\r\n";
1506
1507                         boost::property_tree::wptree info;
1508
1509                         int index = 0;
1510                         BOOST_FOREACH(auto channel, channels())
1511                                 info.add_child(L"channels.channel", channel.channel->info())
1512                                         .add(L"index", ++index);
1513
1514                         boost::property_tree::write_xml(replyString, info, w);
1515                 }
1516                 else // channel
1517                 {
1518                         if(parameters().size() >= 1)
1519                         {
1520                                 replyString << TEXT("201 INFO OK\r\n");
1521                                 boost::property_tree::wptree info;
1522
1523                                 std::vector<std::wstring> split;
1524                                 boost::split(split, parameters()[0], boost::is_any_of("-"));
1525
1526                                 int layer = std::numeric_limits<int>::min();
1527                                 int channel = boost::lexical_cast<int>(split[0]) - 1;
1528
1529                                 if(split.size() > 1)
1530                                         layer = boost::lexical_cast<int>(split[1]);
1531
1532                                 if(layer == std::numeric_limits<int>::min())
1533                                 {
1534                                         info.add_child(L"channel", channels().at(channel).channel->info())
1535                                                         .add(L"index", channel);
1536                                 }
1537                                 else
1538                                 {
1539                                         if(parameters().size() >= 2)
1540                                         {
1541                                                 if(boost::iequals(parameters()[1], L"B"))
1542                                                         info.add_child(L"producer", channels().at(channel).channel->stage().background(layer).get()->info());
1543                                                 else
1544                                                         info.add_child(L"producer", channels().at(channel).channel->stage().foreground(layer).get()->info());
1545                                         }
1546                                         else
1547                                         {
1548                                                 info.add_child(L"layer", channels().at(channel).channel->stage().info(layer).get())
1549                                                         .add(L"index", layer);
1550                                         }
1551                                 }
1552                                 boost::property_tree::xml_parser::write_xml(replyString, info, w);
1553                         }
1554                         else
1555                         {
1556                                 // This is needed for backwards compatibility with old clients
1557                                 replyString << TEXT("200 INFO OK\r\n");
1558                                 for(size_t n = 0; n < channels().size(); ++n)
1559                                         GenerateChannelInfo(n, channels()[n].channel, replyString);
1560                         }
1561
1562                 }
1563         }
1564         catch(...)
1565         {
1566                 CASPAR_LOG_CURRENT_EXCEPTION();
1567                 SetReplyString(TEXT("403 INFO ERROR\r\n"));
1568                 return false;
1569         }
1570
1571         replyString << TEXT("\r\n");
1572         SetReplyString(replyString.str());
1573         return true;
1574 }
1575
1576 bool ClsCommand::DoExecute()
1577 {
1578 /*
1579                 wav = audio
1580                 mp3 = audio
1581                 swf     = movie
1582                 dv  = movie
1583                 tga = still
1584                 col = still
1585         */
1586         try
1587         {
1588                 std::wstringstream replyString;
1589                 replyString << TEXT("200 CLS OK\r\n");
1590                 replyString << ListMedia();
1591                 replyString << TEXT("\r\n");
1592                 SetReplyString(boost::to_upper_copy(replyString.str()));
1593         }
1594         catch(...)
1595         {
1596                 CASPAR_LOG_CURRENT_EXCEPTION();
1597                 SetReplyString(TEXT("501 CLS FAILED\r\n"));
1598                 return false;
1599         }
1600
1601         return true;
1602 }
1603
1604 bool TlsCommand::DoExecute()
1605 {
1606         try
1607         {
1608                 std::wstringstream replyString;
1609                 replyString << TEXT("200 TLS OK\r\n");
1610
1611                 replyString << ListTemplates();
1612                 replyString << TEXT("\r\n");
1613
1614                 SetReplyString(replyString.str());
1615         }
1616         catch(...)
1617         {
1618                 CASPAR_LOG_CURRENT_EXCEPTION();
1619                 SetReplyString(TEXT("501 TLS FAILED\r\n"));
1620                 return false;
1621         }
1622         return true;
1623 }
1624
1625 bool VersionCommand::DoExecute()
1626 {
1627         std::wstring replyString = TEXT("201 VERSION OK\r\n") + env::version() + TEXT("\r\n");
1628
1629         if(parameters().size() > 0)
1630         {
1631                 if(boost::iequals(parameters()[0], L"FLASH"))
1632                         replyString = TEXT("201 VERSION OK\r\n") + flash::version() + TEXT("\r\n");
1633                 else if(boost::iequals(parameters()[0], L"TEMPLATEHOST"))
1634                         replyString = TEXT("201 VERSION OK\r\n") + flash::cg_version() + TEXT("\r\n");
1635                 else if(!boost::iequals(parameters()[0], L"SERVER"))
1636                         replyString = TEXT("403 VERSION ERROR\r\n");
1637         }
1638
1639         SetReplyString(replyString);
1640         return true;
1641 }
1642
1643 bool ByeCommand::DoExecute()
1644 {
1645         client()->disconnect();
1646         return true;
1647 }
1648
1649 bool SetCommand::DoExecute()
1650 {
1651         try
1652         {
1653                 std::wstring name = boost::to_upper_copy(parameters()[0]);
1654                 std::wstring value = boost::to_upper_copy(parameters()[1]);
1655
1656                 if(name == TEXT("MODE"))
1657                 {
1658                         auto format_desc = core::video_format_desc(value);
1659                         if(format_desc.format != core::video_format::invalid)
1660                         {
1661                                 channel()->video_format_desc(format_desc);
1662                                 SetReplyString(TEXT("202 SET MODE OK\r\n"));
1663                         }
1664                         else
1665                                 SetReplyString(TEXT("501 SET MODE FAILED\r\n"));
1666                 }
1667                 else
1668                 {
1669                         this->SetReplyString(TEXT("403 SET ERROR\r\n"));
1670                 }
1671         }
1672         catch(...)
1673         {
1674                 CASPAR_LOG_CURRENT_EXCEPTION();
1675                 SetReplyString(TEXT("501 SET FAILED\r\n"));
1676                 return false;
1677         }
1678
1679         return true;
1680 }
1681
1682 bool LockCommand::DoExecute()
1683 {
1684         try
1685         {
1686                 auto it = parameters().begin();
1687
1688                 std::shared_ptr<caspar::IO::lock_container> lock;
1689                 try
1690                 {
1691                         int channel_index = boost::lexical_cast<int>(*it) - 1;
1692                         lock = channels().at(channel_index).lock;
1693                 }
1694                 catch(const boost::bad_lexical_cast&) {}
1695                 catch(...)
1696                 {
1697                         SetReplyString(L"401 LOCK ERROR\r\n");
1698                         return false;
1699                 }
1700
1701                 if(lock)
1702                         ++it;
1703
1704                 if(it == parameters().end())    //too few parameters
1705                 {
1706                         SetReplyString(L"402 LOCK ERROR\r\n");
1707                         return false;
1708                 }
1709
1710                 std::wstring command = boost::to_upper_copy(*it);
1711                 if(command == L"ACQUIRE")
1712                 {
1713                         ++it;
1714                         if(it == parameters().end())    //too few parameters
1715                         {
1716                                 SetReplyString(L"402 LOCK ACQUIRE ERROR\r\n");
1717                                 return false;
1718                         }
1719                         std::wstring lock_phrase = (*it);
1720
1721                         //TODO: read options
1722
1723                         if(lock)
1724                         {
1725                                 //just lock one channel
1726                                 if(!lock->try_lock(lock_phrase, client()))
1727                                 {
1728                                         SetReplyString(L"503 LOCK ACQUIRE FAILED\r\n");
1729                                         return false;
1730                                 }
1731                         }
1732                         else
1733                         {
1734                                 //TODO: lock all channels
1735                                 CASPAR_THROW_EXCEPTION(not_implemented());
1736                         }
1737                         SetReplyString(L"202 LOCK ACQUIRE OK\r\n");
1738
1739                 }
1740                 else if(command == L"RELEASE")
1741                 {
1742                         if(lock)
1743                         {
1744                                 client()->remove_lifecycle_bound_object(lock->lifecycle_key());
1745                         }
1746                         else
1747                         {
1748                                 //TODO: lock all channels
1749                                 CASPAR_THROW_EXCEPTION(not_implemented());
1750                         }
1751                         SetReplyString(L"202 LOCK RELEASE OK\r\n");
1752                 }
1753                 else if(command == L"CLEAR")
1754                 {
1755                         ++it;
1756                         if(it == parameters().end())
1757                         {
1758                                 SetReplyString(L"402 LOCK CLEAR ERROR\r\n");
1759                                 return false;
1760                         }
1761                         std::wstring override_phrase = (*it);
1762
1763                         //TODO: clear locks
1764
1765
1766                         SetReplyString(L"202 LOCK CLEAR OK\r\n");
1767                 }
1768                 else
1769                 {
1770                         SetReplyString(L"403 LOCK ERROR\r\n");
1771                         return false;
1772                 }
1773         }
1774         catch(...)
1775         {
1776                 CASPAR_LOG_CURRENT_EXCEPTION();
1777                 SetReplyString(L"501 LOCK FAILED\r\n");
1778                 return false;
1779         }
1780
1781         return true;
1782 }
1783
1784
1785 }       //namespace amcp
1786 }}      //namespace caspar