add and export a ring buffer implementation

CMakeLists.txt

@@ -51,8 +51,8 @@ set(LIBSOUNDIO_SOURCES
     "${CMAKE_SOURCE_DIR}/src/util.cpp"
     "${CMAKE_SOURCE_DIR}/src/os.cpp"
     "${CMAKE_SOURCE_DIR}/src/dummy.cpp"
-    "${CMAKE_SOURCE_DIR}/src/dummy_ring_buffer.cpp"
     "${CMAKE_SOURCE_DIR}/src/channel_layout.cpp"
+    "${CMAKE_SOURCE_DIR}/src/ring_buffer.cpp"
 )
 
 set(CONFIGURE_OUT_FILE "${CMAKE_BINARY_DIR}/config.h")
@@ -67,8 +67,8 @@ set(TEST_SOURCES
     "${CMAKE_SOURCE_DIR}/src/os.cpp"
     "${CMAKE_SOURCE_DIR}/src/soundio.cpp"
     "${CMAKE_SOURCE_DIR}/src/dummy.cpp"
-    "${CMAKE_SOURCE_DIR}/src/dummy_ring_buffer.cpp"
     "${CMAKE_SOURCE_DIR}/src/channel_layout.cpp"
+    "${CMAKE_SOURCE_DIR}/src/ring_buffer.cpp"
 )
 
 if(SOUNDIO_HAVE_PULSEAUDIO)
