X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fdecklink%2Fproducer%2Fdecklink_producer.cpp;h=420256641861cd0e3bbd44bbdd16fd89895defdd;hb=bb129b7e3c7537ed6b1c2183cd69479c3d5496da;hp=d211ff16b9f4fe1a06d8c751f5d0977c8ea943ce;hpb=2d80ab0f4f50a627c34d174595352e4751bafd64;p=casparcg

diff --git a/modules/decklink/producer/decklink_producer.cpp b/modules/decklink/producer/decklink_producer.cpp
index d211ff16b..420256641 100644
--- a/modules/decklink/producer/decklink_producer.cpp
+++ b/modules/decklink/producer/decklink_producer.cpp
@@ -27,21 +27,22 @@
 
 #include "../../ffmpeg/producer/filter/filter.h"
 #include "../../ffmpeg/producer/util.h"
+#include "../../ffmpeg/producer/frame_muxer.h"
 
+#include <common/log/log.h>
 #include <common/diagnostics/graph.h>
 #include <common/concurrency/com_context.h>
 #include <common/exception/exceptions.h>
 #include <common/memory/memclr.h>
 
 #include <core/mixer/write_frame.h>
-#include <core/producer/frame/audio_transform.h>
+#include <core/producer/frame/frame_transform.h>
 #include <core/producer/frame/frame_factory.h>
-#include <core/producer/frame_muxer.h>
 
 #include <tbb/concurrent_queue.h>
-#include <tbb/atomic.h>
 
 #include <boost/algorithm/string.hpp>
+#include <boost/foreach.hpp>
 #include <boost/timer.hpp>
 
 #if defined(_MSC_VER)
