diff options
Diffstat (limited to 'src/sound.cpp')
| -rw-r--r-- | src/sound.cpp | 401 |
1 files changed, 339 insertions, 62 deletions
diff --git a/src/sound.cpp b/src/sound.cpp index c3aa4d4..5a0ce77 100644 --- a/src/sound.cpp +++ b/src/sound.cpp @@ -8,12 +8,16 @@ extern "C" { #include <string.h> #include <cmath> #include <time.h> +#include <mutex> #include <pulse/pulseaudio.h> #include <pulse/mainloop.h> #include <pulse/xmalloc.h> #include <pulse/error.h> +#define RECONNECT_TRY_TIMEOUT_SECONDS 0.5 +#define DEVICE_NAME_MAX_SIZE 128 + #define CHECK_DEAD_GOTO(p, rerror, label) \ do { \ if (!(p)->context || !PA_CONTEXT_IS_GOOD(pa_context_get_state((p)->context)) || \ @@ -29,6 +33,12 @@ extern "C" { } \ } while(false); +enum class DeviceType { + STANDARD, + DEFAULT_OUTPUT, + DEFAULT_INPUT +}; + struct pa_handle { pa_context *context; pa_stream *stream; @@ -41,49 +51,153 @@ struct pa_handle { size_t output_index, output_length; int operation_success; + double latency_seconds; + + pa_buffer_attr attr; + pa_sample_spec ss; + + std::mutex reconnect_mutex; + DeviceType device_type; + char stream_name[256]; + bool reconnect; + double reconnect_last_tried_seconds; + + char device_name[DEVICE_NAME_MAX_SIZE]; + char default_output_device_name[DEVICE_NAME_MAX_SIZE]; + char default_input_device_name[DEVICE_NAME_MAX_SIZE]; }; -static void pa_sound_device_free(pa_handle *s) { - assert(s); +static void pa_sound_device_free(pa_handle *p) { + assert(p); + + if (p->stream) { + pa_stream_unref(p->stream); + p->stream = NULL; + } + + if (p->context) { + pa_context_disconnect(p->context); + pa_context_unref(p->context); + p->context = NULL; + } + + if (p->mainloop) { + pa_mainloop_free(p->mainloop); + p->mainloop = NULL; + } + + if (p->output_data) { + free(p->output_data); + p->output_data = NULL; + } + + pa_xfree(p); +} + +static void subscribe_update_default_devices(pa_context*, const pa_server_info *server_info, void *userdata) { + pa_handle *handle = (pa_handle*)userdata; + std::lock_guard<std::mutex> lock(handle->reconnect_mutex); + + if(server_info->default_sink_name) { + // TODO: Size check + snprintf(handle->default_output_device_name, sizeof(handle->default_output_device_name), "%s.monitor", server_info->default_sink_name); + if(handle->device_type == DeviceType::DEFAULT_OUTPUT && strcmp(handle->device_name, handle->default_output_device_name) != 0) { + handle->reconnect = true; + handle->reconnect_last_tried_seconds = clock_get_monotonic_seconds(); + // TODO: Size check + snprintf(handle->device_name, sizeof(handle->device_name), "%s", handle->default_output_device_name); + } + } + + if(server_info->default_source_name) { + // TODO: Size check + snprintf(handle->default_input_device_name, sizeof(handle->default_input_device_name), "%s", server_info->default_source_name); + if(handle->device_type == DeviceType::DEFAULT_INPUT && strcmp(handle->device_name, handle->default_input_device_name) != 0) { + handle->reconnect = true; + handle->reconnect_last_tried_seconds = clock_get_monotonic_seconds(); + // TODO: Size check + snprintf(handle->device_name, sizeof(handle->device_name), "%s", handle->default_input_device_name); + } + } +} + +static void subscribe_cb(pa_context *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) { + (void)idx; + pa_handle *handle = (pa_handle*)userdata; + if((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SERVER) { + pa_operation *pa = pa_context_get_server_info(c, subscribe_update_default_devices, handle); + if(pa) + pa_operation_unref(pa); + } +} - if (s->stream) - pa_stream_unref(s->stream); +static void store_default_devices(pa_context*, const pa_server_info *server_info, void *userdata) { + pa_handle *handle = (pa_handle*)userdata; + if(server_info->default_sink_name) + snprintf(handle->default_output_device_name, sizeof(handle->default_output_device_name), "%s.monitor", server_info->default_sink_name); + if(server_info->default_source_name) + snprintf(handle->default_input_device_name, sizeof(handle->default_input_device_name), "%s", server_info->default_source_name); +} - if (s->context) { - pa_context_disconnect(s->context); - pa_context_unref(s->context); +static bool startup_get_default_devices(pa_handle *p, const char *device_name) { + pa_operation *pa = pa_context_get_server_info(p->context, store_default_devices, p); + while(pa) { + pa_operation_state state = pa_operation_get_state(pa); + if(state == PA_OPERATION_DONE) { + pa_operation_unref(pa); + break; + } else if(state == PA_OPERATION_CANCELLED) { + pa_operation_unref(pa); + return false; + } + pa_mainloop_iterate(p->mainloop, 1, NULL); } - if (s->mainloop) - pa_mainloop_free(s->mainloop); + if(p->default_output_device_name[0] == '\0') { + fprintf(stderr, "Error: failed to find default audio output device\n"); + return false; + } - if (s->output_data) { - free(s->output_data); - s->output_data = NULL; + if(strcmp(device_name, "default_output") == 0) { + snprintf(p->device_name, sizeof(p->device_name), "%s", p->default_output_device_name); + p->device_type = DeviceType::DEFAULT_OUTPUT; + } else if(strcmp(device_name, "default_input") == 0) { + snprintf(p->device_name, sizeof(p->device_name), "%s", p->default_input_device_name); + p->device_type = DeviceType::DEFAULT_INPUT; + } else { + snprintf(p->device_name, sizeof(p->device_name), "%s", device_name); + p->device_type = DeviceType::STANDARD; } - pa_xfree(s); + return true; } static pa_handle* pa_sound_device_new(const char *server, const char *name, - const char *dev, + const char *device_name, const char *stream_name, const pa_sample_spec *ss, const pa_buffer_attr *attr, int *rerror) { pa_handle *p; - int error = PA_ERR_INTERNAL, r; + int error = PA_ERR_INTERNAL; + pa_operation *pa = NULL; p = pa_xnew0(pa_handle, 1); - p->read_data = NULL; - p->read_length = 0; - p->read_index = 0; + p->attr = *attr; + p->ss = *ss; + snprintf(p->stream_name, sizeof(p->stream_name), "%s", stream_name); + + p->reconnect = true; + p->reconnect_last_tried_seconds = clock_get_monotonic_seconds() - 1000.0; + p->default_output_device_name[0] = '\0'; + p->default_input_device_name[0] = '\0'; + p->device_type = DeviceType::STANDARD; - const int buffer_size = attr->maxlength; + const int buffer_size = attr->fragsize; void *buffer = malloc(buffer_size); if(!buffer) { - fprintf(stderr, "failed to allocate buffer for audio\n"); + fprintf(stderr, "Error: failed to allocate buffer for audio\n"); *rerror = -1; return NULL; } @@ -117,56 +231,96 @@ static pa_handle* pa_sound_device_new(const char *server, pa_mainloop_iterate(p->mainloop, 1, NULL); } - if (!(p->stream = pa_stream_new(p->context, stream_name, ss, NULL))) { - error = pa_context_errno(p->context); + if(!startup_get_default_devices(p, device_name)) goto fail; + + pa_context_set_subscribe_callback(p->context, subscribe_cb, p); + pa = pa_context_subscribe(p->context, PA_SUBSCRIPTION_MASK_SERVER, NULL, NULL); + if(pa) + pa_operation_unref(pa); + + return p; + +fail: + if (rerror) + *rerror = error; + pa_sound_device_free(p); + return NULL; +} + +static bool pa_sound_device_should_reconnect(pa_handle *p, double now, char *device_name, size_t device_name_size) { + std::lock_guard<std::mutex> lock(p->reconnect_mutex); + if(p->reconnect && now - p->reconnect_last_tried_seconds >= RECONNECT_TRY_TIMEOUT_SECONDS) { + p->reconnect_last_tried_seconds = now; + // TODO: Size check + snprintf(device_name, device_name_size, "%s", p->device_name); + return true; + } + return false; +} + +static bool pa_sound_device_handle_reconnect(pa_handle *p, char *device_name, size_t device_name_size, double now) { + int r; + if(!pa_sound_device_should_reconnect(p, now, device_name, device_name_size)) + return true; + + if(p->stream) { + pa_stream_disconnect(p->stream); + pa_stream_unref(p->stream); + p->stream = NULL; } - r = pa_stream_connect_record(p->stream, dev, attr, + if(!(p->stream = pa_stream_new(p->context, p->stream_name, &p->ss, NULL))) { + //pa_context_errno(p->context); + return false; + } + + r = pa_stream_connect_record(p->stream, device_name, &p->attr, (pa_stream_flags_t)(PA_STREAM_INTERPOLATE_TIMING|PA_STREAM_ADJUST_LATENCY|PA_STREAM_AUTO_TIMING_UPDATE)); - if (r < 0) { - error = pa_context_errno(p->context); - goto fail; + if(r < 0) { + //pa_context_errno(p->context); + return false; } - for (;;) { + for(;;) { pa_stream_state_t state = pa_stream_get_state(p->stream); - if (state == PA_STREAM_READY) + if(state == PA_STREAM_READY) break; - if (!PA_STREAM_IS_GOOD(state)) { - error = pa_context_errno(p->context); - goto fail; + if(!PA_STREAM_IS_GOOD(state)) { + //pa_context_errno(p->context); + return false; } pa_mainloop_iterate(p->mainloop, 1, NULL); } - return p; - -fail: - if (rerror) - *rerror = error; - pa_sound_device_free(p); - return NULL; + std::lock_guard<std::mutex> lock(p->reconnect_mutex); + p->reconnect = false; + return true; } -// Returns a negative value on failure or if |p->output_length| data is not available within the time frame specified by the sample rate -static int pa_sound_device_read(pa_handle *p) { +static int pa_sound_device_read(pa_handle *p, double timeout_seconds) { assert(p); - const int64_t timeout_ms = std::round((1000.0 / (double)pa_stream_get_sample_spec(p->stream)->rate) * 1000.0); const double start_time = clock_get_monotonic_seconds(); + char device_name[DEVICE_NAME_MAX_SIZE]; bool success = false; int r = 0; int *rerror = &r; + pa_usec_t latency = 0; + int negative = 0; + + if(!pa_sound_device_handle_reconnect(p, device_name, sizeof(device_name), start_time)) + goto fail; + CHECK_DEAD_GOTO(p, rerror, fail); while (p->output_index < p->output_length) { - if((clock_get_monotonic_seconds() - start_time) * 1000 >= timeout_ms) + if(clock_get_monotonic_seconds() - start_time >= timeout_seconds) return -1; if(!p->read_data) { @@ -195,6 +349,15 @@ static int pa_sound_device_read(pa_handle *p) { CHECK_DEAD_GOTO(p, rerror, fail); continue; } + + pa_operation_unref(pa_stream_update_timing_info(p->stream, NULL, NULL)); + // TODO: Deal with one pa_stream_peek not being enough. In that case we need to add multiple of these together(?) + if(pa_stream_get_latency(p->stream, &latency, &negative) >= 0) { + p->latency_seconds = negative ? -(double)latency : latency; + if(p->latency_seconds < 0.0) + p->latency_seconds = 0.0; + p->latency_seconds *= 0.0000001; + } } const size_t space_free_in_output_buffer = p->output_length - p->output_index; @@ -254,16 +417,16 @@ int sound_device_get_by_name(SoundDevice *device, const char *device_name, const ss.channels = num_channels; pa_buffer_attr buffer_attr; + buffer_attr.fragsize = period_frame_size * audio_format_to_get_bytes_per_sample(audio_format) * num_channels; // 2/4 bytes/sample, @num_channels channels buffer_attr.tlength = -1; buffer_attr.prebuf = -1; buffer_attr.minreq = -1; - buffer_attr.maxlength = period_frame_size * audio_format_to_get_bytes_per_sample(audio_format) * num_channels; // 2/4 bytes/sample, @num_channels channels - buffer_attr.fragsize = buffer_attr.maxlength; + buffer_attr.maxlength = buffer_attr.fragsize; int error = 0; pa_handle *handle = pa_sound_device_new(nullptr, description, device_name, description, &ss, &buffer_attr, &error); if(!handle) { - fprintf(stderr, "pa_sound_device_new() failed: %s. Audio input device %s might not be valid\n", pa_strerror(error), description); + fprintf(stderr, "Error: pa_sound_device_new() failed: %s. Audio input device %s might not be valid\n", pa_strerror(error), device_name); return -1; } @@ -278,13 +441,15 @@ void sound_device_close(SoundDevice *device) { device->handle = NULL; } -int sound_device_read_next_chunk(SoundDevice *device, void **buffer) { +int sound_device_read_next_chunk(SoundDevice *device, void **buffer, double timeout_sec, double *latency_seconds) { pa_handle *pa = (pa_handle*)device->handle; - if(pa_sound_device_read(pa) < 0) { + if(pa_sound_device_read(pa, timeout_sec) < 0) { //fprintf(stderr, "pa_simple_read() failed: %s\n", pa_strerror(error)); + *latency_seconds = 0.0; return -1; } *buffer = pa->output_data; + *latency_seconds = pa->latency_seconds; return device->frames; } @@ -308,26 +473,138 @@ static void pa_state_cb(pa_context *c, void *userdata) { } } -static void pa_sourcelist_cb(pa_context *ctx, const pa_source_info *source_info, int eol, void *userdata) { - (void)ctx; +static void pa_sourcelist_cb(pa_context*, const pa_source_info *source_info, int eol, void *userdata) { if(eol > 0) return; - std::vector<AudioInput> *inputs = (std::vector<AudioInput>*)userdata; - inputs->push_back({ source_info->name, source_info->description }); + AudioDevices *audio_devices = (AudioDevices*)userdata; + audio_devices->audio_inputs.push_back({ source_info->name, source_info->description }); +} + +static void pa_server_info_cb(pa_context*, const pa_server_info *server_info, void *userdata) { + AudioDevices *audio_devices = (AudioDevices*)userdata; + if(server_info->default_sink_name) + audio_devices->default_output = std::string(server_info->default_sink_name) + ".monitor"; + if(server_info->default_source_name) + audio_devices->default_input = server_info->default_source_name; } -std::vector<AudioInput> get_pulseaudio_inputs() { - std::vector<AudioInput> inputs; +static void server_info_callback(pa_context*, const pa_server_info *server_info, void *userdata) { + bool *is_server_pipewire = (bool*)userdata; + if(server_info->server_name && strstr(server_info->server_name, "PipeWire")) + *is_server_pipewire = true; +} + +static void get_pulseaudio_default_inputs(AudioDevices &audio_devices) { + int state = 0; + int pa_ready = 0; + pa_operation *pa_op = NULL; + pa_mainloop *main_loop = pa_mainloop_new(); + if(!main_loop) + return; pa_context *ctx = pa_context_new(pa_mainloop_get_api(main_loop), "gpu-screen-recorder"); - pa_context_connect(ctx, NULL, PA_CONTEXT_NOFLAGS, NULL); + if(pa_context_connect(ctx, NULL, PA_CONTEXT_NOFLAGS, NULL) < 0) + goto done; + + pa_context_set_state_callback(ctx, pa_state_cb, &pa_ready); + + for(;;) { + // Not ready + if(pa_ready == 0) { + pa_mainloop_iterate(main_loop, 1, NULL); + continue; + } + + switch(state) { + case 0: { + pa_op = pa_context_get_server_info(ctx, pa_server_info_cb, &audio_devices); + ++state; + break; + } + } + + // Couldn't get connection to the server + if(pa_ready == 2 || (state == 1 && pa_op && pa_operation_get_state(pa_op) == PA_OPERATION_DONE)) + break; + + pa_mainloop_iterate(main_loop, 1, NULL); + } + + done: + if(pa_op) + pa_operation_unref(pa_op); + pa_context_disconnect(ctx); + pa_context_unref(ctx); + pa_mainloop_free(main_loop); +} + +AudioDevices get_pulseaudio_inputs() { + AudioDevices audio_devices; int state = 0; int pa_ready = 0; + pa_operation *pa_op = NULL; + + // TODO: Do this in the same connection below instead of two separate connections + get_pulseaudio_default_inputs(audio_devices); + + pa_mainloop *main_loop = pa_mainloop_new(); + if(!main_loop) + return audio_devices; + + pa_context *ctx = pa_context_new(pa_mainloop_get_api(main_loop), "gpu-screen-recorder"); + if(pa_context_connect(ctx, NULL, PA_CONTEXT_NOFLAGS, NULL) < 0) + goto done; + pa_context_set_state_callback(ctx, pa_state_cb, &pa_ready); + for(;;) { + // Not ready + if(pa_ready == 0) { + pa_mainloop_iterate(main_loop, 1, NULL); + continue; + } + + switch(state) { + case 0: { + pa_op = pa_context_get_source_info_list(ctx, pa_sourcelist_cb, &audio_devices); + ++state; + break; + } + } + + // Couldn't get connection to the server + if(pa_ready == 2 || (state == 1 && pa_op && pa_operation_get_state(pa_op) == PA_OPERATION_DONE)) + break; + + pa_mainloop_iterate(main_loop, 1, NULL); + } + + done: + if(pa_op) + pa_operation_unref(pa_op); + pa_context_disconnect(ctx); + pa_context_unref(ctx); + pa_mainloop_free(main_loop); + return audio_devices; +} + +bool pulseaudio_server_is_pipewire() { + int state = 0; + int pa_ready = 0; pa_operation *pa_op = NULL; + bool is_server_pipewire = false; + + pa_mainloop *main_loop = pa_mainloop_new(); + if(!main_loop) + return is_server_pipewire; + + pa_context *ctx = pa_context_new(pa_mainloop_get_api(main_loop), "gpu-screen-recorder"); + if(pa_context_connect(ctx, NULL, PA_CONTEXT_NOFLAGS, NULL) < 0) + goto done; + + pa_context_set_state_callback(ctx, pa_state_cb, &pa_ready); for(;;) { // Not ready @@ -338,24 +615,24 @@ std::vector<AudioInput> get_pulseaudio_inputs() { switch(state) { case 0: { - pa_op = pa_context_get_source_info_list(ctx, pa_sourcelist_cb, &inputs); + pa_op = pa_context_get_server_info(ctx, server_info_callback, &is_server_pipewire); ++state; break; } } // Couldn't get connection to the server - if(pa_ready == 2 || (state == 1 && pa_op && pa_operation_get_state(pa_op) == PA_OPERATION_DONE)) { - if(pa_op) - pa_operation_unref(pa_op); - pa_context_disconnect(ctx); - pa_context_unref(ctx); + if(pa_ready == 2 || (state == 1 && pa_op && pa_operation_get_state(pa_op) == PA_OPERATION_DONE)) break; - } pa_mainloop_iterate(main_loop, 1, NULL); } + done: + if(pa_op) + pa_operation_unref(pa_op); + pa_context_disconnect(ctx); + pa_context_unref(ctx); pa_mainloop_free(main_loop); - return inputs; + return is_server_pipewire; } |