1 files changed, 293 insertions, 57 deletions

diff --git a/drivers/pulseaudio/audio_driver_pulseaudio.cpp b/drivers/pulseaudio/audio_driver_pulseaudio.cpp
index 6db0e58737..987cd9c85f 100644
--- a/drivers/pulseaudio/audio_driver_pulseaudio.cpp
+++ b/drivers/pulseaudio/audio_driver_pulseaudio.cpp
@@ -64,18 +64,32 @@ void AudioDriverPulseAudio::pa_sink_info_cb(pa_context *c, const pa_sink_info *l
 	ad->pa_status++;
 }
 
+void AudioDriverPulseAudio::pa_source_info_cb(pa_context *c, const pa_source_info *l, int eol, void *userdata) {
+	AudioDriverPulseAudio *ad = (AudioDriverPulseAudio *)userdata;
+
+	// If eol is set to a positive number, you're at the end of the list
+	if (eol > 0) {
+		return;
+	}
+
+	ad->pa_rec_map = l->channel_map;
+	ad->pa_status++;
+}
+
 void AudioDriverPulseAudio::pa_server_info_cb(pa_context *c, const pa_server_info *i, void *userdata) {
 	AudioDriverPulseAudio *ad = (AudioDriverPulseAudio *)userdata;
 
+	ad->capture_default_device = i->default_source_name;
 	ad->default_device = i->default_sink_name;
 	ad->pa_status++;
 }
 
