2.0.0.2:

 - consumer interface improvements.

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

diff --git a/common/gl/pixel_buffer_object.cpp b/common/gl/pixel_buffer_object.cpp
index 2684061698e35d19bcf14702d7a11065016f7c4f..fae1783546ba15e9ab2a28f341afb3db2e6cbc4f 100644 (file)
--- a/common/gl/pixel_buffer_object.cpp
+++ b/common/gl/pixel_buffer_object.cpp
@@ -173,8 +173,14 @@ struct pixel_buffer_object::implementation : boost::noncopyable
 };\r
 \r
 pixel_buffer_object::pixel_buffer_object(){}\r
+pixel_buffer_object::pixel_buffer_object(pixel_buffer_object&& other) : impl_(std::move(other.impl_)){}\r
 pixel_buffer_object::pixel_buffer_object(size_t width, size_t height, GLenum format) \r
        : impl_(new implementation(width, height, format)){}\r
+pixel_buffer_object& pixel_buffer_object::operator=(pixel_buffer_object&& other)\r
+{\r
+       impl_ = std::move(other.impl_);\r
+       return *this;\r
+}\r
 void pixel_buffer_object::create(size_t width, size_t height, GLenum format)\r
 {\r
        impl_.reset(new implementation(width, height, format));\r

diff --git a/common/gl/pixel_buffer_object.h b/common/gl/pixel_buffer_object.h
index 2ea40cf79d70c7144807d9bcbbb29f1cdc94a774..69c3847dcd85f3cd15e1d392fc23c3f213df811d 100644 (file)
--- a/common/gl/pixel_buffer_object.h
+++ b/common/gl/pixel_buffer_object.h
@@ -15,7 +15,9 @@ class pixel_buffer_object : boost::noncopyable
 {\r
 public:\r
        pixel_buffer_object();\r
+       pixel_buffer_object(pixel_buffer_object&& other);\r
        pixel_buffer_object(size_t width, size_t height, GLenum format = GL_BGRA);\r
+       pixel_buffer_object& operator=(pixel_buffer_object&& other);\r
        void create(size_t width, size_t height, GLenum format = GL_BGRA);\r
        ~pixel_buffer_object(){}\r
 \r

diff --git a/common/utility/scope_exit.h b/common/utility/scope_exit.h
index f99f114e30fba7b5778a51f88d0c2bcafe50cc51..2b66140914e6b9f97da358f1f5664aa6152379ab 100644 (file)
--- a/common/utility/scope_exit.h
+++ b/common/utility/scope_exit.h
@@ -39,4 +39,4 @@ namespace caspar
 \r
 #define _CASPAR_EXIT_SCOPE_LINENAME_CAT(name, line) name##line\r
 #define _CASPAR_EXIT_SCOPE_LINENAME(name, line) _CASPAR_EXIT_SCOPE_LINENAME_CAT(name, line)\r
-#define CASPAR_SCOPE_EXIT(f) auto _CASPAR_EXIT_SCOPE_LINENAME(EXIT, __LINE__) = caspar::detail::create_scope_exit(f)
\ No newline at end of file
+#define CASPAR_SCOPE_EXIT(f) const auto& _CASPAR_EXIT_SCOPE_LINENAME(EXIT, __LINE__) = caspar::detail::create_scope_exit(f)
\ No newline at end of file

diff --git a/core/consumer/bluefish/bluefish_consumer.cpp b/core/consumer/bluefish/bluefish_consumer.cpp
index b4d71698e48fce01f926dd2a992d9978445b7204..3a2bdbad5bdf1571dc2bff15349cbc2585f191f6 100644 (file)
--- a/core/consumer/bluefish/bluefish_consumer.cpp
+++ b/core/consumer/bluefish/bluefish_consumer.cpp
@@ -168,19 +168,18 @@ struct consumer::implementation : boost::noncopyable
                        CASPAR_LOG(error) << "BLUECARD ERROR: Failed to disable video output. (device " << device_index_ << TEXT(")");          \r
        }\r
 \r
-       boost::unique_future<void> display(const consumer_frame& frame)\r
-       {\r
-               return executor_.begin_invoke([=]\r
+       void send(const consumer_frame& frame)\r
+       {                       \r
+               static size_t audio_samples = 1920;\r
+               static size_t audio_nchannels = 2;\r
+               static std::vector<short> silence(audio_samples*audio_nchannels*2, 0);\r
+\r
+               active_ = executor_.begin_invoke([=]\r
                {\r
                        try\r
                        {\r
                                auto hanc = hanc_buffers_.front();              \r
                                std::rotate(hanc_buffers_.begin(), hanc_buffers_.begin() + 1, hanc_buffers_.end());\r
-                       \r
-                               static size_t audio_samples = 1920;\r
-                               static size_t audio_nchannels = 2;\r
-                               static std::vector<short> silence(audio_samples*audio_nchannels*2, 0);\r
-\r
 \r
                                unsigned long fieldCount = 0;\r
                                sdk_->wait_output_video_synch(UPD_FMT_FRAME, fieldCount);\r
@@ -224,6 +223,17 @@ struct consumer::implementation : boost::noncopyable
                });\r
        }\r
 \r
+       frame_consumer::sync_mode synchronize()\r
+       {\r
+               active_.get();\r
+               return frame_consumer::clock;\r
+       }\r
+\r
+       size_t buffer_depth() const\r
+       {\r
+               return 1;\r
+       }\r
+\r
 \r
        void encode_hanc(BLUE_UINT32* hanc_data, void* audio_data, size_t audio_samples, size_t audio_nchannels)\r
        {       \r
@@ -233,7 +243,7 @@ struct consumer::implementation : boost::noncopyable
                hanc_stream_info_struct hanc_stream_info;\r
                memset(&hanc_stream_info, 0, sizeof(hanc_stream_info));\r
 \r
-               std::fill_n(hanc_stream_info.AudioDBNArray, sizeof(hanc_stream_info.AudioDBNArray)/sizeof(*hanc_stream_info.AudioDBNArray), -1);\r
+               std::fill_n(hanc_stream_info.AudioDBNArray, sizeof(hanc_stream_info.AudioDBNArray)/sizeof(hanc_stream_info.AudioDBNArray[0]), -1);\r
                hanc_stream_info.hanc_data_ptr = hanc_data;\r
                hanc_stream_info.video_mode = vid_fmt_;\r
                \r
@@ -251,6 +261,7 @@ struct consumer::implementation : boost::noncopyable
                }                                               \r
        }\r
 \r
+       boost::unique_future<void> active_;\r
        common::executor executor_;\r
                        \r
        BlueVelvetPtr sdk_;\r
@@ -272,8 +283,9 @@ struct consumer::implementation : boost::noncopyable
 };\r
 \r
 consumer::consumer(const video_format_desc& format_desc, unsigned int device_index, bool embed_audio) : impl_(new implementation(format_desc, device_index, embed_audio)){}    \r
-boost::unique_future<void> consumer::display(const consumer_frame& frame){return impl_->display(frame);}\r
-\r
+void consumer::send(const consumer_frame& frame){impl_->send(frame);}\r
+frame_consumer::sync_mode consumer::synchronize(){return impl_->synchronize();}\r
+size_t consumer::buffer_depth() const{return impl_->buffer_depth();}\r
 }}}\r
 \r
 #endif
