X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsession.cpp;h=852de2981eb7bd43d9e82cf03154ae7bbeadbff7;hp=e2b6dd7174a0bcdfcadef6ab0041454ab4a2a8c0;hb=47e9e7bbc3a4e91a960f4cbb1db48c5aff6dcace;hpb=86123e2e4711e67f2246998b7172413199f231f4

diff --git a/pv/session.cpp b/pv/session.cpp
index e2b6dd71..852de298 100644
--- a/pv/session.cpp
+++ b/pv/session.cpp
@@ -39,6 +39,7 @@
 #include "data/decoderstack.hpp"
 #include "data/logic.hpp"
 #include "data/logicsegment.hpp"
+#include "data/signalbase.hpp"
 #include "data/decode/decoder.hpp"
 
 #include "devices/hardwaredevice.hpp"
@@ -47,6 +48,8 @@
 #include "view/analogsignal.hpp"
 #include "view/decodetrace.hpp"
 #include "view/logicsignal.hpp"
+#include "view/signal.hpp"
+#include "view/view.hpp"
 
 #include <cassert>
 #include <mutex>
@@ -140,13 +143,35 @@ void Session::set_device(shared_ptr<devices::Device> device)
 
 	device_.reset();
 
-	// Remove all traces
-	signals_.clear();
+	// Remove all stored data
+	for (std::shared_ptr<pv::view::View> view : views_)
+		view->clear_signals();
+	for (const shared_ptr<data::SignalData> d : all_signal_data_)
+		d->clear();
+	all_signal_data_.clear();
+	signalbases_.clear();
+	cur_logic_segment_.reset();
+
+	for (auto entry : cur_analog_segments_) {
+		shared_ptr<sigrok::Channel>(entry.first).reset();
+		shared_ptr<data::AnalogSegment>(entry.second).reset();
+	}
+
+	logic_data_.reset();
 	decode_traces_.clear();
+
 	signals_changed();
 
 	device_ = std::move(device);
-	device_->open();
+
+	try {
+		device_->open();
+	} catch (const QString &e) {
+		device_.reset();
+		device_selected();
+		throw;
+	}
+
 	device_->session()->add_datafeed_callback([=]
 		(shared_ptr<sigrok::Device> device, shared_ptr<Packet> packet) {
 			data_feed_in(device, packet);
@@ -180,10 +205,14 @@ Session::capture_state Session::get_capture_state() const
 
 void Session::start_capture(function<void (const QString)> error_handler)
 {
+	if (!device_) {
+		error_handler(tr("No active device set, can't start acquisition."));
+		return;
+	}
+
 	stop_capture();
 
 	// Check that at least one channel is enabled
-	assert(device_);
 	const shared_ptr<sigrok::Device> sr_dev = device_->device();
 	if (sr_dev) {
 		const auto channels = sr_dev->channels();
@@ -196,13 +225,12 @@ void Session::start_capture(function<void (const QString)> error_handler)
 	}
 
 	// Clear signal data
-	for (const shared_ptr<data::SignalData> d : get_data())
+	for (const shared_ptr<data::SignalData> d : all_signal_data_)
 		d->clear();
 
 	// Begin the session
 	sampling_thread_ = std::thread(
-		&Session::sample_thread_proc, this, device_,
-			error_handler);
+		&Session::sample_thread_proc, this, error_handler);
 }
 
 void Session::stop_capture()
@@ -215,30 +243,27 @@ void Session::stop_capture()
 		sampling_thread_.join();
 }
 
-set< shared_ptr<data::SignalData> > Session::get_data() const
+void Session::register_view(std::shared_ptr<pv::view::View> view)
 {
-	shared_lock<shared_mutex> lock(signals_mutex_);
-	set< shared_ptr<data::SignalData> > data;
-	for (const shared_ptr<view::Signal> sig : signals_) {
-		assert(sig);
-		data.insert(sig->data());
-	}
+	views_.insert(view);
+}
 
