X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fsession.cpp;h=80dad66ee929ef36974da0573cb982f3843b4e06;hp=605cc05c65fd8ab234f5509d5885f30f276f805d;hb=dbed5609ae31cdfc3e9db10f3ab91b7607c08372;hpb=558ad6ceb934ab7406d286c1a4ae08da4aba1448

diff --git a/pv/session.cpp b/pv/session.cpp
index 605cc05c..80dad66e 100644
--- a/pv/session.cpp
+++ b/pv/session.cpp
@@ -28,6 +28,7 @@
 #include <sys/stat.h>
 
 #include "devicemanager.hpp"
+#include "mainwindow.hpp"
 #include "session.hpp"
 
 #include "data/analog.hpp"
@@ -299,8 +300,9 @@ void Session::restore_settings(QSettings &settings)
 				filename.toStdString());
 			set_device(device);
 
-			// TODO Perform error handling
-			start_capture([](QString infoMessage) { (void)infoMessage; });
+			start_capture([](QString infoMessage) {
+				// TODO Emulate noquote()
+				qDebug() << "Session error:" << infoMessage; });
 
 			set_name(QFileInfo(filename).fileName());
 		}
@@ -352,8 +354,7 @@ void Session::select_device(shared_ptr<devices::Device> device)
 		else
 			set_default_device();
 	} catch (const QString &e) {
-		main_bar_->session_error(tr("Failed to Select Device"),
-			tr("Failed to Select Device"));
+		MainWindow::show_session_error(tr("Failed to select device"), e);
 	}
 }
 
@@ -401,6 +402,7 @@ void Session::set_device(shared_ptr<devices::Device> device)
 		device_->open();
 	} catch (const QString &e) {
 		device_.reset();
+		MainWindow::show_session_error(tr("Failed to open device"), e);
 	}
 
 	if (device_) {
@@ -426,7 +428,7 @@ void Session::set_default_device()
 	// Try and find the demo device and select that by default
 	const auto iter = find_if(devices.begin(), devices.end(),
 		[] (const shared_ptr<devices::HardwareDevice> &d) {
-			return d->hardware_device()->driver()->name() == "demo";	});
+			return d->hardware_device()->driver()->name() == "demo"; });
 	set_device((iter == devices.end()) ? devices.front() : *iter);
 }
 
@@ -490,7 +492,7 @@ void Session::load_init_file(const string &file_name, const string &format)
 			[&](const pair<string, shared_ptr<InputFormat> > f) {
 				return f.first == user_name; });
 		if (iter == formats.end()) {
-			main_bar_->session_error(tr("Error"),
+			MainWindow::show_session_error(tr("Error"),
 				tr("Unexpected input format: %s").arg(QString::fromStdString(format)));
 			return;
 		}
@@ -521,8 +523,8 @@ void Session::load_file(QString file_name,
 				new devices::SessionFile(
 					device_manager_.context(),
 					file_name.toStdString())));
-	} catch (Error e) {
-		main_bar_->session_error(tr("Failed to load ") + file_name, e.what());
+	} catch (Error& e) {
+		MainWindow::show_session_error(tr("Failed to load ") + file_name, e.what());
 		set_default_device();
 		main_bar_->update_device_list();
 		return;
@@ -531,7 +533,7 @@ void Session::load_file(QString file_name,
 	main_bar_->update_device_list();
 
 	start_capture([&, errorMessage](QString infoMessage) {
-		main_bar_->session_error(errorMessage, infoMessage); });
+		MainWindow::show_session_error(errorMessage, infoMessage); });
 
 	set_name(QFileInfo(file_name).fileName());
 }
@@ -567,6 +569,8 @@ void Session::start_capture(function<void (const QString)> error_handler)
 	for (const shared_ptr<data::SignalData> d : all_signal_data_)
 		d->clear();
 
+	trigger_list_.clear();
+
 	// Revert name back to default name (e.g. "Session 1") for real devices
 	// as the (possibly saved) data is gone. File devices keep their name.
 	shared_ptr<devices::HardwareDevice> hw_device =
