{ \r
typedef decltype(func()) result_type; \r
\r
- auto task = std::make_shared<boost::packaged_task<result_type>>(std::forward<Func>(func)); // boost::packaged_task cannot be moved, need to used shared_ptr.\r
+ auto task = std::make_shared<boost::packaged_task<result_type>>(std::forward<Func>(func)); // boost::packaged_task cannot be moved into lambda, need to used shared_ptr.\r
auto future = task->get_future();\r
\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
GL(glBindTexture(GL_TEXTURE_2D, texture_));\r
}\r
\r
- void begin_write()\r
+ void unmap_write()\r
{\r
bind_pbo(GL_PIXEL_UNPACK_BUFFER);\r
if(mapped_)\r
writing_ = true;\r
}\r
\r
- void* end_write()\r
+ void* map_write()\r
{\r
if(mapped_)\r
{\r
return data_;\r
}\r
\r
- void begin_read()\r
+ void unmap_read()\r
{ \r
bind_pbo(GL_PIXEL_PACK_BUFFER);\r
if(mapped_)\r
reading_ = true;\r
}\r
\r
- void* end_read()\r
+ void* map_read()\r
{\r
if(mapped_)\r
{\r
}\r
void* pixel_buffer_object::data(){return impl_->data_;}\r
const void* pixel_buffer_object::data() const{return impl_->data_;}\r
-void pixel_buffer_object::begin_write() { impl_->begin_write();}\r
-void* pixel_buffer_object::end_write() {return impl_->end_write();} \r
-void pixel_buffer_object::begin_read() { impl_->begin_read();}\r
-void* pixel_buffer_object::end_read(){return impl_->end_read();}\r
+void pixel_buffer_object::unmap_write() { impl_->unmap_write();}\r
+void* pixel_buffer_object::map_write() {return impl_->map_write();} \r
+void pixel_buffer_object::unmap_read() { impl_->unmap_read();}\r
+void* pixel_buffer_object::map_read(){return impl_->map_read();}\r
void pixel_buffer_object::bind_texture() {impl_->bind_texture();}\r
size_t pixel_buffer_object::width() const {return impl_->width_;}\r
size_t pixel_buffer_object::height() const {return impl_->height_;}\r
void create(size_t width, size_t height, GLenum format = GL_BGRA);\r
~pixel_buffer_object(){}\r
\r
- void begin_write();\r
- void* end_write();\r
+ void unmap_write();\r
+ void* map_write();\r
\r
- void begin_read();\r
- void* end_read();\r
+ void unmap_read();\r
+ void* map_read();\r
\r
void is_smooth(bool smooth);\r
\r
// AsyncEventServer constructor\r
// PARAMS: port(TCP-port the server should listen to)\r
// COMMENT: Initializes the WinSock2 library\r
-AsyncEventServer::AsyncEventServer(const ProtocolStrategyPtr& pProtocol, int port) : port_(port), pProtocolStrategy_(pProtocol)\r
+AsyncEventServer::AsyncEventServer(const safe_ptr<IProtocolStrategy>& pProtocol, int port) : port_(port), pProtocolStrategy_(pProtocol)\r
{\r
if(instanceCount_ == 0) {\r
WSADATA wsaData;\r
return true;\r
}\r
\r
- if(pProtocolStrategy_ != 0) {\r
- //Convert to widechar\r
- if(ConvertMultiByteToWideChar(pProtocolStrategy_->GetCodepage(), pSI->recvBuffer_, recvResult + pSI->recvLeftoverOffset_, pSI->wideRecvBuffer_, pSI->recvLeftoverOffset_))\r
- pProtocolStrategy_->Parse(&pSI->wideRecvBuffer_[0], pSI->wideRecvBuffer_.size(), pSI);\r
- else\r
- {\r
- CASPAR_LOG(error) << "Read from " << pSI->host_.c_str() << TEXT(" failed, could not convert command to UNICODE");\r
- }\r
- }\r
+ //Convert to widechar\r
+ if(ConvertMultiByteToWideChar(pProtocolStrategy_->GetCodepage(), pSI->recvBuffer_, recvResult + pSI->recvLeftoverOffset_, pSI->wideRecvBuffer_, pSI->recvLeftoverOffset_))\r
+ pProtocolStrategy_->Parse(&pSI->wideRecvBuffer_[0], pSI->wideRecvBuffer_.size(), pSI);\r
+ else \r
+ CASPAR_LOG(error) << "Read from " << pSI->host_.c_str() << TEXT(" failed, could not convert command to UNICODE");\r
+ \r
+ \r
\r
maxRecvLength = sizeof(pSI->recvBuffer_)-pSI->recvLeftoverOffset_;\r
recvResult = recv(pSI->socket_, pSI->recvBuffer_+pSI->recvLeftoverOffset_, maxRecvLength, 0);\r
#pragma once\r
#endif\r
\r
+#include "../utility/safe_ptr.h"\r
+\r
#include <string>\r
#include <map>\r
#include <vector>\r
AsyncEventServer& operator=(const AsyncEventServer&);\r
\r
public:\r
- explicit AsyncEventServer(const ProtocolStrategyPtr& pProtocol, int port);\r
+ explicit AsyncEventServer(const safe_ptr<IProtocolStrategy>& pProtocol, int port);\r
~AsyncEventServer();\r
\r
bool Start();\r
- void SetProtocolStrategy(ProtocolStrategyPtr pPS) {\r
+ void SetProtocolStrategy(safe_ptr<IProtocolStrategy> pPS) {\r
pProtocolStrategy_ = pPS;\r
}\r
\r
void OnError(HANDLE waitEvent, int errorCode);\r
\r
SocketInfoPtr pListenSocketInfo_;\r
- ProtocolStrategyPtr pProtocolStrategy_;\r
+ safe_ptr<IProtocolStrategy> pProtocolStrategy_;\r
int port_;\r
\r
friend class SocketInfo;\r
#include <string>\r
#include "clientInfo.h"\r
\r
-namespace caspar {\r
-namespace IO {\r
+namespace caspar { namespace IO {\r
\r
class IProtocolStrategy\r
{\r
public:\r
- virtual ~IProtocolStrategy()\r
- {}\r
+ virtual ~IProtocolStrategy(){}\r
\r
virtual void Parse(const wchar_t* pData, int charCount, ClientInfoPtr pClientInfo) = 0;\r
virtual unsigned int GetCodepage() = 0;\r
};\r
\r
-typedef std::tr1::shared_ptr<IProtocolStrategy> ProtocolStrategyPtr;\r
-\r
-} //namespace IO\r
-} //namespace caspar
\ No newline at end of file
+}} //namespace caspar
\ No newline at end of file
safe_ptr() : impl_(std::make_shared<T>()){static_assert(!std::is_abstract<T>::value, "Cannot construct abstract class.");} \r
\r
safe_ptr(const safe_ptr<T>& other) : impl_(other.impl_){}\r
+ safe_ptr(safe_ptr&& other) : impl_(other.impl_) {} // Move doesn't move.\r
\r
template<typename Y>\r
safe_ptr(const safe_ptr<Y>& other, typename std::enable_if<std::is_convertible<Y*, T*>::value, void*>::type = 0) : impl_(other.impl_){}\r
template<typename Y> \r
safe_ptr(Y&& impl, typename std::enable_if<std::is_convertible<typename std::add_pointer<Y>::type, typename std::add_pointer<T>::type>::value, void>::type* = 0)\r
: impl_(std::make_shared<Y>(std::forward<Y>(impl))) {}\r
+ \r
+ template<typename Y> \r
+ explicit safe_ptr(const std::shared_ptr<Y>& impl, typename std::enable_if<std::is_convertible<Y*, T*>::value, void*>::type = 0) : impl_(impl)\r
+ {\r
+ if(!impl_)\r
+ BOOST_THROW_EXCEPTION(null_argument() << msg_info("impl"));\r
+ }\r
+ \r
+ template<typename Y> \r
+ explicit safe_ptr(std::shared_ptr<Y>&& impl, typename std::enable_if<std::is_convertible<Y*, T*>::value, void*>::type = 0) : impl_(std::move(impl))\r
+ {\r
+ if(!impl_)\r
+ BOOST_THROW_EXCEPTION(null_argument() << msg_info("impl"));\r
+ }\r
\r
template<typename Y>\r
typename std::enable_if<std::is_convertible<Y*, T*>::value, safe_ptr<T>&>::type\r
\r
void swap(safe_ptr& other) { impl_.swap(other.impl_); } \r
\r
- std::shared_ptr<T> get_shared() const { return impl_; }\r
-\r
- static safe_ptr<T> from_shared(const std::shared_ptr<T>& impl) { return safe_ptr<T>(impl); }\r
-\r
-private: \r
+ std::shared_ptr<T> get_shared() const { return impl_; }\r
\r
- template<typename Y> \r
- safe_ptr(const std::shared_ptr<Y>& impl, typename std::enable_if<std::is_convertible<Y*, T*>::value, void*>::type = 0) : impl_(impl)\r
- {\r
- if(!impl)\r
- BOOST_THROW_EXCEPTION(null_argument() << msg_info("impl"));\r
- }\r
-\r
+private: \r
std::shared_ptr<T> impl_;\r
};\r
\r
safe_ptr<T> make_safe(P0&& p0)\r
{\r
static_assert(!std::is_abstract<T>::value, "Cannot construct abstract class.");\r
- return safe_ptr<T>(
T(std::forward<P0>(p0)));
\r+ return safe_ptr<T>(
std::make_shared<T>(std::forward<P0>(p0)));
\r }\r
\r
template<typename T, typename P0, typename P1>\r
safe_ptr<T> make_safe(P0&& p0, P1&& p1)\r
{\r
static_assert(!std::is_abstract<T>::value, "Cannot construct abstract class.");\r
- return safe_ptr<T>(
T(std::forward<P0>(p0), std::forward<P1>(p1)));
\r+ return safe_ptr<T>(
std::make_shared<T>(std::forward<P0>(p0), std::forward<P1>(p1)));
\r }\r
\r
template<typename T, typename P0, typename P1, typename P2>\r
safe_ptr<T> make_safe(P0&& p0, P1&& p1, P2&& p2)\r
{\r
static_assert(!std::is_abstract<T>::value, "Cannot construct abstract class.");\r
- return safe_ptr<T>(
T(std::forward<P0>(p0), std::forward<P1>(p1), std::forward<P2>(p2)));
\r+ return safe_ptr<T>(
std::make_shared<T>(std::forward<P0>(p0), std::forward<P1>(p1), std::forward<P2>(p2)));
\r }\r
\r
}
\ No newline at end of file
struct channel::implementation : boost::noncopyable\r
{\r
public:\r
- implementation(const frame_producer_device_ptr& producer_device, const frame_processor_device_ptr& processor_device, const frame_consumer_device_ptr& consumer_device)\r
+ implementation(const safe_ptr<frame_producer_device>& producer_device, const safe_ptr<frame_processor_device>& processor_device, const safe_ptr<frame_consumer_device>& consumer_device)\r
: producer_device_(producer_device), processor_device_(processor_device), consumer_device_(consumer_device)\r
{\r
}\r
}\r
\r
private:\r
- const frame_processor_device_ptr processor_device_; // Destroyed last inorder to have all frames returned to their pools.\r
- const frame_producer_device_ptr producer_device_;\r
- const frame_consumer_device_ptr consumer_device_;\r
+ const safe_ptr<frame_processor_device> processor_device_; // Destroyed last inorder to have all frames returned to their pools.\r
+ const safe_ptr<frame_producer_device> producer_device_;\r
+ const safe_ptr<frame_consumer_device> consumer_device_;\r
};\r
\r
-channel::channel(const frame_producer_device_ptr& producer_device, const frame_processor_device_ptr& processor_device, const frame_consumer_device_ptr& consumer_device)\r
+channel::channel(channel&& other) : impl_(std::move(other.impl_)){}\r
+channel::channel(const safe_ptr<frame_producer_device>& producer_device, const safe_ptr<frame_processor_device>& processor_device, const safe_ptr<frame_consumer_device>& consumer_device)\r
: impl_(new implementation(producer_device, processor_device, consumer_device)){}\r
void channel::load(int render_layer, const safe_ptr<frame_producer>& producer, load_option::type option){impl_->load(render_layer, producer, option);}\r
void channel::pause(int render_layer){impl_->pause(render_layer);}\r
class channel : boost::noncopyable\r
{\r
public:\r
- channel(const frame_producer_device_ptr& producer_device, const frame_processor_device_ptr& processor_device, const frame_consumer_device_ptr& consumer_device);\r
+ channel(channel&& other);\r
+ channel(const safe_ptr<frame_producer_device>& producer_device, const safe_ptr<frame_processor_device>& processor_device, const safe_ptr<frame_consumer_device>& consumer_device);\r
\r
void load(int render_layer, const safe_ptr<frame_producer>& producer, load_option::type option = load_option::none);\r
void pause(int render_layer);\r
struct implementation;\r
std::shared_ptr<implementation> impl_;\r
};\r
-typedef std::shared_ptr<channel> channel_ptr;\r
\r
}}
\ No newline at end of file
CASPAR_LOG(error) << "BLUECARD ERROR: Failed to disable video output. (device " << device_index_ << TEXT(")"); \r
}\r
\r
- void send(const safe_ptr<read_frame>& frame)\r
+ void send(const safe_ptr<const read_frame>& frame)\r
{ \r
static size_t audio_samples = 1920;\r
static size_t audio_nchannels = 2;\r
unsigned long res_fmt_; \r
unsigned long engine_mode_;\r
\r
- boost::optional<safe_ptr<read_frame>> transferring_frame_;\r
+ boost::optional<safe_ptr<const read_frame>> transferring_frame_;\r
\r
std::array<page_locked_buffer_ptr, 3> hanc_buffers_;\r
int current_id_;\r
bool embed_audio_;\r
};\r
\r
+consumer::consumer(consumer&& other) : impl_(std::move(other.impl_)){}\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
-void consumer::send(const safe_ptr<read_frame>& frame){impl_->send(frame);}\r
+void consumer::send(const safe_ptr<const read_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
class consumer : public frame_consumer\r
{\r
public:\r
+ consumer(consumer&& other);\r
consumer(const video_format_desc& format_desc, unsigned int deviceIndex, bool embed_audio = false);\r
\r
- virtual void send(const safe_ptr<read_frame>&);\r
+ virtual void send(const safe_ptr<const read_frame>&);\r
virtual sync_mode synchronize();\r
virtual size_t buffer_depth() const;\r
private:\r
CoUninitialize();\r
}\r
\r
- void send(const safe_ptr<read_frame>& frame)\r
+ void send(const safe_ptr<const read_frame>& frame)\r
{\r
active_ = executor_.begin_invoke([=]\r
{ \r
};\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 safe_ptr<read_frame>& frame){pImpl_->send(frame);}\r
+void decklink_consumer::send(const safe_ptr<const read_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
public:\r
explicit decklink_consumer(const video_format_desc& format_desc, bool internalKey = false);\r
\r
- virtual void send(const safe_ptr<read_frame>&);\r
+ virtual void send(const safe_ptr<const read_frame>&);\r
virtual sync_mode synchronize();\r
virtual size_t buffer_depth() const;\r
private:\r
\r
virtual ~frame_consumer() {}\r
\r
- virtual void send(const safe_ptr<read_frame>& frame) = 0;\r
+ virtual void send(const safe_ptr<const read_frame>& frame) = 0;\r
virtual sync_mode synchronize() = 0;\r
virtual size_t buffer_depth() const = 0;\r
};\r
struct frame_consumer_device::implementation\r
{\r
public:\r
- implementation(const frame_processor_device_ptr& frame_processor, const video_format_desc& format_desc, const std::vector<frame_consumer_ptr>& consumers) \r
+ implementation(const safe_ptr<frame_processor_device>& frame_processor, const video_format_desc& format_desc, const std::vector<safe_ptr<frame_consumer>>& consumers) \r
: frame_processor_(frame_processor), consumers_(consumers), fmt_(format_desc)\r
{ \r
std::vector<size_t> depths;\r
executor_.begin_invoke([=]{tick();});\r
}\r
\r
- void process(const safe_ptr<read_frame>& frame)\r
+ void process(const safe_ptr<const read_frame>& frame)\r
{ \r
buffer_.push_back(frame);\r
\r
clock_sync clock;\r
\r
- boost::range::for_each(consumers_, [&](const frame_consumer_ptr& consumer)\r
+ boost::range::for_each(consumers_, [&](const safe_ptr<frame_consumer>& consumer)\r
{\r
size_t offset = max_depth_ - consumer->buffer_depth();\r
if(offset < buffer_.size())\r
});\r
\r
frame_consumer::sync_mode sync = frame_consumer::ready;\r
- boost::range::for_each(consumers_, [&](const frame_consumer_ptr& consumer)\r
+ boost::range::for_each(consumers_, [&](const safe_ptr<frame_consumer>& consumer)\r
{\r
try\r
{\r
executor executor_; \r
\r
size_t max_depth_;\r
- std::deque<safe_ptr<read_frame>> buffer_; \r
+ std::deque<safe_ptr<const read_frame>> buffer_; \r
\r
- std::vector<frame_consumer_ptr> consumers_;\r
+ std::vector<safe_ptr<frame_consumer>> consumers_;\r
\r
- frame_processor_device_ptr frame_processor_;\r
+ safe_ptr<frame_processor_device> frame_processor_;\r
\r
const video_format_desc& fmt_;\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
+frame_consumer_device::frame_consumer_device(frame_consumer_device&& other) : impl_(std::move(other.impl_)){}\r
+frame_consumer_device::frame_consumer_device(const safe_ptr<frame_processor_device>& frame_processor, const video_format_desc& format_desc, const std::vector<safe_ptr<frame_consumer>>& consumers)\r
: impl_(new implementation(frame_processor, format_desc, consumers)){}\r
}}
\ No newline at end of file
namespace caspar { namespace core {\r
\r
class frame_processor_device;\r
-typedef std::shared_ptr<frame_processor_device> frame_processor_device_ptr;\r
\r
class frame_consumer_device : boost::noncopyable\r
{\r
public:\r
- frame_consumer_device(const frame_processor_device_ptr& frame_processor, const video_format_desc& format_desc, const std::vector<frame_consumer_ptr>& consumers);\r
+ frame_consumer_device(frame_consumer_device&& other);\r
+ frame_consumer_device(const safe_ptr<frame_processor_device>& frame_processor, const video_format_desc& format_desc, const std::vector<safe_ptr<frame_consumer>>& consumers);\r
private:\r
struct implementation;\r
std::shared_ptr<implementation> impl_;\r
};\r
-typedef std::shared_ptr<frame_consumer_device> frame_consumer_device_ptr;\r
\r
}}
\ No newline at end of file
Stop();\r
}\r
\r
- void send(const safe_ptr<read_frame>& frame)\r
+ void send(const safe_ptr<const read_frame>& frame)\r
{ \r
input_.push(frame->audio_data()); \r
\r
boost::circular_buffer<std::vector<short>> container_;\r
};\r
\r
+consumer::consumer(consumer&& other) : impl_(std::move(other.impl_)){}\r
consumer::consumer(const video_format_desc&) : impl_(new implementation()){}\r
-void consumer::send(const safe_ptr<read_frame>& frame){impl_->send(frame);}\r
+void consumer::send(const safe_ptr<const read_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
class consumer : public frame_consumer\r
{\r
public: \r
+ consumer(consumer&& other);\r
explicit consumer(const video_format_desc& format_desc);\r
\r
- virtual void send(const safe_ptr<read_frame>&);\r
+ virtual void send(const safe_ptr<const read_frame>&);\r
virtual sync_mode synchronize();\r
virtual size_t buffer_depth() const;\r
private:\r
return std::make_pair(width, height);\r
}\r
\r
- void render(const safe_ptr<read_frame>& frame)\r
+ void render(const safe_ptr<const read_frame>& frame)\r
{ \r
- auto ptr = pbos_.front().end_write();\r
+ auto ptr = pbos_.front().map_write();\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
glTexCoord2f(0.0f, 0.0f); glVertex2f(-wSize_, hSize_);\r
glEnd();\r
\r
- pbos_.back().begin_write();\r
+ pbos_.back().unmap_write();\r
\r
std::rotate(pbos_.begin(), pbos_.begin() + 1, pbos_.end());\r
}\r
\r
- void send(const safe_ptr<read_frame>& frame)\r
+ void send(const safe_ptr<const read_frame>& frame)\r
{\r
active_ = executor_.begin_invoke([=]\r
{\r
sf::Window window_;\r
};\r
\r
+consumer::consumer(consumer&& other) : impl_(std::move(other.impl_)){}\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
-void consumer::send(const safe_ptr<read_frame>& frame){impl_->send(frame);}\r
+void consumer::send(const safe_ptr<const read_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
class consumer : public frame_consumer\r
{\r
public: \r
+ consumer(consumer&& other);\r
explicit consumer(const video_format_desc& format_desc, unsigned int screen_index = 0, stretch stretch = stretch::fill, bool windowed = false);\r
\r
- virtual void send(const safe_ptr<read_frame>&);\r
+ virtual void send(const safe_ptr<const read_frame>&);\r
virtual sync_mode synchronize();\r
virtual size_t buffer_depth() const;\r
private:\r
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../stdAfx.h</PrecompiledHeaderFile>\r
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../stdAfx.h</PrecompiledHeaderFile>\r
</ClCompile>\r
- <ClCompile Include="producer\frame_producer.cpp">\r
- <PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../StdAfx.h</PrecompiledHeaderFile>\r
- <PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../StdAfx.h</PrecompiledHeaderFile>\r
- </ClCompile>\r
<ClCompile Include="producer\image\image_loader.cpp">\r
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">../../StdAfx.h</PrecompiledHeaderFile>\r
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../StdAfx.h</PrecompiledHeaderFile>\r
<ClCompile Include="producer\ffmpeg\input.cpp">\r
<Filter>Source\channel\producer\ffmpeg\io</Filter>\r
</ClCompile>\r
- <ClCompile Include="producer\frame_producer.cpp">\r
- <Filter>Source\channel\producer</Filter>\r
- </ClCompile>\r
<ClCompile Include="format\pixel_format.cpp">\r
<Filter>Source\channel\format</Filter>\r
</ClCompile>\r
\r
namespace caspar { namespace core {\r
\r
-struct composite_frame::implementation\r
+struct composite_frame::implementation : public draw_frame_decorator\r
{ \r
implementation(std::vector<safe_ptr<draw_frame>>&& frames) : frames_(std::move(frames))\r
{ \r
});\r
}\r
\r
- void begin_write()\r
+ void prepare()\r
{\r
- boost::range::for_each(frames_, std::bind(&draw_frame::begin_write, std::placeholders::_1));\r
+ boost::range::for_each(frames_, std::bind(&draw_frame_decorator::prepare, std::placeholders::_1));\r
}\r
-\r
- void end_write()\r
- {\r
- boost::range::for_each(frames_, std::bind(&draw_frame::end_write, std::placeholders::_1));\r
- }\r
- \r
+ \r
void draw(frame_shader& shader)\r
{\r
- boost::range::for_each(frames_, std::bind(&draw_frame::draw, std::placeholders::_1, std::ref(shader)));\r
+ boost::range::for_each(frames_, std::bind(&draw_frame_decorator::draw, std::placeholders::_1, std::ref(shader)));\r
}\r
\r
- const std::vector<short>& audio_data()\r
+ const std::vector<short>& audio_data() const\r
{\r
static std::vector<short> no_audio;\r
return !audio_data_.empty() ? audio_data_ : (!frames_.empty() ? frames_.front()->audio_data() : no_audio);\r
impl_.reset(new implementation(std::move(frames)));\r
}\r
\r
-void composite_frame::begin_write(){impl_->begin_write();}\r
-void composite_frame::end_write(){impl_->end_write();} \r
+void composite_frame::prepare(){impl_->prepare();}\r
void composite_frame::draw(frame_shader& shader){impl_->draw(shader);}\r
const std::vector<short>& composite_frame::audio_data() const {return impl_->audio_data();}\r
\r
virtual const std::vector<short>& audio_data() const;\r
\r
private: \r
- virtual void begin_write();\r
- virtual void end_write();\r
+ virtual void prepare();\r
virtual void draw(frame_shader& shader);\r
\r
struct implementation;\r
\r
namespace caspar { namespace core {\r
\r
+struct draw_frame_decorator;\r
+\r
class draw_frame : boost::noncopyable\r
{ \r
+ friend struct draw_frame_decorator;\r
+ friend class frame_renderer;\r
public:\r
virtual ~draw_frame(){}\r
\r
virtual const std::vector<short>& audio_data() const = 0; \r
- virtual void begin_write() = 0;\r
- virtual void end_write() = 0;\r
- virtual void draw(frame_shader& shader) = 0;\r
\r
static safe_ptr<draw_frame> eof()\r
{\r
static std::vector<short> audio_data;\r
return audio_data;\r
}\r
- virtual void begin_write(){}\r
- virtual void end_write(){}\r
+ virtual void prepare(){}\r
virtual void draw(frame_shader&){}\r
};\r
static safe_ptr<draw_frame> frame = make_safe<eof_frame>();\r
static std::vector<short> audio_data;\r
return audio_data;\r
}\r
- virtual void begin_write(){}\r
- virtual void end_write(){}\r
+ virtual void prepare(){}\r
virtual void draw(frame_shader&){}\r
};\r
static safe_ptr<draw_frame> frame = make_safe<empty_frame>();\r
return frame;\r
}\r
+private:\r
+ virtual void prepare() = 0;\r
+ virtual void draw(frame_shader& shader) = 0;\r
+};\r
+\r
+struct draw_frame_decorator\r
+{\r
+protected:\r
+ static void prepare(const safe_ptr<draw_frame>& frame) {frame->prepare();}\r
+ static void draw(const safe_ptr<draw_frame>& frame, frame_shader& shader) {frame->draw(shader);}\r
};\r
\r
\r
#include "../../common/concurrency/executor.h"\r
#include "../../common/gl/utility.h"\r
\r
-#include <Glee.h>\r
-#include <SFML/Window.hpp>\r
-\r
#include <tbb/concurrent_queue.h>\r
#include <tbb/concurrent_unordered_map.h>\r
#include <tbb/concurrent_vector.h>\r
executor_.start();\r
executor_.invoke([=]\r
{\r
- ogl_context_.reset(new sf::Context());\r
- ogl_context_->SetActive(true);\r
-\r
renderer_.reset(new frame_renderer(format_desc));\r
});\r
}\r
\r
- void send(const safe_ptr<draw_frame>& frame)\r
+ void send(safe_ptr<draw_frame>&& frame)\r
{ \r
- auto future = executor_.begin_invoke([=]{return renderer_->render(frame);}); \r
+ auto future = executor_.begin_invoke([=]() -> safe_ptr<const read_frame>\r
+ {\r
+ return renderer_->render(safe_ptr<draw_frame>(frame));\r
+ }); \r
output_.push(std::move(future)); // Blocks\r
}\r
\r
- safe_ptr<read_frame> receive()\r
+ safe_ptr<const read_frame> receive()\r
{\r
- boost::shared_future<safe_ptr<read_frame>> future;\r
+ boost::shared_future<safe_ptr<const read_frame>> future;\r
\r
if(!output_.try_pop(future))\r
{\r
{\r
executor_.begin_invoke([=]\r
{\r
- frame->reset();\r
+ frame->audio_data().clear();\r
pool->push(frame);\r
});\r
});\r
\r
- return safe_ptr<write_frame>::from_shared(frame);\r
+ return safe_ptr<write_frame>(frame);\r
}\r
\r
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<safe_ptr<read_frame>>> output_; \r
+ tbb::concurrent_bounded_queue<boost::shared_future<safe_ptr<const read_frame>>> output_; \r
\r
tbb::concurrent_unordered_map<pixel_format_desc, tbb::concurrent_bounded_queue<std::shared_ptr<write_frame>>, std::hash<pixel_format_desc>> pools_;\r
\r
long underrun_count_;\r
};\r
\r
+frame_processor_device::frame_processor_device(frame_processor_device&& other) : impl_(std::move(other.impl_)){}\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 safe_ptr<draw_frame>& frame){impl_->send(std::move(frame));}\r
-safe_ptr<read_frame> frame_processor_device::receive(){return impl_->receive();}\r
+void frame_processor_device::send(safe_ptr<draw_frame>&& frame){impl_->send(std::move(frame));}\r
+safe_ptr<const read_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
safe_ptr<write_frame> frame_processor_device::create_frame(const pixel_format_desc& desc){ return impl_->create_frame(desc); } \r
class frame_processor_device : boost::noncopyable\r
{\r
public:\r
+ frame_processor_device(frame_processor_device&& other);\r
frame_processor_device(const video_format_desc& format_desc);\r
\r
- void send(const safe_ptr<draw_frame>& frame);\r
- safe_ptr<read_frame> receive();\r
+ void send(safe_ptr<draw_frame>&& frame);\r
+ safe_ptr<const read_frame> receive();\r
\r
safe_ptr<write_frame> create_frame(const pixel_format_desc& desc); \r
safe_ptr<write_frame> create_frame(size_t width, size_t height); \r
struct implementation;\r
std::shared_ptr<implementation> impl_;\r
};\r
-typedef std::shared_ptr<frame_processor_device> frame_processor_device_ptr;\r
\r
}}
\ No newline at end of file
#include "frame_shader.h"\r
#include "write_frame.h"\r
#include "read_frame.h"\r
-#include "draw_frame.h"\r
-#include "read_frame.h"\r
\r
#include "../format/video_format.h"\r
\r
#include "../../common/gl/frame_buffer_object.h"\r
\r
#include <Glee.h>\r
+#include <SFML/Window.hpp>\r
\r
#include <tbb/concurrent_queue.h>\r
\r
\r
namespace caspar { namespace core {\r
\r
+struct ogl_context\r
+{\r
+ ogl_context(){context_.SetActive(true);};\r
+ sf::Context context_;\r
+};\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_(create_reading()), fbo_(format_desc.width, format_desc.height), writing_(draw_frame::empty()), drawing_(draw_frame::empty())\r
+ fbo_(format_desc.width, format_desc.height), writing_(draw_frame::empty()), reading_(create_reading())\r
{ \r
GL(glEnable(GL_POLYGON_STIPPLE));\r
GL(glEnable(GL_TEXTURE_2D));\r
GL(glDisable(GL_DEPTH_TEST));\r
GL(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)); \r
GL(glViewport(0, 0, format_desc.width, format_desc.height));\r
- reading_->begin_read();\r
+ reading_->unmap();\r
}\r
\r
- safe_ptr<read_frame> render(const safe_ptr<draw_frame>& frame)\r
- {\r
- safe_ptr<read_frame> result = create_reading();\r
- try\r
- {\r
- drawing_ = writing_;\r
- writing_ = frame;\r
- \r
- writing_->begin_write();\r
- \r
- reading_->end_read();\r
+ safe_ptr<const read_frame> render(safe_ptr<draw_frame>&& frame)\r
+ { \r
+ frame->prepare(); // Start transfer from system memory to texture. End in next tick.\r
\r
- GL(glClear(GL_COLOR_BUFFER_BIT));\r
+ reading_->map(); // Map texture to system memory.\r
+ auto result = reading_;\r
\r
- drawing_->draw(shader_);\r
- \r
- result.swap(reading_);\r
- reading_->begin_read();\r
- reading_->audio_data(drawing_->audio_data());\r
+ GL(glClear(GL_COLOR_BUFFER_BIT));\r
\r
- drawing_ = draw_frame::empty();\r
- }\r
- catch(...)\r
- {\r
- CASPAR_LOG_CURRENT_EXCEPTION();\r
- }\r
+ writing_->draw(shader_); // Draw to frame buffer. Maps texture to system memory when done.\r
+ writing_ = frame; \r
+\r
+ reading_ = create_reading();\r
+ reading_->unmap(); // Start transfer from frame buffer to texture. End in next tick.\r
+ reading_->audio_data(writing_->audio_data()); \r
\r
return result;\r
}\r
if(!pool_.try_pop(frame)) \r
frame = std::make_shared<read_frame>(format_desc_.width, format_desc_.height);\r
frame = std::shared_ptr<read_frame>(frame.get(), [=](read_frame*){pool_.push(frame);});\r
- return safe_ptr<read_frame>::from_shared(frame);\r
+ return safe_ptr<read_frame>(frame);\r
}\r
- \r
- const video_format_desc format_desc_;\r
+\r
+ const ogl_context context_;\r
const gl::fbo fbo_;\r
+ const video_format_desc format_desc_;\r
\r
tbb::concurrent_bounded_queue<std::shared_ptr<read_frame>> pool_;\r
\r
safe_ptr<read_frame> reading_; \r
safe_ptr<draw_frame> writing_;\r
- safe_ptr<draw_frame> drawing_;\r
\r
frame_shader shader_;\r
};\r
\r
frame_renderer::frame_renderer(const video_format_desc& format_desc) : impl_(new implementation(format_desc)){}\r
-safe_ptr<read_frame> frame_renderer::render(const safe_ptr<draw_frame>& frame){return impl_->render(std::move(frame));}\r
+safe_ptr<const read_frame> frame_renderer::render(safe_ptr<draw_frame>&& frame){return impl_->render(std::move(frame));}\r
}}
\ No newline at end of file
public:\r
frame_renderer(const video_format_desc& format_desc_);\r
\r
- safe_ptr<read_frame> render(const safe_ptr<draw_frame>& frame);\r
+ safe_ptr<const read_frame> render(safe_ptr<draw_frame>&& frame);\r
private:\r
struct implementation;\r
std::shared_ptr<implementation> impl_;\r
class composite_frame;\r
\r
class frame_shader;\r
-typedef std::shared_ptr<frame_shader> frame_shader_ptr;\r
-\r
class frame_renderer;\r
-typedef std::shared_ptr<frame_renderer> frame_renderer_ptr;\r
-\r
class frame_processor_device;\r
-typedef std::shared_ptr<frame_processor_device> frame_processor_device_ptr;\r
}}
\ No newline at end of file
const boost::iterator_range<const unsigned char*> read_frame::pixel_data() const{return impl_->pixel_data();}\r
const std::vector<short>& read_frame::audio_data() const { return impl_->audio_data_; }\r
void read_frame::audio_data(const std::vector<short>& audio_data) { impl_->audio_data_ = audio_data; }\r
-void read_frame::begin_read(){impl_->pbo_.begin_read();}\r
-void read_frame::end_read(){impl_->pbo_.end_read();}\r
+void read_frame::unmap(){impl_->pbo_.unmap_read();}\r
+void read_frame::map(){impl_->pbo_.map_read();}\r
\r
}}
\ No newline at end of file
explicit read_frame(size_t width, size_t height);\r
\r
const boost::iterator_range<const unsigned char*> pixel_data() const;\r
- const std::vector<short>& audio_data() const;\r
\r
-private:\r
- friend class frame_renderer;\r
- \r
- void begin_read();\r
- void end_read();\r
+ const std::vector<short>& audio_data() const;\r
void audio_data(const std::vector<short>& audio_data);\r
+ \r
+ void unmap();\r
+ void map();\r
\r
+private:\r
struct implementation;\r
std::shared_ptr<implementation> impl_;\r
};\r
\r
namespace caspar { namespace core {\r
\r
-struct transform_frame::implementation\r
+struct transform_frame::implementation : public draw_frame_decorator\r
{\r
implementation(const safe_ptr<draw_frame>& frame) : frame_(frame), audio_volume_(255){}\r
implementation(const safe_ptr<draw_frame>& frame, std::vector<short>&& audio_data) : frame_(frame), audio_volume_(255), override_audio_data_(std::move(audio_data)){}\r
implementation(safe_ptr<draw_frame>&& frame) : frame_(std::move(frame)), audio_volume_(255){}\r
\r
- void begin_write(){frame_->begin_write();}\r
- void end_write(){frame_->end_write();}\r
+ void prepare(){draw_frame_decorator::prepare(frame_);}\r
\r
void draw(frame_shader& shader)\r
{\r
shader.begin(transform_);\r
- frame_->draw(shader);\r
+ draw_frame_decorator::draw(frame_, shader);\r
shader.end();\r
}\r
\r
temp.swap(*this);\r
return *this;\r
}\r
-void transform_frame::begin_write(){impl_->begin_write();}\r
-void transform_frame::end_write(){impl_->end_write();} \r
+void transform_frame::prepare(){impl_->prepare();} \r
void transform_frame::draw(frame_shader& shader){impl_->draw(shader);}\r
void transform_frame::audio_volume(unsigned char volume){impl_->audio_volume(volume);}\r
void transform_frame::translate(double x, double y){impl_->transform_.pos = boost::make_tuple(x, y);}\r
\r
private:\r
\r
- virtual void begin_write();\r
- virtual void end_write();\r
+ virtual void prepare();\r
virtual void draw(frame_shader& shader);\r
\r
struct implementation;\r
{\r
return gl::pbo(plane.width, plane.height, mapping[plane.channels-1]);\r
});\r
- end_write();\r
+ boost::range::for_each(pbos_, std::mem_fn(&gl::pbo::map_write));\r
}\r
\r
- void begin_write()\r
+ void prepare()\r
{\r
- boost::range::for_each(pbos_, std::mem_fn(&gl::pbo::begin_write));\r
- }\r
-\r
- void end_write()\r
- {\r
- boost::range::for_each(pbos_, std::mem_fn(&gl::pbo::end_write));\r
+ boost::range::for_each(pbos_, std::mem_fn(&gl::pbo::unmap_write));\r
}\r
\r
void draw(frame_shader& shader)\r
pbos_[n].bind_texture();\r
}\r
shader.render(desc_);\r
+ boost::range::for_each(pbos_, std::mem_fn(&gl::pbo::map_write));\r
}\r
\r
boost::iterator_range<unsigned char*> pixel_data(size_t index)\r
auto ptr = static_cast<const unsigned char*>(pbos_[index].data());\r
return boost::iterator_range<const unsigned char*>(ptr, ptr+pbos_[index].size());\r
}\r
-\r
- void reset()\r
- {\r
- end_write();\r
- audio_data_.clear();\r
- }\r
- \r
+ \r
std::vector<gl::pbo> pbos_;\r
std::vector<short> audio_data_;\r
const pixel_format_desc desc_;\r
temp.swap(*this);\r
return *this;\r
}\r
-void write_frame::reset(){impl_->reset();}\r
-void write_frame::begin_write(){impl_->begin_write();}\r
-void write_frame::end_write(){impl_->end_write();} \r
+void write_frame::prepare(){impl_->prepare();} \r
void write_frame::draw(frame_shader& shader){impl_->draw(shader);}\r
boost::iterator_range<unsigned char*> write_frame::pixel_data(size_t index){return impl_->pixel_data(index);}\r
const boost::iterator_range<const unsigned char*> write_frame::pixel_data(size_t index) const {return impl_->pixel_data(index);}\r
void swap(write_frame& other);\r
\r
write_frame& operator=(write_frame&& other);\r
-\r
- void reset();\r
-\r
+ \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
\r
private:\r
\r
- void begin_write();\r
- void end_write();\r
+ void prepare();\r
void draw(frame_shader& shader);\r
\r
struct implementation;\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)), frame_(draw_frame::empty()){}\r
color_producer(color_producer&& other) : frame_(std::move(other.frame_)), color_value_(std::move(other.color_value_)), color_str_(std::move(other.color_str_)){}\r
+ explicit color_producer(const std::wstring& color) : color_str_(color), color_value_(get_pixel_color_value(color)), frame_(draw_frame::empty()){}\r
\r
safe_ptr<draw_frame> receive()\r
{ \r
return frame_;\r
}\r
\r
- void initialize(const frame_processor_device_ptr& frame_processor)\r
+ void initialize(const safe_ptr<frame_processor_device>& frame_processor)\r
{\r
auto frame = std::move(frame_processor->create_frame());\r
__stosd(reinterpret_cast<unsigned long*>(frame->pixel_data().begin()), color_value_, frame->pixel_data().size() / sizeof(unsigned long));\r
}\r
}\r
\r
- void initialize(const frame_processor_device_ptr& frame_processor)\r
+ void initialize(const safe_ptr<frame_processor_device>& frame_processor)\r
{\r
format_desc_ = frame_processor->get_video_format_desc();\r
video_transformer_->initialize(frame_processor);\r
ffmpeg_producer(const std::wstring& filename, const std::vector<std::wstring>& params) : impl_(new ffmpeg_producer_impl(filename, params)){}\r
ffmpeg_producer(ffmpeg_producer&& other) : impl_(std::move(other.impl_)){}\r
virtual safe_ptr<draw_frame> receive(){return impl_->receive();}\r
- virtual void initialize(const frame_processor_device_ptr& frame_processor){impl_->initialize(frame_processor);}\r
+ virtual void initialize(const safe_ptr<frame_processor_device>& frame_processor){impl_->initialize(frame_processor);}\r
virtual std::wstring print() const{return impl_->print();}\r
private:\r
std::shared_ptr<ffmpeg_producer_impl> impl_;\r
} \r
}\r
\r
- void initialize(const frame_processor_device_ptr& frame_processor)\r
+ void initialize(const safe_ptr<frame_processor_device>& frame_processor)\r
{\r
- frame_processor_ = frame_processor;\r
+ frame_processor_ = frame_processor.get_shared();\r
}\r
\r
- frame_processor_device_ptr frame_processor_;\r
+ std::shared_ptr<frame_processor_device> frame_processor_;\r
std::shared_ptr<SwsContext> sws_context_;\r
\r
AVCodecContext* codec_context_;\r
\r
video_transformer::video_transformer(AVCodecContext* codec_context) : impl_(new implementation(codec_context)){}\r
safe_ptr<draw_frame> 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
+void video_transformer::initialize(const safe_ptr<frame_processor_device>& frame_processor){impl_->initialize(frame_processor); }\r
}}}
\ No newline at end of file
public:\r
video_transformer(AVCodecContext* codec_context);\r
safe_ptr<draw_frame> execute(const std::shared_ptr<AVFrame>& video_packet); \r
- void initialize(const frame_processor_device_ptr& frame_processor);\r
+ void initialize(const safe_ptr<frame_processor_device>& frame_processor);\r
private:\r
struct implementation;\r
std::shared_ptr<implementation> impl_;\r
return flash_producer_->receive();\r
}\r
\r
- void initialize(const frame_processor_device_ptr& frame_processor)\r
+ void initialize(const safe_ptr<frame_processor_device>& frame_processor)\r
{\r
- frame_processor_ = frame_processor;\r
- flash_producer_->initialize(frame_processor_);\r
+ frame_processor_ = frame_processor.get_shared();\r
+ flash_producer_->initialize(frame_processor);\r
}\r
\r
std::wstring print() const\r
\r
safe_ptr<flash_producer> flash_producer_;\r
template_version::type ver_;\r
- frame_processor_device_ptr frame_processor_;\r
+ std::shared_ptr<frame_processor_device> frame_processor_;\r
};\r
\r
-safe_ptr<cg_producer> get_default_cg_producer(const channel_ptr& channel, int render_layer)\r
-{\r
- if(!channel)\r
- BOOST_THROW_EXCEPTION(null_argument() << msg_info("channel"));\r
- \r
+safe_ptr<cg_producer> get_default_cg_producer(const safe_ptr<channel>& channel, int render_layer)\r
+{ \r
auto producer = std::dynamic_pointer_cast<cg_producer>(channel->foreground(render_layer).get().get_shared());\r
if(producer == nullptr)\r
{\r
producer = std::make_shared<cg_producer>(); \r
- channel->load(render_layer, safe_ptr<frame_producer>::from_shared(producer), load_option::auto_play); \r
+ channel->load(render_layer, safe_ptr<frame_producer>(producer), load_option::auto_play); \r
}\r
\r
- return safe_ptr<cg_producer>::from_shared(producer);\r
+ return safe_ptr<cg_producer>(producer);\r
}\r
\r
cg_producer::cg_producer() : impl_(new implementation()){}\r
+cg_producer::cg_producer(cg_producer&& other) : impl_(std::move(other.impl_)){}\r
safe_ptr<draw_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::next(int layer){impl_->next(layer);}\r
void cg_producer::update(int layer, const std::wstring& data){impl_->update(layer, data);}\r
void cg_producer::invoke(int layer, const std::wstring& label){impl_->invoke(layer, label);}\r
-void cg_producer::initialize(const frame_processor_device_ptr& frame_processor){impl_->initialize(frame_processor);}\r
+void cg_producer::initialize(const safe_ptr<frame_processor_device>& frame_processor){impl_->initialize(frame_processor);}\r
std::wstring cg_producer::print() const{return impl_->print();}\r
}}}
\ No newline at end of file
static const unsigned int DEFAULT_LAYER = 5000;\r
\r
cg_producer();\r
- cg_producer(cg_producer&& other) : impl_(std::move(other.impl_)){}\r
+ cg_producer(cg_producer&& other);\r
\r
virtual safe_ptr<draw_frame> receive();\r
- virtual void initialize(const frame_processor_device_ptr& frame_processor);\r
+ virtual void initialize(const safe_ptr<frame_processor_device>& frame_processor);\r
\r
void clear();\r
void add(int layer, const std::wstring& template_name, bool play_on_load, const std::wstring& start_from_label = TEXT(""), const std::wstring& data = TEXT(""));\r
std::shared_ptr<implementation> impl_;\r
};\r
\r
-safe_ptr<cg_producer> get_default_cg_producer(const channel_ptr& channel, int layer_index = cg_producer::DEFAULT_LAYER);\r
+safe_ptr<cg_producer> get_default_cg_producer(const safe_ptr<channel>& channel, int layer_index = cg_producer::DEFAULT_LAYER);\r
\r
}}}
\ No newline at end of file
\r
safe_ptr<draw_frame> receive()\r
{ \r
- return ((frame_buffer_.try_pop(last_frame_) || !is_empty_) && last_frame_) ? safe_ptr<draw_frame>::from_shared(last_frame_) : draw_frame::empty();\r
+ return ((frame_buffer_.try_pop(last_frame_) || !is_empty_) && last_frame_) ? safe_ptr<draw_frame>(last_frame_) : draw_frame::empty();\r
}\r
\r
- void initialize(const frame_processor_device_ptr& frame_processor)\r
+ void initialize(const safe_ptr<frame_processor_device>& frame_processor)\r
{\r
- frame_processor_ = frame_processor;\r
+ frame_processor_ = frame_processor.get_shared();\r
auto format_desc = frame_processor_->get_video_format_desc();\r
bmp_frame_ = std::make_shared<bitmap>(format_desc.width, format_desc.height);\r
start(false);\r
executor executor_;\r
int invalid_count_;\r
\r
- frame_processor_device_ptr frame_processor_;\r
+ std::shared_ptr<frame_processor_device> frame_processor_;\r
};\r
\r
+flash_producer::flash_producer(flash_producer&& other) : impl_(std::move(other.impl_)){}\r
flash_producer::flash_producer(const std::wstring& filename) : impl_(new implementation(this, filename)){}\r
safe_ptr<draw_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
+void flash_producer::initialize(const safe_ptr<frame_processor_device>& frame_processor) { impl_->initialize(frame_processor);}\r
std::wstring flash_producer::print() const {return impl_->print();}\r
\r
std::wstring flash_producer::find_template(const std::wstring& template_name)\r
class flash_producer : public frame_producer\r
{\r
public:\r
+ flash_producer(flash_producer&& other);\r
\r
flash_producer(const std::wstring& filename);\r
- flash_producer(flash_producer&& other) : impl_(std::move(other.impl_)){}\r
\r
virtual safe_ptr<draw_frame> receive();\r
- virtual void initialize(const frame_processor_device_ptr& frame_processor);\r
+ virtual void initialize(const safe_ptr<frame_processor_device>& frame_processor);\r
virtual std::wstring print() const;\r
\r
void param(const std::wstring& param);\r
+++ /dev/null
-/*\r
-* copyright (c) 2010 Sveriges Television AB <info@casparcg.com>\r
-*\r
-* This file is part of CasparCG.\r
-*\r
-* CasparCG is free software: you can redistribute it and/or modify\r
-* it under the terms of the GNU General Public License as published by\r
-* the Free Software Foundation, either version 3 of the License, or\r
-* (at your option) any later version.\r
-*\r
-* CasparCG is distributed in the hope that it will be useful,\r
-* but WITHOUT ANY WARRANTY; without even the implied warranty of\r
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
-* GNU General Public License for more details.\r
-\r
-* You should have received a copy of the GNU General Public License\r
-* along with CasparCG. If not, see <http://www.gnu.org/licenses/>.\r
-*\r
-*/\r
-#include "../stdafx.h"\r
-\r
-#include "frame_producer.h"\r
-\r
-namespace caspar { namespace core {\r
- \r
-struct empty_frame_producer : public frame_producer\r
-{\r
- virtual safe_ptr<draw_frame> receive(){return draw_frame::eof();}\r
- virtual void initialize(const frame_processor_device_ptr&){}\r
- virtual std::wstring print() const { return L"empty";}\r
-};\r
-\r
-safe_ptr<frame_producer> frame_producer::empty()\r
-{\r
- static auto empty_producer = std::make_shared<empty_frame_producer>();\r
- return safe_ptr<frame_producer>::from_shared(empty_producer);\r
-}\r
-\r
-inline std::wostream& operator<<(std::wostream& out, const frame_producer& producer)\r
-{\r
- out << producer.print().c_str();\r
- return out;\r
-}\r
-\r
-}}
\ No newline at end of file
virtual void set_leading_producer(const safe_ptr<frame_producer>& /*producer*/) {}\r
\r
////////////////////////////////////////////////////////////////////////////////////////////////////\r
- /// \fn virtual void :::initialize(const frame_processor_device_ptr& frame_processor) = 0;\r
+ /// \fn virtual void :::initialize(const safe_ptr<frame_processor_device>& frame_processor) = 0;\r
///\r
/// \brief Provides the frame frame_processor used to create frames and initializes the producer. \r
///\r
/// \param frame_processor The frame frame_processor. \r
////////////////////////////////////////////////////////////////////////////////////////////////////\r
- virtual void initialize(const frame_processor_device_ptr& frame_processor) = 0;\r
+ virtual void initialize(const safe_ptr<frame_processor_device>& frame_processor) = 0;\r
\r
- static safe_ptr<frame_producer> empty();\r
+ static safe_ptr<frame_producer> empty()\r
+ {\r
+ struct empty_frame_producer : public frame_producer\r
+ {\r
+ virtual safe_ptr<draw_frame> receive(){return draw_frame::eof();}\r
+ virtual void initialize(const safe_ptr<frame_processor_device>&){}\r
+ virtual std::wstring print() const { return L"empty";}\r
+ };\r
+ static safe_ptr<frame_producer> producer = make_safe<empty_frame_producer>();\r
+ return producer;\r
+ }\r
\r
virtual std::wstring print() const = 0;\r
};\r
\r
-inline std::wostream& operator<<(std::wostream& out, const frame_producer& producer);\r
+inline std::wostream& operator<<(std::wostream& out, const frame_producer& producer)\r
+{\r
+ out << producer.print().c_str();\r
+ return out;\r
+}\r
\r
}}\r
\r
struct frame_producer_device::implementation : boost::noncopyable\r
{ \r
- implementation(const frame_processor_device_ptr& frame_processor) : frame_processor_(frame_processor)\r
+ implementation(const safe_ptr<frame_processor_device>& frame_processor) : frame_processor_(frame_processor)\r
{\r
executor_.start();\r
executor_.begin_invoke([=]{tick();});\r
return it != layers_.end() ? it->second.background() : frame_producer::empty();\r
});\r
}\r
+\r
mutable executor executor_;\r
\r
- frame_processor_device_ptr frame_processor_;\r
+ safe_ptr<frame_processor_device> frame_processor_;\r
\r
std::map<int, layer> layers_; \r
};\r
\r
-frame_producer_device::frame_producer_device(const frame_processor_device_ptr& frame_processor) : impl_(new implementation(frame_processor)){}\r
+frame_producer_device::frame_producer_device(frame_producer_device&& other) : impl_(std::move(other.impl_)){}\r
+frame_producer_device::frame_producer_device(const safe_ptr<frame_processor_device>& frame_processor) : impl_(new implementation(frame_processor)){}\r
void frame_producer_device::load(int render_layer, const safe_ptr<frame_producer>& producer, load_option::type option){impl_->load(render_layer, producer, option);}\r
void frame_producer_device::pause(int render_layer){impl_->pause(render_layer);}\r
void frame_producer_device::play(int render_layer){impl_->play(render_layer);}\r
class frame_producer_device : boost::noncopyable\r
{ \r
public:\r
- frame_producer_device(const frame_processor_device_ptr& frame_processor);\r
+ frame_producer_device(frame_producer_device&& other);\r
+ frame_producer_device(const safe_ptr<frame_processor_device>& frame_processor);\r
\r
void load (int render_layer, const safe_ptr<frame_producer>& producer, load_option::type option = load_option::none); \r
void pause (int render_layer);\r
\r
safe_ptr<draw_frame> receive(){return frame_;}\r
\r
- void initialize(const frame_processor_device_ptr& frame_processor)\r
+ void initialize(const safe_ptr<frame_processor_device>& frame_processor)\r
{\r
- frame_processor_ = frame_processor;\r
+ frame_processor_ = frame_processor.get_shared();\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
return L"image_producer. filename: " + filename_;\r
}\r
\r
- frame_processor_device_ptr frame_processor_;\r
+ std::shared_ptr<frame_processor_device> frame_processor_;\r
std::wstring filename_;\r
safe_ptr<draw_frame> frame_;\r
};\r
// return receive(); \r
// }\r
// \r
-// void initialize(const frame_processor_device_ptr& frame_processor)\r
+// void initialize(const safe_ptr<frame_processor_device>& frame_processor)\r
// {\r
// frame_processor_ = frame_processor;\r
// format_desc_ = frame_processor_->get_video_format_desc();\r
//\r
// std::wstring filename_;\r
//\r
-// frame_processor_device_ptr frame_processor_;\r
+// safe_ptr<frame_processor_device> frame_processor_;\r
//};\r
//\r
//safe_ptr<frame_producer> create_image_scroll_producer(const std::vector<std::wstring>& params)\r
try\r
{\r
auto following = producer->get_following_producer();\r
- following->initialize(frame_processor_);\r
+ following->initialize(safe_ptr<frame_processor_device>(frame_processor_));\r
following->set_leading_producer(producer);\r
producer = following;\r
}\r
return composite_frame(std::move(my_src_frame), std::move(my_dest_frame));\r
}\r
\r
- void initialize(const frame_processor_device_ptr& frame_processor)\r
+ void initialize(const safe_ptr<frame_processor_device>& frame_processor)\r
{\r
dest_producer_->initialize(frame_processor);\r
- frame_processor_ = frame_processor;\r
+ frame_processor_ = frame_processor.get_shared();\r
}\r
\r
std::wstring print() const\r
unsigned short current_frame_;\r
\r
const transition_info info_;\r
- frame_processor_device_ptr frame_processor_;\r
+ std::shared_ptr<frame_processor_device> frame_processor_;\r
};\r
\r
+transition_producer::transition_producer(transition_producer&& other) : impl_(std::move(other.impl_)){}\r
transition_producer::transition_producer(const safe_ptr<frame_producer>& dest, const transition_info& info) : impl_(new implementation(dest, info)){}\r
safe_ptr<draw_frame> transition_producer::receive(){return impl_->receive();}\r
safe_ptr<frame_producer> transition_producer::get_following_producer() const{return impl_->get_following_producer();}\r
void transition_producer::set_leading_producer(const safe_ptr<frame_producer>& producer) { impl_->set_leading_producer(producer); }\r
-void transition_producer::initialize(const frame_processor_device_ptr& frame_processor) { impl_->initialize(frame_processor);}\r
+void transition_producer::initialize(const safe_ptr<frame_processor_device>& frame_processor) { impl_->initialize(frame_processor);}\r
std::wstring transition_producer::print() const { return impl_->print();}\r
\r
}}\r
class transition_producer : public frame_producer\r
{\r
public:\r
+ transition_producer(transition_producer&& other);\r
+\r
transition_producer(const safe_ptr<frame_producer>& destination, const transition_info& info);\r
- transition_producer(transition_producer&& other) : impl_(std::move(other.impl_)){}\r
+\r
safe_ptr<draw_frame> receive();\r
\r
safe_ptr<frame_producer> get_following_producer() const;\r
void set_leading_producer(const safe_ptr<frame_producer>& producer);\r
- virtual void initialize(const frame_processor_device_ptr& frame_processor);\r
+ virtual void initialize(const safe_ptr<frame_processor_device>& frame_processor);\r
virtual std::wstring print() const;\r
private:\r
struct implementation;\r
void SetClientInfo(IO::ClientInfoPtr& s){pClientInfo_ = s;}\r
IO::ClientInfoPtr GetClientInfo(){return pClientInfo_;}\r
\r
- void SetChannel(const channel_ptr& pChannel){pChannel_ = pChannel;}\r
- channel_ptr GetChannel(){return pChannel_;}\r
+ void SetChannel(const std::shared_ptr<channel>& pChannel){pChannel_ = pChannel;}\r
+ std::shared_ptr<channel> GetChannel(){return pChannel_;}\r
\r
void SetChannelIndex(unsigned int channelIndex){channelIndex_ = channelIndex;}\r
unsigned int GetChannelIndex(){return channelIndex_;}\r
unsigned int channelIndex_;\r
int layerIndex_;\r
IO::ClientInfoPtr pClientInfo_;\r
- channel_ptr pChannel_;\r
+ std::shared_ptr<channel> pChannel_;\r
AMCPCommandScheduling scheduling_;\r
std::wstring replyString_;\r
};\r
\r
void AMCPCommand::Clear() \r
{\r
- pChannel_.reset();\r
+ pChannel_->clear();\r
pClientInfo_.reset();\r
channelIndex_ = 0;\r
_parameters.clear();\r
std::wstring filename = _parameters[2];\r
filename.append(extension);\r
\r
- flash::get_default_cg_producer(GetChannel(), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->add(layer, filename, bDoStart, label, (pDataString!=0) ? pDataString : TEXT(""));\r
+ flash::get_default_cg_producer(safe_ptr<channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->add(layer, filename, bDoStart, label, (pDataString!=0) ? pDataString : TEXT(""));\r
SetReplyString(TEXT("202 CG OK\r\n"));\r
}\r
else\r
return false;\r
}\r
int layer = _ttoi(_parameters[1].c_str());\r
- flash::get_default_cg_producer(GetChannel(), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->play(layer);\r
+ flash::get_default_cg_producer(safe_ptr<channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->play(layer);\r
}\r
else\r
{\r
return false;\r
}\r
int layer = _ttoi(_parameters[1].c_str());\r
- flash::get_default_cg_producer(GetChannel(), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->stop(layer, 0);\r
+ flash::get_default_cg_producer(safe_ptr<channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->stop(layer, 0);\r
}\r
else \r
{\r
return false;\r
}\r
int layer = _ttoi(_parameters[1].c_str());\r
- flash::get_default_cg_producer(GetChannel(), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->next(layer);\r
+ flash::get_default_cg_producer(safe_ptr<channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->next(layer);\r
}\r
else \r
{\r
return false;\r
}\r
int layer = _ttoi(_parameters[1].c_str());\r
- flash::get_default_cg_producer(GetChannel(), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->remove(layer);\r
+ flash::get_default_cg_producer(safe_ptr<channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->remove(layer);\r
}\r
else \r
{\r
\r
bool CGCommand::DoExecuteClear() \r
{\r
- flash::get_default_cg_producer(GetChannel(), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->clear();\r
+ flash::get_default_cg_producer(safe_ptr<channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->clear();\r
SetReplyString(TEXT("202 CG OK\r\n"));\r
return true;\r
}\r
}\r
int layer = _ttoi(_parameters[1].c_str());\r
//TODO: Implement indirect data loading from file. Same as in Add\r
- flash::get_default_cg_producer(GetChannel(), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->update(layer, _parameters[2]);\r
+ flash::get_default_cg_producer(safe_ptr<channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->update(layer, _parameters[2]);\r
}\r
else \r
{\r
return false;\r
}\r
int layer = _ttoi(_parameters[1].c_str());\r
- flash::get_default_cg_producer(GetChannel(), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->invoke(layer, _parameters[2]);\r
+ flash::get_default_cg_producer(safe_ptr<channel>(GetChannel()), GetLayerIndex(flash::cg_producer::DEFAULT_LAYER))->invoke(layer, _parameters[2]);\r
}\r
else \r
{\r
return false;\r
}\r
\r
-void GenerateChannelInfo(int index, const channel_ptr& pChannel, std::wstringstream& replyString)\r
+void GenerateChannelInfo(int index, const safe_ptr<channel>& pChannel, std::wstringstream& replyString)\r
{\r
replyString << index << TEXT(" ") << pChannel->get_video_format_desc().name << TEXT("\r\n") << (pChannel->foreground(0).get()->print());\r
}\r
class InfoCommand : public AMCPCommandBase<false, AddToQueue, 0>\r
{\r
public:\r
- InfoCommand(const std::vector<channel_ptr>& channels) : channels_(channels){}\r
+ InfoCommand(const std::vector<safe_ptr<channel>>& channels) : channels_(channels){}\r
bool DoExecute();\r
private:\r
- const std::vector<channel_ptr>& channels_;\r
+ const std::vector<safe_ptr<channel>>& channels_;\r
};\r
\r
class VersionCommand : public AMCPCommandBase<false, AddToQueue, 0>\r
\r
const std::wstring AMCPProtocolStrategy::MessageDelimiter = TEXT("\r\n");\r
\r
-inline channel_ptr GetChannelSafe(unsigned int index, const std::vector<channel_ptr>& channels)\r
+inline std::shared_ptr<channel> GetChannelSafe(unsigned int index, const std::vector<safe_ptr<channel>>& channels)\r
{\r
- return index < channels.size() ? channels[index] : nullptr;\r
+ return index < channels.size() ? channels[index].get_shared() : nullptr;\r
}\r
\r
-AMCPProtocolStrategy::AMCPProtocolStrategy(const std::vector<channel_ptr>& channels) : channels_(channels) {\r
+AMCPProtocolStrategy::AMCPProtocolStrategy(const std::vector<safe_ptr<channel>>& channels) : channels_(channels) {\r
AMCPCommandQueuePtr pGeneralCommandQueue(new AMCPCommandQueue());\r
if(!pGeneralCommandQueue->Start()) {\r
CASPAR_LOG(error) << "Failed to start the general command-queue";\r
commandQueues_.push_back(pGeneralCommandQueue);\r
\r
\r
- channel_ptr pChannel;\r
+ std::shared_ptr<channel> pChannel;\r
unsigned int index = -1;\r
//Create a commandpump for each channel\r
while((pChannel = GetChannelSafe(++index, channels_)) != 0) {\r
goto ParseFinnished;\r
}\r
\r
- channel_ptr pChannel = GetChannelSafe(channelIndex, channels_);\r
+ std::shared_ptr<channel> pChannel = GetChannelSafe(channelIndex, channels_);\r
if(pChannel == 0) {\r
goto ParseFinnished;\r
}\r
switch(message[charIndex])\r
{\r
case TEXT('\\'):\r
- currentToken += TEXT("\\");\r
+ currentToken += TEXT("\\");\r
break;\r
case TEXT('\"'):\r
currentToken += TEXT("\"");\r
AMCPProtocolStrategy& operator=(const AMCPProtocolStrategy&);\r
\r
public:\r
- AMCPProtocolStrategy(const std::vector<channel_ptr>& channels);\r
+ AMCPProtocolStrategy(const std::vector<safe_ptr<channel>>& channels);\r
virtual ~AMCPProtocolStrategy();\r
\r
virtual void Parse(const TCHAR* pData, int charCount, IO::ClientInfoPtr pClientInfo);\r
\r
bool QueueCommand(AMCPCommandPtr);\r
\r
- std::vector<channel_ptr> channels_;\r
+ std::vector<safe_ptr<channel>> channels_;\r
std::vector<AMCPCommandQueuePtr> commandQueues_;\r
static const std::wstring MessageDelimiter;\r
};\r
const std::wstring CIIProtocolStrategy::MessageDelimiter = TEXT("\r\n");\r
const TCHAR CIIProtocolStrategy::TokenDelimiter = TEXT('\\');\r
\r
-CIIProtocolStrategy::CIIProtocolStrategy(const std::vector<channel_ptr>& channels) \r
+CIIProtocolStrategy::CIIProtocolStrategy(const std::vector<safe_ptr<channel>>& channels) : pChannel_(channels.at(0))\r
{\r
- if(channels.empty())\r
- BOOST_THROW_EXCEPTION(invalid_argument() << arg_name_info("channels"));\r
- pChannel_ = channels[0];\r
executor_.start();\r
}\r
\r
class CIIProtocolStrategy : public IO::IProtocolStrategy\r
{\r
public:\r
- CIIProtocolStrategy(const std::vector<channel_ptr>& channels);\r
+ CIIProtocolStrategy(const std::vector<safe_ptr<channel>>& channels);\r
\r
void Parse(const TCHAR* pData, int charCount, IO::ClientInfoPtr pClientInfo);\r
UINT GetCodepage() {return 28591;} //ISO 8859-1\r
\r
void SetProfile(const std::wstring& profile) {currentProfile_ = profile;}\r
\r
- channel_ptr GetChannel() const{return this->pChannel_;}\r
+ safe_ptr<channel> GetChannel() const{return this->pChannel_;}\r
\r
void DisplayMediaFile(const std::wstring& filename);\r
void DisplayTemplate(const std::wstring& titleName);\r
std::wstring currentMessage_;\r
\r
std::wstring currentProfile_;\r
- channel_ptr pChannel_;\r
+ safe_ptr<channel> pChannel_;\r
};\r
\r
}}}
\ No newline at end of file
\r
namespace caspar { namespace core { namespace CLK {\r
\r
-CLKProtocolStrategy::CLKProtocolStrategy(const std::vector<channel_ptr>& channels) \r
- : currentState_(ExpectingNewCommand), bClockLoaded_(false) \r
-{ \r
- if(channels.empty())\r
- BOOST_THROW_EXCEPTION(invalid_argument() << arg_name_info("channels"));\r
- pChannel_ = channels[0];\r
-}\r
+CLKProtocolStrategy::CLKProtocolStrategy(const std::vector<safe_ptr<channel>>& channels) \r
+ : currentState_(ExpectingNewCommand), bClockLoaded_(false), pChannel_(channels.at(0))\r
+{}\r
\r
void CLKProtocolStrategy::Parse(const TCHAR* pData, int charCount, IO::ClientInfoPtr pClientInfo) \r
{\r
class CLKProtocolStrategy : public IO::IProtocolStrategy\r
{\r
public:\r
- CLKProtocolStrategy(const std::vector<channel_ptr>& channels);\r
+ CLKProtocolStrategy(const std::vector<safe_ptr<channel>>& channels);\r
\r
void Parse(const TCHAR* pData, int charCount, IO::ClientInfoPtr pClientInfo);\r
UINT GetCodepage() { return 28591; } //ISO 8859-1\r
CLKCommand currentCommand_;\r
std::wstringstream currentCommandString_;\r
\r
- channel_ptr pChannel_;\r
+ safe_ptr<channel> pChannel_;\r
\r
bool bClockLoaded_;\r
};\r
auto format_desc = video_format_desc::get(widen(xml_channel.second.get("videomode", "PAL"))); \r
if(format_desc.format == video_format::invalid)\r
BOOST_THROW_EXCEPTION(caspar_exception() << msg_info("Invalid videomode."));\r
- std::vector<frame_consumer_ptr> consumers;\r
+ std::vector<safe_ptr<frame_consumer>> consumers;\r
\r
BOOST_FOREACH(auto& xml_consumer, xml_channel.second.get_child("consumers"))\r
{\r
try\r
{\r
- frame_consumer_ptr pConsumer;\r
std::string name = xml_consumer.first;\r
if(name == "ogl")\r
{ \r
stretch = ogl::stretch::uniform_to_fill;\r
\r
bool windowed = xml_consumer.second.get("windowed", false);\r
- pConsumer = std::make_shared<ogl::consumer>(format_desc, device, stretch, windowed);\r
+ consumers.push_back(ogl::consumer(format_desc, device, stretch, windowed));\r
}\r
#ifndef DISABLE_BLUEFISH\r
else if(name == "bluefish") \r
- pConsumer = std::make_shared<bluefish::consumer>(format_desc, xml_consumer.second.get("device", 0), xml_consumer.second.get("embedded-audio", false)); \r
+ consumers.push_back(bluefish::consumer(format_desc, xml_consumer.second.get("device", 0), xml_consumer.second.get("embedded-audio", false))); \r
#endif\r
else if(name == "decklink")\r
- pConsumer = std::make_shared<decklink::decklink_consumer>(format_desc, xml_consumer.second.get("internalkey", false));\r
+ consumers.push_back(make_safe<decklink::decklink_consumer>(format_desc, xml_consumer.second.get("internalkey", false)));\r
else if(name == "audio")\r
- pConsumer = std::make_shared<oal::consumer>(format_desc);\r
-\r
- if(pConsumer) \r
- consumers.push_back(pConsumer); \r
+ consumers.push_back(oal::consumer(format_desc)); \r
}\r
catch(...)\r
{\r
}\r
}\r
\r
- auto processor_device = std::make_shared<frame_processor_device>(format_desc);\r
- auto producer_device = std::make_shared<frame_producer_device>(processor_device);\r
- auto consumer_device = std::make_shared<frame_consumer_device>(processor_device, format_desc, consumers);\r
- channels_.push_back(std::make_shared<channel>(producer_device, processor_device, consumer_device));\r
+ auto processor_device = make_safe<frame_processor_device>(format_desc);\r
+ auto producer_device = make_safe<frame_producer_device>(processor_device);\r
+ auto consumer_device = make_safe<frame_consumer_device>(processor_device, format_desc, consumers);\r
+ channels_.push_back(channel(producer_device, processor_device, consumer_device));\r
}\r
}\r
\r
{ \r
unsigned int port = xml_controller.second.get<unsigned int>("port");\r
port = port != 0 ? port : 5250;\r
- auto asyncserver = std::make_shared<IO::AsyncEventServer>(create_protocol(protocol), port);\r
+ auto asyncserver = make_safe<IO::AsyncEventServer>(create_protocol(protocol), port);\r
asyncserver->Start();\r
async_servers_.push_back(asyncserver);\r
}\r
}\r
}\r
\r
- IO::ProtocolStrategyPtr create_protocol(const std::string& name) const\r
+ safe_ptr<IO::IProtocolStrategy> create_protocol(const std::string& name) const\r
{\r
if(name == "AMCP")\r
- return
std::make_shared<amcp::AMCPProtocolStrategy>(channels_);
\r+ return
make_safe<amcp::AMCPProtocolStrategy>(channels_);
\r else if(name == "CII")\r
- return std::make_shared<cii::CIIProtocolStrategy>(channels_);\r
+ return make_safe<cii::CIIProtocolStrategy>(channels_);\r
else if(name == "CLOCK")\r
- return std::make_shared<CLK::CLKProtocolStrategy>(channels_);\r
+ return make_safe<CLK::CLKProtocolStrategy>(channels_);\r
\r
BOOST_THROW_EXCEPTION(invalid_configuration() << arg_name_info("name") << arg_value_info(name) << msg_info("Invalid protocol"));\r
}\r
\r
- std::vector<IO::AsyncEventServerPtr> async_servers_;\r
+ std::vector<safe_ptr<IO::AsyncEventServer>> async_servers_;\r
\r
- std::vector<channel_ptr> channels_;\r
+ std::vector<safe_ptr<channel>> channels_;\r
\r
int logLevel_;\r
\r
return server::implementation::data_folder_;\r
}\r
\r
-const std::vector<channel_ptr> server::get_channels() const\r
+const std::vector<safe_ptr<channel>> server::get_channels() const\r
{\r
return impl_->channels_;\r
}\r
static const std::wstring& template_folder(); \r
static const std::wstring& data_folder();\r
\r
- const std::vector<channel_ptr> get_channels() const;\r
+ const std::vector<safe_ptr<channel>> get_channels() const;\r
\r
private:\r
struct implementation;\r
projects / casparcg / commitdiff