\ No newline at end of file

diff --git a/core/consumer/bluefish/bluefish_consumer.h b/core/consumer/bluefish/bluefish_consumer.h
index a89e970e3f38326493d19a2bbcc4dfc51eebd099..f3358f27ca2de5d0f63bca1012a88acdc4c4ccf0 100644 (file)
--- a/core/consumer/bluefish/bluefish_consumer.h
+++ b/core/consumer/bluefish/bluefish_consumer.h
@@ -29,8 +29,9 @@ class consumer : public frame_consumer
 public:\r
        consumer(const video_format_desc& format_desc, unsigned int deviceIndex, bool embed_audio = false);\r
        \r
-       virtual boost::unique_future<void> display(const consumer_frame&);              \r
-       virtual bool has_sync_clock() const {return true;}\r
+       virtual void send(const consumer_frame&);\r
+       virtual sync_mode synchronize();\r
+       virtual size_t buffer_depth() const;\r
 private:\r
        struct implementation;\r
        std::shared_ptr<implementation> impl_;\r

diff --git a/core/consumer/decklink/decklink_consumer.cpp b/core/consumer/decklink/decklink_consumer.cpp
index b9323f2e3eb01de0f61b71031c8fe7bd1b551f8b..959689d881c29390bd1ab5694cf3ef511d53a45c 100644 (file)
--- a/core/consumer/decklink/decklink_consumer.cpp
+++ b/core/consumer/decklink/decklink_consumer.cpp
@@ -139,27 +139,32 @@ struct decklink_consumer::Implementation : boost::noncopyable
                CoUninitialize();\r
        }\r
        \r
-       boost::unique_future<void> display(const consumer_frame& input_frame)\r
+       void send(const consumer_frame& input_frame)\r
        {\r
-               return executor_.begin_invoke([=]\r
+               active_ = executor_.begin_invoke([=]\r
                {\r
-                       try\r
-                       {\r
-                               auto& output_frame = reserved_frames_[current_index_];\r
-                               current_index_ = (++current_index_) % reserved_frames_.size();\r
+                       auto& output_frame = reserved_frames_[current_index_];\r
+                       current_index_ = (++current_index_) % reserved_frames_.size();\r
                \r
-                               std::copy(input_frame.data().begin(), input_frame.data().end(), static_cast<char*>(output_frame.first));\r
+                       std::copy(input_frame.data().begin(), input_frame.data().end(), static_cast<char*>(output_frame.first));\r
                                \r
-                               if(FAILED(output_->DisplayVideoFrameSync(output_frame.second)))\r
-                                       CASPAR_LOG(error) << L"DECKLINK: Failed to display frame.";\r
-                       }\r
-                       catch(...)\r
-                       {\r
-                               CASPAR_LOG_CURRENT_EXCEPTION();\r
-                       }\r
+                       if(FAILED(output_->DisplayVideoFrameSync(output_frame.second)))\r
+                               CASPAR_LOG(error) << L"DECKLINK: Failed to display frame.";\r
                });\r
        }\r
+       \r
+       frame_consumer::sync_mode synchronize()\r
+       {\r
+               active_.get();\r
+               return frame_consumer::ready;\r
+       }\r
+\r
+       size_t buffer_depth() const\r
+       {\r
+               return 1;\r
+       }\r
                        \r
+       boost::unique_future<void> active_;\r
        common::executor executor_;\r
 \r
        std::vector<std::pair<void*, CComPtr<IDeckLinkMutableVideoFrame>>> reserved_frames_;\r
@@ -174,12 +179,9 @@ struct decklink_consumer::Implementation : boost::noncopyable
        video_format_desc format_desc_;\r
 };\r
 \r
-decklink_consumer::decklink_consumer(const video_format_desc& format_desc, bool internalKey) : pImpl_(new Implementation(format_desc, internalKey))\r
-{}\r
-\r
-boost::unique_future<void> decklink_consumer::display(const consumer_frame& frame)\r
-{\r
-       return pImpl_->display(frame);\r
-}\r
+decklink_consumer::decklink_consumer(const video_format_desc& format_desc, bool internalKey) : pImpl_(new Implementation(format_desc, internalKey)){}\r
+void decklink_consumer::send(const consumer_frame& frame){pImpl_->send(frame);}\r
+frame_consumer::sync_mode decklink_consumer::synchronize(){return pImpl_->synchronize();}\r
+size_t decklink_consumer::buffer_depth() const{return pImpl_->buffer_depth();}\r
        \r
 }}}    
\ No newline at end of file

diff --git a/core/consumer/decklink/decklink_consumer.h b/core/consumer/decklink/decklink_consumer.h
index eef3ef800a490ce77ecfc7505f8b6c16c4307b5c..27ca078657127b4c64b5a398362860e802a5c366 100644 (file)
--- a/core/consumer/decklink/decklink_consumer.h
+++ b/core/consumer/decklink/decklink_consumer.h
@@ -30,8 +30,9 @@ class decklink_consumer : public frame_consumer
 public:\r
        explicit decklink_consumer(const video_format_desc& format_desc, bool internalKey = false);\r
        \r
-       virtual boost::unique_future<void> display(const consumer_frame&);\r
-       virtual bool has_sync_clock() const {return false;}\r
+       virtual void send(const consumer_frame&);\r
+       virtual sync_mode synchronize();\r
+       virtual size_t buffer_depth() const;\r
 private:\r
        struct Implementation;\r
        std::tr1::shared_ptr<Implementation> pImpl_;\r

diff --git a/core/consumer/frame_consumer.h b/core/consumer/frame_consumer.h
index e5d5d2a753e41ef4f08bcadad3570c5fb22ecc33..619770c011159e4538e7c87085c0daadb33116e7 100644 (file)
--- a/core/consumer/frame_consumer.h
+++ b/core/consumer/frame_consumer.h
@@ -24,30 +24,23 @@
 \r
 #include <boost/noncopyable.hpp>\r
 \r