@@ -677,16 +681,27 @@ double Session::get_samplerate() const
 	return samplerate;
 }
 
-int Session::get_segment_count() const
+uint32_t Session::get_segment_count() const
 {
-	int min_val = INT_MAX;
+	uint32_t value = 0;
 
-	// Find the lowest common number of segments
+	// Find the highest number of segments
 	for (shared_ptr<data::SignalData> data : all_signal_data_)
-		if (data->get_segment_count() < min_val)
-			min_val = data->get_segment_count();
+		if (data->get_segment_count() > value)
+			value = data->get_segment_count();
+
+	return value;
+}
 
-	return (min_val != INT_MAX) ? min_val : 0;
+vector<util::Timestamp> Session::get_triggers(uint32_t segment_id) const
+{
+	vector<util::Timestamp> result;
+
+	for (pair<uint32_t, util::Timestamp> entry : trigger_list_)
+		if (entry.first == segment_id)
+			result.push_back(entry.second);
+
+	return result;
 }
 
 const unordered_set< shared_ptr<data::SignalBase> > Session::signalbases() const
@@ -694,6 +709,17 @@ const unordered_set< shared_ptr<data::SignalBase> > Session::signalbases() const
 	return signalbases_;
 }
 
+bool Session::all_segments_complete(uint32_t segment_id) const
+{
+	bool all_complete = true;
+
+	for (shared_ptr<data::SignalBase> base : signalbases_)
+		if (!base->segment_is_complete(segment_id))
+			all_complete = false;
+
+	return all_complete;
+}
+
 #ifdef ENABLE_DECODE
 shared_ptr<data::DecodeSignal> Session::add_decode_signal()
 {
@@ -708,7 +734,7 @@ shared_ptr<data::DecodeSignal> Session::add_decode_signal()
 		// Add the decode signal to all views
 		for (shared_ptr<views::ViewBase> view : views_)
 			view->add_decode_signal(signal);
-	} catch (runtime_error e) {
+	} catch (runtime_error& e) {
 		remove_decode_signal(signal);
 		return nullptr;
 	}
@@ -906,10 +932,11 @@ void Session::sample_thread_proc(function<void (const QString)> error_handler)
 		cur_analog_segments_.clear();
 	}
 	highest_segment_id_ = -1;
+	frame_began_ = false;
 
 	try {
 		device_->start();
-	} catch (Error e) {
+	} catch (Error& e) {
 		error_handler(e.what());
 		return;
 	}
@@ -919,7 +946,7 @@ void Session::sample_thread_proc(function<void (const QString)> error_handler)
 
 	try {
 		device_->run();
-	} catch (Error e) {
+	} catch (Error& e) {
 		error_handler(e.what());
 		set_capture_state(Stopped);
 		return;
@@ -928,10 +955,8 @@ void Session::sample_thread_proc(function<void (const QString)> error_handler)
 	set_capture_state(Stopped);
 
 	// Confirm that SR_DF_END was received
-	if (cur_logic_segment_) {
-		qDebug("SR_DF_END was not received.");
-		assert(false);
-	}
+	if (cur_logic_segment_)
+		qDebug() << "WARNING: SR_DF_END was not received.";
 
 	// Optimize memory usage
 	free_unused_memory();
@@ -1055,7 +1080,24 @@ void Session::feed_in_trigger()
 		}
 	}
 
-	trigger_event(sample_count / get_samplerate());
+	uint32_t segment_id = 0;  // Default segment when no frames are used
+
+	// If a frame began, we'd ideally be able to use the highest segment ID for
+	// the trigger. However, as new segments are only created when logic or
+	// analog data comes in, this doesn't work if the trigger appears right
+	// after the beginning of the frame, before any sample data.
+	// For this reason, we use highest segment ID + 1 if no sample data came in
+	// yet and the highest segment ID otherwise.
+	if (frame_began_) {
+		segment_id = highest_segment_id_;
+		if (!cur_logic_segment_ && (cur_analog_segments_.size() == 0))
+			segment_id++;
+	}
+
+	// TODO Create timestamp from segment start time + segment's current sample count
+	util::Timestamp timestamp = sample_count / get_samplerate();
+	trigger_list_.emplace_back(segment_id, timestamp);
+	trigger_event(segment_id, timestamp);
 }
 
 void Session::feed_in_frame_begin()