-	return data;
+void Session::deregister_view(std::shared_ptr<pv::view::View> view)
+{
+	views_.erase(view);
 }
 
 double Session::get_samplerate() const
 {
 	double samplerate = 0.0;
 
-	for (const shared_ptr<pv::data::SignalData> d : get_data()) {
+	for (const shared_ptr<pv::data::SignalData> d : all_signal_data_) {
 		assert(d);
 		const vector< shared_ptr<pv::data::Segment> > segments =
 			d->segments();
 		for (const shared_ptr<pv::data::Segment> &s : segments)
 			samplerate = std::max(samplerate, s->samplerate());
 	}
-
 	// If there is no sample rate given we use samples as unit
 	if (samplerate == 0.0)
 		samplerate = 1.0;
@@ -246,21 +271,19 @@ double Session::get_samplerate() const
 	return samplerate;
 }
 
-const unordered_set< shared_ptr<view::Signal> > Session::signals() const
+const std::unordered_set< std::shared_ptr<data::SignalBase> >
+	Session::signalbases() const
 {
-	shared_lock<shared_mutex> lock(signals_mutex_);
-	return signals_;
+	return signalbases_;
 }
 
 #ifdef ENABLE_DECODE
 bool Session::add_decoder(srd_decoder *const dec)
 {
-	map<const srd_channel*, shared_ptr<view::LogicSignal> > channels;
+	map<const srd_channel*, shared_ptr<data::SignalBase> > channels;
 	shared_ptr<data::DecoderStack> decoder_stack;
 
 	try {
-		lock_guard<boost::shared_mutex> lock(signals_mutex_);
-
 		// Create the decoder
 		decoder_stack = shared_ptr<data::DecoderStack>(
 			new data::DecoderStack(*this, dec));
@@ -274,13 +297,12 @@ bool Session::add_decoder(srd_decoder *const dec)
 
 		// Auto select the initial channels
 		for (const srd_channel *pdch : all_channels)
-			for (shared_ptr<view::Signal> s : signals_) {
-				shared_ptr<view::LogicSignal> l =
-					dynamic_pointer_cast<view::LogicSignal>(s);
-				if (l && QString::fromUtf8(pdch->name).
-					toLower().contains(
-					l->name().toLower()))
-					channels[pdch] = l;
+			for (shared_ptr<data::SignalBase> b : signalbases_) {
+				if (b->type() == ChannelType::LOGIC) {
+					if (QString::fromUtf8(pdch->name).toLower().
+						contains(b->name().toLower()))
+						channels[pdch] = b;
+				}
 			}
 
 		assert(decoder_stack);
@@ -289,8 +311,11 @@ bool Session::add_decoder(srd_decoder *const dec)
 		decoder_stack->stack().front()->set_channels(channels);
 
 		// Create the decode signal
+		shared_ptr<data::SignalBase> signalbase =
+			shared_ptr<data::SignalBase>(new data::SignalBase(nullptr));
+
 		shared_ptr<view::DecodeTrace> d(
-			new view::DecodeTrace(*this, decoder_stack,
+			new view::DecodeTrace(*this, signalbase, decoder_stack,
 				decode_traces_.size()));
 		decode_traces_.push_back(d);
 	} catch (std::runtime_error e) {
@@ -307,7 +332,6 @@ bool Session::add_decoder(srd_decoder *const dec)
 
 vector< shared_ptr<view::DecodeTrace> > Session::get_decode_signals() const
 {
-	shared_lock<shared_mutex> lock(signals_mutex_);
 	return decode_traces_;
 }
 
@@ -338,14 +362,22 @@ void Session::set_capture_state(capture_state state)
 
 void Session::update_signals()
 {
-	assert(device_);
+	if (!device_) {
+		signalbases_.clear();
+		logic_data_.reset();
+		for (std::shared_ptr<pv::view::View> view : views_)
+			view->clear_signals();
+		return;
+	}
 
 	lock_guard<recursive_mutex> lock(data_mutex_);
 
 	const shared_ptr<sigrok::Device> sr_dev = device_->device();
 	if (!sr_dev) {
-		signals_.clear();
+		signalbases_.clear();
 		logic_data_.reset();
+		for (std::shared_ptr<pv::view::View> view : views_)
+			view->clear_signals();
 		return;
 	}
 
@@ -370,47 +402,64 @@ void Session::update_signals()
 		}
 	}
 
-	// Make the Signals list
-	{
-		unique_lock<shared_mutex> lock(signals_mutex_);
-
-		unordered_set< shared_ptr<view::Signal> > prev_sigs(signals_);
-		signals_.clear();
+	// Make the signals list
+	for (std::shared_ptr<pv::view::View> view : views_) {
+		unordered_set< shared_ptr<view::Signal> > prev_sigs(view->signals());
+		view->clear_signals();
 
 		for (auto channel : sr_dev->channels()) {
+			shared_ptr<data::SignalBase> signalbase;
 			shared_ptr<view::Signal> signal;
 
 			// Find the channel in the old signals
 			const auto iter = std::find_if(
 				prev_sigs.cbegin(), prev_sigs.cend(),
 				[&](const shared_ptr<view::Signal> &s) {
-					return s->channel() == channel;
+					return s->base()->channel() == channel;
 				});
 			if (iter != prev_sigs.end()) {
 				// Copy the signal from the old set to the new
 				signal = *iter;
-				auto logic_signal = dynamic_pointer_cast<
-					view::LogicSignal>(signal);
-				if (logic_signal)
-					logic_signal->set_logic_data(
-						logic_data_);
 			} else {
-				// Create a new signal
+				// Find the signalbase for this channel if possible
+				signalbase.reset();
+				for (const shared_ptr<data::SignalBase> b : signalbases_)
+					if (b->channel() == channel)
+						signalbase = b;
+
 				switch(channel->type()->id()) {
 				case SR_CHANNEL_LOGIC:
+					if (!signalbase) {
+						signalbase = shared_ptr<data::SignalBase>(
+							new data::SignalBase(channel));
+						signalbases_.insert(signalbase);
+
+						all_signal_data_.insert(logic_data_);
+						signalbase->set_data(logic_data_);
+					}
+
 					signal = shared_ptr<view::Signal>(
 						new view::LogicSignal(*this,
-							device_, channel,
-							logic_data_));
+							device_, signalbase));
+					view->add_signal(signal);
 					break;
 
 				case SR_CHANNEL_ANALOG:
 				{
-					shared_ptr<data::Analog> data(
-						new data::Analog());
+					if (!signalbase) {
+						signalbase = shared_ptr<data::SignalBase>(
+							new data::SignalBase(channel));
+						signalbases_.insert(signalbase);
+
+						shared_ptr<data::Analog> data(new data::Analog());
+						all_signal_data_.insert(data);
+						signalbase->set_data(data);
+					}
+
 					signal = shared_ptr<view::Signal>(
 						new view::AnalogSignal(
-							*this, channel, data));
+							*this, signalbase));
+					view->add_signal(signal);
 					break;
 				}
 
@@ -419,34 +468,29 @@ void Session::update_signals()
 					break;
 				}
 			}
-
-			assert(signal);
-			signals_.insert(signal);
 		}
 	}
 
 	signals_changed();
 }
 