@@ -72,7 +73,7 @@ extern "C"
 
 namespace caspar { 
 		
-class decklink_producer : public IDeckLinkInputCallback
+class decklink_producer : boost::noncopyable, public IDeckLinkInputCallback
 {	
 	CComPtr<IDeckLink>											decklink_;
 	CComQIPtr<IDeckLinkInput>									input_;
@@ -84,18 +85,15 @@ class decklink_producer : public IDeckLinkInputCallback
 	std::shared_ptr<diagnostics::graph>							graph_;
 	boost::timer												tick_timer_;
 	boost::timer												frame_timer_;
-
-	std::vector<int16_t>										audio_samples_;
-	
+		
 	safe_ptr<core::frame_factory>								frame_factory_;
 
 	tbb::concurrent_bounded_queue<safe_ptr<core::basic_frame>>	frame_buffer_;
-	safe_ptr<core::basic_frame>									tail_;
 
 	std::exception_ptr											exception_;
 	filter														filter_;
 		
-	core::frame_muxer											muxer_;
+	frame_muxer													muxer_;
 
 public:
 	decklink_producer(const core::video_format_desc& format_desc, size_t device_index, const safe_ptr<core::frame_factory>& frame_factory, const std::wstring& filter)
@@ -105,15 +103,14 @@ public:
 		, format_desc_(format_desc)
 		, device_index_(device_index)
 		, frame_factory_(frame_factory)
-		, tail_(core::basic_frame::empty())
 		, filter_(filter)
-		, muxer_(double_rate(filter) ? format_desc.fps * 2.0 : format_desc.fps, frame_factory->get_video_format_desc().mode, frame_factory->get_video_format_desc().fps)
+		, muxer_(double_rate(filter) ? format_desc.fps * 2.0 : format_desc.fps, frame_factory)
 	{
 		frame_buffer_.set_capacity(2);
 		
 		graph_ = diagnostics::create_graph(boost::bind(&decklink_producer::print, this));
 		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("frame-time", diagnostics::color(1.0f, 0.0f, 0.0f));
 		graph_->set_color("dropped-frame", diagnostics::color(0.3f, 0.6f, 0.3f));
@@ -127,7 +124,7 @@ public:
 									<< msg_info(narrow(print()) + " Could not enable video input.")
 									<< boost::errinfo_api_function("EnableVideoInput"));
 
-		if(FAILED(input_->EnableAudioInput(bmdAudioSampleRate48kHz, bmdAudioSampleType16bitInteger, 2))) 
+		if(FAILED(input_->EnableAudioInput(bmdAudioSampleRate48kHz, bmdAudioSampleType32bitInteger, format_desc_.audio_channels))) 
 			BOOST_THROW_EXCEPTION(caspar_exception() 
 									<< msg_info(narrow(print()) + " Could not enable audio input.")
 									<< boost::errinfo_api_function("EnableAudioInput"));
@@ -187,22 +184,24 @@ public:
 			av_frame->format			= PIX_FMT_UYVY422;
 			av_frame->width				= video->GetWidth();
 			av_frame->height			= video->GetHeight();
-			av_frame->interlaced_frame	= format_desc_.mode != core::video_mode::progressive;
-			av_frame->top_field_first	= format_desc_.mode == core::video_mode::upper ? 1 : 0;
+			av_frame->interlaced_frame	= format_desc_.field_mode != core::field_mode::progressive;
+			av_frame->top_field_first	= format_desc_.field_mode == core::field_mode::upper ? 1 : 0;
 					
-			filter_.push(av_frame);
-			BOOST_FOREACH(auto& av_frame2, filter_.poll())
-				muxer_.push(make_write_frame(this, av_frame2, frame_factory_));		
+			BOOST_FOREACH(auto& av_frame2, filter_.execute(av_frame))
+				muxer_.push(av_frame2);		
 									
 			// It is assumed that audio is always equal or ahead of video.
 			if(audio && SUCCEEDED(audio->GetBytes(&bytes)))
 			{
-				auto audio_data = reinterpret_cast<short*>(bytes);
-				muxer_.push(std::vector<int16_t>(audio_data, audio_data + audio->GetSampleFrameCount()*2));
+				auto sample_frame_count = audio->GetSampleFrameCount();
+				auto audio_data = reinterpret_cast<int32_t*>(bytes);
+				muxer_.push(std::make_shared<core::audio_buffer>(audio_data, audio_data + sample_frame_count*format_desc_.audio_channels));
 			}
 			else
-				muxer_.push(std::vector<int16_t>(frame_factory_->get_video_format_desc().audio_samples_per_frame, 0));
+				muxer_.push(std::make_shared<core::audio_buffer>(frame_factory_->get_video_format_desc().audio_samples_per_frame, 0));
 					
+			muxer_.commit();
+
 			while(!muxer_.empty())
 			{
 				if(!frame_buffer_.try_push(muxer_.pop()))
@@ -227,10 +226,11 @@ public:
 		if(exception_ != nullptr)
 			std::rethrow_exception(exception_);
 
-		if(!frame_buffer_.try_pop(tail_))
+		safe_ptr<core::basic_frame> frame = core::basic_frame::late();
+		if(!frame_buffer_.try_pop(frame))
 			graph_->add_tag("late-frame");
 		graph_->set_value("output-buffer", static_cast<float>(frame_buffer_.size())/static_cast<float>(frame_buffer_.capacity()));	
-		return tail_;
+		return frame;
 	}
 	
 	std::wstring print() const
@@ -241,18 +241,42 @@ public:
 	
 class decklink_producer_proxy : public core::frame_producer
 {		
-	com_context<decklink_producer> context_;
+	safe_ptr<core::basic_frame>		last_frame_;
+	com_context<decklink_producer>	context_;
+	const int64_t					length_;
 public:
 
-	explicit decklink_producer_proxy(const safe_ptr<core::frame_factory>& frame_factory, const core::video_format_desc& format_desc, size_t device_index, const std::wstring& filter_str = L"")
+	explicit decklink_producer_proxy(const safe_ptr<core::frame_factory>& frame_factory, const core::video_format_desc& format_desc, size_t device_index, const std::wstring& filter_str, int64_t length)
 		: context_(L"decklink_producer[" + boost::lexical_cast<std::wstring>(device_index) + L"]")
+		, last_frame_(core::basic_frame::empty())
+		, length_(length)
 	{
 		context_.reset([&]{return new decklink_producer(format_desc, device_index, frame_factory, filter_str);}); 
 	}
+
+	~decklink_producer_proxy()
+	{
+		auto str = print();
+		context_.reset();
+		CASPAR_LOG(info) << str << L" Successfully Uninitialized.";	
+	}
 				
-	virtual safe_ptr<core::basic_frame> receive()
+	virtual safe_ptr<core::basic_frame> receive(int)
+	{
+		auto frame = context_->get_frame();
+		if(frame != core::basic_frame::late())
+			last_frame_ = frame;
+		return frame;
+	}
+
+	virtual safe_ptr<core::basic_frame> last_frame() const
 	{
-		return context_->get_frame();
+		return disable_audio(last_frame_);
+	}
+	
+	virtual int64_t nb_frames() const 
+	{
+		return length_;
 	}
 	
 	std::wstring print() const
@@ -266,28 +290,19 @@ safe_ptr<core::frame_producer> create_decklink_producer(const safe_ptr<core::fra
 	if(params.empty() || !boost::iequals(params[0], "decklink"))
 		return core::frame_producer::empty();
 
-	size_t device_index = 1;
-	if(params.size() > 1)
-		device_index = lexical_cast_or_default(params[1], 1);
-
-	core::video_format_desc format_desc = core::video_format_desc::get(L"PAL");
-	if(params.size() > 2)
-	{
-		auto desc = core::video_format_desc::get(params[2]);
-		if(desc.format != core::video_format::invalid)
-			format_desc = desc;
-	}
+	auto device_index	= core::get_param(L"DEVICE", params, 1);
+	auto filter_str		= core::get_param<std::wstring>(L"FILTER", params, L""); 	
+	auto length			= core::get_param(L"LENGTH", params, std::numeric_limits<int64_t>::max()); 	
 	
-	std::wstring filter_str = L"";
+	boost::replace_all(filter_str, L"DEINTERLACE", L"YADIF=0:-1");
+	boost::replace_all(filter_str, L"DEINTERLACE_BOB", L"YADIF=1:-1");
 
-	auto filter_it = std::find(params.begin(), params.end(), L"FILTER");
-	if(filter_it != params.end())
-	{
-		if(++filter_it != params.end())
-			filter_str = *filter_it;
-	}
+	auto format_desc	= core::video_format_desc::get(core::get_param<std::wstring>(L"FORMAT", params, L"INVALID"));
 
-	return make_safe<decklink_producer_proxy>(frame_factory, format_desc, device_index, filter_str);
+	if(format_desc.format == core::video_format::invalid)
+		format_desc = frame_factory->get_video_format_desc();
+			
+	return make_safe<decklink_producer_proxy>(frame_factory, format_desc, device_index, filter_str, length);
 }
 
 }
\ No newline at end of file