SendDataInChunks update

* use double-typed max_buffered
* use integer-frequency sine waves so 1-sec pattern has no discontinuities.
* add CLI option to not use test patterns (for debugging).

Author: cboulay

examples/SendDataInChunks.cpp

@@ -44,9 +44,11 @@ struct fake_device {
 		pattern.reserve(pattern_samples * n_channels);
 		for (auto sample_ix = 0; sample_ix < pattern_samples; ++sample_ix) {
 			for (auto chan_ix = 0; chan_ix < n_channels; ++chan_ix) {
+				// 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(M_PI * chan_ix * sample_ix / n_channels)));
+					magnitude * static_cast<int16_t>(sin(2 * M_PI * f * sample_ix / srate)));
 			}
 		}
 		last_time = std::chrono::steady_clock::now();
@@ -64,15 +66,15 @@ struct fake_device {
 		return output;
 	}
 
-	std::size_t get_data(std::vector<int16_t> &buffer) {
+	std::size_t get_data(std::vector<int16_t> &buffer, bool nodata = false) {
 		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));
-		if (false) {
+		if (nodata) {
 			// The fastest but no patterns.
-			memset(&buffer[0], 23, buffer.size() * sizeof buffer[0]);
+			// memset(&buffer[0], 23, buffer.size() * sizeof buffer[0]);
 		} else {
 			std::size_t end_sample = head + elapsed_samples;
 			std::size_t nowrap_samples = std::min(pattern_samples - head, elapsed_samples);
@@ -89,22 +91,24 @@ struct fake_device {
 
 int main(int argc, char **argv) {
 	std::cout << "SendDataInChunks" << std::endl;
-	std::cout << "SendDataInChunks StreamName StreamType samplerate n_channels max_buffered chunk_rate" << std::endl;
+	std::cout << "SendDataInChunks StreamName StreamType samplerate n_channels max_buffered chunk_rate nodata" << std::endl;
 	std::cout << "- max_buffered -- duration in sec (or x100 samples if samplerate is 0) to buffer for each outlet" << std::endl;
 	std::cout << "- chunk_rate -- number of chunks pushed per second. For this example, make it a common factor of samplingrate and 1000." << std::endl;
+	std::cout << "- nodata -- Set non-zero to cause the fake device to not copy pattern data into the buffer." << std::endl;
 
 	std::string name{argc > 1 ? argv[1] : "MyAudioStream"}, type{argc > 2 ? argv[2] : "Audio"};
 	int samplingrate = argc > 3 ? std::stol(argv[3]) : 44100;  // Here we specify srate, but typically this would come from the device.
 	int n_channels = argc > 4 ? std::stol(argv[4]) : 2;        // Here we specify n_chans, but typically this would come from theh device.
-	int32_t max_buffered = argc > 5 ? std::stol(argv[5]) : 360;
+	double max_buffered = argc > 5 ? std::stod(argv[5]) : 360.;
 	int32_t chunk_rate = argc > 6 ? std::stol(argv[6]) : 10;  // Chunks per second.
+	bool nodata = argc > 7;
 	int32_t chunk_samples = samplingrate > 0 ? std::max((samplingrate / chunk_rate), 1) : 100;  // Samples per chunk.
 	int32_t chunk_duration = 1000 / chunk_rate;  // Milliseconds per chunk
 
 	try {
 		// Prepare the LSL stream.
 		lsl::stream_info info(name, type, n_channels, samplingrate, lsl::cf_int16);
-		lsl::stream_outlet outlet(info, 0, max_buffered);
+		lsl::stream_outlet outlet(info, chunk_samples, max_buffered);
 		lsl::xml_element desc = info.desc();
 		desc.append_child_value("manufacturer", "LSL");
 		lsl::xml_element chns = desc.append_child("channels");
@@ -121,6 +125,7 @@ int main(int argc, char **argv) {
 		// Prepare buffer to get data from 'device'.
 		//  The buffer should be larger than you think you need. Here we make it 4x as large.
 		std::vector<int16_t> chunk_buffer(4 * chunk_samples * n_channels);
+		std::fill(chunk_buffer.begin(), chunk_buffer.end(), 0);
 
 		std::cout << "Now sending data..." << std::endl;
 
@@ -133,11 +138,11 @@ int main(int argc, char **argv) {
 			std::this_thread::sleep_until(next_chunk_time);
 
 			// Get data from device
-			std::size_t returned_samples = my_device.get_data(chunk_buffer);
+			std::size_t returned_samples = my_device.get_data(chunk_buffer, nodata);
 
 			// send it to the outlet. push_chunk_multiplexed is one of the more complicated approaches.
 			//  other push_chunk methods are easier but slightly slower.
-			outlet.push_chunk_multiplexed(chunk_buffer.data(), returned_samples * n_channels, 0.0, true);
+			outlet.push_chunk_multiplexed(chunk_buffer.data(), returned_samples * n_channels, 0.0, false);
 		}
 
 	} catch (std::exception &e) { std::cerr << "Got an exception: " << e.what() << std::endl; }