@@ -1083,14 +1125,18 @@ void Session::feed_in_frame_end()
 		cur_analog_segments_.clear();
 	}
 
-	if (frame_began_)
-		frame_began_ = false;
+	frame_began_ = false;
 
 	signal_segment_completed();
 }
 
 void Session::feed_in_logic(shared_ptr<Logic> logic)
 {
+	if (logic->data_length() == 0) {
+		qDebug() << "WARNING: Received logic packet with 0 samples.";
+		return;
+	}
+
 	if (!cur_samplerate_)
 		cur_samplerate_ = device_->read_config<uint64_t>(ConfigKey::SAMPLERATE);
 
@@ -1109,7 +1155,8 @@ void Session::feed_in_logic(shared_ptr<Logic> logic)
 
 		// Create a new data segment
 		cur_logic_segment_ = make_shared<data::LogicSegment>(
-			*logic_data_, logic->unit_size(), cur_samplerate_);
+			*logic_data_, logic_data_->get_segment_count(),
+			logic->unit_size(), cur_samplerate_);
 		logic_data_->push_segment(cur_logic_segment_);
 
 		signal_new_segment();
@@ -1122,6 +1169,11 @@ void Session::feed_in_logic(shared_ptr<Logic> logic)
 
 void Session::feed_in_analog(shared_ptr<Analog> analog)
 {
+	if (analog->num_samples() == 0) {
+		qDebug() << "WARNING: Received analog packet with 0 samples.";
+		return;
+	}
+
 	if (!cur_samplerate_)
 		cur_samplerate_ = device_->read_config<uint64_t>(ConfigKey::SAMPLERATE);
 
@@ -1162,7 +1214,7 @@ void Session::feed_in_analog(shared_ptr<Analog> analog)
 
 			// Create a segment, keep it in the maps of channels
 			segment = make_shared<data::AnalogSegment>(
-				*data, cur_samplerate_);
+				*data, data->get_segment_count(), cur_samplerate_);
 			cur_analog_segments_[channel] = segment;
 
 			// Push the segment into the analog data.
@@ -1211,7 +1263,7 @@ void Session::data_feed_in(shared_ptr<sigrok::Device> device,
 	case SR_DF_LOGIC:
 		try {
 			feed_in_logic(dynamic_pointer_cast<Logic>(packet->payload()));
-		} catch (bad_alloc) {
+		} catch (bad_alloc&) {
 			out_of_memory_ = true;
 			device_->stop();
 		}
@@ -1220,7 +1272,7 @@ void Session::data_feed_in(shared_ptr<sigrok::Device> device,
 	case SR_DF_ANALOG:
 		try {
 			feed_in_analog(dynamic_pointer_cast<Analog>(packet->payload()));
-		} catch (bad_alloc) {
+		} catch (bad_alloc&) {
 			out_of_memory_ = true;
 			device_->stop();
 		}
@@ -1240,6 +1292,15 @@ void Session::data_feed_in(shared_ptr<sigrok::Device> device,
 		// devices use frames, and for those devices, we need to do it here.
 		{
 			lock_guard<recursive_mutex> lock(data_mutex_);
+
+			if (cur_logic_segment_)
+				cur_logic_segment_->set_complete();
+
+			for (auto entry : cur_analog_segments_) {
+				shared_ptr<data::AnalogSegment> segment = entry.second;
+				segment->set_complete();
+			}
+
 			cur_logic_segment_.reset();
 			cur_analog_segments_.clear();
 		}