{\r
execution_queue_.push([=]{try{func();}catch(...){CASPAR_LOG_CURRENT_EXCEPTION();}});\r
}\r
-\r
+ \r
template<typename Func>\r
auto begin_invoke(Func&& func) -> boost::unique_future<decltype(func())>\r
{ \r
auto task = std::make_shared<boost::packaged_task<result_type>>(std::forward<Func>(func)); \r
auto future = task->get_future();\r
\r
- if(boost::this_thread::get_id() != thread_.get_id())\r
- execution_queue_.push([=]{(*task)();});\r
- else\r
- (*task)();\r
+ task->set_wait_callback(std::function<void(decltype(*task)& task)>([=](decltype(*task)& task) // The std::function wrapper is required in order to add ::result_type to functor class.\r
+ {\r
+ try\r
+ {\r
+ if(boost::this_thread::get_id() == thread_.get_id()) // Avoids potential deadlock.\r
+ task();\r
+ }\r
+ catch(boost::task_already_started&){}\r
+ }));\r
+ execution_queue_.push([=]\r
+ {\r
+ try\r
+ {\r
+ (*task)(); \r
+ }\r
+ catch(boost::task_already_started&){}\r
+ });\r
\r
return std::move(future); \r
}\r
template<typename Func>\r
auto invoke(Func&& func) -> decltype(func())\r
{\r
+ if(boost::this_thread::get_id() == thread_.get_id()) // Avoids potential deadlock.\r
+ return func();\r
+ \r
return begin_invoke(std::forward<Func>(func)).get();\r
}\r
\r
producer_device_->clear();\r
}\r
\r
- frame_producer_ptr foreground(int render_layer) const\r
+ boost::unique_future<frame_producer_ptr> foreground(int render_layer) const\r
{\r
return producer_device_->foreground(render_layer);\r
}\r
\r
- frame_producer_ptr background(int render_layer) const\r
+ boost::unique_future<frame_producer_ptr> background(int render_layer) const\r
{\r
return producer_device_->background(render_layer);\r
}\r
void channel::stop(int render_layer){impl_->stop(render_layer);}\r
void channel::clear(int render_layer){impl_->clear(render_layer);}\r
void channel::clear(){impl_->clear();}\r
-frame_producer_ptr channel::foreground(int render_layer) const{ return impl_->foreground(render_layer);}\r
-frame_producer_ptr channel::background(int render_layer) const{return impl_->background(render_layer);}\r
+boost::unique_future<frame_producer_ptr> channel::foreground(int render_layer) const{ return impl_->foreground(render_layer);}\r
+boost::unique_future<frame_producer_ptr> channel::background(int render_layer) const{return impl_->background(render_layer);}\r
const video_format_desc& channel::get_video_format_desc() const{ return impl_->get_video_format_desc();}\r
\r
}}
\ No newline at end of file
void stop(int render_layer);\r
void clear(int render_layer);\r
void clear(); \r
- frame_producer_ptr foreground(int render_layer) const;\r
- frame_producer_ptr background(int render_layer) const;\r
+ boost::unique_future<frame_producer_ptr> foreground(int render_layer) const;\r
+ boost::unique_future<frame_producer_ptr> background(int render_layer) const;\r
const video_format_desc& get_video_format_desc() const;\r
private:\r
struct implementation;\r
\r
encode_hanc(reinterpret_cast<BLUE_UINT32*>(hanc->data()), const_cast<short*>(frame_audio_data.data()), audio_samples, audio_nchannels);\r
\r
- sdk_->system_buffer_write_async(const_cast<unsigned char*>(frame.data().begin()), \r
- frame.data().size(), \r
+ sdk_->system_buffer_write_async(const_cast<unsigned char*>(frame.pixel_data().begin()), \r
+ frame.pixel_data().size(), \r
nullptr, \r
BlueImage_HANC_DMABuffer(current_id_, BLUE_DATA_IMAGE));\r
\r
}\r
else\r
{\r
- sdk_->system_buffer_write_async(const_cast<unsigned char*>(frame.data().begin()),\r
- frame.data().size(), \r
+ sdk_->system_buffer_write_async(const_cast<unsigned char*>(frame.pixel_data().begin()),\r
+ frame.pixel_data().size(), \r
nullptr, \r
BlueImage_DMABuffer(current_id_, BLUE_DATA_IMAGE));\r
\r
\r
struct decklink_consumer::Implementation : boost::noncopyable\r
{\r
- Implementation(const video_format_desc& format_desc, bool internalKey) : format_desc_(format_desc), currentFormat_(video_format::pal), internalKey_(internalKey), current_index_(0)\r
+ Implementation(const video_format_desc& format_desc, bool internalKey) : format_desc_(format_desc), currentFormat_(video_format::pal), internalKey_(internalKey)\r
{ \r
executor_.start();\r
executor_.invoke([=]\r
{\r
if(FAILED(CoInitialize(nullptr))) \r
- BOOST_THROW_EXCEPTION(caspar_exception() << msg_info("Initialization of COM failed.")); \r
+ BOOST_THROW_EXCEPTION(caspar_exception() << msg_info("DECKLINK: Initialization of COM failed.")); \r
\r
CComPtr<IDeckLinkIterator> pDecklinkIterator;\r
if(FAILED(pDecklinkIterator.CoCreateInstance(CLSID_CDeckLinkIterator)))\r
- BOOST_THROW_EXCEPTION(caspar_exception() << msg_info("No Decklink drivers installed."));\r
+ BOOST_THROW_EXCEPTION(caspar_exception() << msg_info("DECKLINK: No Decklink drivers installed."));\r
\r
while(pDecklinkIterator->Next(&decklink_) == S_OK && !decklink_){} \r
\r
if(decklink_ == nullptr)\r
- BOOST_THROW_EXCEPTION(caspar_exception() << msg_info("No Decklink card found"));\r
+ BOOST_THROW_EXCEPTION(caspar_exception() << msg_info("DECKLINK: No Decklink card found."));\r
\r
output_ = decklink_;\r
keyer_ = decklink_;\r
\r
BMDDisplayModeSupport displayModeSupport;\r
if(FAILED(output_->DoesSupportVideoMode((BMDDisplayMode)decklinkVideoFormat, bmdFormat8BitBGRA, &displayModeSupport)))\r
- BOOST_THROW_EXCEPTION(caspar_exception() << msg_info("DECKLINK: Card does not support requested videoformat"));\r
+ BOOST_THROW_EXCEPTION(caspar_exception() << msg_info("DECKLINK: Card does not support requested videoformat."));\r
\r
output_->DisableAudioOutput();\r
if(FAILED(output_->EnableVideoOutput((BMDDisplayMode)decklinkVideoFormat, bmdVideoOutputFlagDefault))) \r
- BOOST_THROW_EXCEPTION(caspar_exception() << msg_info("DECKLINK: Could not enable video output"));\r
+ BOOST_THROW_EXCEPTION(caspar_exception() << msg_info("DECKLINK: Could not enable video output."));\r
\r
if(internalKey_) \r
{\r
if(FAILED(keyer_->Enable(FALSE))) \r
- CASPAR_LOG(error) << "DECKLINK: Failed to enable internal keyer"; \r
+ CASPAR_LOG(error) << "DECKLINK: Failed to enable internal keye.r"; \r
else if(FAILED(keyer_->SetLevel(255))) \r
- CASPAR_LOG(error) << "DECKLINK: Keyer - Failed to set blend-level to max";\r
+ CASPAR_LOG(error) << "DECKLINK: Keyer - Failed to set key-level to max.";\r
else\r
- CASPAR_LOG(info) << "DECKLINK: Successfully configured internal keyer"; \r
+ CASPAR_LOG(info) << "DECKLINK: Successfully configured internal keyer."; \r
}\r
else\r
{\r
if(FAILED(keyer_->Enable(TRUE))) \r
- CASPAR_LOG(error) << "DECKLINK: Failed to enable external keyer"; \r
+ CASPAR_LOG(error) << "DECKLINK: Failed to enable external keyer."; \r
else\r
- CASPAR_LOG(info) << "DECKLINK: Successfully configured external keyer"; \r
+ CASPAR_LOG(info) << "DECKLINK: Successfully configured external keyer."; \r
}\r
\r
- reserved_frames_.resize(3);\r
for(int n = 0; n < reserved_frames_.size(); ++n)\r
{\r
if(FAILED(output_->CreateVideoFrame(format_desc_.width, format_desc_.height, format_desc_.size/format_desc_.height, bmdFormat8BitBGRA, bmdFrameFlagDefault, &reserved_frames_[n].second)))\r
~Implementation()\r
{ \r
if(output_) \r
- {\r
- BOOL bIsRunning = FALSE;\r
- output_->IsScheduledPlaybackRunning(&bIsRunning);\r
- if(bIsRunning)\r
- output_->StopScheduledPlayback(0, NULL, 0);\r
-\r
output_->DisableVideoOutput();\r
- }\r
+ \r
CoUninitialize();\r
}\r
\r
- void send(const consumer_frame& input_frame)\r
+ void send(const consumer_frame& frame)\r
{\r
active_ = executor_.begin_invoke([=]\r
- {\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
+ { \r
+ std::copy(frame.pixel_data().begin(), frame.pixel_data().end(), static_cast<char*>(reserved_frames_.front().first));\r
\r
- if(FAILED(output_->DisplayVideoFrameSync(output_frame.second)))\r
+ if(FAILED(output_->DisplayVideoFrameSync(reserved_frames_.front().second)))\r
CASPAR_LOG(error) << L"DECKLINK: Failed to display frame.";\r
+\r
+ std::rotate(reserved_frames_.begin(), reserved_frames_.begin() + 1, reserved_frames_.end());\r
});\r
}\r
\r
boost::unique_future<void> active_;\r
common::executor executor_;\r
\r
- std::vector<std::pair<void*, CComPtr<IDeckLinkMutableVideoFrame>>> reserved_frames_;\r
- size_t current_index_;\r
+ std::array<std::pair<void*, CComPtr<IDeckLinkMutableVideoFrame>>, 3> reserved_frames_;\r
\r
bool internalKey_;\r
CComPtr<IDeckLink> decklink_;\r
#pragma once\r
\r
#include "../format/video_format.h"\r
-#include "../processor/read_frame.h"\r
+#include "../processor/consumer_frame.h"\r
\r
#include <boost/noncopyable.hpp>\r
\r
\r
virtual ~frame_consumer() {}\r
\r
- virtual void send(const consumer_frame&) = 0;\r
+ virtual void send(const consumer_frame& frame) = 0;\r
virtual sync_mode synchronize() = 0;\r
virtual size_t buffer_depth() const = 0;\r
};\r
#include "../format/video_format.h"\r
#include "../processor/write_frame.h"\r
#include "../processor/frame_processor_device.h"\r
+#include "../../common/concurrency/executor.h"\r
\r
#include <tbb/concurrent_queue.h>\r
#include <tbb/atomic.h>\r
\r
-#include <boost/foreach.hpp>\r
-#include <boost/thread.hpp>\r
-\r
#include <boost/date_time/posix_time/posix_time.hpp>\r
\r
#include <boost/range/algorithm_ext/erase.hpp>\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
- ~implementation()\r
- {\r
- is_running_ = false;\r
- display_thread_.join();\r
+ executor_.start();\r
+ executor_.begin_invoke([=]{tick();});\r
}\r
- \r
- void run()\r
+ \r
+ void tick()\r
{\r
- is_running_ = true;\r
- CASPAR_LOG(warning) << "Starting frame_consumer_device."; \r
-\r
- win32_exception::install_handler();\r
- \r
- while(is_running_) \r
- {\r
- display_frame(frame_processor_->receive()); \r
- is_running_ = !consumers_.empty();\r
- }\r
- CASPAR_LOG(warning) << "Shutting down frame_consumer_device."; \r
+ process(frame_processor_->receive()); \r
+ if(!consumers_.empty())\r
+ executor_.begin_invoke([=]{tick();});\r
}\r
\r
- void display_frame(const consumer_frame& frame)\r
+ void process(const consumer_frame& frame)\r
{ \r
buffer_.push_back(frame);\r
\r
buffer_.pop_front();\r
}\r
\r
+ common::executor executor_; \r
+\r
size_t max_depth_;\r
- std::deque<consumer_frame> buffer_;\r
- \r
- tbb::atomic<bool> is_running_;\r
- boost::thread display_thread_;\r
+ std::deque<consumer_frame> buffer_; \r
\r
std::vector<frame_consumer_ptr> consumers_;\r
\r
: format_desc_(format_desc), stretch_(stretch), screen_width_(0), screen_height_(0), windowed_(windowed)\r
{ \r
#ifdef _WIN32\r
- DISPLAY_DEVICE dDevice; \r
- memset(&dDevice,0,sizeof(dDevice));\r
- dDevice.cb = sizeof(dDevice);\r
+ DISPLAY_DEVICE d_device; \r
+ memset(&d_device, 0, sizeof(d_device));\r
+ d_device.cb = sizeof(d_device);\r
\r
std::vector<DISPLAY_DEVICE> displayDevices;\r
- for(int n = 0; EnumDisplayDevices(NULL, n, &dDevice, NULL); ++n)\r
+ for(int n = 0; EnumDisplayDevices(NULL, n, &d_device, NULL); ++n)\r
{\r
- displayDevices.push_back(dDevice);\r
- memset(&dDevice,0,sizeof(dDevice));\r
- dDevice.cb = sizeof(dDevice);\r
+ displayDevices.push_back(d_device);\r
+ memset(&d_device, 0, sizeof(d_device));\r
+ d_device.cb = sizeof(d_device);\r
}\r
\r
if(screen_index >= displayDevices.size())\r
BOOST_THROW_EXCEPTION(out_of_range() << arg_name_info("screen_index_"));\r
\r
DEVMODE devmode;\r
- memset(&devmode,0,sizeof(devmode));\r
+ memset(&devmode, 0, sizeof(devmode));\r
\r
if(!EnumDisplaySettings(displayDevices[screen_index].DeviceName, ENUM_CURRENT_SETTINGS, &devmode))\r
BOOST_THROW_EXCEPTION(invalid_operation() << arg_name_info("screen_index") << msg_info("EnumDisplaySettings"));\r
\r
screen_width_ = windowed ? format_desc_.width : devmode.dmPelsWidth;\r
screen_height_ = windowed ? format_desc_.height : devmode.dmPelsHeight;\r
- screenX_ = devmode.dmPosition.x;\r
- screenY_ = devmode.dmPosition.y;\r
+ screen_x_ = devmode.dmPosition.x;\r
+ screen_y_ = devmode.dmPosition.y;\r
#else\r
if(!windowed)\r
BOOST_THROW_EXCEPTION(not_supported() << msg_info("OGLConsumer doesn't support non-Win32 fullscreen"));\r
\r
screen_width_ = format_desc_.width;\r
screen_height_ = format_desc_.height;\r
- screenX_ = 0;\r
- screenY_ = 0;\r
+ screen_x_ = 0;\r
+ screen_y_ = 0;\r
#endif\r
\r
executor_.start();\r
{\r
window_.Create(sf::VideoMode(format_desc_.width, format_desc_.height, 32), "CasparCG", windowed_ ? sf::Style::Titlebar : sf::Style::Fullscreen);\r
window_.ShowMouseCursor(false);\r
- window_.SetPosition(screenX_, screenY_);\r
+ window_.SetPosition(screen_x_, screen_y_);\r
window_.SetSize(screen_width_, screen_height_);\r
window_.SetActive();\r
GL(glEnable(GL_TEXTURE_2D));\r
void render(const consumer_frame& frame)\r
{ \r
auto ptr = pbos_.front().end_write();\r
- std::copy_n(frame.data().begin(), frame.data().size(), reinterpret_cast<char*>(ptr));\r
+ std::copy_n(frame.pixel_data().begin(), frame.pixel_data().size(), reinterpret_cast<char*>(ptr));\r
\r
GL(glClear(GL_COLOR_BUFFER_BIT)); \r
pbos_.back().bind_texture(); \r
bool windowed_;\r
unsigned int screen_width_;\r
unsigned int screen_height_;\r
- unsigned int screenX_;\r
- unsigned int screenY_;\r
+ unsigned int screen_x_;\r
+ unsigned int screen_y_;\r
\r
stretch stretch_;\r
video_format_desc format_desc_;\r
<ClInclude Include="format\pixel_format.h" />\r
<ClInclude Include="format\video_format.h" />\r
<ClInclude Include="processor\composite_frame.h" />\r
+ <ClInclude Include="processor\consumer_frame.h" />\r
<ClInclude Include="processor\frame_processor_device.h" />\r
<ClInclude Include="processor\frame_renderer.h" />\r
<ClInclude Include="processor\frame_shader.h" />\r
<ClInclude Include="processor\fwd.h" />\r
- <ClInclude Include="processor\gpu_frame.h" />\r
+ <ClInclude Include="processor\producer_frame.h" />\r
<ClInclude Include="processor\read_frame.h" />\r
<ClInclude Include="processor\transform_frame.h" />\r
<ClInclude Include="processor\write_frame.h" />\r
<ClInclude Include="processor\fwd.h">\r
<Filter>Source\channel\processor</Filter>\r
</ClInclude>\r
- <ClInclude Include="processor\gpu_frame.h">\r
- <Filter>Source\channel\processor\frame</Filter>\r
+ <ClInclude Include="processor\producer_frame.h">\r
+ <Filter>Source\channel\processor</Filter>\r
+ </ClInclude>\r
+ <ClInclude Include="processor\consumer_frame.h">\r
+ <Filter>Source\channel\processor</Filter>\r
</ClInclude>\r
</ItemGroup>\r
<ItemGroup>\r
#include "../StdAfx.h"\r
\r
+#include "producer_frame.h"\r
#include "composite_frame.h"\r
#include "transform_frame.h"\r
#include "../../common/gl/utility.h"\r
\r
struct composite_frame::implementation : boost::noncopyable\r
{ \r
- implementation(const std::vector<gpu_frame_ptr>& frames) : frames_(frames)\r
- {\r
- boost::range::remove_erase(frames_, nullptr);\r
- }\r
+ implementation(const std::vector<producer_frame>& frames) : frames_(frames) {}\r
\r
void begin_write()\r
{\r
- boost::range::for_each(frames_, std::mem_fn(&gpu_frame::begin_write)); \r
+ boost::range::for_each(frames_, std::mem_fn(&producer_frame::begin_write)); \r
}\r
\r
void end_write()\r
{\r
- boost::range::for_each(frames_, std::mem_fn(&gpu_frame::end_write)); \r
+ boost::range::for_each(frames_, std::mem_fn(&producer_frame::end_write)); \r
}\r
\r
void draw(frame_shader& shader)\r
{\r
- for(size_t n = 0; n < frames_.size(); ++n)\r
- frames_[n]->draw(shader);\r
+ boost::range::for_each(frames_, std::bind(&producer_frame::draw, std::placeholders::_1, std::ref(shader))); \r
}\r
\r
std::vector<short>& audio_data()\r
\r
for(size_t n = 0; n < frames_.size(); ++n)\r
{\r
- auto frame = frames_[n];\r
+ auto& frame = frames_[n];\r
tbb::parallel_for\r
(\r
- tbb::blocked_range<size_t>(0, frame->audio_data().size()),\r
+ tbb::blocked_range<size_t>(0, frame.audio_data().size()),\r
[&](const tbb::blocked_range<size_t>& r)\r
{\r
for(size_t n = r.begin(); n < r.end(); ++n) \r
- audio_data_[n] = static_cast<short>((static_cast<int>(audio_data_[n]) + static_cast<int>(frame->audio_data()[n])) & 0xFFFF); \r
+ audio_data_[n] = static_cast<short>((static_cast<int>(audio_data_[n]) + static_cast<int>(frame.audio_data()[n])) & 0xFFFF); \r
}\r
);\r
}\r
return audio_data_;\r
}\r
\r
- std::vector<gpu_frame_ptr> frames_;\r
+ std::vector<producer_frame> frames_;\r
std::vector<short> audio_data_;\r
};\r
\r
#pragma warning (disable : 4355) // 'this' : used in base member initializer list\r
#endif\r
\r
-composite_frame::composite_frame(const std::vector<gpu_frame_ptr>& frames) : impl_(new implementation(frames)){}\r
-composite_frame::composite_frame(const gpu_frame_ptr& frame1, const gpu_frame_ptr& frame2)\r
+composite_frame::composite_frame(const std::vector<producer_frame>& frames) : impl_(new implementation(frames)){}\r
+composite_frame::composite_frame(const producer_frame& frame1, const producer_frame& frame2)\r
{\r
- std::vector<gpu_frame_ptr> frames;\r
+ std::vector<producer_frame> frames;\r
frames.push_back(frame1);\r
frames.push_back(frame2);\r
impl_.reset(new implementation(frames));\r
std::vector<short>& composite_frame::audio_data(){return impl_->audio_data();}\r
const std::vector<short>& composite_frame::audio_data() const{return impl_->audio_data();}\r
\r
-composite_frame_ptr composite_frame::interlace(const gpu_frame_ptr& frame1, const gpu_frame_ptr& frame2, video_mode::type mode)\r
+composite_frame_ptr composite_frame::interlace(const producer_frame& frame1, const producer_frame& frame2, video_mode::type mode)\r
{ \r
auto my_frame1 = std::make_shared<transform_frame>(frame1);\r
auto my_frame2 = std::make_shared<transform_frame>(frame2);\r
#pragma once\r
\r
-#include "gpu_frame.h"\r
+#include "fwd.h"\r
\r
#include "../format/video_format.h"\r
\r
\r
namespace caspar { namespace core {\r
\r
-class composite_frame : public gpu_frame\r
+class composite_frame\r
{\r
public:\r
- composite_frame(const std::vector<gpu_frame_ptr>& frames);\r
- composite_frame(const gpu_frame_ptr& frame1, const gpu_frame_ptr& frame2);\r
+ composite_frame(const std::vector<producer_frame>& frames);\r
+ composite_frame(const producer_frame& frame1, const producer_frame& frame2);\r
\r
- static std::shared_ptr<composite_frame> interlace(const gpu_frame_ptr& frame1, const gpu_frame_ptr& frame2, video_mode::type mode);\r
+ static std::shared_ptr<composite_frame> interlace(const producer_frame& frame1, const producer_frame& frame2, video_mode::type mode);\r
\r
- virtual const std::vector<short>& audio_data() const;\r
-\r
-protected: \r
- virtual std::vector<short>& audio_data();\r
-\r
- virtual void begin_write();\r
- virtual void end_write();\r
- virtual void draw(frame_shader& shader);\r
+ const std::vector<short>& audio_data() const;\r
+ std::vector<short>& audio_data();\r
+ \r
+ void begin_write();\r
+ void end_write();\r
+ void draw(frame_shader& shader);\r
\r
private:\r
struct implementation;\r
--- /dev/null
+#pragma once\r
+\r
+#include "read_frame.h"\r
+\r
+#include <boost/noncopyable.hpp>\r
+#include <boost/range/iterator_range.hpp>\r
+\r
+#include <memory>\r
+#include <vector>\r
+\r
+namespace caspar { namespace core {\r
+\r
+class consumer_frame\r
+{\r
+public: \r
+ consumer_frame(const read_frame_ptr& frame) : frame_(frame){}\r
+ const boost::iterator_range<const unsigned char*> pixel_data() const {return frame_->pixel_data();}\r
+ const std::vector<short>& audio_data() const {return frame_->audio_data();}\r
+ \r
+private:\r
+ read_frame_ptr frame_;\r
+};\r
+typedef std::shared_ptr<consumer_frame> consumer_frame_ptr;\r
+typedef std::unique_ptr<consumer_frame> consumer_frame_uptr;\r
+\r
+}}
\ No newline at end of file
#include "write_frame.h"\r
#include "read_frame.h"\r
#include "composite_frame.h"\r
+#include "producer_frame.h"\r
\r
#include "../format/video_format.h"\r
\r
renderer_.reset(new frame_renderer(format_desc));\r
});\r
}\r
-\r
- ~implementation()\r
- {\r
- executor_.stop(); // Wait for executor before destroying anything.\r
- }\r
- \r
+ \r
write_frame_ptr create_frame(const pixel_format_desc& desc)\r
{\r
auto pool = &frame_pools_[desc];\r
});\r
}\r
\r
- void send(const gpu_frame_ptr& input_frame)\r
- { \r
- if(input_frame == nullptr)\r
- return;\r
- \r
- auto future = executor_.begin_invoke([=]{return renderer_->render(input_frame);}); \r
+ void send(const producer_frame& frame)\r
+ { \r
+ auto future = executor_.begin_invoke([=]{return renderer_->render(frame);}); \r
output_.push(std::move(future)); // Blocks\r
}\r
\r
\r
return future.get();\r
}\r
- \r
- std::unique_ptr<sf::Context> ogl_context_;\r
- std::unique_ptr<frame_renderer> renderer_;\r
- \r
+ \r
common::executor executor_; \r
+\r
+ std::unique_ptr<sf::Context> ogl_context_;\r
+ std::unique_ptr<frame_renderer> renderer_; \r
\r
tbb::concurrent_bounded_queue<boost::shared_future<consumer_frame>> output_; \r
tbb::concurrent_unordered_map<pixel_format_desc, tbb::concurrent_bounded_queue<write_frame_ptr>, std::hash<pixel_format_desc>> frame_pools_;\r
\r
- video_format_desc fmt_;\r
+ const video_format_desc fmt_;\r
long underrun_count_;\r
};\r
\r
frame_processor_device::frame_processor_device(const video_format_desc& format_desc) : impl_(new implementation(format_desc)){}\r
-void frame_processor_device::send(const gpu_frame_ptr& frame){impl_->send(frame);}\r
+void frame_processor_device::send(const producer_frame& frame){impl_->send(frame);}\r
consumer_frame frame_processor_device::receive(){return impl_->receive();}\r
const video_format_desc& frame_processor_device::get_video_format_desc() const { return impl_->fmt_; }\r
\r
public:\r
frame_processor_device(const video_format_desc& format_desc);\r
\r
- void send(const gpu_frame_ptr& frame);\r
+ void send(const producer_frame& frame);\r
consumer_frame receive();\r
\r
write_frame_ptr create_frame(const pixel_format_desc& desc); \r
#include "frame_shader.h"\r
#include "write_frame.h"\r
#include "read_frame.h"\r
+#include "producer_frame.h"\r
+#include "consumer_frame.h"\r
\r
#include "../format/video_format.h"\r
\r
struct frame_renderer::implementation : boost::noncopyable\r
{ \r
implementation(const video_format_desc& format_desc) : shader_(format_desc), format_desc_(format_desc),\r
- reading_(new read_frame(0, 0)), writing_(new write_frame(pixel_format_desc())), drawing_(new write_frame(pixel_format_desc())), fbo_(format_desc.width, format_desc.height)\r
+ reading_(new read_frame(0, 0)), writing_(producer_frame::empty()), drawing_(producer_frame::empty()), fbo_(format_desc.width, format_desc.height)\r
{ \r
GL(glEnable(GL_POLYGON_STIPPLE));\r
GL(glEnable(GL_TEXTURE_2D));\r
GL(glViewport(0, 0, format_desc.width, format_desc.height));\r
}\r
\r
- consumer_frame render(const gpu_frame_ptr& frame)\r
+ consumer_frame render(const producer_frame& frame)\r
{\r
- if(frame == nullptr)\r
- return nullptr;\r
-\r
read_frame_ptr result;\r
try\r
{\r
drawing_ = writing_;\r
writing_ = frame;\r
\r
- writing_->begin_write(); // Note: end_write is done when returned to pool, write_frame::reset();\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
+ drawing_.draw(shader_);\r
\r
reading_ = create_output_frame();\r
\r
reading_->begin_read();\r
- reading_->audio_data() = std::move(drawing_->audio_data());\r
+ reading_->audio_data() = drawing_.audio_data();\r
\r
- drawing_ = nullptr;\r
+ drawing_ = producer_frame::empty();\r
}\r
catch(...)\r
{\r
common::gl::frame_buffer_object fbo_;\r
\r
read_frame_ptr reading_; \r
- gpu_frame_ptr writing_;\r
- gpu_frame_ptr drawing_;\r
+ producer_frame writing_;\r
+ producer_frame drawing_;\r
\r
frame_shader shader_;\r
\r
};\r
\r
frame_renderer::frame_renderer(const video_format_desc& format_desc) : impl_(new implementation(format_desc)){}\r
-consumer_frame frame_renderer::render(const gpu_frame_ptr& frame)\r
+consumer_frame frame_renderer::render(const producer_frame& frame)\r
{\r
return impl_->render(frame);\r
}\r
public:\r
frame_renderer(const video_format_desc& format_desc_);\r
\r
- consumer_frame render(const gpu_frame_ptr& frame);\r
+ consumer_frame render(const producer_frame& frame);\r
private:\r
struct implementation;\r
std::shared_ptr<implementation> impl_;\r
double alpha_;\r
std::stack<shader_transform> transform_stack_;\r
\r
- video_format_desc format_desc_;\r
+ const video_format_desc format_desc_;\r
pixel_format::type current_;\r
std::unordered_map<pixel_format::type, common::gl::shader_program> shaders_;\r
};\r
frame_shader(const video_format_desc& format_desc);\r
\r
void begin(const shader_transform& transform);\r
- void render(const pixel_format_desc& image);\r
+ void render(const pixel_format_desc& desc);\r
void end();\r
private:\r
struct implementation;\r
\r
namespace caspar { namespace core {\r
\r
-class gpu_frame;\r
-typedef std::shared_ptr<gpu_frame> gpu_frame_ptr;\r
+class read_frame;\r
+typedef std::shared_ptr<read_frame> read_frame_ptr;\r
\r
class write_frame;\r
typedef std::shared_ptr<write_frame> write_frame_ptr;\r
typedef std::shared_ptr<composite_frame> composite_frame_ptr;\r
\r
class consumer_frame;\r
+class producer_frame;\r
\r
class frame_shader;\r
typedef std::shared_ptr<frame_shader> frame_shader_ptr;\r
--- /dev/null
+#pragma once\r
+\r
+#include "write_frame.h"\r
+#include "composite_frame.h"\r
+#include "transform_frame.h"\r
+\r
+#include <boost/noncopyable.hpp>\r
+#include <boost/range/iterator_range.hpp>\r
+#include <boost/variant.hpp>\r
+\r
+#include <memory>\r
+#include <vector>\r
+\r
+namespace caspar { namespace core {\r
+\r
+class producer_frame\r
+{\r
+public: \r
+ typedef boost::iterator_range<const unsigned char*> pixel_data_type;\r
+ typedef std::vector<short> audio_data_type;\r
+ \r
+ producer_frame() : frame_(empty_frame()){}\r
+ producer_frame(const write_frame_ptr& frame) : frame_(frame){if(!frame) frame_ = eof_frame();}\r
+ producer_frame(const composite_frame_ptr& frame) : frame_(frame){if(!frame) frame_ = eof_frame();}\r
+ producer_frame(const transform_frame_ptr& frame) : frame_(frame){if(!frame) frame_ = eof_frame();}\r
+\r
+ producer_frame(const producer_frame& other) : frame_(other.frame_){}\r
+ producer_frame(producer_frame&& other) : frame_(std::move(other.frame_)){}\r
+\r
+ producer_frame& operator=(const producer_frame& other)\r
+ {\r
+ producer_frame temp(other);\r
+ frame_.swap(temp.frame_);\r
+ return *this;\r
+ }\r
+\r
+ producer_frame& operator=(producer_frame&& other)\r
+ {\r
+ frame_ = std::move(other.frame_);\r
+ return *this;\r
+ }\r
+ \r
+ const audio_data_type& audio_data() const {return boost::apply_visitor(audio_data_visitor(), frame_);}\r
+\r
+ void begin_write() {boost::apply_visitor(begin_write_visitor(), frame_);} \r
+ void draw(frame_shader& shader) {boost::apply_visitor(draw_visitor(shader), frame_); }\r
+ void end_write() {boost::apply_visitor(end_write_visitor(), frame_);}\r
+ \r
+ static const producer_frame& eof()\r
+ {\r
+ static producer_frame eof(eof_frame());\r
+ return eof;\r
+ }\r
+\r
+ static const producer_frame& empty()\r
+ {\r
+ static producer_frame empty(empty_frame());\r
+ return empty;\r
+ }\r
+\r
+ bool operator==(const producer_frame& other)\r
+ {\r
+ return frame_ == other.frame_;\r
+ }\r
+\r
+ bool operator!=(const producer_frame& other)\r
+ {\r
+ return !(*this == other);\r
+ }\r
+\r
+private:\r
+\r
+ friend class frame_processor_device;\r
+ friend class frame_renderer;\r
+ \r
+ struct null_frame\r
+ {\r
+ void begin_write(){}\r
+ void draw(frame_shader& shader){}\r
+ void end_write(){}\r
+ audio_data_type& audio_data() { static audio_data_type audio_data; return audio_data;} \r
+ };\r
+ typedef std::shared_ptr<null_frame> null_frame_ptr;\r
+\r
+ producer_frame(const null_frame_ptr& frame) : frame_(frame){}\r
+ \r
+ static const null_frame_ptr& eof_frame()\r
+ {\r
+ static null_frame_ptr eof(new null_frame());\r
+ return eof;\r
+ }\r
+\r
+ static const null_frame_ptr& empty_frame()\r
+ {\r
+ static null_frame_ptr empty(new null_frame());\r
+ return empty;\r
+ }\r
+\r
+ struct audio_data_visitor : public boost::static_visitor<audio_data_type&>\r
+ {\r
+ template<typename P> audio_data_type& operator()(P& frame) const{return frame->audio_data();}\r
+ };\r
+\r
+ struct begin_write_visitor : public boost::static_visitor<void>\r
+ {\r
+ template<typename P> void operator()(P& frame) const{frame->begin_write();}\r
+ };\r
+ \r
+ struct draw_visitor : public boost::static_visitor<void>\r
+ {\r
+ draw_visitor(frame_shader& shader) : shader_(shader){}\r
+ template<typename P> void operator()(P& frame) const{frame->draw(shader_);}\r
+ frame_shader& shader_;\r
+ };\r
+\r
+ struct end_write_visitor : public boost::static_visitor<void>\r
+ {\r
+ template<typename P> void operator()(P& frame) const{frame->end_write();}\r
+ };\r
+\r
+ boost::variant<write_frame_ptr, composite_frame_ptr, transform_frame_ptr, null_frame_ptr> frame_;\r
+};\r
+\r
+}}
\ No newline at end of file
read_frame::read_frame(size_t width, size_t height) : impl_(new implementation(width, height)){}\r
void read_frame::begin_read(){impl_->begin_read();}\r
void read_frame::end_read(){impl_->end_read();}\r
-const boost::iterator_range<const unsigned char*> read_frame::data() const\r
+const boost::iterator_range<const unsigned char*> read_frame::pixel_data() const\r
{\r
auto ptr = static_cast<const unsigned char*>(impl_->pixel_data_);\r
return boost::iterator_range<const unsigned char*>(ptr, ptr+impl_->pbo_->size());\r
public: \r
explicit read_frame(size_t width, size_t height);\r
\r
- const boost::iterator_range<const unsigned char*> data() const;\r
+ const boost::iterator_range<const unsigned char*> pixel_data() const;\r
const std::vector<short>& audio_data() const;\r
std::vector<short>& audio_data();\r
\r
std::shared_ptr<implementation> impl_;\r
};\r
typedef std::shared_ptr<read_frame> read_frame_ptr;\r
- \r
-class consumer_frame\r
-{\r
-public: \r
- consumer_frame(const read_frame_ptr& frame) : frame_(frame){}\r
- const boost::iterator_range<const unsigned char*> data() const {return frame_->data();}\r
- const std::vector<short>& audio_data() const {return frame_->audio_data();}\r
- \r
-private:\r
- read_frame_ptr frame_;\r
-};\r
-typedef std::shared_ptr<consumer_frame> consumer_frame_ptr;\r
-typedef std::unique_ptr<consumer_frame> consumer_frame_uptr;\r
-\r
}}
\ No newline at end of file
\r
#include "transform_frame.h"\r
\r
+#include "producer_frame.h"\r
#include "frame_shader.h"\r
\r
#include "../format/pixel_format.h"\r
\r
struct transform_frame::implementation : boost::noncopyable\r
{\r
- implementation(const gpu_frame_ptr& frame) : frame_(frame), audio_volume_(255){}\r
+ implementation(const producer_frame& frame) : frame_(frame), audio_volume_(255), calculated_audio_volume_(audio_volume_){}\r
\r
+ void begin_write(){frame_.begin_write();}\r
+ void end_write(){frame_.end_write();}\r
+\r
void draw(frame_shader& shader)\r
{\r
- if(!frame_)\r
+ if(frame_ == producer_frame::empty() || frame_ == producer_frame::eof())\r
return;\r
\r
shader.begin(transform_);\r
- frame_->draw(shader);\r
+ frame_.draw(shader);\r
shader.end();\r
}\r
\r
std::vector<short>& audio_data()\r
{\r
- if(!audio_data_.empty() || !frame_)\r
+ if(!audio_data_.empty() && calculated_audio_volume_ == audio_volume_)\r
return audio_data_;\r
\r
- audio_data_ = frame_->audio_data();\r
+ calculated_audio_volume_ = audio_volume_;\r
+ audio_data_ = frame_.audio_data();\r
tbb::parallel_for\r
(\r
tbb::blocked_range<size_t>(0, audio_data_.size()),\r
\r
return audio_data_;\r
}\r
-\r
- void begin_write()\r
- {\r
- if(frame_)\r
- frame_->begin_write();\r
- }\r
-\r
- void end_write()\r
- {\r
- if(frame_)\r
- frame_->end_write();\r
- }\r
\r
std::vector<short> audio_data_;\r
\r
shader_transform transform_;\r
-\r
+ \r
+ unsigned char calculated_audio_volume_;\r
unsigned char audio_volume_;\r
- gpu_frame_ptr frame_;\r
+ producer_frame frame_;\r
};\r
\r
-transform_frame::transform_frame(const gpu_frame_ptr& frame) : impl_(new implementation(frame)){}\r
+transform_frame::transform_frame(const producer_frame& frame) : impl_(new implementation(frame)){}\r
void transform_frame::begin_write(){impl_->begin_write();}\r
void transform_frame::end_write(){impl_->end_write();} \r
void transform_frame::draw(frame_shader& shader){impl_->draw(shader);}\r
#pragma once\r
\r
-#include "gpu_frame.h"\r
+#include "fwd.h"\r
\r
#include "../format/video_format.h"\r
#include "../format/pixel_format.h"\r
\r
namespace caspar { namespace core {\r
\r
-class transform_frame : public gpu_frame\r
+class transform_frame\r
{\r
public:\r
- explicit transform_frame(const gpu_frame_ptr& frame);\r
+ explicit transform_frame(const producer_frame& frame);\r
\r
- virtual std::vector<short>& audio_data();\r
- virtual const std::vector<short>& audio_data() const;\r
+ std::vector<short>& audio_data();\r
+ const std::vector<short>& audio_data() const;\r
\r
void audio_volume(unsigned char volume);\r
void translate(double x, double y);\r
void video_mode(video_mode::type mode);\r
void alpha(double value);\r
\r
-protected: \r
- virtual void begin_write();\r
- virtual void end_write();\r
- virtual void draw(frame_shader& shader);\r
+ void begin_write();\r
+ void end_write();\r
+ void draw(frame_shader& shader);\r
\r
private:\r
struct implementation;\r
\r
#include "write_frame.h"\r
\r
+#include "producer_frame.h"\r
#include "frame_shader.h"\r
\r
#include "../format/pixel_format.h"\r
void write_frame::begin_write(){impl_->begin_write();}\r
void write_frame::end_write(){impl_->end_write();} \r
void write_frame::draw(frame_shader& shader){impl_->draw(shader);}\r
-boost::iterator_range<unsigned char*> write_frame::data(size_t index)\r
+boost::iterator_range<unsigned char*> write_frame::pixel_data(size_t index)\r
{\r
auto ptr = static_cast<unsigned char*>(impl_->pixel_data_[index]);\r
return boost::iterator_range<unsigned char*>(ptr, ptr+impl_->desc_.planes[index].size);\r
}\r
-const boost::iterator_range<const unsigned char*> write_frame::data(size_t index) const\r
+const boost::iterator_range<const unsigned char*> write_frame::pixel_data(size_t index) const\r
{\r
auto ptr = static_cast<const unsigned char*>(impl_->pixel_data_[index]);\r
return boost::iterator_range<const unsigned char*>(ptr, ptr+impl_->desc_.planes[index].size);\r
\r
#include "fwd.h"\r
\r
-#include "gpu_frame.h"\r
-\r
#include "../format/video_format.h"\r
#include "../format/pixel_format.h"\r
\r
\r
namespace caspar { namespace core {\r
\r
-class write_frame : public gpu_frame\r
+class write_frame\r
{\r
- friend class frame_renderer;\r
- friend class frame_processor_device;\r
-\r
public: \r
- boost::iterator_range<unsigned char*> data(size_t index = 0);\r
- const boost::iterator_range<const unsigned char*> data(size_t index = 0) const;\r
-\r
- virtual std::vector<short>& audio_data();\r
- virtual const std::vector<short>& audio_data() const;\r
- \r
-private:\r
explicit write_frame(const pixel_format_desc& desc);\r
\r
- virtual void reset();\r
+ boost::iterator_range<unsigned char*> pixel_data(size_t index = 0);\r
+ const boost::iterator_range<const unsigned char*> pixel_data(size_t index = 0) const;\r
+\r
+ std::vector<short>& audio_data();\r
+ const std::vector<short>& audio_data() const;\r
+ \r
+ void reset();\r
\r
- virtual void begin_write();\r
- virtual void end_write();\r
- virtual void draw(frame_shader& shader);\r
+ void begin_write();\r
+ void end_write();\r
+ void draw(frame_shader& shader);\r
\r
+private:\r
struct implementation;\r
std::shared_ptr<implementation> impl_;\r
};\r
\r
#include "color_producer.h"\r
\r
+#include "../../processor/producer_frame.h"\r
#include "../../format/video_format.h"\r
\r
#include <intrin.h>\r
class color_producer : public frame_producer\r
{\r
public:\r
- explicit color_producer(const std::wstring& color) : color_str_(color), color_value_(get_pixel_color_value(color)){}\r
+ explicit color_producer(const std::wstring& color) : color_str_(color), color_value_(get_pixel_color_value(color)), frame_(producer_frame::empty()){}\r
\r
- gpu_frame_ptr receive()\r
+ producer_frame receive()\r
{ \r
return frame_;\r
}\r
void initialize(const frame_processor_device_ptr& frame_processor)\r
{\r
auto frame = frame_processor->create_frame();\r
- __stosd(reinterpret_cast<unsigned long*>(frame->data().begin()), color_value_, frame->data().size() / sizeof(unsigned long));\r
+ __stosd(reinterpret_cast<unsigned long*>(frame->pixel_data().begin()), color_value_, frame->pixel_data().size() / sizeof(unsigned long));\r
frame_ = frame;\r
}\r
\r
return + L"color_producer. color: " + color_str_;\r
}\r
\r
- gpu_frame_ptr frame_;\r
+ producer_frame frame_;\r
unsigned int color_value_;\r
std::wstring color_str_;\r
};\r
#include "video/video_transformer.h"\r
\r
#include "../../format/video_format.h"\r
+#include "../../processor/producer_frame.h"\r
#include "../../../common/utility/scope_exit.h"\r
#include "../../server.h"\r
\r
video_transformer_->initialize(frame_processor);\r
}\r
\r
- gpu_frame_ptr receive()\r
+ producer_frame receive()\r
{\r
while(ouput_channel_.empty() && !input_->is_eof())\r
{ \r
CASPAR_LOG(warning) << "### File read underflow has STARTED.";\r
\r
// Return last frame without audio.\r
- if(last_frame_)\r
- last_frame_->audio_data().clear();\r
+ //last_frame_.audio_data().clear(); TODO\r
return last_frame_;\r
}\r
else if(underrun_count_ > 0)\r
\r
while(!video_frame_channel_.empty() && (!audio_chunk_channel_.empty() || !has_audio_))\r
{\r
- if(has_audio_ && video_frame_channel_.front() != nullptr)\r
+ if(has_audio_ && video_frame_channel_.front()) \r
{\r
video_frame_channel_.front()->audio_data() = std::move(audio_chunk_channel_.front());\r
audio_chunk_channel_.pop_front();\r
}\r
\r
- gpu_frame_ptr frame = video_frame_channel_.front();\r
+ auto frame = video_frame_channel_.front();\r
video_frame_channel_.pop_front();\r
ouput_channel_.push(std::move(frame));\r
} \r
ouput_channel_.pop();\r
}\r
else if(input_->is_eof())\r
- last_frame_ = nullptr;\r
+ last_frame_ = producer_frame::eof();\r
\r
return last_frame_;\r
}\r
\r
video_decoder_uptr video_decoder_;\r
video_transformer_uptr video_transformer_;\r
- std::deque<gpu_frame_ptr> video_frame_channel_;\r
+ std::deque<transform_frame_ptr> video_frame_channel_;\r
\r
audio_decoder_ptr audio_decoder_;\r
std::deque<std::vector<short>> audio_chunk_channel_;\r
\r
- std::queue<gpu_frame_ptr> ouput_channel_;\r
+ std::queue<transform_frame_ptr> ouput_channel_;\r
\r
std::wstring filename_;\r
\r
long underrun_count_;\r
\r
- gpu_frame_ptr last_frame_;\r
+ producer_frame last_frame_;\r
};\r
\r
frame_producer_ptr create_ffmpeg_producer(const std::vector<std::wstring>& params)\r
#include "../../../format/video_format.h"\r
#include "../../../processor/write_frame.h"\r
#include "../../../processor/transform_frame.h"\r
+#include "../../../processor/producer_frame.h"\r
#include "../../../processor/frame_processor_device.h"\r
\r
#include <tbb/parallel_for.h>\r
}\r
}\r
\r
-
gpu_frame_ptr execute(const std::shared_ptr<AVFrame>& decoded_frame)
\r+
transform_frame_ptr execute(const std::shared_ptr<AVFrame>& decoded_frame)
\r { \r
if(decoded_frame == nullptr)\r
return nullptr;\r
tbb::parallel_for(0, static_cast<int>(desc_.planes.size()), 1, [&](int n)\r
{\r
auto plane = desc_.planes[n];\r
- auto result = result_frame->data(n).begin();\r
+ auto result = result_frame->pixel_data(n).begin();\r
auto decoded = decoded_frame->data[n];\r
auto decoded_linesize = decoded_frame->linesize[n];\r
\r
\r
AVFrame av_frame; \r
avcodec_get_frame_defaults(&av_frame);\r
- avpicture_fill(reinterpret_cast<AVPicture*>(&av_frame), result_frame->data().begin(), PIX_FMT_BGRA, width_, height_);\r
+ avpicture_fill(reinterpret_cast<AVPicture*>(&av_frame), result_frame->pixel_data().begin(), PIX_FMT_BGRA, width_, height_);\r
\r
sws_scale(sws_context_.get(), decoded_frame->data, decoded_frame->linesize, 0, height_, av_frame.data, av_frame.linesize); \r
}\r
-\r
+ \r
+ auto transform = std::make_shared<transform_frame>(result_frame);\r
// TODO: Make generic for all formats and modes.\r
- if(codec_context_->codec_id == CODEC_ID_DVVIDEO) // Move up one field\r
- {\r
- auto transform = std::make_shared<transform_frame>(result_frame);\r
- transform->translate(0.0f, 1.0/static_cast<double>(frame_processor_->get_video_format_desc().height));\r
- return transform;\r
- }\r
+ if(codec_context_->codec_id == CODEC_ID_DVVIDEO) // Move up one field \r
+ transform->translate(0.0f, 1.0/static_cast<double>(frame_processor_->get_video_format_desc().height)); \r
\r
- return result_frame;\r
+ return transform;\r
}\r
void initialize(const frame_processor_device_ptr& frame_processor)\r
{\r
};\r
\r
video_transformer::video_transformer(AVCodecContext* codec_context) : impl_(new implementation(codec_context)){}\r
-
gpu_frame_ptr video_transformer::execute(const std::shared_ptr<AVFrame>& decoded_frame){return impl_->execute(decoded_frame);}
\r+
transform_frame_ptr video_transformer::execute(const std::shared_ptr<AVFrame>& decoded_frame){return impl_->execute(decoded_frame);}
\r void video_transformer::initialize(const frame_processor_device_ptr& frame_processor){impl_->initialize(frame_processor); }\r
}}}
\ No newline at end of file
{\r
public:\r
video_transformer(AVCodecContext* codec_context);\r
- gpu_frame_ptr execute(const std::shared_ptr<AVFrame>& video_packet); \r
+ transform_frame_ptr execute(const std::shared_ptr<AVFrame>& video_packet); \r
void initialize(const frame_processor_device_ptr& frame_processor);\r
private:\r
struct implementation;\r
#include "cg_producer.h"\r
#include "flash_producer.h"\r
\r
-#include "../../processor/write_frame.h"\r
+#include "../../processor/producer_frame.h"\r
#include "../../Server.h"\r
\r
#include <boost/filesystem.hpp>\r
flash_producer_->param(param.str());\r
}\r
\r
- gpu_frame_ptr receive()\r
+ producer_frame receive()\r
{\r
- return flash_producer_ ? flash_producer_->receive() : nullptr;\r
+ return flash_producer_ ? flash_producer_->receive() : producer_frame::empty();\r
}\r
\r
void initialize(const frame_processor_device_ptr& frame_processor)\r
if(!channel)\r
BOOST_THROW_EXCEPTION(null_argument() << msg_info("channel"));\r
\r
- auto producer = std::dynamic_pointer_cast<cg_producer>(channel->foreground(render_layer));\r
+ auto producer = std::dynamic_pointer_cast<cg_producer>(channel->foreground(render_layer).get());\r
if(producer == nullptr)\r
{\r
producer = std::make_shared<cg_producer>(); \r
}\r
\r
cg_producer::cg_producer() : impl_(new implementation()){}\r
-gpu_frame_ptr cg_producer::receive(){return impl_->receive();}\r
+producer_frame 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
\r
cg_producer();\r
\r
- virtual gpu_frame_ptr receive();\r
+ virtual producer_frame receive();\r
virtual void initialize(const frame_processor_device_ptr& frame_processor);\r
\r
void clear();\r
\r
#include "cg_producer.h"\r
\r
-#include "../../processor/write_frame.h"\r
+#include "../../processor/producer_frame.h"\r
#include "../../server.h"\r
\r
#include <boost/assign/list_of.hpp>\r
{\r
ct_producer(const std::wstring& filename) : filename_(filename), initialized_(false){}\r
\r
- gpu_frame_ptr receive()\r
+ producer_frame receive()\r
{\r
if(!initialized_)\r
{\r
#include "../../../common/concurrency/executor.h"\r
#include "../../../common/utility/scope_exit.h"\r
\r
-#include "../../processor/write_frame.h"\r
+#include "../../processor/producer_frame.h"\r
#include "../../processor/composite_frame.h"\r
\r
#include <boost/assign.hpp>\r
stop();\r
\r
frame_buffer_.clear();\r
- frame_buffer_.try_push(nullptr); // EOF\r
+ frame_buffer_.try_push(producer_frame::eof()); // EOF\r
\r
current_frame_ = nullptr;\r
});\r
auto format_desc = frame_processor_->get_video_format_desc();\r
bool is_progressive = format_desc.mode == video_mode::progressive || (flashax_container_->GetFPS() - format_desc.fps/2 == 0);\r
\r
- gpu_frame_ptr result;\r
+ producer_frame result;\r
\r
if(is_progressive) \r
result = do_receive(); \r
else\r
{\r
- gpu_frame_ptr frame1 = do_receive();\r
- gpu_frame_ptr frame2 = do_receive();\r
+ producer_frame frame1 = do_receive();\r
+ producer_frame frame2 = do_receive();\r
result = composite_frame::interlace(frame1, frame2, format_desc.mode);\r
}\r
\r
}\r
}\r
\r
- gpu_frame_ptr do_receive()\r
+ producer_frame do_receive()\r
{\r
auto format_desc = frame_processor_->get_video_format_desc();\r
\r
} \r
\r
auto frame = frame_processor_->create_frame(format_desc.width, format_desc.height);\r
- std::copy(current_frame_->data(), current_frame_->data() + current_frame_->size(), frame->data().begin());\r
+ std::copy(current_frame_->data(), current_frame_->data() + current_frame_->size(), frame->pixel_data().begin());\r
return frame;\r
}\r
\r
- gpu_frame_ptr receive()\r
+ producer_frame receive()\r
{ \r
- return (frame_buffer_.try_pop(last_frame_) || !is_empty_) && last_frame_ ? last_frame_ : empty_;\r
+ return (frame_buffer_.try_pop(last_frame_) || !is_empty_) ? last_frame_ : producer_frame::empty();\r
}\r
\r
void initialize(const frame_processor_device_ptr& frame_processor)\r
{\r
frame_processor_ = frame_processor;\r
auto format_desc = frame_processor_->get_video_format_desc();\r
- empty_ = frame_processor_->create_frame(pixel_format_desc());\r
bmp_frame_ = std::make_shared<bitmap>(format_desc.width, format_desc.height);\r
start(false);\r
}\r
\r
CComObject<flash::FlashAxContainer>* flashax_container_;\r
\r
- tbb::concurrent_bounded_queue<gpu_frame_ptr> frame_buffer_;\r
+ tbb::concurrent_bounded_queue<producer_frame> frame_buffer_;\r
\r
- gpu_frame_ptr empty_;\r
- gpu_frame_ptr last_frame_;\r
+ producer_frame last_frame_;\r
\r
bitmap_ptr current_frame_;\r
bitmap_ptr bmp_frame_;\r
};\r
\r
flash_producer::flash_producer(const std::wstring& filename) : impl_(new implementation(this, filename)){}\r
-gpu_frame_ptr flash_producer::receive(){return impl_->receive();}\r
+producer_frame 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
\r
flash_producer(const std::wstring& filename);\r
\r
- virtual gpu_frame_ptr receive();\r
+ virtual producer_frame receive();\r
virtual void initialize(const frame_processor_device_ptr& frame_processor);\r
virtual std::wstring print() const;\r
\r
virtual ~frame_producer(){} \r
\r
////////////////////////////////////////////////////////////////////////////////////////////////////\r
- /// \fn virtual gpu_frame_ptr :::receive() = 0;\r
+ /// \fn virtual producer_frame :::receive() = 0;\r
///\r
/// \brief Renders a frame.\r
/// \r
///\r
/// \return The frame. \r
////////////////////////////////////////////////////////////////////////////////////////////////////\r
- virtual gpu_frame_ptr receive() = 0;\r
+ virtual producer_frame receive() = 0;\r
\r
////////////////////////////////////////////////////////////////////////////////////////////////////\r
/// \fn virtual std::shared_ptr<frame_producer> :::get_following_producer() const\r
\r
#include "../format/video_format.h"\r
#include "../processor/composite_frame.h"\r
+#include "../processor/producer_frame.h"\r
\r
#include "../../common/utility/scope_exit.h"\r
+#include "../../common/concurrency/executor.h"\r
\r
#include <boost/thread.hpp>\r
#include <boost/range/algorithm_ext/erase.hpp>\r
\r
namespace caspar { namespace core {\r
\r
-std::vector<gpu_frame_ptr> receives(std::map<int, layer>& layers)\r
+std::vector<producer_frame> receives(std::map<int, layer>& layers)\r
{ \r
- std::vector<gpu_frame_ptr> frames(layers.size(), nullptr);\r
+ std::vector<producer_frame> frames(layers.size(), producer_frame::empty());\r
tbb::parallel_for(tbb::blocked_range<size_t>(0, frames.size()), \r
[&](const tbb::blocked_range<size_t>& r)\r
{\r
\r
struct frame_producer_device::implementation : boost::noncopyable\r
{ \r
- implementation(const frame_processor_device_ptr& frame_processor) \r
- : frame_processor_(frame_processor)\r
+ implementation(const frame_processor_device_ptr& frame_processor) : frame_processor_(frame_processor)\r
{\r
- render_thread_ = boost::thread([=]{run();});\r
+ executor_.start();\r
+ executor_.begin_invoke([=]{tick();});\r
}\r
- \r
- ~implementation()\r
- {\r
- is_running_ = false;\r
- render_thread_.join();\r
- }\r
- \r
- void run()\r
+ \r
+ void tick()\r
{ \r
- win32_exception::install_handler();\r
- \r
- is_running_ = true;\r
- while(is_running_)\r
+ try\r
+ { \r
+ frame_processor_->send(std::make_shared<composite_frame>(receives(layers_)));\r
+ }\r
+ catch(...)\r
{\r
- try\r
- { \r
- std::vector<gpu_frame_ptr> frames;\r
- {\r
- tbb::mutex::scoped_lock lock(layers_mutex_); \r
- frames = receives(layers_);\r
- } \r
- frame_processor_->send(std::make_shared<composite_frame>(frames));\r
- }\r
- catch(...)\r
- {\r
- try\r
- {\r
- CASPAR_LOG_CURRENT_EXCEPTION();\r
- layers_.clear();\r
- CASPAR_LOG(error) << "Unexpected exception. Cleared layers in render-device";\r
- }\r
- catch(...){}\r
- }\r
+ CASPAR_LOG_CURRENT_EXCEPTION();\r
+ layers_.clear();\r
+ CASPAR_LOG(error) << "Unexpected exception. Cleared layers in render-device";\r
}\r
+ executor_.begin_invoke([=]{tick();});\r
}\r
\r
void load(int render_layer, const frame_producer_ptr& producer, load_option::type option)\r
{\r
producer->initialize(frame_processor_);\r
- tbb::mutex::scoped_lock lock(layers_mutex_);\r
- layers_[render_layer].load(producer, option);\r
+ executor_.begin_invoke([=]\r
+ {\r
+ layers_[render_layer].load(producer, option);\r
+ });\r
}\r
\r
void pause(int render_layer)\r
{ \r
- tbb::mutex::scoped_lock lock(layers_mutex_);\r
- auto it = layers_.find(render_layer);\r
- if(it != layers_.end())\r
- it->second.pause(); \r
+ executor_.begin_invoke([=]\r
+ { \r
+ auto it = layers_.find(render_layer);\r
+ if(it != layers_.end())\r
+ it->second.pause(); \r
+ });\r
}\r
\r
void play(int render_layer)\r
{ \r
- tbb::mutex::scoped_lock lock(layers_mutex_);\r
- auto it = layers_.find(render_layer);\r
- if(it != layers_.end())\r
- it->second.play(); \r
+ executor_.begin_invoke([=]\r
+ {\r
+ auto it = layers_.find(render_layer);\r
+ if(it != layers_.end())\r
+ it->second.play(); \r
+ });\r
}\r
\r
void stop(int render_layer)\r
{ \r
- tbb::mutex::scoped_lock lock(layers_mutex_);\r
- auto it = layers_.find(render_layer);\r
- if(it != layers_.end())\r
- it->second.stop();\r
+ executor_.begin_invoke([=]\r
+ {\r
+ auto it = layers_.find(render_layer);\r
+ if(it != layers_.end())\r
+ {\r
+ it->second.stop();\r
+ if(!it->second.background())\r
+ layers_.erase(it);\r
+ }\r
+ });\r
}\r
\r
void clear(int render_layer)\r
{\r
- tbb::mutex::scoped_lock lock(layers_mutex_);\r
- auto it = layers_.find(render_layer);\r
- if(it != layers_.end())\r
- it->second.clear(); \r
+ executor_.begin_invoke([=]\r
+ { \r
+ auto it = layers_.find(render_layer);\r
+ if(it != layers_.end())\r
+ {\r
+ it->second.clear(); \r
+ layers_.erase(it);\r
+ }\r
+ });\r
}\r
\r
void clear()\r
{\r
- tbb::mutex::scoped_lock lock(layers_mutex_);\r
- layers_.clear();\r
+ executor_.begin_invoke([=]\r
+ { \r
+ layers_.clear();\r
+ });\r
} \r
\r
- frame_producer_ptr foreground(int render_layer) const\r
+ boost::unique_future<frame_producer_ptr> foreground(int render_layer) const\r
{\r
- tbb::mutex::scoped_lock lock(layers_mutex_);\r
- auto it = layers_.find(render_layer);\r
- return it != layers_.end() ? it->second.foreground() : nullptr;\r
+ return executor_.begin_invoke([=]() -> frame_producer_ptr\r
+ { \r
+ auto it = layers_.find(render_layer);\r
+ return it != layers_.end() ? it->second.foreground() : nullptr;\r
+ });\r
}\r
\r
- frame_producer_ptr background(int render_layer) const\r
+ boost::unique_future<frame_producer_ptr> background(int render_layer) const\r
{\r
- tbb::mutex::scoped_lock lock(layers_mutex_);\r
- auto it = layers_.find(render_layer);\r
- return it != layers_.end() ? it->second.background() : nullptr;\r
+ return executor_.begin_invoke([=]() -> frame_producer_ptr\r
+ {\r
+ auto it = layers_.find(render_layer);\r
+ return it != layers_.end() ? it->second.background() : nullptr;\r
+ });\r
}\r
+ mutable common::executor executor_;\r
\r
frame_processor_device_ptr frame_processor_;\r
-\r
- boost::thread render_thread_;\r
- \r
- mutable tbb::mutex layers_mutex_;\r
- std::map<int, layer> layers_;\r
- \r
- tbb::atomic<bool> is_running_; \r
+ \r
+ std::map<int, layer> layers_; \r
};\r
\r
frame_producer_device::frame_producer_device(const frame_processor_device_ptr& frame_processor) \r
void frame_producer_device::stop(int render_layer){impl_->stop(render_layer);}\r
void frame_producer_device::clear(int render_layer){impl_->clear(render_layer);}\r
void frame_producer_device::clear(){impl_->clear();}\r
-frame_producer_ptr frame_producer_device::foreground(int render_layer) const {return impl_->foreground(render_layer);}\r
-frame_producer_ptr frame_producer_device::background(int render_layer) const {return impl_->background(render_layer);}\r
+boost::unique_future<frame_producer_ptr> frame_producer_device::foreground(int render_layer) const {return impl_->foreground(render_layer);}\r
+boost::unique_future<frame_producer_ptr> frame_producer_device::background(int render_layer) const {return impl_->background(render_layer);}\r
}}\r
\r
#include "layer.h"\r
\r
+#include <boost/thread.hpp>\r
+\r
#include <functional>\r
\r
namespace caspar { namespace core {\r
void clear(int render_layer);\r
void clear();\r
\r
- frame_producer_ptr foreground(int render_layer) const;\r
- frame_producer_ptr background(int render_layer) const;\r
+ boost::unique_future<frame_producer_ptr> foreground(int render_layer) const;\r
+ boost::unique_future<frame_producer_ptr> background(int render_layer) const;\r
private:\r
struct implementation;\r
std::shared_ptr<implementation> impl_;\r
#include "image_loader.h"\r
\r
#include "../../processor/frame_processor_device.h"\r
+#include "../../processor/producer_frame.h"\r
#include "../../format/video_format.h"\r
#include "../../server.h"\r
\r
{\r
image_producer(const std::wstring& filename) : filename_(filename) {}\r
\r
- gpu_frame_ptr receive(){return frame_;}\r
+ producer_frame receive(){return frame_;}\r
\r
void initialize(const frame_processor_device_ptr& frame_processor)\r
{\r
auto bitmap = load_image(filename_);\r
FreeImage_FlipVertical(bitmap.get());\r
auto frame = frame_processor->create_frame(FreeImage_GetWidth(bitmap.get()), FreeImage_GetHeight(bitmap.get()));\r
- std::copy_n(FreeImage_GetBits(bitmap.get()), frame->data().size(), frame->data().begin());\r
+ std::copy_n(FreeImage_GetBits(bitmap.get()), frame->pixel_data().size(), frame->pixel_data().begin());\r
frame_ = frame;\r
}\r
\r
\r
frame_processor_device_ptr frame_processor_;\r
std::wstring filename_;\r
- gpu_frame_ptr frame_;\r
+ producer_frame frame_;\r
};\r
\r
frame_producer_ptr create_image_producer(const std::vector<std::wstring>& params)\r
\r
#include "image_loader.h"\r
\r
-#include "../../processor/write_frame.h"\r
+#include "../../processor/producer_frame.h"\r
#include "../../processor/composite_frame.h"\r
#include "../../format/video_format.h"\r
#include "../../processor/frame_processor_device.h"\r
std::copy_n(&pBits[i* width * 4], width * 4, &image_.get()[i * image_width_ * 4]);\r
}\r
\r
- gpu_frame_ptr do_receive()\r
+ producer_frame 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
+ std::fill(frame->pixel_data().begin(), frame->pixel_data().end(), 0);\r
\r
const int delta_x = direction_ == direction::Left ? speed_ : -speed_;\r
const int delta_y = direction_ == direction::Up ? speed_ : -speed_;\r
\r
- unsigned char* frame_data = frame->data().begin();\r
+ unsigned char* frame_data = frame->pixel_data().begin();\r
unsigned char* image_data = image_.get();\r
\r
if (direction_ == direction::Up || direction_ == direction::Down)\r
return frame;\r
}\r
\r
- gpu_frame_ptr receive()\r
+ producer_frame receive()\r
{ \r
if(format_desc_.mode != video_mode::progressive) \r
{\r
- gpu_frame_ptr frame1;\r
- gpu_frame_ptr frame2;\r
+ producer_frame frame1;\r
+ producer_frame frame2;\r
tbb::parallel_invoke([&]{ frame1 = do_receive(); }, [&]{ frame2 = do_receive(); });\r
return composite_frame::interlace(frame1, frame2, format_desc_.mode);\r
} \r
\r
#include "layer.h"\r
\r
+#include "../processor/producer_frame.h"\r
#include "../producer/frame_producer.h"\r
\r
#include "../format/video_format.h"\r
\r
struct layer::implementation\r
{ \r
- implementation() : foreground_(nullptr), background_(nullptr), last_frame_(nullptr) {}\r
+ implementation() : foreground_(nullptr), background_(nullptr), last_frame_(producer_frame::empty()) {}\r
\r
void load(const frame_producer_ptr& frame_producer, load_option::type option)\r
- {\r
- if(frame_producer == nullptr) \r
- BOOST_THROW_EXCEPTION(null_argument() << arg_name_info("frame_producer"));\r
- \r
+ { \r
background_ = frame_producer;\r
if(option == load_option::preview) \r
{\r
void stop()\r
{\r
foreground_ = nullptr;\r
- last_frame_ = nullptr;\r
+ last_frame_ = producer_frame::empty();\r
}\r
\r
void clear()\r
{\r
foreground_ = nullptr;\r
background_ = nullptr;\r
- last_frame_ = nullptr;\r
+ last_frame_ = producer_frame::empty();\r
}\r
\r
- gpu_frame_ptr receive()\r
+ producer_frame receive()\r
{ \r
if(!foreground_ || is_paused_)\r
return last_frame_;\r
{\r
last_frame_ = foreground_->receive();\r
\r
- if(last_frame_ == nullptr)\r
+ if(last_frame_ == producer_frame::eof())\r
{\r
CASPAR_LOG(info) << L"EOF: " << foreground_->print();\r
auto following = foreground_->get_following_producer();\r
CASPAR_LOG_CURRENT_EXCEPTION();\r
CASPAR_LOG(warning) << L"Removed " << (foreground_ ? foreground_->print() : L"empty") << L" from layer.";\r
foreground_ = nullptr;\r
- last_frame_ = nullptr;\r
+ last_frame_ = producer_frame::empty();\r
}\r
catch(...){}\r
}\r
} \r
\r
tbb::atomic<bool> is_paused_;\r
- gpu_frame_ptr last_frame_;\r
+ producer_frame last_frame_;\r
frame_producer_ptr foreground_;\r
frame_producer_ptr background_;\r
};\r
void layer::pause(){impl_->pause();}\r
void layer::stop(){impl_->stop();}\r
void layer::clear(){impl_->clear();}\r
-gpu_frame_ptr layer::receive() {return impl_->receive();}\r
+producer_frame 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
frame_producer_ptr foreground() const;\r
frame_producer_ptr background() const;\r
\r
- gpu_frame_ptr receive();\r
+ producer_frame receive();\r
private:\r
struct implementation;\r
std::shared_ptr<implementation> impl_;\r
#include "transition_producer.h"\r
\r
#include "../../format/video_format.h"\r
+#include "../../processor/producer_frame.h"\r
#include "../../processor/composite_frame.h"\r
#include "../../processor/transform_frame.h"\r
#include "../../processor/frame_processor_device.h"\r
org_source_producer_ = source_producer_ = producer;\r
}\r
\r
- gpu_frame_ptr receive()\r
+ producer_frame receive()\r
{\r
if(current_frame_ == 0)\r
CASPAR_LOG(info) << "Transition started.";\r
\r
- gpu_frame_ptr result = [&]() -> gpu_frame_ptr\r
+ producer_frame result = [&]() -> producer_frame\r
{\r
if(current_frame_++ >= info_.duration)\r
- return nullptr;\r
+ return producer_frame::eof();\r
\r
- gpu_frame_ptr source;\r
- gpu_frame_ptr dest;\r
+ producer_frame source;\r
+ producer_frame dest;\r
\r
tbb::parallel_invoke\r
(\r
return compose(dest, source);\r
}();\r
\r
- if(!result)\r
+ if(result == producer_frame::eof())\r
CASPAR_LOG(info) << "Transition ended.";\r
\r
return result;\r
}\r
\r
- gpu_frame_ptr receive(frame_producer_ptr& producer)\r
+ producer_frame receive(frame_producer_ptr& producer)\r
{\r
if(!producer)\r
- return nullptr;\r
+ return producer_frame::eof();\r
\r
- gpu_frame_ptr frame;\r
+ producer_frame frame = producer_frame::eof();\r
try\r
{\r
frame = producer->receive();\r
CASPAR_LOG(warning) << "Removed producer from transition.";\r
}\r
\r
- if(frame == nullptr)\r
+ if(frame == producer_frame::eof())\r
{\r
if(!producer || !producer->get_following_producer())\r
- return nullptr;\r
+ return producer_frame::eof();\r
\r
try\r
{\r
return frame;\r
}\r
\r
- gpu_frame_ptr compose(gpu_frame_ptr dest_frame, gpu_frame_ptr src_frame) \r
+ producer_frame compose(producer_frame dest_frame, producer_frame src_frame) \r
{ \r
- if(!dest_frame && !src_frame)\r
- return nullptr;\r
+ if(dest_frame == producer_frame::eof() && src_frame == producer_frame::eof())\r
+ return producer_frame::eof();\r
\r
if(info_.type == transition::cut) \r
return src_frame;\r
};\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::receive(){return impl_->receive();}\r
+producer_frame 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
public:\r
transition_producer(const frame_producer_ptr& destination, const transition_info& info);\r
\r
- gpu_frame_ptr receive();\r
+ producer_frame receive();\r
\r
frame_producer_ptr get_following_producer() const;\r
void set_leading_producer(const frame_producer_ptr& producer);\r
\r
void GenerateChannelInfo(int index, const channel_ptr& pChannel, std::wstringstream& replyString)\r
{\r
- replyString << index << TEXT(" ") << pChannel->get_video_format_desc().name << TEXT("\r\n") << (pChannel->foreground(0) != nullptr ? TEXT(" PLAYING") : TEXT(" STOPPED"));\r
+ replyString << index << TEXT(" ") << pChannel->get_video_format_desc().name << TEXT("\r\n") << (pChannel->foreground(0).get() != nullptr ? TEXT(" PLAYING") : TEXT(" STOPPED"));\r
}\r
\r
bool InfoCommand::DoExecute()\r
projects / casparcg / commitdiff