-void AudioDriverPulseAudio::detect_channels() {
+void AudioDriverPulseAudio::detect_channels(bool capture) {
 
-	pa_channel_map_init_stereo(&pa_map);
+	pa_channel_map_init_stereo(capture ? &pa_rec_map : &pa_map);
 
-	if (device_name == "Default") {
+	String device = capture ? capture_device_name : device_name;
+	if (device == "Default") {
 		// Get the default output device name
 		pa_status = 0;
 		pa_operation *pa_op = pa_context_get_server_info(pa_ctx, &AudioDriverPulseAudio::pa_server_info_cb, (void *)this);
@@ -93,16 +107,22 @@ void AudioDriverPulseAudio::detect_channels() {
 		}
 	}
 
-	char device[1024];
-	if (device_name == "Default") {
-		strcpy(device, default_device.utf8().get_data());
+	char dev[1024];
+	if (device == "Default") {
+		strcpy(dev, capture ? capture_default_device.utf8().get_data() : default_device.utf8().get_data());
 	} else {
-		strcpy(device, device_name.utf8().get_data());
+		strcpy(dev, device.utf8().get_data());
 	}
 
 	// Now using the device name get the amount of channels
 	pa_status = 0;
-	pa_operation *pa_op = pa_context_get_sink_info_by_name(pa_ctx, device, &AudioDriverPulseAudio::pa_sink_info_cb, (void *)this);
+	pa_operation *pa_op;
+	if (capture) {
+		pa_op = pa_context_get_source_info_by_name(pa_ctx, dev, &AudioDriverPulseAudio::pa_source_info_cb, (void *)this);
+	} else {
+		pa_op = pa_context_get_sink_info_by_name(pa_ctx, dev, &AudioDriverPulseAudio::pa_sink_info_cb, (void *)this);
+	}
+
 	if (pa_op) {
 		while (pa_status == 0) {
 			int ret = pa_mainloop_iterate(pa_ml, 1, NULL);
@@ -113,7 +133,11 @@ void AudioDriverPulseAudio::detect_channels() {
 
 		pa_operation_unref(pa_op);
 	} else {
-		ERR_PRINT("pa_context_get_sink_info_by_name error");
+		if (capture) {
+			ERR_PRINT("pa_context_get_source_info_by_name error");
+		} else {
+			ERR_PRINT("pa_context_get_sink_info_by_name error");
+		}
 	}
 }
 
@@ -195,6 +219,10 @@ Error AudioDriverPulseAudio::init_device() {
 	samples_in.resize(buffer_frames * channels);
 	samples_out.resize(pa_buffer_size);
 
+	// Reset audio input to keep synchronisation.
+	input_position = 0;
+	input_size = 0;
+
 	return OK;
 }
 
@@ -287,74 +315,71 @@ float AudioDriverPulseAudio::get_latency() {
 void AudioDriverPulseAudio::thread_func(void *p_udata) {
 
 	AudioDriverPulseAudio *ad = (AudioDriverPulseAudio *)p_udata;
+	unsigned int write_ofs = 0;
+	size_t avail_bytes = 0;
 
 	while (!ad->exit_thread) {
 
-		ad->lock();
-		ad->start_counting_ticks();
-
-		if (!ad->active) {
-			for (unsigned int i = 0; i < ad->pa_buffer_size; i++) {
-				ad->samples_out.write[i] = 0;
-			}
+		size_t read_bytes = 0;
+		size_t written_bytes = 0;
 
-		} else {
-			ad->audio_server_process(ad->buffer_frames, ad->samples_in.ptrw());
+		if (avail_bytes == 0) {
+			ad->lock();
+			ad->start_counting_ticks();
 
-			if (ad->channels == ad->pa_map.channels) {
+			if (!ad->active) {
 				for (unsigned int i = 0; i < ad->pa_buffer_size; i++) {
-					ad->samples_out.write[i] = ad->samples_in[i] >> 16;
+					ad->samples_out.write[i] = 0;
 				}
 			} else {
-				// Uneven amount of channels
-				unsigned int in_idx = 0;
-				unsigned int out_idx = 0;
+				ad->audio_server_process(ad->buffer_frames, ad->samples_in.ptrw());
 
-				for (unsigned int i = 0; i < ad->buffer_frames; i++) {
-					for (unsigned int j = 0; j < ad->pa_map.channels - 1; j++) {
-						ad->samples_out.write[out_idx++] = ad->samples_in[in_idx++] >> 16;
+				if (ad->channels == ad->pa_map.channels) {
+					for (unsigned int i = 0; i < ad->pa_buffer_size; i++) {
+						ad->samples_out.write[i] = ad->samples_in[i] >> 16;
+					}
+				} else {
+					// Uneven amount of channels
+					unsigned int in_idx = 0;
+					unsigned int out_idx = 0;
+
+					for (unsigned int i = 0; i < ad->buffer_frames; i++) {
+						for (unsigned int j = 0; j < ad->pa_map.channels - 1; j++) {
+							ad->samples_out.write[out_idx++] = ad->samples_in[in_idx++] >> 16;
+						}
+						uint32_t l = ad->samples_in[in_idx++];
+						uint32_t r = ad->samples_in[in_idx++];
+						ad->samples_out.write[out_idx++] = (l >> 1 + r >> 1) >> 16;
 					}
-					uint32_t l = ad->samples_in[in_idx++];
-					uint32_t r = ad->samples_in[in_idx++];
-					ad->samples_out.write[out_idx++] = (l >> 1 + r >> 1) >> 16;
 				}
 			}
+
+			avail_bytes = ad->pa_buffer_size * sizeof(int16_t);
+			write_ofs = 0;
+			ad->stop_counting_ticks();
+			ad->unlock();
 		}
 
-		int error_code;
-		int byte_size = ad->pa_buffer_size * sizeof(int16_t);
+		ad->lock();
+		ad->start_counting_ticks();
+
 		int ret;
 		do {
 			ret = pa_mainloop_iterate(ad->pa_ml, 0, NULL);
 		} while (ret > 0);
 
-		if (pa_stream_get_state(ad->pa_str) == PA_STREAM_READY) {
-			const void *ptr = ad->samples_out.ptr();
-			while (byte_size > 0) {
-				size_t bytes = pa_stream_writable_size(ad->pa_str);
-				if (bytes > 0) {
-					if (bytes > byte_size) {
-						bytes = byte_size;
-					}
-
-					ret = pa_stream_write(ad->pa_str, ptr, bytes, NULL, 0LL, PA_SEEK_RELATIVE);
-					if (ret >= 0) {
-						byte_size -= bytes;
-						ptr = (const char *)ptr + bytes;
-					}
+		if (avail_bytes > 0 && pa_stream_get_state(ad->pa_str) == PA_STREAM_READY) {
+			size_t bytes = pa_stream_writable_size(ad->pa_str);
+			if (bytes > 0) {
+				size_t bytes_to_write = MIN(bytes, avail_bytes);
+				const void *ptr = ad->samples_out.ptr();
+				ret = pa_stream_write(ad->pa_str, ptr + write_ofs, bytes_to_write, NULL, 0LL, PA_SEEK_RELATIVE);
+				if (ret != 0) {
+					ERR_PRINT("pa_stream_write error");
 				} else {
-					ret = pa_mainloop_iterate(ad->pa_ml, 0, NULL);
-					if (ret == 0) {
-						// If pa_mainloop_iterate returns 0 sleep for 1 msec to wait
-						// for the stream to be able to process more bytes
-						ad->stop_counting_ticks();
-						ad->unlock();
-
-						OS::get_singleton()->delay_usec(1000);
-
-						ad->lock();
-						ad->start_counting_ticks();
-					}
+					avail_bytes -= bytes_to_write;
+					write_ofs += bytes_to_write;
+					written_bytes += bytes_to_write;
 				}
 			}
 		}
@@ -379,8 +404,64 @@ void AudioDriverPulseAudio::thread_func(void *p_udata) {
 			}
 		}
 
+		if (ad->pa_rec_str && pa_stream_get_state(ad->pa_rec_str) == PA_STREAM_READY) {
+			size_t bytes = pa_stream_readable_size(ad->pa_rec_str);
+			if (bytes > 0) {
+				const void *ptr = NULL;
+				size_t maxbytes = ad->input_buffer.size() * sizeof(int16_t);
+
+				bytes = MIN(bytes, maxbytes);
+				ret = pa_stream_peek(ad->pa_rec_str, &ptr, &bytes);
+				if (ret != 0) {
+					ERR_PRINT("pa_stream_peek error");
+				} else {
+					int16_t *srcptr = (int16_t *)ptr;
+					for (size_t i = bytes >> 1; i > 0; i--) {
+						int32_t sample = int32_t(*srcptr++) << 16;
+						ad->input_buffer_write(sample);
+
+						if (ad->pa_rec_map.channels == 1) {
+							// In case input device is single channel convert it to Stereo
+							ad->input_buffer_write(sample);
+						}
+					}
+
+					read_bytes += bytes;
+					ret = pa_stream_drop(ad->pa_rec_str);
+					if (ret != 0) {
+						ERR_PRINT("pa_stream_drop error");
+					}
+				}
+			}
+
+			// User selected a new device, finish the current one so we'll init the new device
+			if (ad->capture_device_name != ad->capture_new_device) {
+				ad->capture_device_name = ad->capture_new_device;
+				ad->capture_finish_device();
+
+				Error err = ad->capture_init_device();
+				if (err != OK) {
+					ERR_PRINT("PulseAudio: capture_init_device error");
+					ad->capture_device_name = "Default";
+					ad->capture_new_device = "Default";
+
+					err = ad->capture_init_device();
+					if (err != OK) {
+						ad->active = false;
+						ad->exit_thread = true;
+						break;
+					}
+				}
+			}
+		}
+
 		ad->stop_counting_ticks();
 		ad->unlock();
+
+		// Let the thread rest a while if we haven't read or write anything
+		if (written_bytes == 0 && read_bytes == 0) {
+			OS::get_singleton()->delay_usec(1000);
+		}
 	}
 
 	ad->thread_exited = true;
@@ -510,11 +591,165 @@ void AudioDriverPulseAudio::finish() {
 	thread = NULL;
 }
 
+Error AudioDriverPulseAudio::capture_init_device() {
+
+	// If there is a specified device check that it is really present
+	if (capture_device_name != "Default") {
+		Array list = capture_get_device_list();
+		if (list.find(capture_device_name) == -1) {
+			capture_device_name = "Default";
+			capture_new_device = "Default";
+		}
+	}
+
+	detect_channels(true);
+	switch (pa_rec_map.channels) {
+		case 1: // Mono
+		case 2: // Stereo
+			break;
+
+		default:
+			WARN_PRINTS("PulseAudio: Unsupported number of input channels: " + itos(pa_rec_map.channels));
+			pa_channel_map_init_stereo(&pa_rec_map);
+			break;
+	}
+
+	if (OS::get_singleton()->is_stdout_verbose()) {
+		print_line("PulseAudio: detected " + itos(pa_rec_map.channels) + " input channels");
+	}
+
+	pa_sample_spec spec;
+
+	spec.format = PA_SAMPLE_S16LE;
+	spec.channels = pa_rec_map.channels;
+	spec.rate = mix_rate;
+
+	int latency = 30;
+	input_buffer_frames = closest_power_of_2(latency * mix_rate / 1000);
+	int buffer_size = input_buffer_frames * spec.channels;
+
+	pa_buffer_attr attr;
+	attr.fragsize = buffer_size * sizeof(int16_t);
+
+	pa_rec_str = pa_stream_new(pa_ctx, "Record", &spec, &pa_rec_map);
+	if (pa_rec_str == NULL) {
+		ERR_PRINTS("PulseAudio: pa_stream_new error: " + String(pa_strerror(pa_context_errno(pa_ctx))));
+		ERR_FAIL_V(ERR_CANT_OPEN);
+	}
+
+	const char *dev = capture_device_name == "Default" ? NULL : capture_device_name.utf8().get_data();
+	pa_stream_flags flags = pa_stream_flags(PA_STREAM_INTERPOLATE_TIMING | PA_STREAM_ADJUST_LATENCY | PA_STREAM_AUTO_TIMING_UPDATE);
+	int error_code = pa_stream_connect_record(pa_rec_str, dev, &attr, flags);
+	if (error_code < 0) {
+		ERR_PRINTS("PulseAudio: pa_stream_connect_record error: " + String(pa_strerror(error_code)));
+		ERR_FAIL_V(ERR_CANT_OPEN);
+	}
+
+	input_buffer.resize(input_buffer_frames * 8);
+	input_position = 0;
+	input_size = 0;
+
+	return OK;
+}
+
+void AudioDriverPulseAudio::capture_finish_device() {
+
+	if (pa_rec_str) {
+		int ret = pa_stream_disconnect(pa_rec_str);
+		if (ret != 0) {
+			ERR_PRINTS("PulseAudio: pa_stream_disconnect error: " + String(pa_strerror(ret)));
+		}
+		pa_stream_unref(pa_rec_str);
+		pa_rec_str = NULL;
+	}
+}
+
+Error AudioDriverPulseAudio::capture_start() {
+
+	lock();
+	Error err = capture_init_device();
+	unlock();
+
+	return err;
+}
+
+Error AudioDriverPulseAudio::capture_stop() {
+	lock();
+	capture_finish_device();
+	unlock();
+
+	return OK;
+}
+
+void AudioDriverPulseAudio::capture_set_device(const String &p_name) {
+
+	lock();
+	capture_new_device = p_name;
+	unlock();
+}
+
+void AudioDriverPulseAudio::pa_sourcelist_cb(pa_context *c, const pa_source_info *l, int eol, void *userdata) {
+	AudioDriverPulseAudio *ad = (AudioDriverPulseAudio *)userdata;
+
+	// If eol is set to a positive number, you're at the end of the list
+	if (eol > 0) {
+		return;
+	}
+
+	if (l->monitor_of_sink == PA_INVALID_INDEX) {
+		ad->pa_rec_devices.push_back(l->name);
+	}
+
+	ad->pa_status++;
+}
+
+Array AudioDriverPulseAudio::capture_get_device_list() {
+
+	pa_rec_devices.clear();
+	pa_rec_devices.push_back("Default");
+
+	if (pa_ctx == NULL) {
+		return pa_rec_devices;
+	}
+
+	lock();
+
+	// Get the device list
+	pa_status = 0;
+	pa_operation *pa_op = pa_context_get_source_info_list(pa_ctx, pa_sourcelist_cb, (void *)this);
+	if (pa_op) {
+		while (pa_status == 0) {
+			int ret = pa_mainloop_iterate(pa_ml, 1, NULL);
+			if (ret < 0) {
+				ERR_PRINT("pa_mainloop_iterate error");
+			}
+		}
+
+		pa_operation_unref(pa_op);
+	} else {
+		ERR_PRINT("pa_context_get_server_info error");
+	}
+
+	unlock();
+
+	return pa_rec_devices;
+}
+
+String AudioDriverPulseAudio::capture_get_device() {
+
+	lock();
+	String name = capture_device_name;
+	unlock();
+
+	return name;
+}
+
 AudioDriverPulseAudio::AudioDriverPulseAudio() {
 
 	pa_ml = NULL;
 	pa_ctx = NULL;
 	pa_str = NULL;
+	pa_rec_str = NULL;
 
 	mutex = NULL;
 	thread = NULL;
@@ -528,6 +763,7 @@ AudioDriverPulseAudio::AudioDriverPulseAudio() {
 
 	mix_rate = 0;
 	buffer_frames = 0;
+	input_buffer_frames = 0;
 	pa_buffer_size = 0;
 	channels = 0;
 	pa_ready = 0;