#pragma warning (disable : 4702) // unreachable code\r
#pragma warning (disable : 4714) // marked as __forceinline not inlined\r
#pragma warning (disable : 4505) // unreferenced local function has been removed\r
+#pragma warning (disable : 4481) // nonstandard extension used: override specifier 'override'\r
#endif\r
\r
{\r
struct empty_frame_consumer : public frame_consumer\r
{\r
- core::video_format_desc format_desc;\r
- virtual bool send(const safe_ptr<read_frame>&){return false;}\r
- virtual void initialize(const video_format_desc&, int, int){}\r
- virtual std::wstring print() const {return L"empty";}\r
- virtual bool has_synchronization_clock() const {return false;}\r
- virtual size_t buffer_depth() const {return 0;};\r
+ virtual bool send(const safe_ptr<read_frame>&) override {return false;}\r
+ virtual void initialize(const video_format_desc&, int, int) override{}\r
+ virtual std::wstring print() const override {return L"empty";}\r
+ virtual bool has_synchronization_clock() const override {return false;}\r
+ virtual size_t buffer_depth() const override {return 0;};\r
};\r
static safe_ptr<frame_consumer> consumer = make_safe<empty_frame_consumer>();\r
return consumer;\r
\r
// frame_producer\r
\r
- virtual safe_ptr<basic_frame> receive(int) { return frame_; } \r
- virtual safe_ptr<basic_frame> last_frame() const { return frame_; } \r
- virtual std::wstring print() const { return L"color[" + color_str_ + L"]"; }\r
+ virtual safe_ptr<basic_frame> receive(int) override\r
+ {\r
+ return frame_;\r
+ } \r
+\r
+ virtual safe_ptr<basic_frame> last_frame() const override\r
+ {\r
+ return frame_; \r
+ } \r
+\r
+ virtual std::wstring print() const override\r
+ {\r
+ return L"color[" + color_str_ + L"]";\r
+ }\r
};\r
\r
std::wstring get_hex_color(const std::wstring& str)\r
}\r
}\r
\r
- virtual safe_ptr<basic_frame> receive(int hints) {return (*producer_)->receive(hints);}\r
- virtual safe_ptr<basic_frame> last_frame() const {return (*producer_)->last_frame();}\r
- virtual std::wstring print() const {return (*producer_)->print();}\r
- virtual std::wstring param(const std::wstring& str) {return (*producer_)->param(str);}\r
- virtual safe_ptr<frame_producer> get_following_producer() const {return (*producer_)->get_following_producer();}\r
- virtual void set_leading_producer(const safe_ptr<frame_producer>& producer) {(*producer_)->set_leading_producer(producer);}\r
- virtual int64_t nb_frames() const {return (*producer_)->nb_frames();}\r
+ virtual safe_ptr<basic_frame> receive(int hints) override {return (*producer_)->receive(hints);}\r
+ virtual safe_ptr<basic_frame> last_frame() const override {return (*producer_)->last_frame();}\r
+ virtual std::wstring print() const override {return (*producer_)->print();}\r
+ virtual std::wstring call(const std::wstring& str) override {return (*producer_)->call(str);}\r
+ virtual safe_ptr<frame_producer> get_following_producer() const override {return (*producer_)->get_following_producer();}\r
+ virtual void set_leading_producer(const safe_ptr<frame_producer>& producer) override {(*producer_)->set_leading_producer(producer);}\r
+ virtual int64_t nb_frames() const override {return (*producer_)->nb_frames();}\r
};\r
\r
safe_ptr<core::frame_producer> create_destroy_proxy(safe_ptr<core::frame_producer>&& producer)\r
\r
virtual std::wstring print() const = 0; // nothrow\r
\r
- virtual std::wstring param(const std::wstring&){return L"";}\r
+ virtual std::wstring call(const std::wstring&) {return L"";}\r
\r
virtual safe_ptr<frame_producer> get_following_producer() const {return frame_producer::empty();} // nothrow\r
virtual void set_leading_producer(const safe_ptr<frame_producer>&) {} // nothrow\r
return status;\r
}\r
\r
- std::wstring param(bool foreground, const std::wstring& param)\r
+ std::wstring call(bool foreground, const std::wstring& param)\r
{\r
- return (foreground ? foreground_ : background_)->param(param);\r
+ return (foreground ? foreground_ : background_)->call(param);\r
}\r
\r
bool empty() const\r
safe_ptr<frame_producer> layer::foreground() const { return impl_->foreground_;}\r
safe_ptr<frame_producer> layer::background() const { return impl_->background_;}\r
bool layer::empty() const {return impl_->empty();}\r
-std::wstring layer::param(bool foreground, const std::wstring& param){return impl_->param(foreground, param);}\r
+std::wstring layer::call(bool foreground, const std::wstring& param){return impl_->call(foreground, param);}\r
}}
\ No newline at end of file
void play(); // nothrow\r
void pause(); // nothrow\r
void stop(); // nothrow\r
- std::wstring param(bool foreground, const std::wstring& param);\r
+ std::wstring call(bool foreground, const std::wstring& param);\r
\r
bool is_paused() const;\r
int64_t frame_number() const;\r
, loop_(loop)\r
{\r
}\r
+\r
+ // frame_producer\r
\r
- virtual safe_ptr<basic_frame> receive(int hints)\r
+ virtual safe_ptr<basic_frame> receive(int hints) override\r
{\r
if(current_ == frame_producer::empty() && !producers_.empty())\r
{\r
return last_frame_ = frame;\r
}\r
\r
- virtual safe_ptr<core::basic_frame> last_frame() const\r
+ virtual safe_ptr<core::basic_frame> last_frame() const override\r
{\r
return disable_audio(last_frame_);\r
}\r
\r
- virtual std::wstring print() const\r
+ virtual std::wstring print() const override\r
{\r
return L"playlist[]";\r
} \r
\r
- virtual int64_t nb_frames() const \r
+ virtual int64_t nb_frames() const override\r
{\r
return std::numeric_limits<int>::max();\r
}\r
\r
- virtual std::wstring param(const std::wstring& param)\r
+ virtual std::wstring call(const std::wstring& param) override\r
{ \r
static const boost::wregex push_front_exp (L"PUSH_FRONT (?<PARAM>.+)"); \r
static const boost::wregex push_back_exp (L"(PUSH_BACK|PUSH) (?<PARAM>.+)");\r
\r
BOOST_THROW_EXCEPTION(invalid_argument());\r
}\r
+\r
+ // playlist_producer\r
\r
std::wstring push_front(const std::wstring& str)\r
{\r
, last_frame_(core::basic_frame::empty())\r
{\r
}\r
+\r
// frame_producer\r
\r
- virtual safe_ptr<basic_frame> receive(int hints)\r
+ virtual safe_ptr<basic_frame> receive(int hints) override\r
{\r
tbb::parallel_invoke(\r
[&]\r
return last_frame_ = frame;\r
}\r
\r
- virtual safe_ptr<core::basic_frame> last_frame() const\r
+ virtual safe_ptr<core::basic_frame> last_frame() const override\r
{\r
return disable_audio(last_frame_);\r
}\r
\r
- virtual std::wstring print() const\r
+ virtual std::wstring print() const override\r
{\r
return L"separated[fill:" + fill_producer_->print() + L"|key:" + key_producer_->print() + L"]";\r
} \r
\r
- virtual int64_t nb_frames() const \r
+ virtual int64_t nb_frames() const override\r
{\r
return std::min(fill_producer_->nb_frames(), key_producer_->nb_frames());\r
}\r
}, high_priority);\r
} \r
\r
- std::wstring param(int index, bool foreground, const std::wstring& param)\r
+ std::wstring call(int index, bool foreground, const std::wstring& param)\r
{\r
return executor_.invoke([&]\r
{\r
- return layers_[index].param(foreground, param);\r
+ return layers_[index].call(foreground, param);\r
}, high_priority);\r
}\r
\r
safe_ptr<frame_producer> stage::foreground(size_t index) {return impl_->foreground(index);}\r
safe_ptr<frame_producer> stage::background(size_t index) {return impl_->background(index);}\r
void stage::set_video_format_desc(const video_format_desc& format_desc){impl_->set_video_format_desc(format_desc);}\r
-std::wstring stage::param(int index, bool foreground, const std::wstring& param){return impl_->param(index, foreground, param);}\r
+std::wstring stage::call(int index, bool foreground, const std::wstring& param){return impl_->call(index, foreground, param);}\r
}}
\ No newline at end of file
void stop(int index);\r
void clear(int index);\r
void clear(); \r
- std::wstring param(int index, bool foreground, const std::wstring& param);\r
+ std::wstring call(int index, bool foreground, const std::wstring& param);\r
void swap_layer(int index, size_t other_index);\r
void swap_layer(int index, size_t other_index, stage& other);\r
\r
\r
// frame_producer\r
\r
- virtual safe_ptr<frame_producer> get_following_producer() const\r
+ virtual safe_ptr<frame_producer> get_following_producer() const override\r
{\r
return dest_producer_;\r
}\r
\r
- virtual void set_leading_producer(const safe_ptr<frame_producer>& producer)\r
+ virtual void set_leading_producer(const safe_ptr<frame_producer>& producer) override\r
{\r
source_producer_ = producer;\r
}\r
\r
- virtual safe_ptr<basic_frame> receive(int hints)\r
+ virtual safe_ptr<basic_frame> receive(int hints) override\r
{\r
if(++current_frame_ >= info_.duration)\r
return basic_frame::eof();\r
return compose(dest, source);\r
}\r
\r
- virtual safe_ptr<core::basic_frame> last_frame() const\r
+ virtual safe_ptr<core::basic_frame> last_frame() const override\r
{\r
return disable_audio(last_frame_);\r
}\r
\r
- virtual int64_t nb_frames() const \r
+ virtual int64_t nb_frames() const override\r
{\r
return get_following_producer()->nb_frames();\r
}\r
\r
- virtual std::wstring print() const\r
+ virtual std::wstring print() const override\r
{\r
return L"transition[" + source_producer_->print() + L"|" + dest_producer_->print() + L"]";\r
}\r
, key_only_(key_only)\r
{\r
}\r
+\r
+ // frame_consumer\r
\r
- virtual void initialize(const core::video_format_desc& format_desc, int channel_index, int sub_index)\r
+ virtual void initialize(const core::video_format_desc& format_desc, int channel_index, int sub_index) override\r
{\r
consumer_.reset(new bluefish_consumer(format_desc, device_index_, embedded_audio_, key_only_, channel_index, sub_index));\r
}\r
\r
- virtual bool send(const safe_ptr<core::read_frame>& frame)\r
+ virtual bool send(const safe_ptr<core::read_frame>& frame) override\r
{\r
consumer_->send(frame);\r
return true;\r
}\r
\r
- virtual std::wstring print() const\r
+ virtual std::wstring print() const override\r
{\r
return consumer_->print();\r
}\r
\r
- size_t buffer_depth() const\r
+ size_t buffer_depth() const override\r
{\r
return 1;\r
}\r
context_.reset();\r
CASPAR_LOG(info) << str << L" Successfully Uninitialized."; \r
}\r
+\r
+ // frame_consumer\r
\r
- virtual void initialize(const core::video_format_desc& format_desc, int channel_index, int sub_index)\r
+ virtual void initialize(const core::video_format_desc& format_desc, int channel_index, int sub_index) override\r
{\r
context_.reset([&]{return new decklink_consumer(config_, format_desc, channel_index, sub_index);}); \r
\r
CASPAR_LOG(info) << print() << L" Successfully Initialized."; \r
}\r
\r
- virtual bool send(const safe_ptr<core::read_frame>& frame)\r
+ virtual bool send(const safe_ptr<core::read_frame>& frame) override\r
{\r
context_->send(frame);\r
return true;\r
}\r
\r
- virtual std::wstring print() const\r
+ virtual std::wstring print() const override\r
{\r
return context_->print();\r
} \r
\r
- virtual size_t buffer_depth() const\r
+ virtual size_t buffer_depth() const override\r
{\r
return config_.buffer_depth;\r
}\r
context_.reset();\r
CASPAR_LOG(info) << str << L" Successfully Uninitialized."; \r
}\r
+\r
+ // frame_producer\r
\r
- virtual safe_ptr<core::basic_frame> receive(int)\r
+ virtual safe_ptr<core::basic_frame> receive(int) override\r
{\r
auto frame = context_->get_frame();\r
if(frame != core::basic_frame::late())\r
return frame;\r
}\r
\r
- virtual safe_ptr<core::basic_frame> last_frame() const\r
+ virtual safe_ptr<core::basic_frame> last_frame() const override\r
{\r
return disable_audio(last_frame_);\r
}\r
\r
- virtual int64_t nb_frames() const \r
+ virtual int64_t nb_frames() const override\r
{\r
return length_;\r
}\r
\r
- std::wstring print() const\r
+ std::wstring print() const override\r
{\r
return context_->print();\r
}\r
//colored_fputs(av_clip(level>>3, 0, 6), line);\r
}\r
\r
-//static int query_yadif_formats(AVFilterContext *ctx)
-//{
-// static const int pix_fmts[] = {
-// PIX_FMT_YUV444P,
-// PIX_FMT_YUV422P,
-// PIX_FMT_YUV420P,
-// PIX_FMT_YUV410P,
-// PIX_FMT_YUV411P,
-// PIX_FMT_GRAY8,
-// PIX_FMT_YUVJ444P,
-// PIX_FMT_YUVJ422P,
-// PIX_FMT_YUVJ420P,
-// AV_NE( PIX_FMT_GRAY16BE, PIX_FMT_GRAY16LE ),
-// PIX_FMT_YUV440P,
-// PIX_FMT_YUVJ440P,
-// AV_NE( PIX_FMT_YUV444P16BE, PIX_FMT_YUV444P16LE ),
-// AV_NE( PIX_FMT_YUV422P16BE, PIX_FMT_YUV422P16LE ),
-// AV_NE( PIX_FMT_YUV420P16BE, PIX_FMT_YUV420P16LE ),
-// PIX_FMT_YUVA420P,
-// PIX_FMT_NONE
-// };
-// avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
-//
-// return 0;
+//static int query_yadif_formats(AVFilterContext *ctx)\r
+//{\r
+// static const int pix_fmts[] = {\r
+// PIX_FMT_YUV444P,\r
+// PIX_FMT_YUV422P,\r
+// PIX_FMT_YUV420P,\r
+// PIX_FMT_YUV410P,\r
+// PIX_FMT_YUV411P,\r
+// PIX_FMT_GRAY8,\r
+// PIX_FMT_YUVJ444P,\r
+// PIX_FMT_YUVJ422P,\r
+// PIX_FMT_YUVJ420P,\r
+// AV_NE( PIX_FMT_GRAY16BE, PIX_FMT_GRAY16LE ),\r
+// PIX_FMT_YUV440P,\r
+// PIX_FMT_YUVJ440P,\r
+// AV_NE( PIX_FMT_YUV444P16BE, PIX_FMT_YUV444P16LE ),\r
+// AV_NE( PIX_FMT_YUV422P16BE, PIX_FMT_YUV422P16LE ),\r
+// AV_NE( PIX_FMT_YUV420P16BE, PIX_FMT_YUV420P16LE ),\r
+// PIX_FMT_YUVA420P,\r
+// PIX_FMT_NONE\r
+// };\r
+// avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));\r
+//\r
+// return 0;\r
//}\r
//\r
//#pragma warning (push)\r
//#pragma warning (disable : 4706)\r
//void fix_yadif_filter_format_query()\r
//{\r
-// AVFilter** filter = nullptr;
+// AVFilter** filter = nullptr;\r
// while((filter = av_filter_next(filter)) && *filter)\r
// {\r
// if(strstr((*filter)->name, "yadif") != 0)\r
\r
muxer_.reset(new frame_muxer(video_decoder_ ? video_decoder_->fps() : frame_factory->get_video_format_desc().fps, frame_factory, filter));\r
}\r
+\r
+ // frame_producer\r
\r
- virtual safe_ptr<core::basic_frame> receive(int hints)\r
+ virtual safe_ptr<core::basic_frame> receive(int hints) override\r
{ \r
frame_timer_.restart();\r
\r
return last_frame_;\r
}\r
\r
- virtual safe_ptr<core::basic_frame> last_frame() const\r
+ virtual safe_ptr<core::basic_frame> last_frame() const override\r
{\r
return disable_audio(last_frame_);\r
}\r
- \r
- void try_decode_frame(int hints)\r
- {\r
- std::shared_ptr<AVPacket> pkt;\r
-\r
- for(int n = 0; n < 32 && ((video_decoder_ && !video_decoder_->ready()) || (audio_decoder_ && !audio_decoder_->ready())) && input_.try_pop(pkt); ++n)\r
- {\r
- if(video_decoder_)\r
- video_decoder_->push(pkt);\r
- if(audio_decoder_)\r
- audio_decoder_->push(pkt);\r
- }\r
- \r
- std::shared_ptr<AVFrame> video;\r
- std::shared_ptr<core::audio_buffer> audio;\r
-\r
- tbb::parallel_invoke(\r
- [&]\r
- {\r
- if(!muxer_->video_ready() && video_decoder_) \r
- video = video_decoder_->poll(); \r
- },\r
- [&]\r
- { \r
- if(!muxer_->audio_ready() && audio_decoder_) \r
- audio = audio_decoder_->poll(); \r
- });\r
-\r
- muxer_->push(video, hints);\r
- muxer_->push(audio);\r
-\r
- if(!audio_decoder_)\r
- {\r
- if(video == flush_video())\r
- muxer_->push(flush_audio());\r
- else if(!muxer_->audio_ready())\r
- muxer_->push(empty_audio());\r
- }\r
-\r
- if(!video_decoder_)\r
- {\r
- if(audio == flush_audio())\r
- muxer_->push(flush_video(), 0);\r
- else if(!muxer_->video_ready())\r
- muxer_->push(empty_video(), 0);\r
- }\r
- \r
- for(auto frame = muxer_->poll(); frame; frame = muxer_->poll())\r
- frame_buffer_.push(make_safe_ptr(frame));\r
- }\r
\r
- virtual int64_t nb_frames() const \r
+ virtual int64_t nb_frames() const override\r
{\r
if(loop_)\r
return std::numeric_limits<int64_t>::max();\r
return nb_frames - start_;\r
}\r
\r
- virtual std::wstring param(const std::wstring& param)\r
+ virtual std::wstring call(const std::wstring& param) override\r
{\r
static const boost::wregex loop_exp(L"LOOP\\s*(?<VALUE>\\d?)");\r
static const boost::wregex seek_exp(L"SEEK\\s+(?<VALUE>\\d+)");\r
BOOST_THROW_EXCEPTION(invalid_argument());\r
}\r
\r
- virtual std::wstring print() const\r
+ virtual std::wstring print() const override\r
{\r
if(video_decoder_)\r
{\r
\r
return L"ffmpeg[" + boost::filesystem::wpath(filename_).filename() + L"]";\r
}\r
+\r
+ // ffmpeg_producer\r
+ \r
+ void try_decode_frame(int hints)\r
+ {\r
+ std::shared_ptr<AVPacket> pkt;\r
+\r
+ for(int n = 0; n < 32 && ((video_decoder_ && !video_decoder_->ready()) || (audio_decoder_ && !audio_decoder_->ready())) && input_.try_pop(pkt); ++n)\r
+ {\r
+ if(video_decoder_)\r
+ video_decoder_->push(pkt);\r
+ if(audio_decoder_)\r
+ audio_decoder_->push(pkt);\r
+ }\r
+ \r
+ std::shared_ptr<AVFrame> video;\r
+ std::shared_ptr<core::audio_buffer> audio;\r
+\r
+ tbb::parallel_invoke(\r
+ [&]\r
+ {\r
+ if(!muxer_->video_ready() && video_decoder_) \r
+ video = video_decoder_->poll(); \r
+ },\r
+ [&]\r
+ { \r
+ if(!muxer_->audio_ready() && audio_decoder_) \r
+ audio = audio_decoder_->poll(); \r
+ });\r
+\r
+ muxer_->push(video, hints);\r
+ muxer_->push(audio);\r
+\r
+ if(!audio_decoder_)\r
+ {\r
+ if(video == flush_video())\r
+ muxer_->push(flush_audio());\r
+ else if(!muxer_->audio_ready())\r
+ muxer_->push(empty_audio());\r
+ }\r
+\r
+ if(!video_decoder_)\r
+ {\r
+ if(audio == flush_audio())\r
+ muxer_->push(flush_video(), 0);\r
+ else if(!muxer_->video_ready())\r
+ muxer_->push(empty_video(), 0);\r
+ }\r
+ \r
+ for(auto frame = muxer_->poll(); frame; frame = muxer_->poll())\r
+ frame_buffer_.push(make_safe_ptr(frame));\r
+ }\r
};\r
\r
safe_ptr<core::frame_producer> create_producer(const safe_ptr<core::frame_factory>& frame_factory, const std::vector<std::wstring>& params)\r
#include <boost/filesystem.hpp>\r
#include <boost/format.hpp>\r
#include <boost/algorithm/string.hpp>\r
+#include <boost/regex.hpp>\r
\r
namespace caspar { namespace flash {\r
\r
: flash_producer_(frame_producer)\r
{}\r
\r
- void add(int layer, std::wstring filename, bool play_on_load, const std::wstring& label, const std::wstring& data)\r
+ std::wstring add(int layer, std::wstring filename, bool play_on_load, const std::wstring& label, const std::wstring& data)\r
{\r
if(filename.size() > 0 && filename[0] == L'/')\r
filename = filename.substr(1, filename.size()-1);\r
auto str = (boost::wformat(L"<invoke name=\"Add\" returntype=\"xml\"><arguments><number>%1%</number><string>%2%</string>%3%<string>%4%</string><string><![CDATA[%5%]]></string></arguments></invoke>") % layer % filename % (play_on_load?TEXT("<true/>"):TEXT("<false/>")) % label % data).str();\r
\r
CASPAR_LOG(info) << flash_producer_->print() << " Invoking add-command: " << str;\r
- flash_producer_->param(str);\r
+ return flash_producer_->call(str);\r
}\r
\r
- void remove(int layer)\r
+ std::wstring remove(int layer)\r
{\r
auto str = (boost::wformat(L"<invoke name=\"Delete\" returntype=\"xml\"><arguments><array><property id=\"0\"><number>%1%</number></property></array></arguments></invoke>") % layer).str();\r
CASPAR_LOG(info) << flash_producer_->print() << " Invoking remove-command: " << str;\r
- flash_producer_->param(str);\r
+ return flash_producer_->call(str);\r
}\r
\r
- void play(int layer)\r
+ std::wstring play(int layer)\r
{\r
auto str = (boost::wformat(L"<invoke name=\"Play\" returntype=\"xml\"><arguments><array><property id=\"0\"><number>%1%</number></property></array></arguments></invoke>") % layer).str();\r
CASPAR_LOG(info) << flash_producer_->print() << " Invoking play-command: " << str;\r
- flash_producer_->param(str);\r
+ return flash_producer_->call(str);\r
}\r
\r
- void stop(int layer, unsigned int)\r
+ std::wstring stop(int layer, unsigned int)\r
{\r
auto str = (boost::wformat(L"<invoke name=\"Stop\" returntype=\"xml\"><arguments><array><property id=\"0\"><number>%1%</number></property></array><number>0</number></arguments></invoke>") % layer).str();\r
CASPAR_LOG(info) << flash_producer_->print() << " Invoking stop-command: " << str;\r
- flash_producer_->param(str);\r
+ return flash_producer_->call(str);\r
}\r
\r
- void next(int layer)\r
+ std::wstring next(int layer)\r
{\r
auto str = (boost::wformat(L"<invoke name=\"Next\" returntype=\"xml\"><arguments><array><property id=\"0\"><number>%1%</number></property></array></arguments></invoke>") % layer).str();\r
CASPAR_LOG(info) << flash_producer_->print() << " Invoking next-command: " << str;\r
- flash_producer_->param(str);\r
+ return flash_producer_->call(str);\r
}\r
\r
- void update(int layer, const std::wstring& data)\r
+ std::wstring update(int layer, const std::wstring& data)\r
{\r
auto str = (boost::wformat(L"<invoke name=\"SetData\" returntype=\"xml\"><arguments><array><property id=\"0\"><number>%1%</number></property></array><string><![CDATA[%2%]]></string></arguments></invoke>") % layer % data).str();\r
CASPAR_LOG(info) << flash_producer_->print() <<" Invoking update-command: " << str;\r
- flash_producer_->param(str);\r
+ return flash_producer_->call(str);\r
}\r
\r
std::wstring invoke(int layer, const std::wstring& label)\r
{\r
auto str = (boost::wformat(L"<invoke name=\"Invoke\" returntype=\"xml\"><arguments><array><property id=\"0\"><number>%1%</number></property></array><string>%2%</string></arguments></invoke>") % layer % label).str();\r
CASPAR_LOG(info) << flash_producer_->print() << " Invoking invoke-command: " << str;\r
- return flash_producer_->param(str);\r
+ return flash_producer_->call(str);\r
}\r
\r
std::wstring description(int layer)\r
{\r
auto str = (boost::wformat(L"<invoke name=\"GetDescription\" returntype=\"xml\"><arguments><array><property id=\"0\"><number>%1%</number></property></array></arguments></invoke>") % layer).str();\r
CASPAR_LOG(info) << flash_producer_->print() << " Invoking description-command: " << str;\r
- return flash_producer_->param(str);\r
+ return flash_producer_->call(str);\r
}\r
\r
std::wstring info()\r
{\r
auto str = (boost::wformat(L"<invoke name=\"GetInfo\" returntype=\"xml\"><arguments></arguments></invoke>")).str();\r
CASPAR_LOG(info) << flash_producer_->print() << " Invoking info-command: " << str;\r
- return flash_producer_->param(str);\r
+ return flash_producer_->call(str);\r
}\r
\r
- virtual std::wstring param(const std::wstring& str)\r
+ std::wstring call(const std::wstring& str)\r
{ \r
- return flash_producer_->param(str);\r
+ static const boost::wregex add_exp (L"ADD (?<LAYER>\\d+) (?<FILENAME>[^\\s]+) (?<PLAY_ON_LOAD>\\d)\\s?(?<DATA>.*)?");\r
+ static const boost::wregex remove_exp (L"REMOVE (?<LAYER>\\d+)");\r
+ static const boost::wregex play_exp (L"PLAY (?<LAYER>\\d+)");\r
+ static const boost::wregex stop_exp (L"STOP (?<LAYER>\\d+)");\r
+ static const boost::wregex next_exp (L"NEXT (?<LAYER>\\d+)");\r
+ static const boost::wregex update_exp (L"UPDATE (?<LAYER>\\d+) (?<DATA>.+)");\r
+ static const boost::wregex invoke_exp (L"INVOKE (?<LAYER>\\d+) (?<LABEL>.+)");\r
+ static const boost::wregex description_exp (L"INFO (?<LAYER>\\d+)");\r
+ static const boost::wregex info_exp (L"INFO");\r
+ \r
+ boost::wsmatch what;\r
+ if(boost::regex_match(str, what, add_exp))\r
+ return add(boost::lexical_cast<int>(what["LAYER"].str()), what["FILENAME"].str(), boost::lexical_cast<bool>(what["PLAY_ON_LOAD"].str()), L"", what["DATA"].str()); \r
+ else if(boost::regex_match(str, what, remove_exp))\r
+ return remove(boost::lexical_cast<int>(what["LAYER"].str())); \r
+ else if(boost::regex_match(str, what, stop_exp))\r
+ return stop(boost::lexical_cast<int>(what["LAYER"].str()), 0); \r
+ else if(boost::regex_match(str, what, next_exp))\r
+ return next(boost::lexical_cast<int>(what["LAYER"].str())); \r
+ else if(boost::regex_match(str, what, update_exp))\r
+ return update(boost::lexical_cast<int>(what["LAYER"].str()), what["DATA"].str()); \r
+ else if(boost::regex_match(str, what, next_exp))\r
+ return invoke(boost::lexical_cast<int>(what["LAYER"].str()), what["LABEL"].str()); \r
+ else if(boost::regex_match(str, what, description_exp))\r
+ return description(boost::lexical_cast<int>(what["LAYER"].str())); \r
+ else if(boost::regex_match(str, what, invoke_exp))\r
+ return info(); \r
+\r
+ return flash_producer_->call(str);\r
}\r
\r
- virtual safe_ptr<core::basic_frame> receive(int hints)\r
+ safe_ptr<core::basic_frame> receive(int hints)\r
{\r
return flash_producer_->receive(hints);\r
}\r
\r
- virtual safe_ptr<core::basic_frame> last_frame() const\r
+ safe_ptr<core::basic_frame> last_frame() const\r
{\r
return flash_producer_->last_frame();\r
} \r
void cg_producer::update(int layer, const std::wstring& data){impl_->update(layer, data);}\r
std::wstring cg_producer::invoke(int layer, const std::wstring& label){return impl_->invoke(layer, label);}\r
std::wstring cg_producer::print() const{return impl_->print();}\r
-std::wstring cg_producer::param(const std::wstring& str){return impl_->param(str);}\r
+std::wstring cg_producer::call(const std::wstring& str){return impl_->call(str);}\r
std::wstring cg_producer::description(int layer){return impl_->description(layer);}\r
std::wstring cg_producer::info(){return impl_->info();}\r
\r
cg_producer(cg_producer&& other);\r
\r
// frame_producer\r
- virtual safe_ptr<core::basic_frame> receive(int);\r
- virtual safe_ptr<core::basic_frame> last_frame() const;\r
- virtual std::wstring print() const;\r
- virtual std::wstring param(const std::wstring&);\r
+\r
+ virtual safe_ptr<core::basic_frame> receive(int) override;\r
+ virtual safe_ptr<core::basic_frame> last_frame() const override;\r
+ virtual std::wstring print() const override;\r
+ virtual std::wstring call(const std::wstring&) override;\r
\r
//cg_producer\r
+\r
void add(int layer, const std::wstring& template_name, bool play_on_load, const std::wstring& start_from_label = TEXT(""), const std::wstring& data = TEXT(""));\r
void remove(int layer);\r
void play(int layer);\r
CASPAR_LOG(info) << print() << L" Uninitialized.";\r
}\r
\r
- std::wstring param(const std::wstring& param)\r
+ std::wstring call(const std::wstring& param)\r
{ \r
std::wstring result;\r
\r
\r
// frame_producer\r
\r
- virtual safe_ptr<core::basic_frame> receive(int)\r
+ virtual safe_ptr<core::basic_frame> receive(int) override\r
{ \r
graph_->set_value("output-buffer-count", static_cast<float>(frame_buffer_.size())/static_cast<float>(frame_buffer_.capacity()));\r
\r
return frame;\r
}\r
\r
- virtual safe_ptr<core::basic_frame> last_frame() const\r
+ virtual safe_ptr<core::basic_frame> last_frame() const override\r
{\r
tbb::spin_mutex::scoped_lock lock(last_frame_mutex_);\r
return last_frame_;\r
} \r
\r
- virtual std::wstring param(const std::wstring& param) \r
+ virtual std::wstring call(const std::wstring& param) override\r
{ \r
return context_.invoke([=]() -> std::wstring\r
{\r
\r
try\r
{\r
- return context_->param(param); \r
+ return context_->call(param); \r
\r
//const auto& format_desc = frame_factory_->get_video_format_desc();\r
//if(abs(context_->fps() - format_desc.fps) > 0.01 && abs(context_->fps()/2.0 - format_desc.fps) > 0.01)\r
});\r
}\r
\r
- virtual std::wstring print() const\r
+ virtual std::wstring print() const override\r
{ \r
return L"flash[" + boost::filesystem::wpath(filename_).filename() + L"|" + boost::lexical_cast<std::wstring>(fps_) + L"]"; \r
} \r
core::video_format_desc format_desc_;\r
public:\r
\r
- virtual void initialize(const core::video_format_desc& format_desc, int, int)\r
+ // frame_consumer\r
+\r
+ virtual void initialize(const core::video_format_desc& format_desc, int, int) override\r
{\r
format_desc_ = format_desc;\r
}\r
\r
- virtual bool send(const safe_ptr<core::read_frame>& frame)\r
+ virtual bool send(const safe_ptr<core::read_frame>& frame) override\r
{ \r
auto format_desc = format_desc_;\r
boost::thread async([format_desc, frame]\r
return false;\r
}\r
\r
- virtual std::wstring print() const\r
+ virtual std::wstring print() const override\r
{\r
return L"image[]";\r
}\r
\r
- virtual const core::video_format_desc& get_video_format_desc() const\r
- {\r
- return format_desc_;\r
- }\r
-\r
- virtual size_t buffer_depth() const \r
+ virtual size_t buffer_depth() const override\r
{\r
return 0;\r
}\r
\r
// frame_producer\r
\r
- virtual safe_ptr<core::basic_frame> receive(int){return frame_;}\r
+ virtual safe_ptr<core::basic_frame> receive(int) override\r
+ {\r
+ return frame_;\r
+ }\r
\r
- virtual safe_ptr<core::basic_frame> last_frame() const\r
+ virtual safe_ptr<core::basic_frame> last_frame() const override\r
{\r
return frame_;\r
}\r
\r
- virtual std::wstring print() const\r
+ virtual std::wstring print() const override\r
{\r
return L"image_producer[" + filename_ + L"]";\r
}\r
\r
// frame_producer\r
\r
- virtual safe_ptr<core::basic_frame> receive(int)\r
+ virtual safe_ptr<core::basic_frame> receive(int) override\r
{ \r
delta_ += speed_;\r
\r
return last_frame_ = make_safe<core::basic_frame>(frames_);\r
}\r
\r
- virtual safe_ptr<core::basic_frame> last_frame() const\r
+ virtual safe_ptr<core::basic_frame> last_frame() const override\r
{\r
return last_frame_;\r
}\r
\r
- virtual std::wstring print() const\r
+ virtual std::wstring print() const override\r
{\r
return L"image_scroll_producer[" + filename_ + L"]";\r
}\r
\r
- virtual int64_t nb_frames() const \r
+ virtual int64_t nb_frames() const override\r
{\r
if(height_ > format_desc_.height)\r
{\r
CASPAR_LOG(info) << print() << L" Shutting down."; \r
}\r
\r
- virtual void initialize(const core::video_format_desc& format_desc, int channel_index, int sub_index)\r
+ // frame consumer\r
+\r
+ virtual void initialize(const core::video_format_desc& format_desc, int channel_index, int sub_index) override\r
{\r
format_desc_ = format_desc; \r
channel_index_ = channel_index;\r
CASPAR_LOG(info) << print() << " Sucessfully initialized.";\r
}\r
\r
- virtual bool send(const safe_ptr<core::read_frame>& frame)\r
+ virtual bool send(const safe_ptr<core::read_frame>& frame) override\r
{ \r
input_.push(std::make_shared<std::vector<int16_t, tbb::cache_aligned_allocator<int16_t>>>(core::audio_32_to_16_sse(frame->audio_data())));\r
\r
return true;\r
}\r
\r
- virtual bool OnGetData(sf::SoundStream::Chunk& data)\r
+ virtual std::wstring print() const override\r
+ {\r
+ return L"oal[" + boost::lexical_cast<std::wstring>(channel_index_) + L"-" + boost::lexical_cast<std::wstring>(sub_index_) + L"|" + format_desc_.name + L"]";\r
+ }\r
+ \r
+ virtual size_t buffer_depth() const override\r
+ {\r
+ return 2;\r
+ }\r
+\r
+ // oal_consumer\r
+ \r
+ virtual bool OnGetData(sf::SoundStream::Chunk& data) override\r
{ \r
std::shared_ptr<std::vector<int16_t, tbb::cache_aligned_allocator<int16_t>>> audio_data; \r
input_.pop(audio_data);\r
\r
return is_running_;\r
}\r
-\r
- virtual std::wstring print() const\r
- {\r
- return L"oal[" + boost::lexical_cast<std::wstring>(channel_index_) + L"-" + boost::lexical_cast<std::wstring>(sub_index_) + L"|" + format_desc_.name + L"]";\r
- }\r
- \r
- virtual size_t buffer_depth() const\r
- {\r
- return 2;\r
- }\r
};\r
\r
safe_ptr<core::frame_consumer> create_consumer(const std::vector<std::wstring>& params)\r
ogl_consumer_proxy(const configuration& config)\r
: config_(config){}\r
\r
- virtual void initialize(const core::video_format_desc& format_desc, int channel_index, int sub_index)\r
+ // frame_consumer\r
+\r
+ virtual void initialize(const core::video_format_desc& format_desc, int channel_index, int sub_index) override\r
{\r
consumer_.reset();\r
consumer_.reset(new ogl_consumer(config_, format_desc, channel_index, sub_index));\r
}\r
\r
- virtual bool send(const safe_ptr<core::read_frame>& frame)\r
+ virtual bool send(const safe_ptr<core::read_frame>& frame) override\r
{\r
consumer_->send(frame);\r
return true;\r
}\r
\r
- virtual std::wstring print() const\r
+ virtual std::wstring print() const override\r
{\r
return consumer_->print();\r
}\r
\r
- virtual bool has_synchronization_clock() const \r
+ virtual bool has_synchronization_clock() const override\r
{\r
return false;\r
}\r
\r
- virtual size_t buffer_depth() const\r
+ virtual size_t buffer_depth() const override\r
{\r
return 1;\r
}\r
}\r
}\r
\r
-bool ParamCommand::DoExecute()\r
+bool CallCommand::DoExecute()\r
{ \r
//Perform loading of the clip\r
try\r
\r
std::wstring result;\r
if(what == L"B")\r
- result = GetChannel()->stage()->param(GetLayerIndex(), false, param);\r
+ result = GetChannel()->stage()->call(GetLayerIndex(), false, param);\r
else if(what == L"F")\r
- result = GetChannel()->stage()->param(GetLayerIndex(), true, param);\r
+ result = GetChannel()->stage()->call(GetLayerIndex(), true, param);\r
else\r
- result = GetChannel()->stage()->param(GetLayerIndex(), true, _parameters.at(0) + L" " + param);\r
+ result = GetChannel()->stage()->call(GetLayerIndex(), true, _parameters.at(0) + L" " + param);\r
\r
- CASPAR_LOG(info) << "Executed param: " << _parameters[0] << TEXT(" successfully");\r
+ CASPAR_LOG(info) << "Executed call: " << _parameters[0] << TEXT(" successfully");\r
\r
std::wstringstream replyString;\r
- replyString << TEXT("201 PARAM OK\r\n") << result << L"\r\n";\r
+ replyString << TEXT("201 CALL OK\r\n") << result << L"\r\n";\r
\r
SetReplyString(replyString.str());\r
\r
catch(...)\r
{\r
CASPAR_LOG_CURRENT_EXCEPTION();\r
- SetReplyString(TEXT("502 PARAM FAILED\r\n"));\r
+ SetReplyString(TEXT("502 CALL FAILED\r\n"));\r
return false;\r
}\r
}\r
bool DoExecute();\r
};\r
\r
-class ParamCommand : public AMCPCommandBase<true, AddToQueue, 2>\r
+class CallCommand : public AMCPCommandBase<true, AddToQueue, 2>\r
{\r
- std::wstring print() const { return L"ParamCommand";}\r
+ std::wstring print() const { return L"CallCommand";}\r
bool DoExecute();\r
};\r
\r
\r
if (s == TEXT("MIXER")) return std::make_shared<MixerCommand>();\r
else if(s == TEXT("DIAG")) return std::make_shared<DiagnosticsCommand>();\r
- else if(s == TEXT("PARAM")) return std::make_shared<ParamCommand>();\r
+ else if(s == TEXT("CALL")) return std::make_shared<CallCommand>();\r
else if(s == TEXT("SWAP")) return std::make_shared<SwapCommand>();\r
else if(s == TEXT("LOAD")) return std::make_shared<LoadCommand>();\r
else if(s == TEXT("LOADBG")) return std::make_shared<LoadbgCommand>();\r
\r
std::wstringstream flashParam;\r
flashParam << TEXT("<invoke name=\"Add\" returntype=\"xml\"><arguments><number>1</number><string>") << currentProfile_ << '/' << templateName << TEXT("</string><number>0</number><true/><string> </string><string><![CDATA[ ") << xmlData << TEXT(" ]]></string></arguments></invoke>");\r
- producer->param(flashParam.str());\r
+ producer->call(flashParam.str());\r
\r
CASPAR_LOG(info) << "Saved an instance of " << templateName << TEXT(" as ") << titleName ;\r
\r
projects / casparcg / commitdiff