2.1.0: Implemented monitoring for vide-channel, stage and layer.

git-svn-id: https://casparcg.svn.sourceforge.net/svnroot/casparcg/server/branches/2.1.0@2342 362d55ac-95cf-4e76-9f9a-cbaa9c17b72d

diff --git a/core/monitor/monitor.h b/core/monitor/monitor.h
index f0bc33a95b87d5079ebbc25c5ce50a11601f0ca4..d637493545e4c8a6249ce4ad1b6b1e3ca883d524 100644 (file)
--- a/core/monitor/monitor.h
+++ b/core/monitor/monitor.h
@@ -47,6 +47,11 @@ public:
 \r
                return *this;\r
        }\r
+       \r
+       path& operator%=(const char* value)\r
+       {\r
+               return *this %= std::string(value);\r
+       }\r
 \r
        void swap(path& other);\r
 \r
@@ -106,6 +111,8 @@ private:
        monitor::path                           path_;\r
        std::shared_ptr<params_t>       params_;\r
 };\r
+\r
+typedef reactive::observable<monitor::event> observable;\r
        \r
 class subject : public reactive::subject<monitor::event>\r
 {          \r

diff --git a/core/producer/layer.cpp b/core/producer/layer.cpp
index e22a1211fc896404dac406bd89669abb93b871dc..1e85f467e5856bf2b81167bec90fc43682f1149a 100644 (file)
--- a/core/producer/layer.cpp
+++ b/core/producer/layer.cpp
@@ -25,6 +25,7 @@
 \r
 #include "frame_producer.h"\r
 \r
+#include "../video_format.h"\r
 #include "../frame/draw_frame.h"\r
 #include "../frame/frame_transform.h"\r
 \r
@@ -35,6 +36,7 @@ namespace caspar { namespace core {
 \r
 struct layer::impl\r
 {                              \r
+       monitor::subject                                event_subject_;\r
        spl::shared_ptr<frame_producer> foreground_;\r
        spl::shared_ptr<frame_producer> background_;\r
        int64_t                                                 frame_number_;\r
@@ -42,8 +44,9 @@ struct layer::impl
        bool                                                    is_paused_;\r
 \r
 public:\r
-       impl() \r
-               : foreground_(frame_producer::empty())\r
+       impl(int index) \r
+               : event_subject_(monitor::path("layer") % index)\r
+               , foreground_(frame_producer::empty())\r
                , background_(frame_producer::empty())\r
                , frame_number_(0)\r
                , is_paused_(false)\r
@@ -92,7 +95,7 @@ public:
                pause();\r
        }\r
                \r
-       spl::shared_ptr<draw_frame> receive(frame_producer::flags flags)\r
+       spl::shared_ptr<draw_frame> receive(frame_producer::flags flags, const video_format_desc& format_desc)\r
        {               \r
                try\r
                {\r
@@ -111,9 +114,15 @@ public:
                                if(frames_left < 1)\r
                                {\r
                                        play();\r
-                                       return receive(flags);\r
+                                       return receive(flags, format_desc);\r
                                }\r
                        }\r
+\r
+                       event_subject_  << monitor::event("state")      % u8(is_paused_ ? L"paused" : (foreground_ == frame_producer::empty() ? L"stopped" : L"playing"))                                                       \r
+                                                       << monitor::event("time")       % monitor::duration(frame_number_/format_desc.fps)\r
+                                                                                                               % monitor::duration(static_cast<int64_t>(foreground_->nb_frames()) - static_cast<int64_t>(auto_play_delta_ ? *auto_play_delta_ : 0)/format_desc.fps)\r
+                                                       << monitor::event("frame")      % static_cast<int64_t>(frame_number_)\r
+                                                                                                               % static_cast<int64_t>((static_cast<int64_t>(foreground_->nb_frames()) - static_cast<int64_t>(auto_play_delta_ ? *auto_play_delta_ : 0)));\r
                                \r
                        return frame;\r
                }\r
@@ -142,10 +151,9 @@ public:
        }\r
 };\r
 \r
-layer::layer() : impl_(new impl()){}\r
-layer::layer(const layer& other) : impl_(new impl(*other.impl_)){}\r
+layer::layer(int index) : impl_(new impl(index)){}\r
 layer::layer(layer&& other) : impl_(std::move(other.impl_)){}\r
-layer& layer::operator=(layer other)\r
+layer& layer::operator=(layer&& other)\r
 {\r
        other.swap(*this);\r
        return *this;\r
@@ -158,8 +166,10 @@ void layer::load(spl::shared_ptr<frame_producer> frame_producer, const boost::op
 void layer::play(){impl_->play();}\r
 void layer::pause(){impl_->pause();}\r
 void layer::stop(){impl_->stop();}\r
-spl::shared_ptr<draw_frame> layer::receive(frame_producer::flags flags) {return impl_->receive(flags);}\r
+spl::shared_ptr<draw_frame> layer::receive(frame_producer::flags flags, const video_format_desc& format_desc) {return impl_->receive(flags, format_desc);}\r
 spl::shared_ptr<frame_producer> layer::foreground() const { return impl_->foreground_;}\r
 spl::shared_ptr<frame_producer> layer::background() const { return impl_->background_;}\r
 boost::property_tree::wptree layer::info() const{return impl_->info();}\r
+void layer::subscribe(const monitor::observable::observer_ptr& o) {impl_->event_subject_.subscribe(o);}\r
+void layer::unsubscribe(const monitor::observable::observer_ptr& o) {impl_->event_subject_.unsubscribe(o);}\r
 }}
\ No newline at end of file

diff --git a/core/producer/layer.h b/core/producer/layer.h
index b3077e353328b89d178485585717f69ccb19d602..8e9fef61b3b2de60ed2431aa564fdee1b86b7708 100644 (file)
--- a/core/producer/layer.h
+++ b/core/producer/layer.h
@@ -23,6 +23,8 @@
 \r
 #include "frame_producer.h"\r
 \r
+#include "../monitor/monitor.h"\r
+\r
 #include <common/forward.h>\r
 #include <common/spl/memory.h>\r
 \r
@@ -35,13 +37,12 @@ FORWARD1(boost, template<typename T> class optional);
 \r
 namespace caspar { namespace core {\r
        \r
-class layer sealed\r
+class layer sealed : public monitor::observable\r
 {\r
 public:\r
-       layer(); // nothrow\r
-       layer(const layer&);\r
+       layer(int index = -1); // nothrow\r
        layer(layer&& other); // nothrow\r
-       layer& operator=(layer other); // nothrow\r
+       layer& operator=(layer&& other); // nothrow\r
 \r
        void swap(layer& other); // nothrow \r
                \r
@@ -53,9 +54,14 @@ public:
        spl::shared_ptr<struct frame_producer> foreground() const; // nothrow\r
        spl::shared_ptr<struct frame_producer> background() const; // nothrow\r
 \r
-       spl::shared_ptr<class draw_frame> receive(frame_producer::flags flags); // nothrow\r
+       spl::shared_ptr<class draw_frame> receive(frame_producer::flags flags, const struct video_format_desc& format_desc); // nothrow\r
 \r
        boost::property_tree::wptree info() const;\r
+\r
+       // monitor::observable\r
+\r
+       virtual void subscribe(const monitor::observable::observer_ptr& o) override;\r
+       virtual void unsubscribe(const monitor::observable::observer_ptr& o) override;\r
 private:\r
        struct impl;\r
        spl::shared_ptr<impl> impl_;\r

diff --git a/core/producer/stage.cpp b/core/producer/stage.cpp
index 4d6c426f23b0aeccd2baacafb3525a3c096b58da..14a284141cb73b7ca7e7ff485a79cea98c279ea8 100644 (file)
--- a/core/producer/stage.cpp
+++ b/core/producer/stage.cpp
@@ -40,6 +40,7 @@
 \r
 #include <tbb/parallel_for_each.h>\r
 \r
+#include <functional>\r
 #include <map>\r
 #include <vector>\r
 \r
@@ -48,12 +49,14 @@ namespace caspar { namespace core {
 struct stage::impl : public std::enable_shared_from_this<impl>\r
 {                              \r
        spl::shared_ptr<diagnostics::graph> graph_;\r
+       spl::shared_ptr<monitor::subject>       event_subject_;\r
        std::map<int, layer>                            layers_;        \r
        std::map<int, tweened_transform>        tweens_;        \r
        executor                                                        executor_;\r
 public:\r
        impl(spl::shared_ptr<diagnostics::graph> graph) \r
                : graph_(std::move(graph))\r
+               , event_subject_(new monitor::subject("stage"))\r
                , executor_(L"stage")\r
        {\r
                graph_->set_color("produce-time", diagnostics::color(0.0f, 1.0f, 0.0f));\r
@@ -66,43 +69,19 @@ public:
                        boost::timer frame_timer;\r
 \r
                        std::map<int, spl::shared_ptr<class draw_frame>> frames;\r
-\r
+                       \r
                        try\r
-                       {                                       \r
-                               BOOST_FOREACH(auto& layer, layers_)                     \r
-                                       frames[layer.first] = draw_frame::empty();      \r
+                       {                       \r
+                               std::vector<int> indices;\r
 \r
-                               auto format_desc2 = format_desc;\r
-\r
-                               tbb::parallel_for_each(layers_.begin(), layers_.end(), [&](std::map<int, layer>::value_type& layer)\r
+                               BOOST_FOREACH(auto& layer, layers_)     \r
                                {\r
-                                       auto& tween             = tweens_[layer.first];\r
-                                       auto transform  = tween.fetch_and_tick(1);\r
-\r
-                                       frame_producer::flags flags = frame_producer::flags::none;\r
-                                       if(format_desc2.field_mode != field_mode::progressive)\r
-                                       {\r
-                                               flags |= std::abs(transform.fill_scale[1]  - 1.0) > 0.0001 ? frame_producer::flags::deinterlace : frame_producer::flags::none;\r
-                                               flags |= std::abs(transform.fill_translation[1])  > 0.0001 ? frame_producer::flags::deinterlace : frame_producer::flags::none;\r
-                                       }\r
-\r
-                                       if(transform.is_key)\r
-                                               flags |= frame_producer::flags::alpha_only;\r
+                                       frames[layer.first] = draw_frame::empty();      \r
+                                       indices.push_back(layer.first);\r
+                               }                               \r
 \r
-                                       auto frame = layer.second.receive(flags);       \r
-                               \r
-                                       auto frame1 = spl::make_shared<core::draw_frame>(frame);\r
-                                       frame1->get_frame_transform() = transform;\r
-\r
-                                       if(format_desc2.field_mode != core::field_mode::progressive)\r
-                                       {                               \r
-                                               auto frame2 = spl::make_shared<core::draw_frame>(frame);\r
-                                               frame2->get_frame_transform() = tween.fetch_and_tick(1);\r
-                                               frame1 = core::draw_frame::interlace(frame1, frame2, format_desc2.field_mode);\r
-                                       }\r
-\r
-                                       frames[layer.first] = frame1;\r
-                               });             \r
+                               // WORKAROUND: Compiler doesn't seem to like lambda.\r
+                               tbb::parallel_for_each(indices.begin(), indices.end(), std::bind(&stage::impl::draw, this, std::placeholders::_1, std::ref(format_desc), std::ref(frames)));\r
                        }\r
                        catch(...)\r
                        {\r
@@ -115,6 +94,48 @@ public:
                        return frames;\r
                });\r
        }\r
+\r
+       void draw(int index, const video_format_desc& format_desc, std::map<int, spl::shared_ptr<draw_frame>>& frames)\r
+       {\r
+               auto& layer             = layers_[index];\r
+               auto& tween             = tweens_[index];\r
+               auto transform  = tween.fetch_and_tick(1);\r
+\r
+               frame_producer::flags flags = frame_producer::flags::none;\r
+               if(format_desc.field_mode != field_mode::progressive)\r
+               {\r
+                       flags |= std::abs(transform.fill_scale[1]  - 1.0) > 0.0001 ? frame_producer::flags::deinterlace : frame_producer::flags::none;\r
+                       flags |= std::abs(transform.fill_translation[1])  > 0.0001 ? frame_producer::flags::deinterlace : frame_producer::flags::none;\r
+               }\r
+\r
+               if(transform.is_key)\r
+                       flags |= frame_producer::flags::alpha_only;\r
+\r
+               auto frame = layer.receive(flags, format_desc); \r
+                               \r
+               auto frame1 = spl::make_shared<core::draw_frame>(frame);\r
+               frame1->get_frame_transform() = transform;\r
+\r
+               if(format_desc.field_mode != core::field_mode::progressive)\r
+               {                               \r
+                       auto frame2 = spl::make_shared<core::draw_frame>(frame);\r
+                       frame2->get_frame_transform() = tween.fetch_and_tick(1);\r
+                       frame1 = core::draw_frame::interlace(frame1, frame2, format_desc.field_mode);\r
+               }\r
+\r
+               frames[index] = frame;\r
+       }\r
+\r
+       layer& get_layer(int index)\r
+       {\r
+               auto it = layers_.find(index);\r
+               if(it == std::end(layers_))\r
+               {\r
+                       it = layers_.insert(std::make_pair(index, layer(index))).first;\r
+                       it->second.subscribe(event_subject_);\r
+               }\r
+               return it->second;\r
+       }\r
                \r
        void apply_transforms(const std::vector<std::tuple<int, stage::transform_func_t, unsigned int, tweener>>& transforms)\r
        {\r
@@ -159,7 +180,7 @@ public:
        {\r
                executor_.begin_invoke([=]\r
                {\r
-                       layers_[index].load(producer, auto_play_delta);\r
+                       get_layer(index).load(producer, auto_play_delta);\r
                }, task_priority::high_priority);\r
        }\r
 \r
@@ -203,18 +224,35 @@ public:
                }, task_priority::high_priority);\r
        }       \r
                \r
-       void swap_layers(const spl::shared_ptr<stage>& other)\r
+       void swap_layers(stage& other)\r
        {\r
-               if(other->impl_.get() == this)\r
+               auto other_impl = other.impl_;\r
+\r
+               if(other_impl.get() == this)\r
                        return;\r
                \r
                auto func = [=]\r
                {\r
-                       std::swap(layers_, other->impl_->layers_);\r
+                       auto layers                     = layers_ | boost::adaptors::map_values;\r
+                       auto other_layers       = other_impl->layers_ | boost::adaptors::map_values;\r
+\r
+                       BOOST_FOREACH(auto& layer, layers)\r
+                               layer.unsubscribe(event_subject_);\r
+                       \r
+                       BOOST_FOREACH(auto& layer, other_layers)\r
+                               layer.unsubscribe(event_subject_);\r
+                       \r
+                       std::swap(layers_, other_impl->layers_);\r
+                                               \r
+                       BOOST_FOREACH(auto& layer, layers)\r
+                               layer.subscribe(event_subject_);\r
+                       \r
+                       BOOST_FOREACH(auto& layer, other_layers)\r
+                               layer.subscribe(event_subject_);\r
                };              \r
                executor_.begin_invoke([=]\r
                {\r
-                       other->impl_->executor_.invoke(func, task_priority::high_priority);\r
+                       other_impl->executor_.invoke(func, task_priority::high_priority);\r
                }, task_priority::high_priority);\r
        }\r
 \r
@@ -226,19 +264,30 @@ public:
                }, task_priority::high_priority);\r
        }\r
 \r
-       void swap_layer(int index, int other_index, const spl::shared_ptr<stage>& other)\r
+       void swap_layer(int index, int other_index, stage& other)\r
        {\r
-               if(other->impl_.get() == this)\r
+               auto other_impl = other.impl_;\r
+\r
+               if(other_impl.get() == this)\r
                        swap_layer(index, other_index);\r
                else\r
                {\r
                        auto func = [=]\r
                        {\r
-                               std::swap(layers_[index], other->impl_->layers_[other_index]);\r
+                               auto& my_layer          = get_layer(index);\r
+                               auto& other_layer       = other_impl->get_layer(other_index);\r
+\r
+                               my_layer.unsubscribe(event_subject_);\r
+                               other_layer.unsubscribe(other_impl->event_subject_);\r
+\r
+                               std::swap(my_layer, other_layer);\r
+\r
+                               my_layer.subscribe(event_subject_);\r
+                               other_layer.subscribe(other_impl->event_subject_);\r
                        };              \r
                        executor_.begin_invoke([=]\r
                        {\r
-                               other->impl_->executor_.invoke(func, task_priority::high_priority);\r
+                               other_impl->executor_.invoke(func, task_priority::high_priority);\r
                        }, task_priority::high_priority);\r
                }\r
        }\r
@@ -291,12 +340,14 @@ void stage::play(int index){impl_->play(index);}
 void stage::stop(int index){impl_->stop(index);}\r
 void stage::clear(int index){impl_->clear(index);}\r
 void stage::clear(){impl_->clear();}\r
-void stage::swap_layers(const spl::shared_ptr<stage>& other){impl_->swap_layers(other);}\r
+void stage::swap_layers(stage& other){impl_->swap_layers(other);}\r
 void stage::swap_layer(int index, int other_index){impl_->swap_layer(index, other_index);}\r
-void stage::swap_layer(int index, int other_index, const spl::shared_ptr<stage>& other){impl_->swap_layer(index, other_index, other);}\r
+void stage::swap_layer(int index, int other_index, stage& other){impl_->swap_layer(index, other_index, other);}\r
 boost::unique_future<spl::shared_ptr<frame_producer>> stage::foreground(int index) {return impl_->foreground(index);}\r
 boost::unique_future<spl::shared_ptr<frame_producer>> stage::background(int index) {return impl_->background(index);}\r
 boost::unique_future<boost::property_tree::wptree> stage::info() const{return impl_->info();}\r
 boost::unique_future<boost::property_tree::wptree> stage::info(int index) const{return impl_->info(index);}\r
 std::map<int, spl::shared_ptr<class draw_frame>> stage::operator()(const video_format_desc& format_desc){return (*impl_)(format_desc);}\r
+void stage::subscribe(const monitor::observable::observer_ptr& o) {impl_->event_subject_->subscribe(o);}\r
+void stage::unsubscribe(const monitor::observable::observer_ptr& o) {impl_->event_subject_->unsubscribe(o);}\r
 }}
