X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fdecklink%2Fconsumer%2Fdecklink_consumer.cpp;h=dce653a55babb88ed30bedc7fa6eba18a61f7e79;hb=21f6e85a6f8b6359016c057ed397807cb20a3dae;hp=ffeaa07f093bc856c522886cd273aac8311c4501;hpb=5d10e13c5acbc1b22a9c84449602db937b341790;p=casparcg

diff --git a/modules/decklink/consumer/decklink_consumer.cpp b/modules/decklink/consumer/decklink_consumer.cpp
index ffeaa07f0..dce653a55 100644
--- a/modules/decklink/consumer/decklink_consumer.cpp
+++ b/modules/decklink/consumer/decklink_consumer.cpp
@@ -26,74 +26,88 @@
 
 #include "../interop/DeckLinkAPI_h.h"
 
-#include <core/consumer/frame/read_frame.h>
+#include <core/mixer/read_frame.h>
 
 #include <common/concurrency/com_context.h>
 #include <common/diagnostics/graph.h>
 #include <common/exception/exceptions.h>
 #include <common/memory/memcpy.h>
 #include <common/memory/memclr.h>
+#include <common/memory/memshfl.h>
+
+#include <core/consumer/frame_consumer.h>
 
 #include <tbb/concurrent_queue.h>
