1 files changed, 338 insertions, 117 deletions

diff --git a/src/sound.cpp b/src/sound.cpp
index 779aa87..53000bd 100644
--- a/src/sound.cpp
+++ b/src/sound.cpp
@@ -1,154 +1,375 @@
-/*
-    Copyright (C) 2020 dec05eba
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
 #include "../include/sound.hpp"
+extern "C" {
+#include "../include/utils.h"
+}
 
 #include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
+#include <cmath>
+#include <time.h>
 
-#ifdef PULSEAUDIO
-#include <pulse/simple.h>
+#include <pulse/pulseaudio.h>
+#include <pulse/mainloop.h>
+#include <pulse/xmalloc.h>
 #include <pulse/error.h>
 
-int sound_device_get_by_name(SoundDevice *device, const char *name, unsigned int num_channels, unsigned int period_frame_size) {
-    pa_sample_spec ss;
-    ss.format = PA_SAMPLE_S16LE;
-    ss.rate = 48000;
-    ss.channels = num_channels;
-    int error;
+#define CHECK_DEAD_GOTO(p, rerror, label)                               \
+    do {                                                                \
+        if (!(p)->context || !PA_CONTEXT_IS_GOOD(pa_context_get_state((p)->context)) || \
+            !(p)->stream || !PA_STREAM_IS_GOOD(pa_stream_get_state((p)->stream))) { \
+            if (((p)->context && pa_context_get_state((p)->context) == PA_CONTEXT_FAILED) || \
+                ((p)->stream && pa_stream_get_state((p)->stream) == PA_STREAM_FAILED)) { \
+                if (rerror)                                             \
+                    *(rerror) = pa_context_errno((p)->context);         \
+            } else                                                      \
+                if (rerror)                                             \
+                    *(rerror) = PA_ERR_BADSTATE;                        \
+            goto label;                                                 \
+        }                                                               \
+    } while(false);
 
-    pa_simple *pa_handle = pa_simple_new(nullptr, "gpu-screen-recorder", PA_STREAM_RECORD, name, "record", &ss, nullptr, nullptr, &error);
-    if(!pa_handle) {
-        fprintf(stderr, "pa_simple_new() failed: %s. Audio input device %s might not be valid\n", pa_strerror(error), name);
-        return -1;
+struct pa_handle {
+    pa_context *context;
+    pa_stream *stream;
+    pa_mainloop *mainloop;
+
+    const void *read_data;
+    size_t read_index, read_length;
+
+    uint8_t *output_data;
+    size_t output_index, output_length;
+
+    int operation_success;
+    double latency_seconds;
+};
+
+static void pa_sound_device_free(pa_handle *s) {
+    assert(s);
+
+    if (s->stream)
+        pa_stream_unref(s->stream);
+
+    if (s->context) {
+        pa_context_disconnect(s->context);
+        pa_context_unref(s->context);
+    }
+
+    if (s->mainloop)
+        pa_mainloop_free(s->mainloop);
+
+    if (s->output_data) {
+        free(s->output_data);
+        s->output_data = NULL;
     }
 
-    int buffer_size = period_frame_size * 2 * num_channels; // 2 bytes/sample, @num_channels channels
+    pa_xfree(s);
+}
+
+static pa_handle* pa_sound_device_new(const char *server,
+        const char *name,
+        const char *dev,
+        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;
+
+    p = pa_xnew0(pa_handle, 1);
+    p->read_data = NULL;
+    p->read_length = 0;
+    p->read_index = 0;
+    p->latency_seconds = 0.0;
+
+    const int buffer_size = attr->fragsize;
     void *buffer = malloc(buffer_size);
     if(!buffer) {
         fprintf(stderr, "failed to allocate buffer for audio\n");
-        pa_simple_free(pa_handle);
-        return -1;
+        *rerror = -1;
+        return NULL;
     }
 
-    fprintf(stderr, "Using pulseaudio\n");
+    p->output_data = (uint8_t*)buffer;
+    p->output_length = buffer_size;
+    p->output_index = 0;
 
-    device->handle = pa_handle;
-    device->buffer = buffer;
-    device->buffer_size = buffer_size;
-    device->frames = period_frame_size;
-    return 0;
-}
+    if (!(p->mainloop = pa_mainloop_new()))
+        goto fail;
 
-void sound_device_close(SoundDevice *device) {
-    pa_simple_free((pa_simple*)device->handle);
-    free(device->buffer);
+    if (!(p->context = pa_context_new(pa_mainloop_get_api(p->mainloop), name)))
+        goto fail;
+
+    if (pa_context_connect(p->context, server, PA_CONTEXT_NOFLAGS, NULL) < 0) {
+        error = pa_context_errno(p->context);
+        goto fail;
+    }
+
+    for (;;) {
+        pa_context_state_t state = pa_context_get_state(p->context);
+
+        if (state == PA_CONTEXT_READY)
+            break;
+
+        if (!PA_CONTEXT_IS_GOOD(state)) {
+            error = pa_context_errno(p->context);
+            goto fail;
+        }
+
+        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);
+        goto fail;
+    }
+
+    r = pa_stream_connect_record(p->stream, dev, 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;
+    }
+
+    for (;;) {
+        pa_stream_state_t state = pa_stream_get_state(p->stream);
+
+        if (state == PA_STREAM_READY)
+            break;
+
+        if (!PA_STREAM_IS_GOOD(state)) {
+            error = pa_context_errno(p->context);
+            goto fail;
+        }
+
+        pa_mainloop_iterate(p->mainloop, 1, NULL);
+    }
+
+    return p;
+
+fail:
+    if (rerror)
+        *rerror = error;
+    pa_sound_device_free(p);
+    return NULL;
 }
 
-int sound_device_read_next_chunk(SoundDevice *device, void **buffer) {
-    int error;
-    if(pa_simple_read((pa_simple*)device->handle, device->buffer, device->buffer_size, &error) < 0) {
-        fprintf(stderr, "pa_simple_read() failed: %s\n", pa_strerror(error));
-        return -1;
+static int pa_sound_device_read(pa_handle *p, double timeout_seconds) {
+    assert(p);
+
+    const double start_time = clock_get_monotonic_seconds();
+
+    bool success = false;
+    int r = 0;
+    int *rerror = &r;
+    pa_usec_t latency = 0;
+    int negative = 0;
+
+    CHECK_DEAD_GOTO(p, rerror, fail);
+
+    while (p->output_index < p->output_length) {
+        if(clock_get_monotonic_seconds() - start_time >= timeout_seconds)
+            return -1;
+
+        if(!p->read_data) {
+            pa_mainloop_prepare(p->mainloop, 1 * 1000); // 1 ms
+            pa_mainloop_poll(p->mainloop);
+            pa_mainloop_dispatch(p->mainloop);
+
+            if(pa_stream_peek(p->stream, &p->read_data, &p->read_length) < 0)
+                goto fail;
+
+            if(!p->read_data && p->read_length == 0)
+                continue;
+
+            if(!p->read_data && p->read_length > 0) {
+                // There is a hole in the stream :( drop it. Maybe we should generate silence instead? TODO
+                if(pa_stream_drop(p->stream) != 0)
+                    goto fail;
+                continue;
+            }
+
+            if(p->read_length <= 0) {
+                p->read_data = NULL;
+                if(pa_stream_drop(p->stream) != 0)
+                    goto fail;
+
+                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;
+        if(space_free_in_output_buffer < p->read_length) {
+            memcpy(p->output_data + p->output_index, (const uint8_t*)p->read_data + p->read_index, space_free_in_output_buffer);
+            p->output_index = 0;
+            p->read_index += space_free_in_output_buffer;
+            p->read_length -= space_free_in_output_buffer;
+            break;
+        } else {
+            memcpy(p->output_data + p->output_index, (const uint8_t*)p->read_data + p->read_index, p->read_length);
+            p->output_index += p->read_length;
+            p->read_data = NULL;
+            p->read_length = 0;
+            p->read_index = 0;
+            
+            if(pa_stream_drop(p->stream) != 0)
+                goto fail;
+
+            if(p->output_index == p->output_length) {
+                p->output_index = 0;
+                break;
+            }
+        }
     }
-    *buffer = device->buffer;
-    return device->frames;
+
+    success = true;
+
+    fail:
+    return success ? 0 : -1;
 }
-#else
-#define ALSA_PCM_NEW_HW_PARAMS_API
-#include <alsa/asoundlib.h>
-
-int sound_device_get_by_name(SoundDevice *device, const char *name, unsigned int num_channels, unsigned int period_frame_size) {
-    int rc;
-    snd_pcm_t *handle;
-
-    rc = snd_pcm_open(&handle, name, SND_PCM_STREAM_CAPTURE, 0);
-    if(rc < 0) {
-        fprintf(stderr, "unable to open pcm device 'default', reason: %s\n", snd_strerror(rc));
-        return rc;
+
+static pa_sample_format_t audio_format_to_pulse_audio_format(AudioFormat audio_format) {
+    switch(audio_format) {
+        case S16: return PA_SAMPLE_S16LE;
+        case S32: return PA_SAMPLE_S32LE;
+        case F32: return PA_SAMPLE_FLOAT32LE;
     }
+    assert(false);
+    return PA_SAMPLE_S16LE;
+}
 
-    snd_pcm_hw_params_t *params;
-    snd_pcm_hw_params_alloca(&params);
-    // Fill the params with default values
-    snd_pcm_hw_params_any(handle, params);
-    // Interleaved mode
-    snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
-    // Signed 16--bit little-endian format
-    snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S16_LE);
-    snd_pcm_hw_params_set_channels(handle, params, num_channels);
-
-    // 48000 bits/second samling rate (DVD quality)
-    unsigned int val = 48000;
-    int dir;
-    snd_pcm_hw_params_set_rate_near(handle, params, &val, &dir);
-
-    snd_pcm_uframes_t frames = period_frame_size;
-    snd_pcm_hw_params_set_period_size_near(handle, params, &frames, &dir);
-
-    // Write the parmeters to the driver
-    rc = snd_pcm_hw_params(handle, params);
-    if(rc < 0) {
-        fprintf(stderr, "unable to set hw parameters, reason: %s\n", snd_strerror(rc));
-        snd_pcm_close(handle);
-        return rc;
+static int audio_format_to_get_bytes_per_sample(AudioFormat audio_format) {
+    switch(audio_format) {
+        case S16: return 2;
+        case S32: return 4;
+        case F32: return 4;
     }
+    assert(false);
+    return 2;
+}
 
-    // Use a buffer large enough to hold one period
-    snd_pcm_hw_params_get_period_size(params, &frames, &dir);
-    int buffer_size = frames * 2 * num_channels; // 2 bytes/sample, @num_channels channels
-    void *buffer = malloc(buffer_size);
-    if(!buffer) {
-        fprintf(stderr, "failed to allocate buffer for audio\n");
-        snd_pcm_close(handle);
+int sound_device_get_by_name(SoundDevice *device, const char *device_name, const char *description, unsigned int num_channels, unsigned int period_frame_size, AudioFormat audio_format) {
+    pa_sample_spec ss;
+    ss.format = audio_format_to_pulse_audio_format(audio_format);
+    ss.rate = 48000;
+    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 = 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);
         return -1;
     }
 
-    fprintf(stderr, "Using alsa\n");
-
     device->handle = handle;
-    device->buffer = buffer;
-    device->buffer_size = buffer_size;
-    device->frames = frames;
+    device->frames = period_frame_size;
     return 0;
 }
 
 void sound_device_close(SoundDevice *device) {
-    /* TODO: Is this also needed in @sound_device_get_by_name on failure? */
-    // TODO: This has been commented out since it causes the thread to block forever. Why?
-    //snd_pcm_drain((snd_pcm_t*)device->handle);
-    snd_pcm_close((snd_pcm_t*)device->handle);
-    free(device->buffer);
+    if(device->handle)
+        pa_sound_device_free((pa_handle*)device->handle);
+    device->handle = NULL;
+}
+
+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, 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;
 }
 
