Merge branch 'master' into ubuntu-22.04

Author: cboulay

.github/workflows/cppcmake.yml

@@ -35,8 +35,8 @@ jobs:
         - {name: "ubuntu-20.04", os: "ubuntu-20.04",   cmake_extra: "-DLSL_BUNDLED_PUGIXML=OFF"}
         - {name: "ubuntu-18.04", os: "ubuntu-latest",  docker: "ubuntu:18.04" }
         - {name: "ubuntu-22.04", os: "ubuntu-latest",  docker: "ubuntu:22.04" }
-        - {name: "windows-x64",  os: "windows-latest", cmake_extra: "-T v140,host=x86"}
-        - {name: "windows-32",   os: "windows-latest", cmake_extra: "-T v140,host=x86 -A Win32"}
+        - {name: "windows-x64",  os: "windows-2019", cmake_extra: "-T v140,host=x86"}
+        - {name: "windows-32",   os: "windows-2019", cmake_extra: "-T v140,host=x86 -A Win32"}
         - {name: "macOS-latest", os: "macOS-latest"}
 
     # runs all steps in the container configured in config.docker or as subprocesses when empty

.github/workflows/mingw_static.yml

@@ -13,7 +13,7 @@ on:
 jobs:
   build:
     name: MinGW batteries-included
-    runs-on: windows-latest
+    runs-on: windows-2019
 
     defaults:
       run:

.gitignore

@@ -1,4 +1,6 @@
 /build*/
