X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Foal%2Fconsumer%2Foal_consumer.cpp;h=cb727f62905b54c5189abdbcd2066b8543fd2926;hb=6016fd682b267d2886babd51b1faa9cdd1812d54;hp=259e88cc330756308d01aa08df2ecd8c4a2e09ab;hpb=ff6d30a547b05bcc55d2c8201e70bb016c7c8afd;p=casparcg

diff --git a/modules/oal/consumer/oal_consumer.cpp b/modules/oal/consumer/oal_consumer.cpp
index 259e88cc3..cb727f629 100644
--- a/modules/oal/consumer/oal_consumer.cpp
+++ b/modules/oal/consumer/oal_consumer.cpp
@@ -20,96 +20,111 @@
  
 #include "oal_consumer.h"
 
+#include <common/exception/exceptions.h>
 #include <common/diagnostics/graph.h>
 #include <common/log/log.h>
 #include <common/utility/timer.h>
+#include <common/utility/string.h>
 
+#include <core/consumer/frame_consumer.h>
 #include <core/video_format.h>
 
-#include <core/consumer/frame/read_frame.h>
+#include <core/mixer/read_frame.h>
 
 #include <SFML/Audio.hpp>
 
 #include <boost/circular_buffer.hpp>
+#include <boost/timer.hpp>
 
 #include <tbb/concurrent_queue.h>
 
 namespace caspar {
 
-struct oal_consumer::implementation : public sf::SoundStream, boost::noncopyable
+struct oal_consumer : public core::frame_consumer,  public sf::SoundStream
 {
-	safe_ptr<diagnostics::graph> graph_;
-	timer perf_timer_;
+	safe_ptr<diagnostics::graph>						graph_;
+	boost::timer										perf_timer_;
 
-	tbb::concurrent_bounded_queue<std::vector<short>> input_;
-	boost::circular_buffer<std::vector<short>> container_;
-	tbb::atomic<bool> is_running_;
+	tbb::concurrent_bounded_queue<std::shared_ptr<std::vector<short>>>	input_;
+	boost::circular_buffer<std::vector<short>>			container_;
+	tbb::atomic<bool>									is_running_;
 
-	core::video_format_desc format_desc_;
+	core::video_format_desc								format_desc_;
+	int													preroll_count_;
 public:
-	implementation(const core::video_format_desc& format_desc) 
+	oal_consumer() 
 		: graph_(diagnostics::create_graph(narrow(print())))
-		, container_(5)
-		, format_desc_(format_desc)
+		, container_(16)
+		, preroll_count_(0)
 	{
+		if(core::consumer_buffer_depth() < 3)
+			BOOST_THROW_EXCEPTION(invalid_argument() << msg_info("audio-consumer does not support buffer-depth lower than 3."));
+
 		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));	
 		is_running_ = true;
-		input_.set_capacity(4);
-		for(size_t n = 0; n < buffer_depth(); ++n)
-			input_.push(std::vector<short>(static_cast<size_t>(48000.0f/format_desc_.fps)*2, 0)); 
-
-		sf::SoundStream::Initialize(2, 48000);
-		Play();		
-		CASPAR_LOG(info) << print() << " Sucessfully initialized.";
+		input_.set_capacity(core::consumer_buffer_depth()-2);
 	}
 
-	~implementation()
+	~oal_consumer()
 	{
 		is_running_ = false;
-		input_.try_push(std::vector<short>());
-		input_.try_push(std::vector<short>());
+		input_.try_push(std::make_shared<std::vector<short>>());
+		input_.try_push(std::make_shared<std::vector<short>>());
 		Stop();
 		CASPAR_LOG(info) << print() << L" Shutting down.";	
 	}
+
+	virtual void initialize(const core::video_format_desc& format_desc)
+	{
+		format_desc_ = format_desc;		
+		sf::SoundStream::Initialize(2, 48000);
+		CASPAR_LOG(info) << print() << " Sucessfully initialized.";
+	}
 	
-	void send(const safe_ptr<const core::read_frame>& frame)
-	{				
-		if(!frame->audio_data().empty())
-			input_.push(std::vector<short>(frame->audio_data().begin(), frame->audio_data().end())); 	
-		else
-			input_.push(std::vector<short>(static_cast<size_t>(48000.0f/format_desc_.fps)*2, 0)); 
+	virtual bool send(const safe_ptr<core::read_frame>& frame)
+	{			
+		if(preroll_count_ < input_.capacity())
+		{
+			while(input_.try_push(std::make_shared<std::vector<int16_t>>(format_desc_.audio_samples_per_frame, 0)))
+				++preroll_count_;
+			Play();		
+		}
+
+		std::vector<int16_t> audio16(frame->audio_data().size());
+		for(size_t n = 0; n < audio16.size(); ++n)		
+			audio16[n] = (frame->audio_data()[n] >> 16) & 0xffff;		
+
+		input_.push(std::make_shared<std::vector<int16_t>>(std::move(audio16)));
+
+		return true;
 	}
-
-	size_t buffer_depth() const{return 3;}
-
+	
 	virtual bool OnGetData(sf::SoundStream::Chunk& data)
 	{		
-		std::vector<short> audio_data;		
+		std::shared_ptr<std::vector<short>> audio_data;		
 		input_.pop(audio_data);
 				
-		container_.push_back(std::move(audio_data));
+		container_.push_back(std::move(*audio_data));
 		data.Samples = container_.back().data();
 		data.NbSamples = container_.back().size();	
 		
-		graph_->update_value("tick-time", static_cast<float>(perf_timer_.elapsed()/format_desc_.interval*0.5));		
-		perf_timer_.reset();
+		graph_->update_value("tick-time", perf_timer_.elapsed()*format_desc_.fps*0.5);		
+		perf_timer_.restart();
 
 		return is_running_;
 	}
 
-	std::wstring print() const
+	virtual std::wstring print() const
 	{
-		return L"oal[default]";
+		return L"oal[" + format_desc_.name + L"]";
 	}
-};
 
-oal_consumer::oal_consumer(){}
-oal_consumer::oal_consumer(oal_consumer&& other) : impl_(std::move(other.impl_)){}
-void oal_consumer::send(const safe_ptr<const core::read_frame>& frame){impl_->send(frame);}
-size_t oal_consumer::buffer_depth() const{return impl_->buffer_depth();}
-void oal_consumer::initialize(const core::video_format_desc& format_desc){impl_.reset(new implementation(format_desc));}
-std::wstring oal_consumer::print() const { return impl_->print(); }
+	virtual const core::video_format_desc& get_video_format_desc() const
+	{
+		return format_desc_;
+	}
+};
 
 safe_ptr<core::frame_consumer> create_oal_consumer(const std::vector<std::wstring>& params)
 {
@@ -118,4 +133,10 @@ safe_ptr<core::frame_consumer> create_oal_consumer(const std::vector<std::wstrin
 
 	return make_safe<oal_consumer>();
 }
+
+safe_ptr<core::frame_consumer> create_oal_consumer()
+{
+	return make_safe<oal_consumer>();
+}
+
 }