git.sesse.net Git - casparcg/blob - protocol/cii/CIICommandsImpl.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
  23 #include "../StdAfx.h"
  24
  25 #pragma warning (disable: 4244)
  26
  27 #include "CIIProtocolStrategy.h"
  28 #include "CIICommandsImpl.h"
  29 #include <sstream>
  30 #include <algorithm>
  31 #include <modules/flash/producer/cg_proxy.h>
  32 #include <boost/locale.hpp>
  33 #include <boost/algorithm/string/trim.hpp>
  34 #include <boost/algorithm/string/split.hpp>
  35 #include <boost/lexical_cast.hpp>
  36
  37 namespace caspar { namespace protocol { namespace cii {
  38
  39 ////////
  40 // MediaCommand
  41 void MediaCommand::Setup(const std::vector<std::wstring>& parameters)
  42 {
  43         graphicProfile_ = parameters[1].substr(2);
  44 }
  45
  46 void MediaCommand::Execute()
  47 {
  48         pCIIStrategy_->SetProfile(graphicProfile_);
  49 }
  50
  51
  52 ////////
  53 // WriteCommand
  54 void WriteCommand::Setup(const std::vector<std::wstring>& parameters)
  55 {
  56         try
  57         {
  58                 if(parameters.size() > 2)
  59                 {
  60                         targetName_ = parameters[1];
  61                         templateName_ = parameters[2];
  62
  63                         std::wstringstream dataStream;
  64
  65                         dataStream << TEXT("<templateData>");
  66
  67                         std::vector<std::wstring>::size_type end = parameters.size();
  68                         for(std::vector<std::wstring>::size_type i = 3; i < end; ++i)
  69                                 dataStream << TEXT("<componentData id=\"field") << i-2 << TEXT("\"><data id=\"text\" value=\"") << parameters[i] << TEXT("\" /></componentData>");
  70
  71                         dataStream << TEXT("</templateData>");
  72                         xmlData_ = dataStream.str();
  73                 }
  74         }
  75         catch(std::exception) {
  76         }
  77 }
  78
  79 void WriteCommand::Execute()
  80 {
  81         pCIIStrategy_->WriteTemplateData(templateName_, targetName_, xmlData_);
  82 }
  83
  84
  85 //////////
  86 // ImagestoreCommand
  87 void ImagestoreCommand::Setup(const std::vector<std::wstring>& parameters)
  88 {
  89         if(parameters[1] == TEXT("7") && parameters.size() > 2)
  90                 titleName_ = parameters[2].substr(0, 4);
  91 }
  92
  93 void ImagestoreCommand::Execute()
  94 {
  95         pCIIStrategy_->DisplayTemplate(titleName_);
  96 }
  97
  98
  99 //////////
 100 // MiscellaneousCommand
 101 void MiscellaneousCommand::Setup(const std::vector<std::wstring>& parameters)
 102 {
 103         //HAWRYS:       V\5\3\1\1\namn.tga\1
 104         //                      Display still
 105         if((parameters.size() > 5) && parameters[1] == TEXT("5") && parameters[2] == TEXT("3"))
 106         {
 107                 filename_ = parameters[5];
 108                 filename_ = filename_.substr(0, filename_.find_last_of(TEXT('.')));
 109                 filename_.append(L".ft");
 110                 state_ = 0;
 111                 return;
 112         }
 113
 114         //NEPTUNE:      V\5\13\1\X\Template\0\TabField1\TabField2...
 115         //                      Add Template to layer X in the active templatehost
 116         if((parameters.size() > 5) && parameters[1] == TEXT("5") && parameters[2] == TEXT("13"))
 117         {
 118                 layer_ = _ttoi(parameters[4].c_str());
 119                 filename_ = parameters[5];
 120                 if(filename_.find(L"PK/") == std::wstring::npos && filename_.find(L"PK\\") == std::wstring::npos)
 121                         filename_ = L"PK/" + filename_;
 122
 123                 state_ = 1;
 124                 if(parameters.size() > 7) {
 125                         std::wstringstream dataStream;
 126
 127                         dataStream << TEXT("<templateData>");
 128                         std::vector<std::wstring>::size_type end = parameters.size();
 129                         for(std::vector<std::wstring>::size_type i = 7; i < end; ++i) {
 130                                 dataStream << TEXT("<componentData id=\"f") << i-7 << TEXT("\"><data id=\"text\" value=\"") << parameters[i] << TEXT("\" /></componentData>");
 131                         }
 132                         dataStream << TEXT("</templateData>");
 133
 134                         xmlData_ = dataStream.str();
 135                 }
 136         }
 137
 138         // VIDEO MODE V\5\14\MODE
 139         if((parameters.size() > 3) && parameters[1] == TEXT("5") && parameters[2] == TEXT("14"))
 140         {
 141                 std::wstring value = parameters[3];
 142                 std::transform(value.begin(), value.end(), value.begin(), toupper);
 143
 144                 this->pCIIStrategy_->GetChannel()->video_format_desc(core::video_format_desc(value));
 145         }
 146 }
 147
 148 void MiscellaneousCommand::Execute()
 149 {
 150         if(state_ == 0)
 151                 pCIIStrategy_->DisplayMediaFile(filename_);
 152
 153         //TODO: Need to be checked for validity
 154         else if(state_ == 1)
 155         {
 156                 // HACK fix. The data sent is UTF8, however the protocol is implemented for ISO-8859-1. Instead of doing risky changes we simply convert into proper encoding when leaving protocol code.
 157                 auto xmlData2 = boost::locale::conv::utf_to_utf<wchar_t, char>(std::string(xmlData_.begin(), xmlData_.end()));
 158                 flash::create_cg_proxy(pCIIStrategy_->GetChannel()).add(layer_, filename_, false, TEXT(""), xmlData2);
 159         }
 160 }
 161
 162
 163 /////////
 164 // KeydataCommand
 165 void KeydataCommand::Execute()
 166 {
 167         if(state_ == 0)
 168                 pCIIStrategy_->DisplayTemplate(titleName_);
 169
 170
 171         //TODO: Need to be checked for validity
 172         else if(state_ == 1)
 173                 flash::create_cg_proxy(pCIIStrategy_->GetChannel(), casparLayer_).stop(layer_, 0);
 174         else if(state_ == 2)
 175                 pCIIStrategy_->GetChannel()->stage().clear();
 176         else if(state_ == 3)
 177                 flash::create_cg_proxy(pCIIStrategy_->GetChannel(), casparLayer_).play(layer_);
 178 }
 179
 180 void KeydataCommand::Setup(const std::vector<std::wstring>& parameters) {
 181         //HAWRYS:       Y\<205><247><202><196><192><192><200><248>
 182         //parameter[1] looks like this: "=g:XXXXh" where XXXX is the name that we want
 183         if(parameters[1].size() > 6)
 184         {
 185                 titleName_.resize(4);
 186                 for(int i=0;i<4;++i)
 187                 {
 188                         if(parameters[1][i+3] < 176) {
 189                                 titleName_ = TEXT("");
 190                                 break;
 191                         }
 192                         titleName_[i] = parameters[1][i+3]-144;
 193                 }
 194                 state_ = 0;
 195         }
 196
 197         casparLayer_ = flash::cg_proxy::DEFAULT_LAYER;
 198         if(parameters.size() > 2)
 199         {
 200                 //The layer parameter now supports casparlayers.
 201                 //the format is [CasparLayer]-[FlashLayer]
 202                 std::wstring str = boost::trim_copy(parameters[2]);
 203                 std::vector<std::wstring> split;
 204                 boost::split(split, str, boost::is_any_of("-"));
 205
 206                 try
 207                 {
 208                         casparLayer_ = boost::lexical_cast<int>(split[0]);
 209
 210                         if(split.size() > 1)
 211                                 layer_ = boost::lexical_cast<int>(split[1]);
 212                 }
 213                 catch(...)
 214                 {
 215                         casparLayer_ = flash::cg_proxy::DEFAULT_LAYER;
 216                         layer_ = 0;
 217                 }
 218         }
 219
 220
 221         if(parameters[1].at(0) == 27)   //NEPTUNE:      Y\<27>\X                        Stop layer X.
 222                 state_ = 1;
 223         else if(static_cast<unsigned char>(parameters[1].at(1)) == 190) //NEPTUNE:      Y\<254>                 Clear Canvas.
 224                 state_ = 2;
 225         else if(static_cast<unsigned char>(parameters[1].at(1)) == 149) //NEPTUNE:      Y\<213><243>\X  Play layer X.
 226                 state_ = 3;                                                                                                     //UPDATE 2011-05-09: These char-codes are aparently not valid after converting to wide-chars
 227                                                                                                                                         //the correct sequence is <195><149><195><179>
 228
 229 }
 230
 231 }}}