+/install/
+/package/
 /CMakeLists.txt.user
 /CMakeLists.json
 /CMakeSettings.json

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required (VERSION 3.12)
 project (liblsl
-	VERSION 1.15.2
+	VERSION 1.16.0
 	LANGUAGES C CXX
 	DESCRIPTION "Labstreaminglayer C/C++ library"
 	HOMEPAGE_URL "https://github.com/sccn/liblsl"

README.md

@@ -20,9 +20,15 @@ The most up-to-date instructions are in the
 Precompiled packages are uploaded
 
 - to the [Release page](https://github.com/sccn/liblsl/releases)
-- the [Anaconda cloud](https://anaconda.org/conda-force/liblsl), install with `conda install -c conda-forge liblsl`
+- the [Anaconda cloud](https://anaconda.org/conda-forge/liblsl), install with `conda install -c conda-forge liblsl`
 
-To compile the library yourself from source please follow the [online documentation](https://labstreaminglayer.readthedocs.io/dev/lib_dev.html).
+liblsl is also available via the following package managers:
+
+- [vcpkg](https://vcpkg.io)
+- [Conan](https://conan.io/center/liblsl)
+
+To compile the library yourself from source,
+please follow the [online documentation](https://labstreaminglayer.readthedocs.io/dev/lib_dev.html).
 
 For single board computers running linux, you can also try
 `standalone_compilation_linux.sh`.

examples/ReceiveDataInChunks.cpp

@@ -22,7 +22,7 @@ int main(int argc, char **argv) {
 		bool flush = argc > 3;
 		// resolve the stream of interest & make an inlet
 		lsl::stream_info inlet_info = lsl::resolve_stream("name", name).at(0);
-		lsl::stream_inlet inlet(inlet_info, max_buffered);
+		lsl::stream_inlet inlet(inlet_info, (int32_t)max_buffered);
 
 		// Use set_postprocessing to get the timestamps in a common base clock.
 		// Do not use if this application will record timestamps to disk -- it is better to 

examples/SendData.cpp

@@ -71,7 +71,7 @@ int main(int argc, char *argv[]) {
 			// Create random data for the first 8 channels.
 			for (int c = 0; c < 8; c++) sample[c] = (float)((rand() % 1500) / 500.0 - 1.5);
 			// For the remaining channels, fill them with a sample counter (wraps at 1M).
-			std::fill(sample.begin() + 8, sample.end(), t % 1000000);
+			std::fill(sample.begin() + 8, sample.end(), (float)(t % 1000000));
 
 			// Wait until the next expected sample time.
 			next_sample_time += std::chrono::microseconds(sample_dur_us);

examples/SendDataInChunks.cpp

@@ -25,14 +25,14 @@ struct fake_device {
 	*/
 	std::size_t n_channels;
 	double srate;
-	int64_t pattern_samples;
-	int64_t head;
+	std::size_t pattern_samples;
+	std::size_t head;
 	std::vector<int16_t> pattern;
 	std::chrono::steady_clock::time_point last_time;
 
 	fake_device(const int16_t n_channels, const float srate)
 		: n_channels(n_channels), srate(srate), head(0) {
-		pattern_samples = (int64_t)(srate - 0.5) + 1;  // truncate OK.
+		pattern_samples = (std::size_t)(srate - 0.5) + 1;  // truncate OK.
 
 		// Pre-allocate entire test pattern. The data _could_ be generated on the fly
 		//  for a much smaller memory hit, but we also use this example application
@@ -47,8 +47,9 @@ struct fake_device {
 				// sin(2*pi*f*t), where f cycles from 1 Hz to Nyquist: srate / 2
 				double f = (chan_ix + 1) % (int)(srate / 2);
 				pattern.emplace_back(
-					offset_0 + chan_ix * offset_step +
-					magnitude * static_cast<int16_t>(sin(2 * M_PI * f * sample_ix / srate)));
+					static_cast<int16_t>(
+						offset_0 + chan_ix * offset_step +
+						magnitude * sin(2 * M_PI * f * sample_ix / srate)));
 			}
 		}
 		last_time = std::chrono::steady_clock::now();
@@ -70,8 +71,8 @@ struct fake_device {
 		auto now = std::chrono::steady_clock::now();
 		auto elapsed_nano =
 			std::chrono::duration_cast<std::chrono::nanoseconds>(now - last_time).count();
-		int64_t elapsed_samples = std::size_t(elapsed_nano * srate * 1e-9); // truncate OK.
-		elapsed_samples = std::min(elapsed_samples, (int64_t)(buffer.size() / n_channels));
+		std::size_t elapsed_samples = std::size_t(elapsed_nano * srate * 1e-9); // truncate OK.
+		elapsed_samples = std::min(elapsed_samples, (std::size_t)(buffer.size() / n_channels));
 		if (nodata) {
 			// The fastest but no patterns.
 			// memset(&buffer[0], 23, buffer.size() * sizeof buffer[0]);
@@ -116,7 +117,7 @@ int main(int argc, char **argv) {
 			chn.append_child_value("unit", "microvolts");
 			chn.append_child_value("type", type);
 		}
-		int32_t buf_samples = max_buffered * samplingrate;
+		int32_t buf_samples = (int32_t)(max_buffered * samplingrate);
 		lsl::stream_outlet outlet(info, chunk_samples, buf_samples);
 		info = outlet.info(); // Refresh info with whatever the outlet captured.
 		std::cout << "Stream UID: " << info.uid() << std::endl;

examples/SendDataMinimal.cpp

@@ -0,0 +1,30 @@
+#include <chrono>
+#include <thread>
+#include <lsl_cpp.h>
+
+/**
+ * This is a minimal example of how a multi-channel data stream can be sent to LSL.
+ * Here, the stream is named SimpleStream, has content-type EEG, 8 channels, and 200 Hz.
+ * The transmitted samples contain random numbers.
+ */
+
+const int nchannels = 8;
+
+int main(int argc, char *argv[]) {
+	// make a new stream_info and open an outlet with it
+	lsl::stream_info info("SimpleStream", "EEG", nchannels, 200.0);
+	lsl::stream_outlet outlet(info);
+
+	// send data forever
+	float sample[nchannels];
+	while (true) {
+		// generate random data
+		for (int c = 0; c < nchannels; c++) sample[c] = (float)((rand() % 1500) / 500.0 - 1.5);
+		// send it
+		outlet.push_sample(sample);
+		// maintain our desired sampling rate (approximately; real software might do something else)
+		std::this_thread::sleep_for(std::chrono::milliseconds(5));
+	}
+
+	return 0;
+}

examples/SendDataSimple.cpp

@@ -22,7 +22,7 @@ int main(int argc, char *argv[]) {
 	float sample[nchannels];
 	while (outlet.have_consumers()) {
 		// generate random data
-		for (int c = 0; c < nchannels; c++) sample[c] = (rand() % 1500) / 500.0 - 1.5;
+		for (int c = 0; c < nchannels; c++) sample[c] = (float)((rand() % 1500) / 500.0 - 1.5);
 		// send it
 		outlet.push_sample(sample);
 		std::this_thread::sleep_for(std::chrono::milliseconds(5));