Merge pull request #38 from labstreaminglayer/refactor_stream_tracking

Refactor stream tracking

Author: cboulay

LabRecorder.cfg

@@ -44,7 +44,8 @@
 ; a warning is issued if one of the streams is not present when the record button is pressed
 ; The syntax is as in: RequiredStreams = "BioSemi (MyHostname)","PhaseSpace (MyHostname)","Eyelink (AnotherHostname)"
 ; where the format is identical to what the LabRecorder displays in the "Record from streams" list.
-; RequiredStreams="RequiredExample (PC)" 
+; There must not be any spaces within the parentheses.
+; RequiredStreams="RequiredExample (PC-HOSTNAME)" 
 
 ; === Online Sync ===
 ; A list of sync settings. Each setting follows the following format: "SrcStreamName (SrcHostName) post_FLAG"
@@ -62,3 +63,7 @@
 ; RCSPort to set the port number for the socket; default 22345
 RCSEnabled=1
 RCSPort=22345
+
+; === Auto Start Recording ===
+; Set AutoStart to 1 to automatically start recording as soon as the config file has concluded parsing.
+; AutoStart=1

README.md

@@ -21,9 +21,13 @@ The Ubuntu releases do not typically ship with the libsl dependencies so you wil
 The LabRecorder displays a list of currently present device streams under "Record from Streams". If you have turned on a device after you have already started the recorder, click the "Update" button to update the list (this takes ca. 2 seconds).
 > For testing you can use a "dummy" device from the `lslexamples` found in the [liblsl release assets](https://github.com/sccn/liblsl/releases) (for example SendData<!--, SendStringMarkers, and SendDataSimple-->).
 
-If you cannot see streams that are provided on another computer, read the section Network Troubleshooting on the NetworkConnectivity page. You can select which streams you want to record from and which not by checking the check boxes next to them.
+If you cannot see streams that are provided on another computer, read the section Network Troubleshooting on the NetworkConnectivity page.
+
+You can select which streams you want to record from and which not by checking the check boxes next to them.
 > ![labrecorder-default.png](doc/labrecorder-default.png)
 
+Note that if you have multiple streams with the same name and host, it is impossible to check only 1. If any is checked then they will all be recorded.
+
 The entry in "Saving to..." shows you the file name (or file name template) where your recording will be stored. You can change this by modifying the Study Root folder (e.g., by clicking the browse button) and the `File Name / Template` field. If the respective directory does not yet exist, it will be created automatically (except if you do not have the permissions to create it). The file name string may contain placeholders that will be replaced by the values in the fields below. Checking the BIDS box will automatically change the filename template to be BIDS compliant. If the file that you are trying to record to already exists, the existing file will be renamed (the string `_oldX` will be appended where X is the lowest number that is not yet occupied by another existing file). This way, it is impossible to accidentally overwrite data.
 
 The Block/Task field can be overwriten or selected among a list of items found in the configuration file.

src/mainwindow.cpp

@@ -80,12 +80,12 @@ MainWindow::MainWindow(QWidget *parent, const char *config_file)
 		}
 	});
 
-	QString cfgfilepath = find_config_file(config_file);
-	load_config(cfgfilepath);
-
 	timer = std::make_unique<QTimer>(this);
 	connect(&*timer, &QTimer::timeout, this, &MainWindow::statusUpdate);
 	timer->start(1000);