-#include <boost/thread/future.hpp>\r
-\r
 #include <memory>\r
 \r
 namespace caspar { namespace core {\r
        \r
 struct frame_consumer : boost::noncopyable\r
 {\r
-       virtual ~frame_consumer() {}\r
-\r
-       virtual boost::unique_future<void> prepare(const consumer_frame&)\r
+       enum sync_mode\r
        {\r
-               boost::promise<void> promise;\r
-               promise.set_value();\r
-               return promise.get_future();\r
-       }\r
+               ready = 0,\r
+               clock           \r
+       };\r
 \r
-       virtual boost::unique_future<void> display(const consumer_frame&)\r
-       {\r
-               boost::promise<void> promise;\r
-               promise.set_value();\r
-               return promise.get_future();\r
-       }\r
-       virtual bool has_sync_clock() const {return false;}\r
+       virtual ~frame_consumer() {}\r
+\r
+       virtual void send(const consumer_frame&) = 0;\r
+       virtual sync_mode synchronize() = 0;\r
+       virtual size_t buffer_depth() const = 0;\r
 };\r
 typedef std::shared_ptr<frame_consumer> frame_consumer_ptr;\r
 typedef std::shared_ptr<const frame_consumer> frame_consumer_const_ptr;\r

diff --git a/core/consumer/frame_consumer_device.cpp b/core/consumer/frame_consumer_device.cpp
index 4f9c3feaeb3b07be8f052d41164b1ffbab543df8..34622fb99228f120823b06f3179e4c216cb33bc5 100644 (file)
--- a/core/consumer/frame_consumer_device.cpp
+++ b/core/consumer/frame_consumer_device.cpp
@@ -19,28 +19,23 @@
 #include <boost/date_time/posix_time/posix_time.hpp>\r
 \r
 #include <boost/range/algorithm_ext/erase.hpp>\r
+#include <boost/range/algorithm.hpp>\r
 \r
 namespace caspar { namespace core {\r
 \r
-class video_sync_clock\r
+class clock_sync\r
 {\r
 public:\r
-       video_sync_clock(const video_format_desc& format_desc)\r
-       {\r
-               period_ = static_cast<long>(format_desc.period*1000000.0);\r
-               time_ = boost::posix_time::microsec_clock::local_time();\r
-       }\r
+       clock_sync() : time_(boost::posix_time::microsec_clock::local_time()){}\r
 \r
-       void synchronize()\r
-       {\r
-               auto remaining = boost::posix_time::microseconds(period_) -     (boost::posix_time::microsec_clock::local_time() - time_);\r
+       void wait(double period)\r
+       {                               \r
+               auto remaining = boost::posix_time::microseconds(static_cast<long>(period*1000000.0)) - (boost::posix_time::microsec_clock::local_time() - time_);\r
                if(remaining > boost::posix_time::microseconds(5000))\r
                        boost::this_thread::sleep(remaining - boost::posix_time::microseconds(5000));\r
-               time_ = boost::posix_time::microsec_clock::local_time();\r
        }\r
 private:\r
        boost::posix_time::ptime time_;\r
-       long period_;\r
 };\r
 \r
 struct frame_consumer_device::implementation\r
@@ -48,13 +43,10 @@ struct frame_consumer_device::implementation
 public:\r
        implementation(const frame_processor_device_ptr& frame_processor, const video_format_desc& format_desc, const std::vector<frame_consumer_ptr>& consumers) \r
                : frame_processor_(frame_processor), consumers_(consumers), fmt_(format_desc)\r
-       {\r
-               if(consumers.empty())\r
-                       BOOST_THROW_EXCEPTION(invalid_argument() << arg_name_info("consumer") \r
-                               << msg_info("frame_consumer_device requires atleast one consumer."));\r
-               \r
-               needs_clock_ = !std::any_of(consumers.begin(), consumers.end(), std::mem_fn(&frame_consumer::has_sync_clock));\r
-               is_running_ = true;\r
+       {               \r
+               std::vector<size_t> depths;\r
+               boost::range::transform(consumers_, std::back_inserter(depths), std::mem_fn(&frame_consumer::buffer_depth));\r
+               max_depth_ = *boost::range::max_element(depths);\r
                display_thread_ = boost::thread([=]{run();});\r
        }\r
 \r
@@ -66,71 +58,70 @@ public:
                                \r
        void run()\r
        {\r
+               is_running_ = true;\r
+               CASPAR_LOG(warning) << "Starting frame_consumer_device.";               \r
+\r
                win32_exception::install_handler();\r
-                               \r
-               video_sync_clock clock(fmt_);\r
-                               \r
-               while(is_running_)\r
+                                                               \r
+               while(is_running_)                                              \r
                {\r
-                       if(needs_clock_)\r
-                               clock.synchronize();\r
-                                               \r
-                       display_frame(frame_processor_->receive());                     \r
+                       display_frame(frame_processor_->receive());             \r
+                       is_running_ = !consumers_.empty();\r
                }\r
+               CASPAR_LOG(warning) << "Shutting down frame_consumer_device.";                  \r
        }\r
 \r
        void display_frame(const consumer_frame& frame)\r
        {               \r
-               typedef std::vector<std::pair<boost::unique_future<void>, frame_consumer_ptr>> sync_container;\r
-               sync_container sync;\r
-               boost::range::transform(consumers_, std::back_inserter(sync), [=](const frame_consumer_ptr& consumer)\r
+               buffer_.push_back(frame);\r
+\r
+               clock_sync clock;\r
+               \r
+               boost::range::for_each(consumers_, [&](const frame_consumer_ptr& consumer)\r
                {\r
-                       return std::make_pair(consumer->prepare(frame), consumer);\r
+                       size_t offset = max_depth_ - consumer->buffer_depth();\r
+                       if(offset < buffer_.size())\r
+                               consumer->send(*(buffer_.begin() + offset));\r
                });\r
-               \r
-               prepared_frames_.push_back(frame);\r
-                               \r
-               if(prepared_frames_.size() > 2)\r
-               {       \r
-                       boost::range::transform(consumers_, std::back_inserter(sync), [=](const frame_consumer_ptr& consumer)\r
-                       {\r
-                               return std::make_pair(consumer->display(prepared_frames_.front()), consumer);\r
-                       });\r
-                       prepared_frames_.pop_front();\r
-               }\r
-\r
-               boost::range::for_each(sync, [=](sync_container::value_type& sync)\r
+                       \r
+               frame_consumer::sync_mode sync = frame_consumer::ready;\r
+               boost::range::for_each(consumers_, [&](const frame_consumer_ptr& consumer)\r
                {\r
                        try\r
                        {\r
-                               sync.first.get();\r
+                               size_t offset = max_depth_ - consumer->buffer_depth();\r
+                               if(offset >= buffer_.size())\r
+                                       return;\r
+\r
+                               if(consumer->synchronize() == frame_consumer::clock)\r
+                                       sync = frame_consumer::clock;\r
                        }\r
                        catch(...)\r
                        {\r
                                CASPAR_LOG_CURRENT_EXCEPTION();\r
-                               boost::range::remove_erase(consumers_, sync.second);\r
+                               boost::range::remove_erase(consumers_, consumer);\r
                                CASPAR_LOG(warning) << "Removed consumer from frame_consumer_device.";\r
-                               if(consumers_.empty())\r
-                               {\r
-                                       CASPAR_LOG(warning) << "No consumers available. Shutting down frame_consumer_device.";\r
-                                       is_running_ = false;\r
-                               }\r
                        }\r
                });\r
+       \r
+               if(sync != frame_consumer::clock)\r
+                       clock.wait(fmt_.period);\r
+\r
+               if(buffer_.size() >= max_depth_)\r
+                       buffer_.pop_front();\r
        }\r
 \r
-       std::deque<consumer_frame> prepared_frames_;\r
+       size_t max_depth_;\r
+       std::deque<consumer_frame> buffer_;\r
                \r
-       boost::thread display_thread_;\r
-\r
        tbb::atomic<bool> is_running_;\r
+       boost::thread display_thread_;\r
 \r
-       bool needs_clock_;\r
        std::vector<frame_consumer_ptr> consumers_;\r
+       \r
+       frame_processor_device_ptr frame_processor_;\r
 \r
        const video_format_desc& fmt_;\r
-\r
-       frame_processor_device_ptr frame_processor_;\r
 };\r
 \r
 frame_consumer_device::frame_consumer_device(const frame_processor_device_ptr& frame_processor, const video_format_desc& format_desc, const std::vector<frame_consumer_ptr>& consumers)\r

diff --git a/core/consumer/oal/oal_consumer.cpp b/core/consumer/oal/oal_consumer.cpp
index fe0e167a767c29b319b02f27014f6f67a50a939a..828832627a5aa5a01063586b1069e6d0b45d0e98 100644 (file)
--- a/core/consumer/oal/oal_consumer.cpp
+++ b/core/consumer/oal/oal_consumer.cpp
@@ -36,6 +36,7 @@ struct consumer::implementation : public sf::SoundStream, boost::noncopyable
        implementation() : container_(5), underrun_count_(0)\r
        {\r
                sf::SoundStream::Initialize(2, 48000);\r
+               tickets_.set_capacity(3);\r
        }\r
 \r
        ~implementation()\r
@@ -43,21 +44,23 @@ struct consumer::implementation : public sf::SoundStream, boost::noncopyable
                Stop();\r
        }\r
        \r
-       boost::unique_future<void> push(const consumer_frame& frame)\r
-       {\r
+       void send(const consumer_frame& frame)\r
+       {                               \r
                input_.push(frame.audio_data()); \r
 \r
-               auto promise = std::make_shared<boost::promise<void>>();\r
-               \r
-               if(GetStatus() != Playing && input_.size() > 2)\r
-                       Play();\r
-               \r
-               if(GetStatus() == Playing)\r
-                       promises_.push(promise);\r
-               else\r
-                       promise->set_value();\r
+               if(GetStatus() != Playing && input_.size() > 2)         \r
+                       Play();         \r
+       }\r
 \r
-               return promise->get_future();\r
+       frame_consumer::sync_mode synchronize()\r
+       {\r
+               tickets_.push(true);\r
+               return frame_consumer::clock;\r
+       }\r
+\r
+       size_t buffer_depth() const\r
+       {\r
+               return 3;\r
        }\r
        \r
        bool OnStart() \r
@@ -70,9 +73,8 @@ struct consumer::implementation : public sf::SoundStream, boost::noncopyable
        {\r
                static std::vector<short> silence(1920*2, 0);\r
                \r
-               std::shared_ptr<boost::promise<void>> promise;\r
-               promises_.pop(promise);\r
-               promise->set_value();\r
+               bool dummy;\r
+               tickets_.pop(dummy);\r
 \r
                std::vector<short> audio_data;          \r
                if(!input_.try_pop(audio_data))\r
@@ -103,7 +105,7 @@ struct consumer::implementation : public sf::SoundStream, boost::noncopyable
                return true;\r
        }\r
 \r
-       tbb::concurrent_bounded_queue<std::shared_ptr<boost::promise<void>>> promises_;\r
+       tbb::concurrent_bounded_queue<bool> tickets_;\r
        tbb::concurrent_bounded_queue<std::vector<short>> input_;\r
 \r
        long underrun_count_;\r
@@ -111,5 +113,7 @@ struct consumer::implementation : public sf::SoundStream, boost::noncopyable
 };\r
 \r
 consumer::consumer(const video_format_desc&) : impl_(new implementation()){}\r
-boost::unique_future<void> consumer::prepare(const consumer_frame& frame){return impl_->push(frame);}\r
+void consumer::send(const consumer_frame& frame){impl_->send(frame);}\r
+frame_consumer::sync_mode consumer::synchronize(){return impl_->synchronize();}\r
+size_t consumer::buffer_depth() const{return impl_->buffer_depth();}\r
 }}}\r

diff --git a/core/consumer/oal/oal_consumer.h b/core/consumer/oal/oal_consumer.h
index 33e2cb03e0f25e5130843540c94a267cd1ade993..63d56b32c63531897ba2453008c7e6bb375af82b 100644 (file)
--- a/core/consumer/oal/oal_consumer.h
+++ b/core/consumer/oal/oal_consumer.h
@@ -28,8 +28,9 @@ class consumer : public frame_consumer
 public:        \r
        explicit consumer(const video_format_desc& format_desc);\r
        \r
-       virtual boost::unique_future<void> prepare(const consumer_frame& frame);\r
-       virtual bool has_sync_clock() const {return true;}\r
+       virtual void send(const consumer_frame&);\r
+       virtual sync_mode synchronize();\r
+       virtual size_t buffer_depth() const;\r
 private:\r
        struct implementation;\r
        std::shared_ptr<implementation> impl_;\r

diff --git a/core/consumer/ogl/ogl_consumer.cpp b/core/consumer/ogl/ogl_consumer.cpp
index 8a8c0b77cc3da730d36702c1bc19970267d9dca1..0c1cb930240ac61bdc5036686623d25c5943a61d 100644 (file)
--- a/core/consumer/ogl/ogl_consumer.cpp
+++ b/core/consumer/ogl/ogl_consumer.cpp
@@ -23,7 +23,7 @@
 #include "ogl_consumer.h"\r
 \r
 #include "../../format/video_format.h"\r
-#include "../../processor/write_frame.h"\r
+\r
 #include "../../../common/gl/utility.h"\r
 #include "../../../common/gl/pixel_buffer_object.h"\r
 #include "../../../common/concurrency/executor.h"\r
@@ -42,7 +42,7 @@ namespace caspar { namespace core { namespace ogl{
 struct consumer::implementation : boost::noncopyable\r
 {      \r
        implementation(const video_format_desc& format_desc, unsigned int screen_index, stretch stretch, bool windowed) \r
-               : index_(0), format_desc_(format_desc), stretch_(stretch), screen_width_(0), screen_height_(0), windowed_(windowed)\r
+               : format_desc_(format_desc), stretch_(stretch), screen_width_(0), screen_height_(0), windowed_(windowed)\r
        {               \r
 #ifdef _WIN32\r
                DISPLAY_DEVICE dDevice;                 \r
@@ -151,15 +151,12 @@ struct consumer::implementation : boost::noncopyable
        }\r
 \r
        void render(const consumer_frame& frame)\r
-       {               \r
-               index_ = (index_ + 1) % 2;\r
-               int next_index = (index_ + 1) % 2;\r
-                               \r
-               auto ptr = pbos_[index_].end_write();\r
+       {                                               \r
+               auto ptr = pbos_.front().end_write();\r
                std::copy_n(frame.data().begin(), frame.data().size(), reinterpret_cast<char*>(ptr));\r
 \r
                GL(glClear(GL_COLOR_BUFFER_BIT));       \r
-               pbos_[next_index].bind_texture();                               \r
+               pbos_.back().bind_texture();                            \r
                glBegin(GL_QUADS);\r
                                glTexCoord2f(0.0f,        hratio_);     glVertex2f(-wSize_, -hSize_);\r
                                glTexCoord2f(wratio_, hratio_); glVertex2f( wSize_, -hSize_);\r
@@ -167,12 +164,14 @@ struct consumer::implementation : boost::noncopyable
                                glTexCoord2f(0.0f,        0.0f);        glVertex2f(-wSize_,  hSize_);\r
                glEnd();\r
 \r
-               pbos_[next_index].begin_write();\r
+               pbos_.back().begin_write();\r
+\r
+               std::rotate(pbos_.begin(), pbos_.begin() + 1, pbos_.end());\r
        }\r
-                       \r
-       boost::unique_future<void> display(const consumer_frame& frame)\r
+               \r
+       void send(const consumer_frame& frame)\r
        {\r
-               return executor_.begin_invoke([=]\r
+               active_ = executor_.begin_invoke([=]\r
                {\r
                        sf::Event e;\r
                        while(window_.GetEvent(e)){}\r
@@ -182,6 +181,18 @@ struct consumer::implementation : boost::noncopyable
                });\r
        }\r
 \r
+       frame_consumer::sync_mode synchronize()\r
+       {\r
+               active_.get();\r
+               return frame_consumer::ready;\r
+       }\r
+\r
+       size_t buffer_depth() const\r
+       {\r
+               return 2;\r
+       }\r
+               \r
+       boost::unique_future<void> active_;\r
        common::executor executor_;\r
        \r
        float wratio_;\r
@@ -190,8 +201,7 @@ struct consumer::implementation : boost::noncopyable
        float wSize_;\r
        float hSize_;\r
 \r
-       int index_;\r
-       common::gl::pixel_buffer_object pbos_[2];\r
+       std::array<common::gl::pixel_buffer_object, 2> pbos_;\r
 \r
        bool windowed_;\r
        unsigned int screen_width_;\r
@@ -207,5 +217,7 @@ struct consumer::implementation : boost::noncopyable
 \r
 consumer::consumer(const video_format_desc& format_desc, unsigned int screen_index, stretch stretch, bool windowed)\r
 : impl_(new implementation(format_desc, screen_index, stretch, windowed)){}\r
-boost::unique_future<void> consumer::display(const consumer_frame& frame){return impl_->display(frame);}\r
+void consumer::send(const consumer_frame& frame){impl_->send(frame);}\r
+frame_consumer::sync_mode consumer::synchronize(){return impl_->synchronize();}\r
+size_t consumer::buffer_depth() const{return impl_->buffer_depth();}\r
 }}}\r

diff --git a/core/consumer/ogl/ogl_consumer.h b/core/consumer/ogl/ogl_consumer.h
index d948845de4b0d8a5c96aa68f5845015c66cd10ad..794836b1e2b79c26e2f4e2a252152c54e38a1b02 100644 (file)
--- a/core/consumer/ogl/ogl_consumer.h
+++ b/core/consumer/ogl/ogl_consumer.h
@@ -38,8 +38,9 @@ class consumer : public frame_consumer
 public:        \r
        explicit consumer(const video_format_desc& format_desc, unsigned int screen_index = 0, stretch stretch = stretch::fill, bool windowed = false);\r
        \r
-       virtual boost::unique_future<void> display(const consumer_frame& frame);\r
-       virtual bool has_sync_clock() const {return false;}\r
+       virtual void send(const consumer_frame&);\r
+       virtual sync_mode synchronize();\r
+       virtual size_t buffer_depth() const;\r
 private:\r
        struct implementation;\r
        std::shared_ptr<implementation> impl_;\r

diff --git a/core/processor/frame_renderer.cpp b/core/processor/frame_renderer.cpp
index 142feece5d33eda4f0188ce3692f925a2cf2f60b..3c819dbd71f6501d3b3fa78af7a3941255b80797 100644 (file)
--- a/core/processor/frame_renderer.cpp
+++ b/core/processor/frame_renderer.cpp
@@ -41,32 +41,26 @@ struct frame_renderer::implementation : boost::noncopyable
                if(frame == nullptr)\r
                        return nullptr;\r
 \r
+               read_frame_ptr result;\r
                try\r
                {\r
                        drawing_ = writing_;\r
                        writing_ = frame;\r
-                       \r
-                       // Write from page-locked system memory to video memory.\r
-                       writing_->begin_write();\r
-                               \r
-                       //  Map video memory to page-locked system memory.\r
-                       reading_->end_read(); // Note: This frame has already been sent, it is assumed that there is external buffering of atleast 2 frames.\r
-                       \r
-                       // Clear framebuffer.\r
-                       GL(glClear(GL_COLOR_BUFFER_BIT));       \r
-\r
-                       // Draw to framebuffer\r
+                                               \r
+                       writing_->begin_write(); // Note: end_write is done when returned to pool, write_frame::reset();\r
+                                               \r
+                       reading_->end_read();\r
+                       result = reading_; \r
+                                               \r
+                       GL(glClear(GL_COLOR_BUFFER_BIT));\r
+                                               \r
                        drawing_->draw(shader_);\r
                                \r
-                       // Create an output frame\r
                        reading_ = create_output_frame();\r
                        \r
-                       // Read from framebuffer into page-locked memory.\r
                        reading_->begin_read();\r
                        reading_->audio_data() = std::move(drawing_->audio_data());\r
-                       \r
-                       // Return frames to pool.\r
-                       // Note: end_write is done in writing_fram::reset();\r
+                                               \r
                        drawing_ = nullptr;\r
                }\r
                catch(...)\r
@@ -74,7 +68,7 @@ struct frame_renderer::implementation : boost::noncopyable
                        CASPAR_LOG_CURRENT_EXCEPTION();\r
                }\r
 \r
-               return reading_;\r
+               return result;\r
        }\r
 \r
        read_frame_ptr create_output_frame()\r

diff --git a/core/producer/color/color_producer.cpp b/core/producer/color/color_producer.cpp
index 0b448bf842456263cb5dc7f06685393fed44873d..37ced840288564a346119af41323c5c79feb08a5 100644 (file)
--- a/core/producer/color/color_producer.cpp
+++ b/core/producer/color/color_producer.cpp
@@ -67,7 +67,7 @@ class color_producer : public frame_producer
 public:\r
        explicit color_producer(const std::wstring& color) : color_str_(color), color_value_(get_pixel_color_value(color)){}\r
        \r
-       gpu_frame_ptr render_frame()\r
+       gpu_frame_ptr receive()\r
        { \r
                return frame_;\r
        }\r

diff --git a/core/producer/ffmpeg/ffmpeg_producer.cpp b/core/producer/ffmpeg/ffmpeg_producer.cpp
index e91f111b4f79c6feb845e5f5404b87ea345fb33e..11c5e56963a7329bb049741d8663fbbd41aeb6d3 100644 (file)
--- a/core/producer/ffmpeg/ffmpeg_producer.cpp
+++ b/core/producer/ffmpeg/ffmpeg_producer.cpp
@@ -79,7 +79,7 @@ public:
                video_transformer_->initialize(frame_processor);\r
        }\r
                \r
-       gpu_frame_ptr render_frame()\r
+       gpu_frame_ptr receive()\r
        {\r
                while(ouput_channel_.empty() && !input_->is_eof())\r
                {       \r

diff --git a/core/producer/flash/axflash.h b/core/producer/flash/axflash.h
index 74ac05c1f8e254a9af50eacc0bebdacb45469696..da7aa8b56787dee9e45f0c05420e451470d065e7 100644 (file)
--- a/core/producer/flash/axflash.h
+++ b/core/producer/flash/axflash.h
@@ -188,7 +188,7 @@ EXTERN_C const IID IID_IShockwaveFlash;
         virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_Movie( \r
             /* [in] */ BSTR pVal) = 0;\r
         \r
-        virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE render_frameNum( \r
+        virtual /* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE receiveNum( \r
             /* [retval][out] */ long *pVal) = 0;\r
         \r
         virtual /* [helpstring][propput][id] */ HRESULT STDMETHODCALLTYPE put_FrameNum( \r
@@ -549,7 +549,7 @@ EXTERN_C const IID IID_IShockwaveFlash;
             IShockwaveFlash * This,\r
             /* [in] */ BSTR pVal);\r
         \r
-        /* [helpstring][propget][id] */ HRESULT ( STDMETHODCALLTYPE *render_frameNum )( \r
+        /* [helpstring][propget][id] */ HRESULT ( STDMETHODCALLTYPE *receiveNum )( \r
             IShockwaveFlash * This,\r
             /* [retval][out] */ long *pVal);\r
         \r
@@ -959,8 +959,8 @@ EXTERN_C const IID IID_IShockwaveFlash;
 #define IShockwaveFlash_put_Movie(This,pVal)   \\r
     (This)->lpVtbl -> put_Movie(This,pVal)\r
 \r
-#define IShockwaveFlash_render_frameNum(This,pVal)     \\r
-    (This)->lpVtbl -> render_frameNum(This,pVal)\r
+#define IShockwaveFlash_receiveNum(This,pVal)  \\r
+    (This)->lpVtbl -> receiveNum(This,pVal)\r
 \r
 #define IShockwaveFlash_put_FrameNum(This,pVal)        \\r
     (This)->lpVtbl -> put_FrameNum(This,pVal)\r
@@ -1389,12 +1389,12 @@ void __RPC_STUB IShockwaveFlash_put_Movie_Stub(
     DWORD *_pdwStubPhase);\r
 \r
 \r
-/* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE IShockwaveFlash_render_frameNum_Proxy( \r
+/* [helpstring][propget][id] */ HRESULT STDMETHODCALLTYPE IShockwaveFlash_receiveNum_Proxy( \r
     IShockwaveFlash * This,\r
     /* [retval][out] */ long *pVal);\r
 \r
 \r
-void __RPC_STUB IShockwaveFlash_render_frameNum_Stub(\r
+void __RPC_STUB IShockwaveFlash_receiveNum_Stub(\r
     IRpcStubBuffer *This,\r
     IRpcChannelBuffer *_pRpcChannelBuffer,\r
     PRPC_MESSAGE _pRpcMessage,\r

diff --git a/core/producer/flash/cg_producer.cpp b/core/producer/flash/cg_producer.cpp
index 84d714a0aec1d869eebcbe7ce8d885ecd1c23754..c9e7c9c4282ca63b91abf123231fd33f59c963c7 100644 (file)
--- a/core/producer/flash/cg_producer.cpp
+++ b/core/producer/flash/cg_producer.cpp
@@ -146,9 +146,9 @@ public:
                flash_producer_->param(param.str());\r
        }\r
 \r
-       gpu_frame_ptr render_frame()\r
+       gpu_frame_ptr receive()\r
        {\r
-               return flash_producer_ ? flash_producer_->render_frame() : nullptr;\r
+               return flash_producer_ ? flash_producer_->receive() : nullptr;\r
        }\r
                \r
        void initialize(const frame_processor_device_ptr& frame_processor)\r
@@ -184,7 +184,7 @@ cg_producer_ptr get_default_cg_producer(const channel_ptr& channel, int render_l
 }\r
 \r
 cg_producer::cg_producer() : impl_(new implementation()){}\r
-gpu_frame_ptr cg_producer::render_frame(){return impl_->render_frame();}\r
+gpu_frame_ptr cg_producer::receive(){return impl_->receive();}\r
 void cg_producer::clear(){impl_->clear();}\r
 void cg_producer::add(int layer, const std::wstring& template_name,  bool play_on_load, const std::wstring& startFromLabel, const std::wstring& data){impl_->add(layer, template_name, play_on_load, startFromLabel, data);}\r
 void cg_producer::remove(int layer){impl_->remove(layer);}\r

diff --git a/core/producer/flash/cg_producer.h b/core/producer/flash/cg_producer.h
index 5b1ff8084ec7b71d3a2987e5e478db41bdbd2aba..b0778a42f1682e4ec77981f88cfdb54d00aaf37a 100644 (file)
--- a/core/producer/flash/cg_producer.h
+++ b/core/producer/flash/cg_producer.h
@@ -13,7 +13,7 @@ public:
 \r
        cg_producer();\r
        \r
-       virtual gpu_frame_ptr render_frame();\r
+       virtual gpu_frame_ptr receive();\r
        virtual void initialize(const frame_processor_device_ptr& frame_processor);\r
 \r
        void clear();\r

diff --git a/core/producer/flash/ct_producer.cpp b/core/producer/flash/ct_producer.cpp
index d71f9b871fcf09e779d093f4b5f43c1e0b0a3a19..be5efa9f109fe1019ed8abbe7d7dd7d673a45b91 100644 (file)
--- a/core/producer/flash/ct_producer.cpp
+++ b/core/producer/flash/ct_producer.cpp
@@ -37,14 +37,14 @@ struct ct_producer : public cg_producer
 {\r
        ct_producer(const std::wstring& filename) : filename_(filename), initialized_(false){}\r
 \r
-       gpu_frame_ptr render_frame()\r
+       gpu_frame_ptr receive()\r
        {\r
                if(!initialized_)\r
                {\r
                        cg_producer::add(0, filename_, 1);\r
                        initialized_ = true;\r
                }\r
-               return cg_producer::render_frame();\r
+               return cg_producer::receive();\r
        }\r
 \r
        std::wstring print() const\r

diff --git a/core/producer/flash/flash_producer.cpp b/core/producer/flash/flash_producer.cpp
index d0ad54e6bc0a494b29dfc7fd02ffc41a50f76ed7..a0a1a65aac8d3f0d2e20b7a53086cf88f52fd4f0 100644 (file)
--- a/core/producer/flash/flash_producer.cpp
+++ b/core/producer/flash/flash_producer.cpp
@@ -228,11 +228,11 @@ struct flash_producer::implementation
                        gpu_frame_ptr result;\r
 \r
                        if(is_progressive)                                                      \r
-                               result = do_render_frame();             \r
+                               result = do_receive();          \r
                        else\r
                        {\r
-                               gpu_frame_ptr frame1 = do_render_frame();\r
-                               gpu_frame_ptr frame2 = do_render_frame();\r
+                               gpu_frame_ptr frame1 = do_receive();\r
+                               gpu_frame_ptr frame2 = do_receive();\r
                                result = composite_frame::interlace(frame1, frame2, format_desc.mode);\r
                        }\r
 \r
@@ -241,7 +241,7 @@ struct flash_producer::implementation
                }\r
        }\r
                \r
-       gpu_frame_ptr do_render_frame()\r
+       gpu_frame_ptr do_receive()\r
        {\r
                auto format_desc = frame_processor_->get_video_format_desc();\r
 \r
@@ -259,7 +259,7 @@ struct flash_producer::implementation
                return frame;\r
        }\r
                \r
-       gpu_frame_ptr render_frame()\r
+       gpu_frame_ptr receive()\r
        {               \r
                return (frame_buffer_.try_pop(last_frame_) || !is_empty_) && last_frame_ ? last_frame_ : empty_;\r
        }\r
@@ -299,7 +299,7 @@ struct flash_producer::implementation
 };\r
 \r
 flash_producer::flash_producer(const std::wstring& filename) : impl_(new implementation(this, filename)){}\r
-gpu_frame_ptr flash_producer::render_frame(){return impl_->render_frame();}\r
+gpu_frame_ptr flash_producer::receive(){return impl_->receive();}\r
 void flash_producer::param(const std::wstring& param){impl_->param(param);}\r
 void flash_producer::initialize(const frame_processor_device_ptr& frame_processor) { impl_->initialize(frame_processor);}\r
 std::wstring flash_producer::print() const {return impl_->print();}\r

diff --git a/core/producer/flash/flash_producer.h b/core/producer/flash/flash_producer.h
index f6618983965ea08b44a35dec9d60811da3813fef..1e6fa7284668077d7b04e1dbbcad5cde920c6ed2 100644 (file)
--- a/core/producer/flash/flash_producer.h
+++ b/core/producer/flash/flash_producer.h
@@ -38,7 +38,7 @@ public:
 \r
        flash_producer(const std::wstring& filename);\r
 \r
-       virtual gpu_frame_ptr render_frame();\r
+       virtual gpu_frame_ptr receive();\r
        virtual void initialize(const frame_processor_device_ptr& frame_processor);\r
        virtual std::wstring print() const;\r
 \r

diff --git a/core/producer/frame_producer.h b/core/producer/frame_producer.h
index 76485a15b8ffbdf0c1fef5c4a2be3e4c4d0bc9a4..f2644735ecbbf813ecea90ee5fd330eddcfbd66e 100644 (file)
--- a/core/producer/frame_producer.h
+++ b/core/producer/frame_producer.h
@@ -34,7 +34,7 @@ public:
        virtual ~frame_producer(){}     \r
 \r
        ////////////////////////////////////////////////////////////////////////////////////////////////////\r
-       /// \fn virtual gpu_frame_ptr :::render_frame() = 0;\r
+       /// \fn virtual gpu_frame_ptr :::receive() = 0;\r
        ///\r
        /// \brief      Renders a frame.\r
        ///             \r
@@ -42,7 +42,7 @@ public:
        ///\r
        /// \return     The frame. \r
        ////////////////////////////////////////////////////////////////////////////////////////////////////\r
-       virtual gpu_frame_ptr render_frame() = 0;\r
+       virtual gpu_frame_ptr receive() = 0;\r
 \r
        ////////////////////////////////////////////////////////////////////////////////////////////////////\r
        /// \fn virtual std::shared_ptr<frame_producer> :::get_following_producer() const\r

diff --git a/core/producer/frame_producer_device.cpp b/core/producer/frame_producer_device.cpp
index 9ebb3e110769af9ead36fd79cca06bfb6975c39b..fef0d47e8309160189e2d6606c59d29881a34afa 100644 (file)
--- a/core/producer/frame_producer_device.cpp
+++ b/core/producer/frame_producer_device.cpp
@@ -20,7 +20,7 @@
        \r
 namespace caspar { namespace core {\r
        \r
-std::vector<gpu_frame_ptr> render_frames(std::map<int, layer>& layers)\r
+std::vector<gpu_frame_ptr> receives(std::map<int, layer>& layers)\r
 {      \r
        std::vector<gpu_frame_ptr> frames(layers.size(), nullptr);\r
        tbb::parallel_for(tbb::blocked_range<size_t>(0, frames.size()), \r
@@ -29,7 +29,7 @@ std::vector<gpu_frame_ptr> render_frames(std::map<int, layer>& layers)
                auto it = layers.begin();\r
                std::advance(it, r.begin());\r
                for(size_t i = r.begin(); i != r.end(); ++i, ++it)\r
-                       frames[i] = it->second.render_frame();\r
+                       frames[i] = it->second.receive();\r
        });             \r
        return frames;\r
 }\r
@@ -60,7 +60,7 @@ struct frame_producer_device::implementation : boost::noncopyable
                                std::vector<gpu_frame_ptr> frames;\r
                                {\r
                                        tbb::mutex::scoped_lock lock(layers_mutex_);    \r
-                                       frames = render_frames(layers_);\r
+                                       frames = receives(layers_);\r
                                }                               \r
                                frame_processor_->send(std::make_shared<composite_frame>(frames));\r
                        }\r

diff --git a/core/producer/image/image_producer.cpp b/core/producer/image/image_producer.cpp
index 2b22d758bb963b21def2a8725d650f069960b624..25096bf3610e12746b12e3727c5d158cdec1bc39 100644 (file)
--- a/core/producer/image/image_producer.cpp
+++ b/core/producer/image/image_producer.cpp
@@ -19,7 +19,7 @@ struct image_producer : public frame_producer
 {\r
        image_producer(const std::wstring& filename) : filename_(filename)      {}\r
        \r
-       gpu_frame_ptr render_frame(){return frame_;}\r
+       gpu_frame_ptr receive(){return frame_;}\r
 \r
        void initialize(const frame_processor_device_ptr& frame_processor)\r
        {\r

diff --git a/core/producer/image/image_scroll_producer.cpp b/core/producer/image/image_scroll_producer.cpp
index 90bd88201179ef118faa93e9b4a095ec527ccd99..873e9bf12033a2968020477e9cd7cf7d31ee24ac 100644 (file)
--- a/core/producer/image/image_scroll_producer.cpp
+++ b/core/producer/image/image_scroll_producer.cpp
@@ -67,7 +67,7 @@ struct image_scroll_producer : public frame_producer
                        std::copy_n(&pBits[i* width * 4], width * 4, &image_.get()[i * image_width_ * 4]);\r
        }\r
 \r
-       gpu_frame_ptr do_render_frame()\r
+       gpu_frame_ptr do_receive()\r
        {\r
                auto frame = frame_processor_->create_frame(format_desc_.width, format_desc_.height);\r
                std::fill(frame->data().begin(), frame->data().end(), 0);\r
@@ -112,17 +112,17 @@ struct image_scroll_producer : public frame_producer
                return frame;\r
        }\r
                \r
-       gpu_frame_ptr render_frame()\r
+       gpu_frame_ptr receive()\r
        {               \r
                if(format_desc_.mode != video_mode::progressive)                                \r
                {\r
                        gpu_frame_ptr frame1;\r
                        gpu_frame_ptr frame2;\r
-                       tbb::parallel_invoke([&]{ frame1 = do_render_frame(); }, [&]{ frame2 = do_render_frame(); });\r
+                       tbb::parallel_invoke([&]{ frame1 = do_receive(); }, [&]{ frame2 = do_receive(); });\r
                        return composite_frame::interlace(frame1, frame2, format_desc_.mode);\r
                }                       \r
 \r
-               return render_frame();  \r
+               return receive();       \r
        }\r
        \r
        void initialize(const frame_processor_device_ptr& frame_processor)\r

diff --git a/core/producer/layer.cpp b/core/producer/layer.cpp
index 339c3e701d614e0c40f597e7de7073c7165ef4d8..5d362075dcee198e674227170d2780111a494b69 100644 (file)
--- a/core/producer/layer.cpp
+++ b/core/producer/layer.cpp
@@ -21,7 +21,7 @@ struct layer::implementation
                if(option == load_option::preview)              \r
                {\r
                        foreground_ = nullptr;  \r
-                       last_frame_ = frame_producer->render_frame();\r
+                       last_frame_ = frame_producer->receive();\r
                }\r
                else if(option == load_option::auto_play)\r
                        play();                 \r
@@ -56,14 +56,14 @@ struct layer::implementation
                last_frame_ = nullptr;\r
        }\r
        \r
-       gpu_frame_ptr render_frame()\r
+       gpu_frame_ptr receive()\r
        {               \r
                if(!foreground_ || is_paused_)\r
                        return last_frame_;\r
 \r
                try\r
                {\r
-                       last_frame_ = foreground_->render_frame();\r
+                       last_frame_ = foreground_->receive();\r
 \r
                        if(last_frame_ == nullptr)\r
                        {\r
@@ -71,7 +71,7 @@ struct layer::implementation
                                auto following = foreground_->get_following_producer();\r
                                following->set_leading_producer(foreground_);\r
                                foreground_ = following;\r
-                               last_frame_ = render_frame();\r
+                               last_frame_ = receive();\r
                        }\r
                }\r
                catch(...)\r
@@ -108,7 +108,7 @@ void layer::play(){impl_->play();}
 void layer::pause(){impl_->pause();}\r
 void layer::stop(){impl_->stop();}\r
 void layer::clear(){impl_->clear();}\r
-gpu_frame_ptr layer::render_frame() {return impl_->render_frame();}\r
+gpu_frame_ptr layer::receive() {return impl_->receive();}\r
 frame_producer_ptr layer::foreground() const { return impl_->foreground_;}\r
 frame_producer_ptr layer::background() const { return impl_->background_;}\r
 }}
\ No newline at end of file

diff --git a/core/producer/layer.h b/core/producer/layer.h
index 37bdaa912b961d79d6489a3812f23925bb6d002b..881c8f0c08cae4b904fe5c8ece8b8f928f0f4321 100644 (file)
--- a/core/producer/layer.h
+++ b/core/producer/layer.h
@@ -2,6 +2,8 @@
 \r
 #include "../producer/frame_producer.h"\r
 \r
+#include <boost/noncopyable.hpp>\r
+\r
 namespace caspar { namespace core {\r
 \r
 struct load_option\r
@@ -14,10 +16,8 @@ struct load_option
        };\r
 };\r
 \r
-class layer\r
+class layer : boost::noncopyable\r
 {\r
-       layer(const layer& other);\r
-       layer& operator=(const layer& other);\r
 public:\r
        layer();\r
        layer(layer&& other);\r
@@ -32,7 +32,7 @@ public:
        frame_producer_ptr foreground() const;\r
        frame_producer_ptr background() const;\r
 \r
-       gpu_frame_ptr render_frame();\r
+       gpu_frame_ptr receive();\r
 private:\r
        struct implementation;\r
        std::shared_ptr<implementation> impl_;\r

diff --git a/core/producer/transition/transition_producer.cpp b/core/producer/transition/transition_producer.cpp
index 4c7772f529461a85c1986c096993b55a8722bdc3..d0c6bcf975ee6b224615b9e82142d3fb19433ba2 100644 (file)
--- a/core/producer/transition/transition_producer.cpp
+++ b/core/producer/transition/transition_producer.cpp
@@ -51,7 +51,7 @@ struct transition_producer::implementation : boost::noncopyable
                org_source_producer_ = source_producer_ = producer;\r
        }\r
                \r
-       gpu_frame_ptr render_frame()\r
+       gpu_frame_ptr receive()\r
        {\r
                if(current_frame_ == 0)\r
                        CASPAR_LOG(info) << "Transition started.";\r
@@ -66,8 +66,8 @@ struct transition_producer::implementation : boost::noncopyable
 \r
                        tbb::parallel_invoke\r
                        (\r
-                               [&]{dest   = render_frame(dest_producer_);},\r
-                               [&]{source = render_frame(source_producer_);}\r
+                               [&]{dest   = receive(dest_producer_);},\r
+                               [&]{source = receive(source_producer_);}\r
                        );\r
 \r
                        return compose(dest, source);\r
@@ -79,7 +79,7 @@ struct transition_producer::implementation : boost::noncopyable
                return result;\r
        }\r
 \r
-       gpu_frame_ptr render_frame(frame_producer_ptr& producer)\r
+       gpu_frame_ptr receive(frame_producer_ptr& producer)\r
        {\r
                if(!producer)\r
                        return nullptr;\r
@@ -87,7 +87,7 @@ struct transition_producer::implementation : boost::noncopyable
                gpu_frame_ptr frame;\r
                try\r
                {\r
-                       frame = producer->render_frame();\r
+                       frame = producer->receive();\r
                }\r
                catch(...)\r
                {\r
@@ -114,7 +114,7 @@ struct transition_producer::implementation : boost::noncopyable
                                producer = nullptr;\r
                        }\r
 \r
-                       return render_frame(producer);\r
+                       return receive(producer);\r
                }\r
                return frame;\r
        }\r
@@ -180,7 +180,7 @@ struct transition_producer::implementation : boost::noncopyable
 };\r
 \r
 transition_producer::transition_producer(const frame_producer_ptr& dest, const transition_info& info) : impl_(new implementation(dest, info)){}\r
-gpu_frame_ptr transition_producer::render_frame(){return impl_->render_frame();}\r
+gpu_frame_ptr transition_producer::receive(){return impl_->receive();}\r
 frame_producer_ptr transition_producer::get_following_producer() const{return impl_->get_following_producer();}\r
 void transition_producer::set_leading_producer(const frame_producer_ptr& producer) { impl_->set_leading_producer(producer); }\r
 void transition_producer::initialize(const frame_processor_device_ptr& frame_processor) { impl_->initialize(frame_processor);}\r

diff --git a/core/producer/transition/transition_producer.h b/core/producer/transition/transition_producer.h
index ecabd9ec07dec0a631831b8c1717cb72b373ae15..9f90a779a1897555d596bd0658211af9a06b8757 100644 (file)
--- a/core/producer/transition/transition_producer.h
+++ b/core/producer/transition/transition_producer.h
@@ -62,7 +62,7 @@ class transition_producer : public frame_producer
 public:\r
        transition_producer(const frame_producer_ptr& destination, const transition_info& info);\r
 \r
-       gpu_frame_ptr render_frame();\r
+       gpu_frame_ptr receive();\r
 \r
        frame_producer_ptr get_following_producer() const;\r
        void set_leading_producer(const frame_producer_ptr& producer);\r