@@ -152,6 +152,13 @@ set_target_properties(list_devices PROPERTIES
 include_directories(${EXAMPLE_INCLUDES})
 target_link_libraries(list_devices libsoundio_shared)
 
+add_executable(microphone example/microphone.c)
+set_target_properties(microphone PROPERTIES
+    LINKER_LANGUAGE C
+    COMPILE_FLAGS ${EXAMPLE_CFLAGS})
+include_directories(${EXAMPLE_INCLUDES})
+target_link_libraries(microphone libsoundio_shared)
+
 
 
 enable_testing()

example/microphone.c

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2015 Andrew Kelley
+ *
+ * This file is part of libsoundio, which is MIT licensed.
+ * See http://opensource.org/licenses/MIT
+ */
+
+#include <soundio.h>
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+__attribute__ ((cold))
+__attribute__ ((noreturn))
+__attribute__ ((format (printf, 1, 2)))
+static void panic(const char *format, ...) {
+    va_list ap;
+    va_start(ap, format);
+    vfprintf(stderr, format, ap);
+    fprintf(stderr, "\n");
+    va_end(ap);
+    abort();
+}
+
+static void read_callback(struct SoundIoInputDevice *input_device) {
+    fprintf(stderr, "read_callback\n");
+}
+
+static void write_callback(struct SoundIoOutputDevice *output_device, int requested_frame_count) {
+    fprintf(stderr, "write_callback\n");
+}
+
+static void underrun_callback(struct SoundIoOutputDevice *output_device) {
+    static int count = 0;
+    fprintf(stderr, "underrun %d\n", count++);
+    soundio_output_device_fill_with_silence(output_device);
+}
+
+int main(int argc, char **argv) {
+    struct SoundIo *soundio = soundio_create();
+    if (!soundio)
+        panic("out of memory");
+
+    int err;
+    if ((err = soundio_connect(soundio)))
+        panic("error connecting: %s", soundio_error_string(err));
+
+    int default_out_device_index = soundio_get_default_output_device_index(soundio);
+    if (default_out_device_index < 0)
+        panic("no output device found");
+
+    int default_in_device_index = soundio_get_default_output_device_index(soundio);
+    if (default_in_device_index < 0)
+        panic("no output device found");
+
+    struct SoundIoDevice *out_device = soundio_get_output_device(soundio, default_out_device_index);
+    if (!out_device)
+        panic("could not get output device: out of memory");
+
+    struct SoundIoDevice *in_device = soundio_get_input_device(soundio, default_in_device_index);
+    if (!in_device)
+        panic("could not get input device: out of memory");
+
+    fprintf(stderr, "Input device: %s: %s\n",
+            soundio_device_name(in_device),
+            soundio_device_description(in_device));
+    fprintf(stderr, "Output device: %s: %s\n",
+            soundio_device_name(out_device),
+            soundio_device_description(out_device));
+
+    struct SoundIoInputDevice *input_device;
+    soundio_input_device_create(in_device, SoundIoSampleFormatFloat, 0.1, NULL,
+            read_callback, &input_device);
+
+    struct SoundIoOutputDevice *output_device;
+    soundio_output_device_create(out_device, SoundIoSampleFormatFloat, 0.1, NULL,
+            write_callback, underrun_callback, &output_device);
+
+    if ((err = soundio_input_device_start(input_device)))
+        panic("unable to start input device: %s", soundio_error_string(err));
+
+    if ((err = soundio_output_device_start(output_device)))
+        panic("unable to start output device: %s", soundio_error_string(err));
+
+    for (;;)
+        soundio_wait_events(soundio);
+
+    soundio_output_device_destroy(output_device);
+    soundio_input_device_destroy(input_device);
+    soundio_device_unref(in_device);
+    soundio_device_unref(out_device);
+    soundio_destroy(soundio);
+    return 0;
+}

src/atomics.hpp

@@ -3,10 +3,15 @@
 
 #include <atomic>
 using std::atomic_flag;
+using std::atomic_int;
 using std::atomic_long;
 using std::atomic_bool;
 using std::atomic_uintptr_t;
 
+#if ATOMIC_INT_LOCK_FREE != 2
+#error "require atomic_int to be lock free"
+#endif
+
 #if ATOMIC_LONG_LOCK_FREE != 2
 #error "require atomic_long to be lock free"
 #endif

src/dummy.cpp

@@ -7,9 +7,9 @@
 
 #include "dummy.hpp"
 #include "soundio.hpp"
-#include "dummy_ring_buffer.hpp"
 #include "os.hpp"
 #include "atomics.hpp"
+#include "ring_buffer.hpp"
 
 #include <stdio.h>
 #include <string.h>
@@ -20,7 +20,7 @@ struct SoundIoOutputDeviceDummy {
     atomic_flag abort_flag;
     int buffer_size;
     double period;
-    struct SoundIoDummyRingBuffer ring_buffer;
+    struct SoundIoRingBuffer ring_buffer;
 };
 
 struct SoundIoInputDeviceDummy {
@@ -49,12 +49,12 @@ static void playback_thread_run(void *arg) {
         double total_time = now - start_time;
         long total_frames = total_time / time_per_frame;
         int frames_to_kill = total_frames - frames_consumed;
-        int fill_count = soundio_dummy_ring_buffer_fill_count(&opd->ring_buffer);
+        int fill_count = soundio_ring_buffer_fill_count(&opd->ring_buffer);
         int frames_in_buffer = fill_count / output_device->bytes_per_frame;
         int read_count = min(frames_to_kill, frames_in_buffer);
         int frames_left = frames_to_kill - read_count;
         int byte_count = read_count * output_device->bytes_per_frame;
-        soundio_dummy_ring_buffer_advance_read_ptr(&opd->ring_buffer, byte_count);
+        soundio_ring_buffer_advance_read_ptr(&opd->ring_buffer, byte_count);
         frames_consumed += read_count;
 
         if (frames_left > 0) {
@@ -128,7 +128,7 @@ static void output_device_destroy_dummy(SoundIo *soundio,
     soundio_os_cond_destroy(opd->cond);
     opd->cond = nullptr;
 
-    soundio_dummy_ring_buffer_deinit(&opd->ring_buffer);
+    soundio_ring_buffer_deinit(&opd->ring_buffer);
 
     destroy(opd);
     output_device->backend_data = nullptr;
@@ -150,7 +150,7 @@ static int output_device_init_dummy(SoundIo *soundio,
     opd->buffer_size = output_device->bytes_per_frame * buffer_frame_count;
     opd->period = output_device->latency * 0.5;
 
-    soundio_dummy_ring_buffer_init(&opd->ring_buffer, opd->buffer_size);
+    soundio_ring_buffer_init(&opd->ring_buffer, opd->buffer_size);
 
     opd->cond = soundio_os_cond_create();
     if (!opd->cond) {
@@ -167,7 +167,7 @@ static int output_device_start_dummy(SoundIo *soundio,
     SoundIoOutputDeviceDummy *opd = (SoundIoOutputDeviceDummy *)output_device->backend_data;
 
     soundio_output_device_fill_with_silence(output_device);
-    assert(soundio_dummy_ring_buffer_fill_count(&opd->ring_buffer) == opd->buffer_size);
+    assert(soundio_ring_buffer_fill_count(&opd->ring_buffer) == opd->buffer_size);
 
     opd->abort_flag.test_and_set();
     int err;
@@ -182,7 +182,7 @@ static int output_device_free_count_dummy(SoundIo *soundio,
         SoundIoOutputDevice *output_device)
 {
     SoundIoOutputDeviceDummy *opd = (SoundIoOutputDeviceDummy *)output_device->backend_data;
-    int fill_count = soundio_dummy_ring_buffer_fill_count(&opd->ring_buffer);
+    int fill_count = soundio_ring_buffer_fill_count(&opd->ring_buffer);
     int bytes_free_count = opd->buffer_size - fill_count;
     return bytes_free_count / output_device->bytes_per_frame;
 }
@@ -203,14 +203,14 @@ static void output_device_write_dummy(SoundIo *soundio,
     SoundIoOutputDeviceDummy *opd = (SoundIoOutputDeviceDummy *)output_device->backend_data;
     assert(data == opd->ring_buffer.address);
     int byte_count = frame_count * output_device->bytes_per_frame;
-    soundio_dummy_ring_buffer_advance_write_ptr(&opd->ring_buffer, byte_count);
+    soundio_ring_buffer_advance_write_ptr(&opd->ring_buffer, byte_count);
 }
 
 static void output_device_clear_buffer_dummy(SoundIo *soundio,
         SoundIoOutputDevice *output_device)
 {
     SoundIoOutputDeviceDummy *opd = (SoundIoOutputDeviceDummy *)output_device->backend_data;
-    soundio_dummy_ring_buffer_clear(&opd->ring_buffer);
+    soundio_ring_buffer_clear(&opd->ring_buffer);
 }
 
 static int input_device_init_dummy(SoundIo *soundio,

src/dummy_ring_buffer.cpp

@@ -1,75 +0,0 @@
-#include "dummy_ring_buffer.hpp"
-#include "soundio.hpp"
-#include <math.h>
-
-int soundio_dummy_ring_buffer_create(int requested_capacity, struct SoundIoDummyRingBuffer **out) {
-    *out = nullptr;
-    SoundIoDummyRingBuffer *rb = create<SoundIoDummyRingBuffer>();
-
-    if (!rb) {
-        soundio_dummy_ring_buffer_destroy(rb);
-        return SoundIoErrorNoMem;
-    }
-
-    int err;
-    if ((err = soundio_dummy_ring_buffer_init(rb, requested_capacity))) {
-        soundio_dummy_ring_buffer_destroy(rb);
-        return SoundIoErrorNoMem;
-    }
-
-    *out = rb;
-    return 0;
-}
-
-int soundio_dummy_ring_buffer_init(struct SoundIoDummyRingBuffer *rb, int requested_capacity) {
-    // round size up to the nearest power of two
-    rb->capacity = powf(2, ceilf(log2(requested_capacity)));
-
-    rb->address = allocate_nonzero<char>(rb->capacity);
-    if (!rb->address) {
-        soundio_dummy_ring_buffer_deinit(rb);
-        return SoundIoErrorNoMem;
-    }
-
-    return 0;
-}
-
-void soundio_dummy_ring_buffer_destroy(struct SoundIoDummyRingBuffer *rb) {
-    if (!rb)
-        return;
-
-    soundio_dummy_ring_buffer_deinit(rb);
-
-    destroy(rb);
-}
-
-void soundio_dummy_ring_buffer_deinit(struct SoundIoDummyRingBuffer *rb) {
-    deallocate(rb->address, rb->capacity);
-    rb->address = nullptr;
-}
-
-void soundio_dummy_ring_buffer_clear(struct SoundIoDummyRingBuffer *rb) {
-    rb->write_offset.store(rb->read_offset.load());
-}
-
-int soundio_dummy_ring_buffer_free_count(struct SoundIoDummyRingBuffer *rb) {
-    return rb->capacity - soundio_dummy_ring_buffer_fill_count(rb);
-}
-
-int soundio_dummy_ring_buffer_fill_count(struct SoundIoDummyRingBuffer *rb) {
-    int count = rb->write_offset - rb->read_offset;
-    assert(count >= 0);
-    assert(count <= rb->capacity);
-    return count;
-}
-
-void soundio_dummy_ring_buffer_advance_write_ptr(struct SoundIoDummyRingBuffer *rb, int count) {
-    rb->write_offset += count;
-    assert(soundio_dummy_ring_buffer_fill_count(rb) >= 0);
-}
-
-void soundio_dummy_ring_buffer_advance_read_ptr(struct SoundIoDummyRingBuffer *rb, int count) {
-    rb->read_offset += count;
-    assert(soundio_dummy_ring_buffer_fill_count(rb) >= 0);
-}
-

src/dummy_ring_buffer.hpp

@@ -1,33 +0,0 @@
-#ifndef SOUNDIO_DUMMY_RING_BUFFER_HPP
-#define SOUNDIO_DUMMY_RING_BUFFER_HPP
-
-#include "util.hpp"
-#include "atomics.hpp"
-
-struct SoundIoDummyRingBuffer {
-    char *address;
-    long capacity;
-    atomic_long write_offset;
-    atomic_long read_offset;
-};
-
-int soundio_dummy_ring_buffer_create(int requested_capacity, struct SoundIoDummyRingBuffer **out);
-void soundio_dummy_ring_buffer_destroy(struct SoundIoDummyRingBuffer *rb);
-int soundio_dummy_ring_buffer_init(struct SoundIoDummyRingBuffer *rb, int requested_capacity);
-void soundio_dummy_ring_buffer_deinit(struct SoundIoDummyRingBuffer *rb);
-
-// must be called by the writer
-void soundio_dummy_ring_buffer_clear(struct SoundIoDummyRingBuffer *rb);
-
-
-// how much is available, ready for writing
-int soundio_dummy_ring_buffer_free_count(struct SoundIoDummyRingBuffer *rb);
-
-// how much of the buffer is used, ready for reading
-int soundio_dummy_ring_buffer_fill_count(struct SoundIoDummyRingBuffer *rb);
-
-void soundio_dummy_ring_buffer_advance_write_ptr(struct SoundIoDummyRingBuffer *rb, int count);
-void soundio_dummy_ring_buffer_advance_read_ptr(struct SoundIoDummyRingBuffer *rb, int count);
-
-#endif
-

src/pulseaudio.cpp

@@ -720,7 +720,8 @@ static void recording_stream_state_callback(pa_stream *stream, void *userdata) {
             ord->stream_ready = true;
             break;
         case PA_STREAM_FAILED:
-            soundio_panic("pulseaudio stream error: %s", pa_strerror(pa_context_errno(pa_stream_get_context(stream))));
+            soundio_panic("pulseaudio stream error: %s",
+                    pa_strerror(pa_context_errno(pa_stream_get_context(stream))));
             break;
     }
 }
@@ -730,10 +731,39 @@ static void recording_stream_read_callback(pa_stream *stream, size_t nbytes, voi
     input_device->read_callback(input_device);
 }
 
-static int input_device_init_pa(SoundIo *soundio,
+static void input_device_destroy_pa(SoundIo *soundio,
         SoundIoInputDevice *input_device)
 {
     SoundIoInputDevicePulseAudio *ord = (SoundIoInputDevicePulseAudio *)input_device->backend_data;
+    if (!ord)
+        return;
+
+    SoundIoPulseAudio *sipa = (SoundIoPulseAudio *)soundio->backend_data;
+    pa_stream *stream = ord->stream;
+    if (stream) {
+        pa_threaded_mainloop_lock(sipa->main_loop);
+
+        pa_stream_set_state_callback(stream, nullptr, nullptr);
+        pa_stream_set_read_callback(stream, nullptr, nullptr);
+        pa_stream_disconnect(stream);
+        pa_stream_unref(stream);
+
+        pa_threaded_mainloop_unlock(sipa->main_loop);
+
+        ord->stream = nullptr;
+    }
+}
+
+static int input_device_init_pa(SoundIo *soundio,
+        SoundIoInputDevice *input_device)
+{
+    SoundIoInputDevicePulseAudio *ord = create<SoundIoInputDevicePulseAudio>();
+    if (!ord) {
+        input_device_destroy_pa(soundio, input_device);
+        return SoundIoErrorNoMem;
+    }
+    input_device->backend_data = ord;
+
     SoundIoPulseAudio *sipa = (SoundIoPulseAudio *)soundio->backend_data;
     SoundIoDevice *device = input_device->device;
     ord->stream_ready = false;
@@ -750,6 +780,7 @@ static int input_device_init_pa(SoundIo *soundio,
     ord->stream = pa_stream_new(sipa->pulse_context, "SoundIo", &sample_spec, &channel_map);
     if (!input_device) {
         pa_threaded_mainloop_unlock(sipa->main_loop);
+        input_device_destroy_pa(soundio, input_device);
         return SoundIoErrorNoMem;
     }
 
@@ -773,26 +804,6 @@ static int input_device_init_pa(SoundIo *soundio,
     return 0;
 }
 
-static void input_device_destroy_pa(SoundIo *soundio,
-        SoundIoInputDevice *input_device)
-{
-    SoundIoInputDevicePulseAudio *ord = (SoundIoInputDevicePulseAudio *)input_device->backend_data;
-    SoundIoPulseAudio *sipa = (SoundIoPulseAudio *)soundio->backend_data;
-    pa_stream *stream = ord->stream;
-    if (stream) {
-        pa_threaded_mainloop_lock(sipa->main_loop);
-
-        pa_stream_set_state_callback(stream, nullptr, nullptr);
-        pa_stream_set_read_callback(stream, nullptr, nullptr);
-        pa_stream_disconnect(stream);
-        pa_stream_unref(stream);
-
-        pa_threaded_mainloop_unlock(sipa->main_loop);
-
-        ord->stream = nullptr;
-    }
-}
-
 static int input_device_start_pa(SoundIo *soundio,
         SoundIoInputDevice *input_device)
 {

src/ring_buffer.cpp

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2015 Andrew Kelley
+ *
+ * This file is part of libsoundio, which is MIT licensed.
+ * See http://opensource.org/licenses/MIT
+ */
+
+#include "ring_buffer.hpp"
+#include "soundio.hpp"
+#include "util.hpp"
+
+#include <sys/mman.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <math.h>
+#include <string.h>
+#include <errno.h>
+
+struct SoundIoRingBuffer *soundio_ring_buffer_create(struct SoundIo *soundio, int requested_capacity) {
+    SoundIoRingBuffer *rb = create<SoundIoRingBuffer>();
+
+    if (!rb) {
+        soundio_ring_buffer_destroy(rb);
+        return nullptr;
+    }
+
+    if (soundio_ring_buffer_init(rb, requested_capacity)) {
+        soundio_ring_buffer_destroy(rb);
+        return nullptr;
+    }
+
+    return rb;
+}
+
+void soundio_ring_buffer_destroy(struct SoundIoRingBuffer *rb) {
+    if (!rb)
+        return;
+
+    soundio_ring_buffer_deinit(rb);
+
+    destroy(rb);
+}
+
+int soundio_ring_buffer_capacity(struct SoundIoRingBuffer *rb) {
+    return rb->capacity;
+}
+
+char *soundio_ring_buffer_write_ptr(struct SoundIoRingBuffer *rb) {
+    return rb->address + (rb->write_offset % rb->capacity);
+}
+
+void soundio_ring_buffer_advance_write_ptr(struct SoundIoRingBuffer *rb, int count) {
+    rb->write_offset += count;
+    assert(soundio_ring_buffer_fill_count(rb) >= 0);
+}
+
+char *soundio_ring_buffer_read_ptr(struct SoundIoRingBuffer *rb) {
+    return rb->address + (rb->read_offset % rb->capacity);
+}
+
+void soundio_ring_buffer_advance_read_ptr(struct SoundIoRingBuffer *rb, int count) {
+    rb->read_offset += count;
+    assert(soundio_ring_buffer_fill_count(rb) >= 0);
+}
+
+int soundio_ring_buffer_fill_count(struct SoundIoRingBuffer *rb) {
+    int count = rb->write_offset - rb->read_offset;
+    assert(count >= 0);
+    assert(count <= rb->capacity);
+    return count;
+}
+
+int soundio_ring_buffer_free_count(struct SoundIoRingBuffer *rb) {
+    return rb->capacity - soundio_ring_buffer_fill_count(rb);
+}
+
+void soundio_ring_buffer_clear(struct SoundIoRingBuffer *rb) {
+    return rb->write_offset.store(rb->read_offset.load());
+}
+
+int soundio_ring_buffer_init(struct SoundIoRingBuffer *rb, int requested_capacity) {
+    // round size up to the nearest power of two
+    int pow2_size = powf(2, ceilf(log2(requested_capacity)));
+    // at minimum must be page size
+    int page_size = getpagesize();
+    rb->capacity = max(pow2_size, page_size);
+
+    rb->write_offset = 0;
+    rb->read_offset = 0;
+
+    char shm_path[] = "/dev/shm/ring-buffer-XXXXXX";
+    int fd = mkstemp(shm_path);
+    if (fd < 0)
+        return SoundIoErrorSystemResources;
+
+    if (unlink(shm_path))
+        return SoundIoErrorSystemResources;
+
+    if (ftruncate(fd, rb->capacity))
+        return SoundIoErrorNoMem;
+
+    rb->address = (char*)mmap(NULL, rb->capacity * 2, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+    if (rb->address == MAP_FAILED)
+        return SoundIoErrorNoMem;
+
+    char *other_address = (char*)mmap(rb->address, rb->capacity,
+            PROT_READ|PROT_WRITE, MAP_FIXED|MAP_SHARED, fd, 0);
+    if (other_address != rb->address)
+        return SoundIoErrorNoMem;
+
+    other_address = (char*)mmap(rb->address + rb->capacity, rb->capacity,
+            PROT_READ|PROT_WRITE, MAP_FIXED|MAP_SHARED, fd, 0);
+    if (other_address != rb->address + rb->capacity)
+        return SoundIoErrorNoMem;
+
+    if (close(fd))
+        return SoundIoErrorSystemResources;
+
+    return 0;
+}
+
+void soundio_ring_buffer_deinit(struct SoundIoRingBuffer *rb) {
+    if (munmap(rb->address, 2 * rb->capacity))
+        soundio_panic("munmap failed: %s", strerror(errno));
+}

src/ring_buffer.hpp

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2015 Andrew Kelley
+ *
+ * This file is part of libsoundio, which is MIT licensed.
+ * See http://opensource.org/licenses/MIT
+ */
+
+#ifndef SOUNDIO_RING_BUFFER_HPP
+#define SOUNDIO_RING_BUFFER_HPP
+
+#include "atomics.hpp"
+
+struct SoundIoRingBuffer {
+    char *address;
+    long capacity;
+    atomic_long write_offset;
+    atomic_long read_offset;
+};
+
+int soundio_ring_buffer_init(struct SoundIoRingBuffer *rb, int requested_capacity);
+void soundio_ring_buffer_deinit(struct SoundIoRingBuffer *rb);
+
+#endif

src/soundio.cpp

@@ -336,3 +336,54 @@ int soundio_output_device_start(struct SoundIoOutputDevice *output_device) {
     SoundIo *soundio = output_device->device->soundio;
     return soundio->output_device_start(soundio, output_device);
 }
+
+int soundio_input_device_create(struct SoundIoDevice *device,
+        enum SoundIoSampleFormat sample_format, double latency, void *userdata,
+        void (*read_callback)(struct SoundIoInputDevice *),
+        struct SoundIoInputDevice **out_input_device)
+{
+    *out_input_device = nullptr;
+
+    SoundIoInputDevice *sid = create<SoundIoInputDevice>();
+    if (!sid) {
+        soundio_input_device_destroy(sid);
+        return SoundIoErrorNoMem;
+    }
+
+    soundio_device_ref(device);
+    sid->device = device;
+    sid->userdata = userdata;
+    sid->read_callback = read_callback;
+    sid->sample_format = sample_format;
+    sid->latency = latency;
+    sid->bytes_per_frame = soundio_get_bytes_per_frame(sample_format,
+            device->channel_layout.channel_count);
+
+    SoundIo *soundio = device->soundio;
+    int err = soundio->input_device_init(soundio, sid);
+    if (err) {
+        soundio_input_device_destroy(sid);
+        return err;
+    }
+
+    *out_input_device = sid;
+    return 0;
+}
+
+int soundio_input_device_start(struct SoundIoInputDevice *input_device) {
+    SoundIo *soundio = input_device->device->soundio;
+    return soundio->input_device_start(soundio, input_device);
+}
+
+void soundio_input_device_destroy(struct SoundIoInputDevice *input_device) {
+    if (!input_device)
+        return;
+
+    SoundIo *soundio = input_device->device->soundio;
+
+    if (soundio->input_device_destroy)
+        soundio->input_device_destroy(soundio, input_device);
+
+    soundio_device_unref(input_device->device);
+    destroy(input_device);
+}

src/soundio.h

@@ -309,16 +309,41 @@ void soundio_output_device_clear_buffer(struct SoundIoOutputDevice *output_devic
 
 int soundio_input_device_create(struct SoundIoDevice *device,
         enum SoundIoSampleFormat sample_format, double latency, void *userdata,
-        void (*read_callback)(struct SoundIoOutputDevice *),
+        void (*read_callback)(struct SoundIoInputDevice *),
-        struct SoundIoOutputDevice **out_input_device);
+        struct SoundIoInputDevice **out_input_device);
-void soundio_input_device_destroy(struct SoundIoOutputDevice *input_device);
+void soundio_input_device_destroy(struct SoundIoInputDevice *input_device);
 
-int soundio_input_device_start(struct SoundIoOutputDevice *input_device);
+int soundio_input_device_start(struct SoundIoInputDevice *input_device);
-void soundio_input_device_peek(struct SoundIoOutputDevice *input_device,
+void soundio_input_device_peek(struct SoundIoInputDevice *input_device,
         const char **data, int *frame_count);
-void soundio_input_device_drop(struct SoundIoOutputDevice *input_device);
+void soundio_input_device_drop(struct SoundIoInputDevice *input_device);
+
+void soundio_input_device_clear_buffer(struct SoundIoInputDevice *input_device);
+
+
+// Ring Buffer
+struct SoundIoRingBuffer;
+struct SoundIoRingBuffer *soundio_ring_buffer_create(struct SoundIo *soundio, int requested_capacity);
+void soundio_ring_buffer_destroy(struct SoundIoRingBuffer *ring_buffer);
+int soundio_ring_buffer_capacity(struct SoundIoRingBuffer *ring_buffer);
+
+// don't write more than capacity
+char *soundio_ring_buffer_write_ptr(struct SoundIoRingBuffer *ring_buffer);
+void soundio_ring_buffer_advance_write_ptr(struct SoundIoRingBuffer *ring_buffer, int count);
+
+// don't read more than capacity
+char *soundio_ring_buffer_read_ptr(struct SoundIoRingBuffer *ring_buffer);
+void soundio_ring_buffer_advance_read_ptr(struct SoundIoRingBuffer *ring_buffer, int count);
+
+// how much of the buffer is used, ready for reading
+int soundio_ring_buffer_fill_count(struct SoundIoRingBuffer *ring_buffer);
+
+// how much is available, ready for writing
+int soundio_ring_buffer_free_count(struct SoundIoRingBuffer *ring_buffer);
+
+// must be called by the writer
+void soundio_ring_buffer_clear(struct SoundIoRingBuffer *ring_buffer);
 
-void soundio_input_device_clear_buffer(struct SoundIoOutputDevice *input_device);
 
 #ifdef __cplusplus
 }

test/unit_tests.cpp

@@ -1,8 +1,9 @@
 #undef NDEBUG
 
-#include "soundio.h"
+#include "soundio.hpp"
 #include "os.hpp"
 #include "util.hpp"
+#include "atomics.hpp"
 
 #include <stdio.h>
 #include <string.h>
@@ -43,6 +44,116 @@ static void test_create_output_device(void) {
     soundio_destroy(soundio);
 }
 
+
+static void test_ring_buffer_basic(void) {
+    struct SoundIo *soundio = soundio_create();
+    assert(soundio);
+    SoundIoRingBuffer *rb = soundio_ring_buffer_create(soundio, 10);
+    assert(rb);
+
+    assert(soundio_ring_buffer_capacity(rb) == 4096);
+
+    char *write_ptr = soundio_ring_buffer_write_ptr(rb);
+    int amt = sprintf(write_ptr, "hello") + 1;
+    soundio_ring_buffer_advance_write_ptr(rb, amt);
+
+    assert(soundio_ring_buffer_fill_count(rb) == amt);
+    assert(soundio_ring_buffer_free_count(rb) == 4096 - amt);
+
+    char *read_ptr = soundio_ring_buffer_read_ptr(rb);
+
+    assert(strcmp(read_ptr, "hello") == 0);
+
+    soundio_ring_buffer_advance_read_ptr(rb, amt);
+
+    assert(soundio_ring_buffer_fill_count(rb) == 0);
+    assert(soundio_ring_buffer_free_count(rb) == soundio_ring_buffer_capacity(rb));
+
+    soundio_ring_buffer_advance_write_ptr(rb, 4094);
+    soundio_ring_buffer_advance_read_ptr(rb, 4094);
+    amt = sprintf(soundio_ring_buffer_write_ptr(rb), "writing past the end") + 1;
+    soundio_ring_buffer_advance_write_ptr(rb, amt);
+
+    assert(soundio_ring_buffer_fill_count(rb) == amt);
+
+    assert(strcmp(soundio_ring_buffer_read_ptr(rb), "writing past the end") == 0);
+
+    soundio_ring_buffer_advance_read_ptr(rb, amt);
+
+    assert(soundio_ring_buffer_fill_count(rb) == 0);
+    assert(soundio_ring_buffer_free_count(rb) == soundio_ring_buffer_capacity(rb));
+    soundio_ring_buffer_destroy(rb);
+    soundio_destroy(soundio);
+}
+
+static SoundIoRingBuffer *rb = nullptr;
+static const int rb_size = 3528;
+static long expected_write_head;
+static long expected_read_head;
+static atomic_bool rb_done;
+static atomic_int rb_write_it;
+static atomic_int rb_read_it;
+
+// just for testing purposes; does not need to be high quality random
+static double random_double(void) {
+    return ((double)rand() / (double)RAND_MAX);
+}
+
+static void reader_thread_run(void *) {
+    while (!rb_done) {
+        rb_read_it += 1;
+        int fill_count = soundio_ring_buffer_fill_count(rb);
+        assert(fill_count >= 0);
+        assert(fill_count <= rb_size);
+        int amount_to_read = min((int)(random_double() * 2.0 * fill_count), fill_count);
+        soundio_ring_buffer_advance_read_ptr(rb, amount_to_read);
+        expected_read_head += amount_to_read;
+    }
+}
+
+static void writer_thread_run(void *) {
+    while (!rb_done) {
+        rb_write_it += 1;
+        int fill_count = soundio_ring_buffer_fill_count(rb);
+        assert(fill_count >= 0);
+        assert(fill_count <= rb_size);
+        int free_count = rb_size - fill_count;
+        assert(free_count >= 0);
+        assert(free_count <= rb_size);
+        int value = min((int)(random_double() * 2.0 * free_count), free_count);
+        soundio_ring_buffer_advance_write_ptr(rb, value);
+        expected_write_head += value;
+    }
+}
+
+static void test_ring_buffer_threaded(void) {
+    struct SoundIo *soundio = soundio_create();
+    assert(soundio);
+    rb = soundio_ring_buffer_create(soundio, rb_size);
+    expected_write_head = 0;
+    expected_read_head = 0;
+    rb_read_it = 0;
+    rb_write_it = 0;
+    rb_done = false;
+
+    SoundIoOsThread *reader_thread;
+    ok_or_panic(soundio_os_thread_create(reader_thread_run, nullptr, false, &reader_thread));
+
+    SoundIoOsThread *writer_thread;
+    ok_or_panic(soundio_os_thread_create(writer_thread_run, nullptr, false, &writer_thread));
+
+    while (rb_read_it < 100000 || rb_write_it < 100000) {}
+    rb_done = true;
+
+    soundio_os_thread_destroy(reader_thread);
+    soundio_os_thread_destroy(writer_thread);
+
+    int fill_count = soundio_ring_buffer_fill_count(rb);
+    int expected_fill_count = expected_write_head - expected_read_head;
+    assert(fill_count == expected_fill_count);
+    soundio_destroy(soundio);
+}
+
 struct Test {
     const char *name;
     void (*fn)(void);
@@ -51,6 +162,8 @@ struct Test {
 static struct Test tests[] = {
     {"os_get_time", test_os_get_time},
     {"create output device", test_create_output_device},
+    {"ring buffer basic", test_ring_buffer_basic},
+    {"ring buffer threaded", test_ring_buffer_threaded},
     {NULL, NULL},
 };