\ No newline at end of file

diff --git a/core/producer/stage.h b/core/producer/stage.h
index 192fcb524341eeb46047506dc5f89f1ec18ef123..2fddec0c23f7f1dd83af68d0fbe9b6775ffd19f2 100644 (file)
--- a/core/producer/stage.h
+++ b/core/producer/stage.h
@@ -23,6 +23,8 @@
 \r
 #include "frame_producer.h"\r
 \r
+#include "../monitor/monitor.h"\r
+\r
 #include <common/forward.h>\r
 #include <common/spl/memory.h>\r
 #include <common/tweener.h>\r
@@ -39,7 +41,7 @@ FORWARD1(boost, template<typename> class unique_future);
 \r
 namespace caspar { namespace core {\r
        \r
-class stage sealed\r
+class stage sealed : public monitor::observable\r
 {\r
        stage(const stage&);\r
        stage& operator=(const stage&);\r
@@ -62,9 +64,9 @@ public:
        void stop(int index);\r
        void clear(int index);\r
        void clear();   \r
-       void swap_layers(const spl::shared_ptr<stage>& other);\r
+       void swap_layers(stage& other);\r
        void swap_layer(int index, int other_index);\r
-       void swap_layer(int index, int other_index, const spl::shared_ptr<stage>& other);\r
+       void swap_layer(int index, int other_index, stage& other);\r
        \r
        boost::unique_future<spl::shared_ptr<struct frame_producer>>    foreground(int index);\r
        boost::unique_future<spl::shared_ptr<struct frame_producer>>    background(int index);\r
@@ -72,6 +74,10 @@ public:
        boost::unique_future<boost::property_tree::wptree> info() const;\r
        boost::unique_future<boost::property_tree::wptree> info(int index) const;\r
        \r
+       // monitor::observable\r
+\r
+       virtual void subscribe(const monitor::observable::observer_ptr& o) override;\r
+       virtual void unsubscribe(const monitor::observable::observer_ptr& o) override;\r
 private:\r
        struct impl;\r
        spl::shared_ptr<impl> impl_;\r

diff --git a/core/video_channel.cpp b/core/video_channel.cpp
index 2c01acd1db7d4c21885f24c27f954be7e3e30b36..661bb969bea6c440cad529e5dd7ec9d3a0d20ca4 100644 (file)
--- a/core/video_channel.cpp
+++ b/core/video_channel.cpp
@@ -47,7 +47,7 @@ namespace caspar { namespace core {
 struct video_channel::impl sealed : public frame_factory\r
 {\r
        reactive::basic_subject<spl::shared_ptr<const data_frame>> frame_subject_;\r
-       monitor::subject                                                                                   event_subject_;\r
+       spl::shared_ptr<monitor::subject>                                                  event_subject_;\r
 \r
        const int                                                                               index_;\r
 \r
@@ -63,7 +63,7 @@ struct video_channel::impl sealed : public frame_factory
        executor                                                                                executor_;\r
 public:\r
        impl(int index, const video_format_desc& format_desc, spl::shared_ptr<image_mixer> image_mixer)  \r
-               : event_subject_(monitor::path() % "channel" % index)\r
+               : event_subject_(new monitor::subject(monitor::path() % "channel" % index))\r
                , index_(index)\r
                , format_desc_(format_desc)\r
                , output_(new caspar::core::output(graph_, format_desc, index))\r
@@ -75,6 +75,8 @@ public:
                graph_->set_text(print());\r
                diagnostics::register_graph(graph_);\r
 \r
+               stage_->subscribe(event_subject_);\r
+\r
                executor_.begin_invoke([=]{tick();});\r
 \r
                CASPAR_LOG(info) << print() << " Successfully Initialized.";\r
@@ -121,8 +123,8 @@ public:
                \r
                        graph_->set_value("tick-time", frame_timer.elapsed()*format_desc.fps*0.5);\r
 \r
-                       event_subject_ << monitor::event("debug/time") % frame_timer.elapsed();\r
-                       event_subject_ << monitor::event("format")              % u8(format_desc.name);\r
+                       *event_subject_ << monitor::event("debug/time")  % frame_timer.elapsed();\r
+                       *event_subject_ << monitor::event("format")             % u8(format_desc.name);\r
                }\r
                catch(...)\r
                {\r
@@ -172,7 +174,7 @@ void video_channel::set_video_format_desc(const video_format_desc& format_desc){
 boost::property_tree::wptree video_channel::info() const{return impl_->info();}\r
 void video_channel::subscribe(const frame_observer::observer_ptr& o) {impl_->frame_subject_.subscribe(o);}\r
 void video_channel::unsubscribe(const frame_observer::observer_ptr& o) {impl_->frame_subject_.unsubscribe(o);}         \r
-void video_channel::subscribe(const event_observer::observer_ptr& o) {impl_->event_subject_.subscribe(o);}\r
-void video_channel::unsubscribe(const event_observer::observer_ptr& o) {impl_->event_subject_.unsubscribe(o);}\r
+void video_channel::subscribe(const monitor::observable::observer_ptr& o) {impl_->event_subject_->subscribe(o);}\r
+void video_channel::unsubscribe(const monitor::observable::observer_ptr& o) {impl_->event_subject_->unsubscribe(o);}\r
 \r
 }}
\ No newline at end of file

diff --git a/core/video_channel.h b/core/video_channel.h
index 8255160f8eb1b8b09bcfe4a8ccaa280e691ad2ea..2fb89e5865980efbbef93454016f0333313944d9 100644 (file)
--- a/core/video_channel.h
+++ b/core/video_channel.h
@@ -34,10 +34,9 @@ FORWARD3(caspar, core, ogl, class accelerator);
 namespace caspar { namespace core {\r
        \r
 typedef reactive::observable<spl::shared_ptr<const struct data_frame>> frame_observer;\r
-typedef reactive::observable<monitor::event>                                                   event_observer;\r
 \r
 class video_channel sealed : public frame_observer\r
-                                                  , public event_observer\r
+                                                  , public monitor::observable\r
 {\r
        video_channel(const video_channel&);\r
        video_channel& operator=(const video_channel&);\r
@@ -59,8 +58,10 @@ public:
        virtual void subscribe(const frame_observer::observer_ptr& o) override;\r
        virtual void unsubscribe(const frame_observer::observer_ptr& o) override;\r
                \r
-       virtual void subscribe(const event_observer::observer_ptr& o) override;\r
-       virtual void unsubscribe(const event_observer::observer_ptr& o) override;\r
+       // monitor::observable\r
+\r
+       virtual void subscribe(const monitor::observable::observer_ptr& o) override;\r
+       virtual void unsubscribe(const monitor::observable::observer_ptr& o) override;\r
 private:\r
        struct impl;\r
        spl::shared_ptr<impl> impl_;\r

diff --git a/protocol/amcp/AMCPCommandsImpl.cpp b/protocol/amcp/AMCPCommandsImpl.cpp
index dddba91cf66a38bfc83bc03b1005a209a189d86f..a99eb9b4118968d76c100ef5a92109fa76554714 100644 (file)
--- a/protocol/amcp/AMCPCommandsImpl.cpp
+++ b/protocol/amcp/AMCPCommandsImpl.cpp
@@ -548,13 +548,13 @@ bool SwapCommand::DoExecute()
                        int l1 = GetLayerIndex();\r
                        int l2 = boost::lexical_cast<int>(strs.at(1));\r
 \r
-                       ch1->stage()->swap_layer(l1, l2, ch2->stage());\r
+                       ch1->stage()->swap_layer(l1, l2, *ch2->stage());\r
                }\r
                else\r
                {\r
                        auto ch1 = GetChannel();\r
                        auto ch2 = GetChannels().at(boost::lexical_cast<int>(_parameters[0])-1);\r
-                       ch1->stage()->swap_layers(ch2->stage());\r
+                       ch1->stage()->swap_layers(*ch2->stage());\r
                }\r
                \r
                SetReplyString(TEXT("202 SWAP OK\r\n"));\r