+
+	QString cfgfilepath = find_config_file(config_file);
+	load_config(cfgfilepath);
 }
 
 void MainWindow::statusUpdate() const {
@@ -119,13 +119,14 @@ void MainWindow::blockSelected(const QString &block) {
 
 void MainWindow::load_config(QString filename) {
 	qInfo() << "loading config file " << QDir::toNativeSeparators(filename);
+	bool auto_start = false;
 	try {
 		QSettings pt(QDir::cleanPath(filename), QSettings::Format::IniFormat);
 
 		// ----------------------------
 		// required streams
 		// ----------------------------
-		requiredStreams = pt.value("RequiredStreams").toStringList();
+		missingStreams = pt.value("RequiredStreams").toStringList().toSet();
 
 		// ----------------------------
 		// online sync streams
@@ -239,28 +240,34 @@ void MainWindow::load_config(QString filename) {
 			}
 		}
 
+		if (pt.contains("AutoStart")) {
+			auto_start = pt.value("AutoStart").toBool();
+		}
+
 	} catch (std::exception &e) { qWarning() << "Problem parsing config file: " << e.what(); }
 	// std::cout << "refreshing streams ..." <<std::endl;
 	refreshStreams();
-}
+
+	if (auto_start) { startRecording(); }
+ }
 
 void MainWindow::save_config(QString filename) {
 	QSettings settings(filename, QSettings::Format::IniFormat);
 	settings.setValue("StudyRoot", QDir::cleanPath(ui->rootEdit->text()));
 	if (!ui->check_bids->isChecked())
 		settings.setValue("PathTemplate", QDir::cleanPath(ui->lineEdit_template->text()));
-	qInfo() << requiredStreams;
+	// Build QStringList from missingStreams and knownStreams that are missing.
+	QStringList requiredStreams = missingStreams.values();
+	for (auto &k : knownStreams) {
+		if (k.checked) { requiredStreams.append(k.listName()); }
+	}
+	qInfo() << missingStreams;
 	settings.setValue("RequiredStreams", requiredStreams);
 	// Stub.
 }
 