-int sound_device_read_next_chunk(SoundDevice *device, void **buffer) {
-    int rc = snd_pcm_readi((snd_pcm_t*)device->handle, device->buffer, device->frames);
-    if (rc == -EPIPE) {
-        /* overrun */
-        fprintf(stderr, "overrun occured\n");
-        snd_pcm_prepare((snd_pcm_t*)device->handle);
-        return rc;
-    } else if(rc < 0) {
-        fprintf(stderr, "failed to read from sound device, reason: %s\n", snd_strerror(rc));
-        return rc;
-    } else if (rc != (int)device->frames) {
-        fprintf(stderr, "short read, read %d frames\n", rc);
+static void pa_state_cb(pa_context *c, void *userdata) {
+    pa_context_state state = pa_context_get_state(c);
+    int *pa_ready = (int*)userdata;
+    switch(state) {
+        case PA_CONTEXT_UNCONNECTED:
+        case PA_CONTEXT_CONNECTING:
+        case PA_CONTEXT_AUTHORIZING:
+        case PA_CONTEXT_SETTING_NAME:
+        default:
+            break;
+        case PA_CONTEXT_FAILED:
+        case PA_CONTEXT_TERMINATED:
+            *pa_ready = 2;
+            break;
+        case PA_CONTEXT_READY:
+            *pa_ready = 1;
+            break;
     }
-    *buffer = device->buffer;
-    return rc;
 }
-#endif
+
+static void pa_sourcelist_cb(pa_context *ctx, const pa_source_info *source_info, int eol, void *userdata) {
+    (void)ctx;
+    if(eol > 0)
+        return;
+
+    std::vector<AudioInput> *inputs = (std::vector<AudioInput>*)userdata;
+    inputs->push_back({ source_info->name, source_info->description });
+}
+
+std::vector<AudioInput> get_pulseaudio_inputs() {
+    std::vector<AudioInput> inputs;
+    pa_mainloop *main_loop = pa_mainloop_new();
+
+    pa_context *ctx = pa_context_new(pa_mainloop_get_api(main_loop), "gpu-screen-recorder");
+    pa_context_connect(ctx, NULL, PA_CONTEXT_NOFLAGS, NULL);
+    int state = 0;
+    int pa_ready = 0;
+    pa_context_set_state_callback(ctx, pa_state_cb, &pa_ready);
+
+    pa_operation *pa_op = NULL;
+
+    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, &inputs);
+                ++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);
+            break;
+        }
+
+        pa_mainloop_iterate(main_loop, 1, NULL);
+    }
+
+    pa_mainloop_free(main_loop);
+    return inputs;
+}