+#include <tbb/cache_aligned_allocator.h>
 
 #include <boost/circular_buffer.hpp>
 #include <boost/timer.hpp>
 
 namespace caspar { 
 	
-enum key
-{
-	external_key,
-	internal_key,
-	default_key
-};
-
-enum latency
-{
-	low_latency,
-	normal_latency,
-	default_latency
-};
-
 struct configuration
 {
 	size_t	device_index;
 	bool	embedded_audio;
-	key		keyer;
-	latency latency;
+	bool	internal_key;
+	bool	low_latency;
+	bool	key_only;
+	size_t	buffer_depth;
 	
 	configuration()
 		: device_index(1)
 		, embedded_audio(false)
-		, keyer(default_key)
-		, latency(default_latency){}
+		, internal_key(false)
+		, low_latency(false)
+		, key_only(false)
+		, buffer_depth(core::consumer_buffer_depth()){}
 };
 
-class decklink_frame_adapter : public IDeckLinkVideoFrame
+class decklink_frame : public IDeckLinkVideoFrame
 {
-	const safe_ptr<const core::read_frame>	frame_;
-	const core::video_format_desc			format_desc_;
+	std::shared_ptr<core::read_frame>							frame_;
+	const core::video_format_desc								format_desc_;
+
+	bool														key_only_;
+	std::vector<uint8_t, tbb::cache_aligned_allocator<uint8_t>> key_data_;
 public:
-	decklink_frame_adapter(const safe_ptr<const core::read_frame>& frame, const core::video_format_desc& format_desc)
+	decklink_frame(const safe_ptr<core::read_frame>& frame, const core::video_format_desc& format_desc, bool key_only)
 		: frame_(frame)
-		, format_desc_(format_desc){}
+		, format_desc_(format_desc)
+		, key_only_(key_only){}
 	
-	STDMETHOD (QueryInterface(REFIID, LPVOID*))	{return E_NOINTERFACE;}
-	STDMETHOD_(ULONG, AddRef())					{return 1;}
-	STDMETHOD_(ULONG, Release())				{return 1;}
-
-	STDMETHOD_(long, GetWidth())				{return format_desc_.width;}        
-    STDMETHOD_(long, GetHeight())				{return format_desc_.height;}        
-    STDMETHOD_(long, GetRowBytes())				{return format_desc_.width*4;}        
-	STDMETHOD_(BMDPixelFormat, GetPixelFormat()){return bmdFormat8BitBGRA;}        
-    STDMETHOD_(BMDFrameFlags, GetFlags())		{return bmdFrameFlagDefault;}
+	STDMETHOD (QueryInterface(REFIID, LPVOID*))		{return E_NOINTERFACE;}
+	STDMETHOD_(ULONG,			AddRef())			{return 1;}
+	STDMETHOD_(ULONG,			Release())			{return 1;}
+
+	STDMETHOD_(long,			GetWidth())			{return format_desc_.width;}        
+    STDMETHOD_(long,			GetHeight())		{return format_desc_.height;}        
+    STDMETHOD_(long,			GetRowBytes())		{return format_desc_.width*4;}        
+	STDMETHOD_(BMDPixelFormat,	GetPixelFormat())	{return bmdFormat8BitBGRA;}        
+    STDMETHOD_(BMDFrameFlags,	GetFlags())			{return bmdFrameFlagDefault;}
         
     STDMETHOD(GetBytes(void** buffer))
 	{
-		static std::vector<unsigned char> zeros(1920*1080*4, 0);
-		*buffer = const_cast<unsigned char*>(frame_->image_data().begin());
+		static std::vector<uint8_t> zeros(1920*1080*4, 0);
 		if(static_cast<size_t>(frame_->image_data().size()) != format_desc_.size)
+		{
 			*buffer = zeros.data();
+			return S_OK;
+		}
+
+		if(!key_only_)
+			*buffer = const_cast<uint8_t*>(frame_->image_data().begin());
+		else
+		{
+			if(key_data_.empty())
+			{
+				key_data_.resize(frame_->image_data().size());
+				fast_memshfl(key_data_.data(), frame_->image_data().begin(), frame_->image_data().size(), 0x0F0F0F0F, 0x0B0B0B0B, 0x07070707, 0x03030303);
+				frame_.reset();
+			}
+			*buffer = key_data_.data();
+		}
+
 		return S_OK;
 	}
         
@@ -103,29 +117,32 @@ public:
 
 struct decklink_consumer : public IDeckLinkVideoOutputCallback, public IDeckLinkAudioOutputCallback, boost::noncopyable
 {		
-	const configuration config_;
+	const configuration					config_;
 
 	CComPtr<IDeckLink>					decklink_;
 	CComQIPtr<IDeckLinkOutput>			output_;
 	CComQIPtr<IDeckLinkConfiguration>	configuration_;
 	CComQIPtr<IDeckLinkKeyer>			keyer_;
 
-	std::exception_ptr exception_;
+	tbb::spin_mutex						exception_mutex_;
+	std::exception_ptr					exception_;
 
-	tbb::atomic<bool> is_running_;
+	tbb::atomic<bool>					is_running_;
 		
-	const std::wstring model_name_;
-	const core::video_format_desc format_desc_;
-	const size_t buffer_size_;
+	const std::wstring					model_name_;
+	const core::video_format_desc		format_desc_;
+	const size_t						buffer_size_;
 
-	unsigned long frames_scheduled_;
-	unsigned long audio_scheduled_;
+	long long							frames_scheduled_;
+	long long							audio_scheduled_;
+
+	size_t								preroll_count_;
 		
-	std::list<decklink_frame_adapter> frame_container_; // Must be std::list in order to guarantee that pointers are always valid.
-	boost::circular_buffer<std::vector<short>> audio_container_;
+	std::list<std::shared_ptr<IDeckLinkVideoFrame>> frame_container_; // Must be std::list in order to guarantee that pointers are always valid.
+	boost::circular_buffer<std::vector<int16_t>>	audio_container_;
 
-	tbb::concurrent_bounded_queue<std::shared_ptr<const core::read_frame>> video_frame_buffer_;
-	tbb::concurrent_bounded_queue<std::shared_ptr<const core::read_frame>> audio_frame_buffer_;
+	tbb::concurrent_bounded_queue<std::shared_ptr<core::read_frame>> video_frame_buffer_;
+	tbb::concurrent_bounded_queue<std::shared_ptr<core::read_frame>> audio_frame_buffer_;
 	
 	std::shared_ptr<diagnostics::graph> graph_;
 	boost::timer tick_timer_;
@@ -139,9 +156,10 @@ public:
 		, keyer_(decklink_)
 		, model_name_(get_model_name(decklink_))
 		, format_desc_(format_desc)
-		, buffer_size_(config.embedded_audio ? 5 : 4) // Minimum buffer-size (3 + 1 tolerance).
+		, buffer_size_(config.embedded_audio ? config.buffer_depth + 1 : config.buffer_depth) // Minimum buffer-size 3.
 		, frames_scheduled_(0)
 		, audio_scheduled_(0)
+		, preroll_count_(0)
 		, audio_container_(buffer_size_+1)
 	{
 		is_running_ = true;
@@ -151,38 +169,34 @@ public:
 
 		graph_ = diagnostics::create_graph(narrow(print()));
 		graph_->add_guide("tick-time", 0.5);
-		graph_->set_color("tick-time", diagnostics::color(0.1f, 0.7f, 0.8f));
+		graph_->set_color("tick-time", diagnostics::color(0.0f, 0.6f, 0.9f));	
 		graph_->set_color("late-frame", diagnostics::color(0.6f, 0.3f, 0.3f));
 		graph_->set_color("dropped-frame", diagnostics::color(0.3f, 0.6f, 0.3f));
-		graph_->set_color("flushed-frame", diagnostics::color(0.3f, 0.3f, 0.6f));
+		graph_->set_color("flushed-frame", diagnostics::color(0.4f, 0.3f, 0.8f));
 		
 		enable_video(get_display_mode(output_, format_desc_.format, bmdFormat8BitBGRA, bmdVideoOutputFlagDefault));
 				
 		if(config.embedded_audio)
 			enable_audio();
 
-		set_latency(config.latency);				
-		set_keyer(config.keyer);
-								
-		for(size_t n = 0; n < buffer_size_; ++n)
-			schedule_next_video(core::read_frame::empty());
+		set_latency(config.low_latency);				
+		set_keyer(config.internal_key);
+				
+		if(config.embedded_audio)		
+			output_->BeginAudioPreroll();		
 		
-		if(config.embedded_audio)
-			output_->BeginAudioPreroll();
-		else
+		for(size_t n = 0; n < buffer_size_; ++n)
+			schedule_next_video(make_safe<core::read_frame>());
+
+		if(!config.embedded_audio)
 			start_playback();
-		
-		CASPAR_LOG(info) << print() << L" Buffer depth: " << buffer_size_;		
-		CASPAR_LOG(info) << print() << L" Successfully initialized for " << format_desc_.name;	
 	}
 
 	~decklink_consumer()
 	{		
 		is_running_ = false;
-		video_frame_buffer_.clear();
-		audio_frame_buffer_.clear();
-		video_frame_buffer_.try_push(core::read_frame::empty());
-		audio_frame_buffer_.try_push(core::read_frame::empty());
+		video_frame_buffer_.try_push(std::make_shared<core::read_frame>());
+		audio_frame_buffer_.try_push(std::make_shared<core::read_frame>());
 
 		if(output_ != nullptr) 
 		{
@@ -193,25 +207,28 @@ public:
 		}
 	}
 			
-	void set_latency(latency latency)
+	const core::video_format_desc& get_video_format_desc() const
+	{
+		return format_desc_;
+	}
+
+	void set_latency(bool low_latency)
 	{		
-		if(latency == normal_latency)
+		if(!low_latency)
 		{
 			configuration_->SetFlag(bmdDeckLinkConfigLowLatencyVideoOutput, false);
 			CASPAR_LOG(info) << print() << L" Enabled normal-latency mode";
 		}
-		else if(latency == low_latency)
+		else
 		{			
 			configuration_->SetFlag(bmdDeckLinkConfigLowLatencyVideoOutput, true);
 			CASPAR_LOG(info) << print() << L" Enabled low-latency mode";
 		}
-		else
-			CASPAR_LOG(info) << print() << L" Uses driver latency settings.";	
 	}
 
-	void set_keyer(key keyer)
+	void set_keyer(bool internal_key)
 	{
-		if(keyer == internal_key) 
+		if(internal_key) 
 		{
 			if(FAILED(keyer_->Enable(FALSE)))			
 				CASPAR_LOG(error) << print() << L" Failed to enable internal keyer.";			
@@ -220,7 +237,7 @@ public:
 			else
 				CASPAR_LOG(info) << print() << L" Enabled internal keyer.";		
 		}
-		else if(keyer == external_key)
+		else
 		{
 			if(FAILED(keyer_->Enable(TRUE)))			
 				CASPAR_LOG(error) << print() << L" Failed to enable external keyer.";	
@@ -229,8 +246,6 @@ public:
 			else
 				CASPAR_LOG(info) << print() << L" Enabled external keyer.";			
 		}
-		else
-			CASPAR_LOG(info) << print() << L" Uses driver keyer settings.";	
 	}
 	
 	void enable_audio()
@@ -250,7 +265,9 @@ public:
 			BOOST_THROW_EXCEPTION(caspar_exception() << msg_info(narrow(print()) + " Could not enable video output."));
 		
 		if(FAILED(output_->SetScheduledFrameCompletionCallback(this)))
-			BOOST_THROW_EXCEPTION(caspar_exception() << msg_info(narrow(print()) + " Failed to set playback completion callback."));
+			BOOST_THROW_EXCEPTION(caspar_exception() 
+									<< msg_info(narrow(print()) + " Failed to set playback completion callback.")
+									<< boost::errinfo_api_function("SetScheduledFrameCompletionCallback"));
 	}
 
 	void start_playback()
@@ -263,6 +280,13 @@ public:
 	STDMETHOD_(ULONG, AddRef())					{return 1;}
 	STDMETHOD_(ULONG, Release())				{return 1;}
 	
+	STDMETHOD(ScheduledPlaybackHasStopped())
+	{
+		is_running_ = false;
+		CASPAR_LOG(info) << print() << L" Scheduled playback has stopped.";
+		return S_OK;
+	}
+
 	STDMETHOD(ScheduledFrameCompleted(IDeckLinkVideoFrame* completed_frame, BMDOutputFrameCompletionResult result))
 	{
 		if(!is_running_)
@@ -271,36 +295,34 @@ public:
 		try
 		{
 			if(result == bmdOutputFrameDisplayedLate)
+			{
 				graph_->add_tag("late-frame");
+				++frames_scheduled_;
+				++audio_scheduled_;
+			}
 			else if(result == bmdOutputFrameDropped)
 				graph_->add_tag("dropped-frame");
 			else if(result == bmdOutputFrameFlushed)
 				graph_->add_tag("flushed-frame");
 
-			frame_container_.erase(std::find_if(frame_container_.begin(), frame_container_.end(), [&](const decklink_frame_adapter& frame)
+			frame_container_.erase(std::find_if(frame_container_.begin(), frame_container_.end(), [&](const std::shared_ptr<IDeckLinkVideoFrame>& frame)
 			{
-				return &frame == completed_frame;
+				return frame.get() == completed_frame;
 			}));
 
-			std::shared_ptr<const core::read_frame> frame;	
-			video_frame_buffer_.pop(frame);		
-			schedule_next_video(safe_ptr<const core::read_frame>(frame));			
+			std::shared_ptr<core::read_frame> frame;	
+			video_frame_buffer_.pop(frame);					
+			schedule_next_video(make_safe(frame));	
 		}
 		catch(...)
 		{
+			tbb::spin_mutex::scoped_lock lock(exception_mutex_);
 			exception_ = std::current_exception();
 			return E_FAIL;
 		}
 
 		return S_OK;
 	}
-
-	STDMETHOD(ScheduledPlaybackHasStopped())
-	{
-		is_running_ = false;
-		CASPAR_LOG(info) << print() << L" Scheduled playback has stopped.";
-		return S_OK;
-	}
 		
 	STDMETHOD(RenderAudioSamples(BOOL preroll))
 	{
@@ -308,16 +330,27 @@ public:
 			return E_FAIL;
 		
 		try
-		{
-			std::shared_ptr<const core::read_frame> frame;
-			audio_frame_buffer_.pop(frame);
-			schedule_next_audio(safe_ptr<const core::read_frame>(frame));		
-
+		{	
 			if(preroll)
-				start_playback();
+			{
+				if(++preroll_count_ >= buffer_size_)
+				{
+					output_->EndAudioPreroll();
+					start_playback();				
+				}
+				else
+					schedule_next_audio(make_safe<core::read_frame>());	
+			}
+			else
+			{
+				std::shared_ptr<core::read_frame> frame;
+				audio_frame_buffer_.pop(frame);
+				schedule_next_audio(make_safe(frame));	
+			}
 		}
 		catch(...)
 		{
+			tbb::spin_mutex::scoped_lock lock(exception_mutex_);
 			exception_ = std::current_exception();
 			return E_FAIL;
 		}
@@ -325,34 +358,33 @@ public:
 		return S_OK;
 	}
 
-	void schedule_next_audio(const safe_ptr<const core::read_frame>& frame)
+	void schedule_next_audio(const safe_ptr<core::read_frame>& frame)
 	{
-		static std::vector<short> silence(48000, 0);
-		
-		const int sample_count = format_desc_.audio_samples_per_frame;
-		const int sample_frame_count = sample_count/2;
+		const int sample_frame_count = frame->audio_data().size()/format_desc_.audio_channels;
 
-		const short* frame_audio_data = frame->audio_data().size() == sample_count ? frame->audio_data().begin() : silence.data();
-		audio_container_.push_back(std::vector<short>(frame_audio_data, frame_audio_data+sample_count));
+		audio_container_.push_back(std::vector<int16_t>(frame->audio_data().begin(), frame->audio_data().end()));
 
 		if(FAILED(output_->ScheduleAudioSamples(audio_container_.back().data(), sample_frame_count, (audio_scheduled_++) * sample_frame_count, format_desc_.audio_sample_rate, nullptr)))
 			CASPAR_LOG(error) << print() << L" Failed to schedule audio.";
 	}
 			
-	void schedule_next_video(const safe_ptr<const core::read_frame>& frame)
+	void schedule_next_video(const safe_ptr<core::read_frame>& frame)
 	{
-		frame_container_.push_back(decklink_frame_adapter(frame, format_desc_));
-		if(FAILED(output_->ScheduleVideoFrame(&frame_container_.back(), (frames_scheduled_++) * format_desc_.duration, format_desc_.duration, format_desc_.time_scale)))
+		frame_container_.push_back(std::make_shared<decklink_frame>(frame, format_desc_, config_.key_only));
+		if(FAILED(output_->ScheduleVideoFrame(frame_container_.back().get(), (frames_scheduled_++) * format_desc_.duration, format_desc_.duration, format_desc_.time_scale)))
 			CASPAR_LOG(error) << print() << L" Failed to schedule video.";
 
 		graph_->update_value("tick-time", tick_timer_.elapsed()*format_desc_.fps*0.5);
 		tick_timer_.restart();
 	}
 
-	void send(const safe_ptr<const core::read_frame>& frame)
+	void send(const safe_ptr<core::read_frame>& frame)
 	{
-		if(exception_ != nullptr)
-			std::rethrow_exception(exception_);
+		{
+			tbb::spin_mutex::scoped_lock lock(exception_mutex_);
+			if(exception_ != nullptr)
+				std::rethrow_exception(exception_);
+		}
 
 		if(!is_running_)
 			BOOST_THROW_EXCEPTION(caspar_exception() << msg_info(narrow(print()) + " Is not running."));
@@ -364,34 +396,71 @@ public:
 	
 	std::wstring print() const
 	{
-		return model_name_ + L" [" + boost::lexical_cast<std::wstring>(config_.device_index) + L"]";
+		return model_name_ + L" [" + boost::lexical_cast<std::wstring>(config_.device_index) + L"|" +  format_desc_.name + L"]";
 	}
 };
 
 struct decklink_consumer_proxy : public core::frame_consumer
 {
-	const configuration config_;
-
-	com_context<decklink_consumer> context_;
+	const configuration				config_;
+	com_context<decklink_consumer>	context_;
+	core::video_format_desc			format_desc_;
+	size_t							fail_count_;
 public:
 
 	decklink_consumer_proxy(const configuration& config)
 		: config_(config)
-		, context_(L"decklink_consumer[" + boost::lexical_cast<std::wstring>(config.device_index) + L"]"){}
+		, context_(L"decklink_consumer[" + boost::lexical_cast<std::wstring>(config.device_index) + L"]")
+		, fail_count_(0)
+	{
+	}
+
+	~decklink_consumer_proxy()
+	{
+		auto str = print();
+		context_.reset();
+		CASPAR_LOG(info) << str << L" Successfully Uninitialized.";	
+	}
 	
 	virtual void initialize(const core::video_format_desc& format_desc)
 	{
-		context_.reset([&]{return new decklink_consumer(config_, format_desc);});
+		format_desc_ = format_desc;
+		context_.reset([&]{return new decklink_consumer(config_, format_desc_);});		
+				
+		CASPAR_LOG(info) << print() << L" Successfully Initialized.";	
 	}
 	
-	virtual void send(const safe_ptr<const core::read_frame>& frame)
+	virtual bool send(const safe_ptr<core::read_frame>& frame)
 	{
-		context_->send(frame);
+		if(!context_)
+			context_.reset([&]{return new decklink_consumer(config_, format_desc_);});
+
+		try
+		{
+			context_->send(frame);
+			fail_count_ = 0;
+		}
+		catch(...)
+		{
+			context_.reset();
+
+			if(fail_count_++ > 3)
+				return false;  // Outside didn't handle exception properly, just give up.
+			
+			throw;
+		}
+
+		return true;
 	}
 	
 	virtual std::wstring print() const
 	{
-		return context_->print();
+		return context_ ? context_->print() : L"decklink_consumer";
+	}
+			
+	virtual const core::video_format_desc& get_video_format_desc() const
+	{
+		return format_desc_;
 	}
 };	
 
@@ -404,18 +473,11 @@ safe_ptr<core::frame_consumer> create_decklink_consumer(const std::vector<std::w
 		
 	if(params.size() > 1)
 		config.device_index = lexical_cast_or_default<int>(params[1], config.device_index);
-		
-	if(std::find(params.begin(), params.end(), L"INTERNAL_KEY") != params.end())
-		config.keyer = internal_key;
-	else if(std::find(params.begin(), params.end(), L"EXTERNAL_KEY") != params.end())
-		config.keyer = external_key;
 	
-	if(std::find(params.begin(), params.end(), L"LOW_LATENCY") != params.end())
-		config.latency = low_latency;
-	else if(std::find(params.begin(), params.end(), L"NORMAL_LATENCY") != params.end())
-		config.latency = normal_latency;
-		
-	config.embedded_audio = std::find(params.begin(), params.end(), L"EMBEDDED_AUDIO") != params.end();
+	config.internal_key		= std::find(params.begin(), params.end(), L"INTERNAL_KEY")	 != params.end();
+	config.low_latency		= std::find(params.begin(), params.end(), L"LOW_LATENCY")	 != params.end();
+	config.embedded_audio	= std::find(params.begin(), params.end(), L"EMBEDDED_AUDIO") != params.end();
+	config.key_only			= std::find(params.begin(), params.end(), L"KEY_ONLY")		 != params.end();
 
 	return make_safe<decklink_consumer_proxy>(config);
 }
@@ -424,20 +486,11 @@ safe_ptr<core::frame_consumer> create_decklink_consumer(const boost::property_tr
 {
 	configuration config;
 
-	auto key_str = ptree.get("key", "default");
-	if(key_str == "internal")
-		config.keyer = internal_key;
-	else if(key_str == "external")
-		config.keyer = external_key;
-
-	auto latency_str = ptree.get("latency", "default");
-	if(latency_str == "normal")
-		config.latency = normal_latency;
-	else if(latency_str == "low")
-		config.latency = low_latency;
-
-	config.device_index = ptree.get("device", 0);
-	config.embedded_audio  = ptree.get("embedded-audio", false);
+	config.internal_key		= ptree.get("internal-key",	  config.internal_key);
+	config.low_latency		= ptree.get("low-latency",	  config.low_latency);
+	config.key_only			= ptree.get("key-only",		  config.key_only);
+	config.device_index		= ptree.get("device",		  config.device_index);
+	config.embedded_audio	= ptree.get("embedded-audio", config.embedded_audio);
 
 	return make_safe<decklink_consumer_proxy>(config);
 }