-shared_ptr<view::Signal> Session::signal_from_channel(
-	shared_ptr<Channel> channel) const
+shared_ptr<data::SignalBase> Session::signalbase_from_channel(
+	shared_ptr<sigrok::Channel> channel) const
 {
-	lock_guard<boost::shared_mutex> lock(signals_mutex_);
-	for (shared_ptr<view::Signal> sig : signals_) {
+	for (shared_ptr<data::SignalBase> sig : signalbases_) {
 		assert(sig);
 		if (sig->channel() == channel)
 			return sig;
 	}
-	return shared_ptr<view::Signal>();
+	return shared_ptr<data::SignalBase>();
 }
 
-void Session::sample_thread_proc(shared_ptr<devices::Device> device,
-	function<void (const QString)> error_handler)
+void Session::sample_thread_proc(function<void (const QString)> error_handler)
 {
-	assert(device);
 	assert(error_handler);
 
-	(void)device;
+	if (!device_)
+		return;
 
 	cur_samplerate_ = device_->read_config<uint64_t>(ConfigKey::SAMPLERATE);
 
@@ -506,17 +550,19 @@ void Session::feed_in_trigger()
 	// The channel containing most samples should be most accurate
 	uint64_t sample_count = 0;
 
-	for (const shared_ptr<pv::data::SignalData> d : get_data()) {
-		assert(d);
-		uint64_t temp_count = 0;
+	{
+		for (const shared_ptr<pv::data::SignalData> d : all_signal_data_) {
+			assert(d);
+			uint64_t temp_count = 0;
 
-		const vector< shared_ptr<pv::data::Segment> > segments =
-			d->segments();
-		for (const shared_ptr<pv::data::Segment> &s : segments)
-			temp_count += s->get_sample_count();
+			const vector< shared_ptr<pv::data::Segment> > segments =
+				d->segments();
+			for (const shared_ptr<pv::data::Segment> &s : segments)
+				temp_count += s->get_sample_count();
 
-		if (temp_count > sample_count)
-			sample_count = temp_count;
+			if (temp_count > sample_count)
+				sample_count = temp_count;
+		}
 	}
 
 	trigger_event(sample_count / get_samplerate());
@@ -574,7 +620,7 @@ void Session::feed_in_analog(shared_ptr<Analog> analog)
 	const float *data = static_cast<const float *>(analog->data_pointer());
 	bool sweep_beginning = false;
 
-	if (signals_.empty())
+	if (signalbases_.empty())
 		update_signals();
 
 	for (auto channel : channels) {
@@ -598,12 +644,10 @@ void Session::feed_in_analog(shared_ptr<Analog> analog)
 			cur_analog_segments_[channel] = segment;
 
 			// Find the analog data associated with the channel
-			shared_ptr<view::AnalogSignal> sig =
-				dynamic_pointer_cast<view::AnalogSignal>(
-					signal_from_channel(channel));
-			assert(sig);
+			shared_ptr<data::SignalBase> base = signalbase_from_channel(channel);
+			assert(base);
 
-			shared_ptr<data::Analog> data(sig->analog_data());
+			shared_ptr<data::Analog> data(base->analog_data());
 			assert(data);
 
 			// Push the segment into the analog data.