-QSet<QString> MainWindow::getCheckedStreams() const {
-	QSet<QString> checked;
-	for (int i = 0; i < ui->streamList->count(); i++) {
-		QListWidgetItem *item = ui->streamList->item(i);
-		if (item->checkState() == Qt::Checked) checked.insert(item->text());
-	}
-	return checked;
+QString info_to_listName(lsl::stream_info info) {
+	return QString::fromStdString(info.name() + " (" + info.hostname() + ")");
 }
 
 /**
@@ -271,42 +278,87 @@ QSet<QString> MainWindow::getCheckedStreams() const {
 std::vector<lsl::stream_info> MainWindow::refreshStreams() {
 	std::vector<lsl::stream_info> resolvedStreams = lsl::resolve_streams(1.0);
 
-	QSet<QString> foundStreamNames;
-	for (auto &s : resolvedStreams)
-		foundStreamNames.insert(QString::fromStdString(s.name() + " (" + s.hostname() + ")"));
-
-	const QSet<QString> previouslyChecked = getCheckedStreams();
-	// Missing streams: all checked or required streams that weren't found
-	// requiredStreams.toSet() is deprecated. Eventually change to: QSet<QString>(requiredStreams.begin(), requiredStreams.end())
-	missingStreams = (previouslyChecked + requiredStreams.toSet()) - foundStreamNames;
-
-	// (Re-)Populate the UI list
+	// For each item in resolvedStreams, ignore if already in knownStreams, otherwise add to knownStreams.
+	// if in missingStreams then also mark it as required (--> checked by default) and remove from missingStreams.
+	for (auto& s : resolvedStreams) {
+		bool known = false;
+		for (auto &k : knownStreams) {
+			known |= s.name() == k.name && s.type() == k.type && s.source_id() == k.id;
+		}
+		if (!known) {
+			bool found = missingStreams.contains(info_to_listName(s));
+			knownStreams << StreamItem(s.name(), s.type(), s.source_id(), s.hostname(), found);
+			if (found) { missingStreams.remove(info_to_listName(s)); }
+		}
+	}
+	// For each item in knownStreams, update its checked status from GUI. (only works for streams found on a previous refresh)
+	// Because we search by name + host, entries aren't guaranteed to be unique, so checking one entry with matching name and host checks them all.
+	for (auto &k : knownStreams) {
+		QList<QListWidgetItem *> foundItems = ui->streamList->findItems(k.listName(), Qt::MatchCaseSensitive);
+		if (foundItems.count() > 0) {
+			bool checked = false;
+			for (auto &fi : foundItems) { checked |= fi->checkState() == Qt::Checked; }
+			k.checked = checked;
+		}
+	}
+	// For each item in knownStreams; if it is not resolved then drop it. If it was checked then add back to missingStreams.
+	int k_ind = 0;
+	while (k_ind < knownStreams.count()) {
+		StreamItem k = knownStreams.at(k_ind);
+		bool resolved = false;
+		size_t r_ind = 0;
+		while (!resolved && r_ind < resolvedStreams.size()) {
+			lsl::stream_info r = resolvedStreams[r_ind];
+			resolved |= (r.name() == k.name) && (r.type() == k.type) && (r.source_id() == k.id);
+			r_ind++;
+		}
+		if (!resolved) {
+			if (k.checked) { missingStreams += k.listName(); }
+			knownStreams.removeAt(k_ind);
+		} else {
+			k_ind++;
+		}
+	}
+	// Clear the streamList
+	// Add missing items first.
+	// Then add knownStreams (only in list if resolved).
 	const QBrush good_brush(QColor(0, 128, 0)), bad_brush(QColor(255, 0, 0));
 	ui->streamList->clear();
-	for (auto &&streamName : foundStreamNames + missingStreams) {
-		auto *item = new QListWidgetItem(streamName, ui->streamList);
-
-		item->setCheckState(previouslyChecked.contains(streamName) ? Qt::Checked : Qt::Unchecked);
-		item->setForeground(missingStreams.contains(streamName) ? bad_brush : good_brush);
-
+	for (auto& m : missingStreams) {
+		auto *item = new QListWidgetItem(m, ui->streamList);
+		item->setCheckState(Qt::Checked);
+		item->setForeground(bad_brush);
+		ui->streamList->addItem(item);
+	}
+	for (auto& k : knownStreams) {
+		auto *item = new QListWidgetItem(k.listName(), ui->streamList);
+		item->setCheckState(k.checked ? Qt::Checked : Qt::Unchecked);
+		item->setForeground(good_brush);
 		ui->streamList->addItem(item);
 	}
 
-	return resolvedStreams;
+	// return a std::vector of streams of checked and not missing streams.
+	std::vector<lsl::stream_info> requestedAndAvailableStreams;
+	for (auto &r : resolvedStreams) {
+		for (auto &k : knownStreams) {
+			if ((r.name() == k.name) && (r.type() == k.type) && (r.source_id() == k.id)) {
+				if (k.checked) { requestedAndAvailableStreams.push_back(r); }
+				break;
+			}
+		}
+	}
+	return requestedAndAvailableStreams;
 }
 
 void MainWindow::startRecording() {
 	if (!currentRecording) {
 
 		// automatically refresh streams
-		const std::vector<lsl::stream_info> resolvedStreams = refreshStreams();
-		const QSet<QString> checked = getCheckedStreams();
+		const std::vector<lsl::stream_info> requestedAndAvailableStreams = refreshStreams();
 
 		if (!hideWarnings) {
 			// if a checked stream is now missing
-			// change to "checked.intersects(missingStreams) as soon as Ubuntu 16.04/Qt 5.5 is EOL
-			QSet<QString> missing = checked;
-			if (!missing.intersect(missingStreams).isEmpty()) {
+			if (!missingStreams.isEmpty()) {
 				// are you sure?
 				QMessageBox msgBox(QMessageBox::Warning, "Stream not found",
 					"At least one of the streams that you checked seems to be offline",
@@ -316,8 +368,8 @@ void MainWindow::startRecording() {
 				if (msgBox.exec() != QMessageBox::Yes) return;
 			}
 
-			if (checked.isEmpty()) {
-				QMessageBox msgBox(QMessageBox::Warning, "No streams selected",
+			if (requestedAndAvailableStreams.size() == 0) {
+				QMessageBox msgBox(QMessageBox::Warning, "No available streams selected",
 					"You have selected no streams", QMessageBox::Yes | QMessageBox::No, this);
 				msgBox.setInformativeText("Do you want to start recording anyway?");
 				msgBox.setDefaultButton(QMessageBox::No);
@@ -363,20 +415,24 @@ void MainWindow::startRecording() {
 			return;
 		}
 
-		// go through all the listed streams
-		std::vector<lsl::stream_info> checkedStreams;
-
-		for (const lsl::stream_info &stream : resolvedStreams)
-			if (checked.contains(
-					QString::fromStdString(stream.name() + " (" + stream.hostname() + ')')))
-				checkedStreams.push_back(stream);
-
+		
 		std::vector<std::string> watchfor;
-		for (const QString &missing : missingStreams) watchfor.push_back(missing.toStdString());
+		for (const QString &missing : missingStreams) {
+			// Convert missing to query expected by lsl::resolve_stream
+			// name='BioSemi' and hostname=AASDFSDF
+			// QRegularExpression rx("(\S+)\s+\((\S+)\)");
+			QStringList name_host = missing.split(QRegExp("\\s+"));
+			std::string query = "name='" + name_host[0].toStdString() + "'";
+			if (name_host.size() > 1) {
+				std::string host = name_host[1].toStdString();
+				query += " and hostname='" + host.substr(1, host.length() - 2) + "'";
+			}
+			watchfor.push_back(query);
+		}
 		qInfo() << "Missing: " << missingStreams;
 
-		currentRecording = std::make_unique<recording>(
-			recFilename.toStdString(), checkedStreams, watchfor, syncOptionsByStreamName, true);
+		currentRecording = std::make_unique<recording>(recFilename.toStdString(),
+			requestedAndAvailableStreams, watchfor, syncOptionsByStreamName, true);
 		ui->stopButton->setEnabled(true);
 		ui->startButton->setEnabled(false);
 		startTime = (int)lsl::local_clock();

src/mainwindow.h

@@ -18,11 +18,19 @@ class MainWindow;
 class recording;
 class RemoteControlSocket;
 
-class RecorderItem {
-
+class StreamItem {
+	
 public:
-	QListWidgetItem listItem;
-	std::string uid;
+	StreamItem(std::string stream_name, std::string stream_type, std::string source_id,
+		std::string hostname, bool required)
+		: name(stream_name), type(stream_type), id(source_id), host(hostname), checked(required) {}
+	
+	QString listName() { return QString::fromStdString(name + " (" + host + ")"); }
+	std::string name;
+	std::string type;
+	std::string id;
+	std::string host;
+	bool checked;
 };
 
 
@@ -52,7 +60,6 @@ private slots:
 	void rcsportValueChangedInt(int value);
 
 private:
-	QSet<QString> getCheckedStreams() const;
 	QString replaceFilename(QString fullfile) const;
 	// function for loading / saving the config file
 	QString find_config_file(const char *filename);
@@ -66,9 +73,9 @@ private slots:
 	int startTime;
 	std::unique_ptr<QTimer> timer;
 
-	QStringList requiredStreams;
-	std::map<std::string, int> syncOptionsByStreamName;
+	QList<StreamItem> knownStreams;
 	QSet<QString> missingStreams;
+	std::map<std::string, int> syncOptionsByStreamName;
 
 	// QString recFilename;
 	QString legacyTemplate;

src/recording.cpp

@@ -133,10 +133,12 @@ void recording::record_from_query_results(const std::string &query) {
 			// for each result...
 			for (auto &result : results) {
 				// if it is a new stream...
+				std::string _uid = result.uid();
+				std::string _src_id = result.source_id();
 				if (!known_uids.count(result.uid()))
 					// and doesn't have a previously seen source id...
-					if (!(!result.source_id().empty() &&
-							(!known_source_ids.count(result.source_id())))) {
+					if (!result.source_id().empty() &&
+							(!known_source_ids.count(result.source_id()))) {
 						std::cout << "Found a new stream named " << result.name()
 								  << ", adding it to the recording." << std::endl;
 						// start a new recording thread