sfml3-rb 0.0.1 → 0.2.2

data/ext/audio/sound_buffer.c

@@ -0,0 +1,274 @@
+#include "audio/sound_buffer.h"
+
+#include <ruby.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "audio/audio_enums.h"
+#include "core/exceptions.h"
+#include "core/macros.h"
+#include "system/input_stream.h"
+#include "system/time.h"
+
+typedef struct {
+    sfSoundBuffer *buffer;
+    bool owns;
+} SoundBuffer;
+
+static VALUE rb_cSoundBuffer;
+
+static void SoundBuffer_free(void *ptr) {
+    SoundBuffer *sound_buffer = ptr;
+
+    if (sound_buffer->owns) {
+        sfSoundBuffer_destroy(sound_buffer->buffer);
+    }
+
+    free(sound_buffer);
+}
+
+static const rb_data_type_t SoundBuffer_data_type = {
+    .wrap_struct_name = "SFML::SoundBuffer",
+    .function = {.dmark = NULL, .dfree = SoundBuffer_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE SoundBuffer_wrap(VALUE klass, sfSoundBuffer *buffer) {
+    SoundBuffer *ptr;
+
+    if (buffer == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create sound buffer");
+    }
+
+    ptr = malloc(sizeof(SoundBuffer));
+    ptr->buffer = buffer;
+    ptr->owns = true;
+
+    return TypedData_Wrap_Struct(klass, &SoundBuffer_data_type, ptr);
+}
+
+VALUE sound_buffer_from_borrowed(const sfSoundBuffer *buffer) {
+    SoundBuffer *ptr;
+
+    if (buffer == NULL) {
+        return Qnil;
+    }
+
+    ptr = malloc(sizeof(SoundBuffer));
+    ptr->buffer = (sfSoundBuffer *) buffer;
+    ptr->owns = false;
+
+    return TypedData_Wrap_Struct(rb_cSoundBuffer, &SoundBuffer_data_type, ptr);
+}
+
+static VALUE SoundBuffer_from_file(VALUE klass, VALUE rb_path) {
+    return SoundBuffer_wrap(klass, sfSoundBuffer_createFromFile(StringValueCStr(rb_path)));
+}
+
+static VALUE SoundBuffer_from_memory(VALUE klass, VALUE rb_data) {
+    StringValue(rb_data);
+
+    return SoundBuffer_wrap(klass, sfSoundBuffer_createFromMemory(RSTRING_PTR(rb_data),
+                                                                  (size_t) RSTRING_LEN(rb_data)));
+}
+
+static VALUE SoundBuffer_from_stream(VALUE klass, VALUE rb_stream) {
+    VALUE holder = Qnil;
+    sfInputStream *stream = input_stream_from_rb(rb_stream, &holder);
+
+    (void) holder;
+
+    return SoundBuffer_wrap(klass, sfSoundBuffer_createFromStream(stream));
+}
+
+/* SFML rejects a buffer whose channel map does not have exactly one entry per
+   channel, so an omitted map is filled with the conventional layout for 1 and
+   2 channels and left Unspecified beyond that. */
+static void SoundBuffer_default_channel_map(unsigned int channel_count, sfSoundChannel *map) {
+    static const sfSoundChannel surround[] = {
+        sfSoundChannelFrontLeft,      sfSoundChannelFrontRight,     sfSoundChannelFrontCenter,
+        sfSoundChannelLowFrequencyEffects, sfSoundChannelBackLeft,  sfSoundChannelBackRight,
+        sfSoundChannelSideLeft,       sfSoundChannelSideRight,      sfSoundChannelTopCenter
+    };
+    unsigned int i;
+
+    for (i = 0; i < channel_count; i++) {
+        if (i < sizeof(surround) / sizeof(surround[0])) {
+            map[i] = surround[i];
+        } else {
+            map[i] = sfSoundChannelUnspecified;
+        }
+    }
+
+    if (channel_count == 1) {
+        map[0] = sfSoundChannelMono;
+    }
+}
+
+/* Copies the samples into a contiguous int16 buffer: an Array is converted
+   element by element, a String is memcpy'd out of (possibly unaligned) Ruby
+   storage. The channel map, when given, is translated symbol by symbol. */
+static VALUE SoundBuffer_from_samples(int argc, VALUE *argv, VALUE klass) {
+    VALUE rb_samples, rb_channel_count, rb_sample_rate, rb_channel_map;
+    int16_t *samples;
+    sfSoundChannel *channel_map;
+    unsigned int channel_count;
+    uint64_t sample_count;
+    sfSoundBuffer *buffer;
+
+    rb_scan_args(argc, argv, "31", &rb_samples, &rb_channel_count, &rb_sample_rate,
+                 &rb_channel_map);
+
+    channel_count = (unsigned int) NUM2INT(rb_channel_count);
+
+    if (channel_count == 0) {
+        rb_raise(rb_eArgError, "channel count must be positive");
+    }
+
+    if (RB_TYPE_P(rb_samples, T_STRING)) {
+        size_t bytes = (size_t) RSTRING_LEN(rb_samples);
+
+        if (bytes % sizeof(int16_t) != 0) {
+            rb_raise(rb_eArgError, "sample string length must be a multiple of 2 bytes");
+        }
+
+        sample_count = bytes / sizeof(int16_t);
+        samples = malloc(bytes > 0 ? bytes : 1);
+
+        if (bytes > 0) {
+            memcpy(samples, RSTRING_PTR(rb_samples), bytes);
+        }
+    } else if (RB_TYPE_P(rb_samples, T_ARRAY)) {
+        long i;
+
+        sample_count = (uint64_t) RARRAY_LEN(rb_samples);
+        samples = malloc(sizeof(int16_t) * ((size_t) sample_count + 1));
+
+        for (i = 0; i < (long) sample_count; i++) {
+            samples[i] = (int16_t) NUM2INT(rb_ary_entry(rb_samples, i));
+        }
+    } else {
+        rb_raise(rb_eArgError, "samples must be an Array of integers or a String");
+        return Qnil;
+    }
+
+    channel_map = malloc(sizeof(sfSoundChannel) * channel_count);
+
+    if (NIL_P(rb_channel_map)) {
+        SoundBuffer_default_channel_map(channel_count, channel_map);
+    } else {
+        long i;
+
+        if (!RB_TYPE_P(rb_channel_map, T_ARRAY) ||
+            (unsigned long) RARRAY_LEN(rb_channel_map) != channel_count) {
+            free(samples);
+            free(channel_map);
+            rb_raise(rb_eArgError, "channel map must have exactly one entry per channel");
+        }
+
+        for (i = 0; i < (long) channel_count; i++) {
+            channel_map[i] = sound_channel_from_rb(rb_ary_entry(rb_channel_map, i));
+        }
+    }
+
+    buffer = sfSoundBuffer_createFromSamples(samples, sample_count, channel_count,
+                                              (unsigned int) NUM2INT(rb_sample_rate), channel_map,
+                                              channel_count);
+
+    free(samples);
+    free(channel_map);
+
+    return SoundBuffer_wrap(klass, buffer);
+}
+
+static VALUE SoundBuffer_copy(VALUE self) {
+    return SoundBuffer_wrap(Get_Klass_SoundBuffer(),
+                            sfSoundBuffer_copy(Get_SoundBuffer_Struct(self)));
+}
+
+static VALUE SoundBuffer_save_to_file(VALUE self, VALUE rb_path) {
+    return BOOL2RB(sfSoundBuffer_saveToFile(Get_SoundBuffer_Struct(self), StringValueCStr(rb_path)));
+}
+
+static VALUE SoundBuffer_samples(VALUE self) {
+    const int16_t *samples = sfSoundBuffer_getSamples(Get_SoundBuffer_Struct(self));
+    uint64_t count = sfSoundBuffer_getSampleCount(Get_SoundBuffer_Struct(self));
+    VALUE rb_array;
+    uint64_t i;
+
+    if (samples == NULL) {
+        return rb_ary_new();
+    }
+
+    rb_array = rb_ary_new_capa((long) count);
+
+    for (i = 0; i < count; i++) {
+        rb_ary_push(rb_array, INT2NUM(samples[i]));
+    }
+
+    return rb_array;
+}
+
+static VALUE SoundBuffer_sample_count(VALUE self) {
+    return ULL2NUM(sfSoundBuffer_getSampleCount(Get_SoundBuffer_Struct(self)));
+}
+
+static VALUE SoundBuffer_sample_rate(VALUE self) {
+    return UINT2NUM(sfSoundBuffer_getSampleRate(Get_SoundBuffer_Struct(self)));
+}
+
+static VALUE SoundBuffer_channel_count(VALUE self) {
+    return UINT2NUM(sfSoundBuffer_getChannelCount(Get_SoundBuffer_Struct(self)));
+}
+
+static VALUE SoundBuffer_channel_map(VALUE self) {
+    size_t count = 0;
+    sfSoundChannel *map = sfSoundBuffer_getChannelMap(Get_SoundBuffer_Struct(self), &count);
+    VALUE rb_array;
+    size_t i;
+
+    if (map == NULL) {
+        return rb_ary_new();
+    }
+
+    rb_array = rb_ary_new_capa((long) count);
+
+    for (i = 0; i < count; i++) {
+        rb_ary_push(rb_array, ID2SYM(rb_intern(sound_channel_name(map[i]))));
+    }
+
+    return rb_array;
+}
+
+static VALUE SoundBuffer_duration(VALUE self) {
+    return time_to_rb(sfSoundBuffer_getDuration(Get_SoundBuffer_Struct(self)));
+}
+
+void Init_SoundBuffer(VALUE rb_module) {
+    rb_cSoundBuffer = rb_define_class_under(rb_module, "SoundBuffer", rb_cObject);
+
+    rb_define_singleton_method(rb_cSoundBuffer, "from_file", SoundBuffer_from_file, 1);
+    rb_define_singleton_method(rb_cSoundBuffer, "from_memory", SoundBuffer_from_memory, 1);
+    rb_define_singleton_method(rb_cSoundBuffer, "from_stream", SoundBuffer_from_stream, 1);
+    rb_define_singleton_method(rb_cSoundBuffer, "from_samples", SoundBuffer_from_samples, -1);
+
+    rb_define_method(rb_cSoundBuffer, "copy", SoundBuffer_copy, 0);
+    rb_define_method(rb_cSoundBuffer, "save_to_file", SoundBuffer_save_to_file, 1);
+    rb_define_method(rb_cSoundBuffer, "samples", SoundBuffer_samples, 0);
+    rb_define_method(rb_cSoundBuffer, "sample_count", SoundBuffer_sample_count, 0);
+    rb_define_method(rb_cSoundBuffer, "sample_rate", SoundBuffer_sample_rate, 0);
+    rb_define_method(rb_cSoundBuffer, "channel_count", SoundBuffer_channel_count, 0);
+    rb_define_method(rb_cSoundBuffer, "channel_map", SoundBuffer_channel_map, 0);
+    rb_define_method(rb_cSoundBuffer, "duration", SoundBuffer_duration, 0);
+}
+
+VALUE Get_Klass_SoundBuffer(void) {
+    return rb_cSoundBuffer;
+}
+
+void *Get_SoundBuffer_Struct(VALUE self) {
+    SoundBuffer *ptr;
+    TypedData_Get_Struct(self, SoundBuffer, &SoundBuffer_data_type, ptr);
+    return ptr->buffer;
+}

data/ext/audio/sound_buffer.h

@@ -0,0 +1,18 @@
+#ifndef SFML_RB_AUDIO_SOUND_BUFFER_H
+#define SFML_RB_AUDIO_SOUND_BUFFER_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_SoundBuffer(VALUE rb_module);
+
+VALUE Get_Klass_SoundBuffer(void);
+
+void *Get_SoundBuffer_Struct(VALUE self);
+
+/* Wraps a buffer owned by someone else (a SoundBufferRecorder) without taking
+   ownership, so freeing the wrapper must not destroy it. */
+VALUE sound_buffer_from_borrowed(const sfSoundBuffer *buffer);
+
+#endif //SFML_RB_AUDIO_SOUND_BUFFER_H

data/ext/audio/sound_buffer_recorder.c

@@ -0,0 +1,109 @@
+#include "audio/sound_buffer_recorder.h"
+
+#include <ruby.h>
+#include <stdlib.h>
+
+#include "audio/audio_enums.h"
+#include "audio/sound_buffer.h"
+#include "core/macros.h"
+
+typedef struct {
+    sfSoundBufferRecorder *handle;
+} SoundBufferRecorder;
+
+static VALUE rb_cSoundBufferRecorder;
+
+static void SoundBufferRecorder_free(void *ptr) {
+    SoundBufferRecorder *recorder = ptr;
+
+    if (recorder->handle != NULL) {
+        sfSoundBufferRecorder_destroy(recorder->handle);
+    }
+
+    free(recorder);
+}
+
+static const rb_data_type_t SoundBufferRecorder_data_type = {
+    .wrap_struct_name = "SFML::SoundBufferRecorder",
+    .function = {.dmark = NULL, .dfree = SoundBufferRecorder_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE SoundBufferRecorder_wrap(VALUE klass, sfSoundBufferRecorder *handle) {
+    SoundBufferRecorder *ptr;
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create sound buffer recorder (no capture device?)");
+    }
+
+    ptr = malloc(sizeof(SoundBufferRecorder));
+    ptr->handle = handle;
+
+    return TypedData_Wrap_Struct(klass, &SoundBufferRecorder_data_type, ptr);
+}
+
+static VALUE SoundBufferRecorder_new(VALUE klass) {
+    return SoundBufferRecorder_wrap(klass, sfSoundBufferRecorder_create());
+}
+
+static VALUE SoundBufferRecorder_start(VALUE self, VALUE rb_sample_rate) {
+    return BOOL2RB(sfSoundBufferRecorder_start(Get_SoundBufferRecorder_Struct(self),
+                                               (unsigned int) NUM2INT(rb_sample_rate)));
+}
+
+static VALUE SoundBufferRecorder_stop(VALUE self) {
+    sfSoundBufferRecorder_stop(Get_SoundBufferRecorder_Struct(self));
+    return self;
+}
+
+static VALUE SoundBufferRecorder_sample_rate(VALUE self) {
+    return UINT2NUM(sfSoundBufferRecorder_getSampleRate(Get_SoundBufferRecorder_Struct(self)));
+}
+
+static VALUE SoundBufferRecorder_buffer(VALUE self) {
+    return sound_buffer_from_borrowed(sfSoundBufferRecorder_getBuffer(Get_SoundBufferRecorder_Struct(self)));
+}
+
+static VALUE SoundBufferRecorder_device(VALUE self) {
+    return rb_str_new_cstr(sfSoundBufferRecorder_getDevice(Get_SoundBufferRecorder_Struct(self)));
+}
+
+static VALUE SoundBufferRecorder_set_device(VALUE self, VALUE rb_name) {
+    return BOOL2RB(sfSoundBufferRecorder_setDevice(Get_SoundBufferRecorder_Struct(self),
+                                                   StringValueCStr(rb_name)));
+}
+
+static VALUE SoundBufferRecorder_channel_count(VALUE self) {
+    return UINT2NUM(sfSoundBufferRecorder_getChannelCount(Get_SoundBufferRecorder_Struct(self)));
+}
+
+static VALUE SoundBufferRecorder_set_channel_count(VALUE self, VALUE rb_count) {
+    sfSoundBufferRecorder_setChannelCount(Get_SoundBufferRecorder_Struct(self),
+                                          (unsigned int) NUM2INT(rb_count));
+    return rb_count;
+}
+
+void Init_SoundBufferRecorder(VALUE rb_module) {
+    rb_cSoundBufferRecorder = rb_define_class_under(rb_module, "SoundBufferRecorder", rb_cObject);
+
+    rb_define_singleton_method(rb_cSoundBufferRecorder, "new", SoundBufferRecorder_new, 0);
+
+    rb_define_method(rb_cSoundBufferRecorder, "start", SoundBufferRecorder_start, 1);
+    rb_define_method(rb_cSoundBufferRecorder, "stop", SoundBufferRecorder_stop, 0);
+    rb_define_method(rb_cSoundBufferRecorder, "sample_rate", SoundBufferRecorder_sample_rate, 0);
+    rb_define_method(rb_cSoundBufferRecorder, "buffer", SoundBufferRecorder_buffer, 0);
+    rb_define_method(rb_cSoundBufferRecorder, "device", SoundBufferRecorder_device, 0);
+    rb_define_method(rb_cSoundBufferRecorder, "device=", SoundBufferRecorder_set_device, 1);
+    rb_define_method(rb_cSoundBufferRecorder, "channel_count", SoundBufferRecorder_channel_count, 0);
+    rb_define_method(rb_cSoundBufferRecorder, "channel_count=", SoundBufferRecorder_set_channel_count, 1);
+}
+
+VALUE Get_Klass_SoundBufferRecorder(void) {
+    return rb_cSoundBufferRecorder;
+}
+
+void *Get_SoundBufferRecorder_Struct(VALUE self) {
+    SoundBufferRecorder *ptr;
+    TypedData_Get_Struct(self, SoundBufferRecorder, &SoundBufferRecorder_data_type, ptr);
+    return ptr->handle;
+}

data/ext/audio/sound_buffer_recorder.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_AUDIO_SOUND_BUFFER_RECORDER_H
+#define SFML_RB_AUDIO_SOUND_BUFFER_RECORDER_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_SoundBufferRecorder(VALUE rb_module);
+
+VALUE Get_Klass_SoundBufferRecorder(void);
+
+void *Get_SoundBufferRecorder_Struct(VALUE self);
+
+#endif //SFML_RB_AUDIO_SOUND_BUFFER_RECORDER_H

data/ext/audio/sound_recorder.c

@@ -0,0 +1,268 @@
+#include "audio/sound_recorder.h"
+
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "audio/audio_enums.h"
+#include "core/macros.h"
+
+/* A subclassable recorder. The capture callbacks arrive on SFML's audio
+   thread, so each re-enters Ruby through rb_thread_call_with_gvl and treats an
+   exception as "stop capturing" instead of unwinding into the audio engine.
+   A subclass only has to implement #on_process; #on_start and #on_stop are
+   optional and default to continuing. */
+typedef struct {
+    VALUE rb_self;
+    sfSoundRecorder *handle;
+} SoundRecorder;
+
+static VALUE rb_cSoundRecorder;
+
+static void SoundRecorder_mark(void *ptr) {
+    SoundRecorder *recorder = ptr;
+
+    rb_gc_mark(recorder->rb_self);
+}
+
+static void SoundRecorder_free(void *ptr) {
+    SoundRecorder *recorder = ptr;
+
+    if (recorder->handle != NULL) {
+        sfSoundRecorder_destroy(recorder->handle);
+    }
+
+    free(recorder);
+}
+
+static const rb_data_type_t SoundRecorder_data_type = {
+    .wrap_struct_name = "SFML::SoundRecorder",
+    .function = {.dmark = SoundRecorder_mark, .dfree = SoundRecorder_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+typedef struct {
+    VALUE self;
+    ID method;
+} InvokeContext;
+
+static VALUE SoundRecorder_invoke_body(VALUE raw) {
+    InvokeContext *ctx = (InvokeContext *) raw;
+
+    return rb_funcall(ctx->self, ctx->method, 0);
+}
+
+/* Calls a zero-argument Ruby method, swallowing any exception it raises. */
+static void SoundRecorder_invoke(VALUE self, ID method) {
+    InvokeContext ctx = {.self = self, .method = method};
+    int state = 0;
+
+    rb_protect(SoundRecorder_invoke_body, (VALUE) &ctx, &state);
+
+    if (state) {
+        rb_set_errinfo(Qnil);
+    }
+}
+
+static bool SoundRecorder_on_start(void *userData) {
+    SoundRecorder *recorder = userData;
+
+    if (rb_respond_to(recorder->rb_self, rb_intern("on_start"))) {
+        SoundRecorder_invoke(recorder->rb_self, rb_intern("on_start"));
+    }
+
+    return true;
+}
+
+typedef struct {
+    SoundRecorder *recorder;
+    const int16_t *samples;
+    size_t sample_count;
+    int ok;
+} ProcessContext;
+
+static VALUE SoundRecorder_process_body(VALUE raw) {
+    ProcessContext *ctx = (ProcessContext *) raw;
+    VALUE rb_samples = rb_ary_new_capa((long) ctx->sample_count);
+    VALUE result;
+    size_t i;
+
+    for (i = 0; i < ctx->sample_count; i++) {
+        rb_ary_push(rb_samples, INT2NUM(ctx->samples[i]));
+    }
+
+    result = rb_funcall(ctx->recorder->rb_self, rb_intern("on_process"), 1, rb_samples);
+    ctx->ok = RTEST(result) ? 1 : 0;
+
+    return Qnil;
+}
+
+static void *SoundRecorder_process_gvl(void *raw) {
+    int state = 0;
+
+    rb_protect(SoundRecorder_process_body, (VALUE) raw, &state);
+
+    if (state) {
+        rb_set_errinfo(Qnil);
+        ((ProcessContext *) raw)->ok = 0;
+    }
+
+    return NULL;
+}
+
+static bool SoundRecorder_on_process(const int16_t *samples, size_t sample_count, void *userData) {
+    SoundRecorder *recorder = userData;
+    ProcessContext ctx = {
+        .recorder = recorder, .samples = samples, .sample_count = sample_count, .ok = 0
+    };
+
+    rb_thread_call_with_gvl(SoundRecorder_process_gvl, &ctx);
+
+    return ctx.ok ? true : false;
+}
+
+static void SoundRecorder_on_stop(void *userData) {
+    SoundRecorder *recorder = userData;
+
+    if (rb_respond_to(recorder->rb_self, rb_intern("on_stop"))) {
+        SoundRecorder_invoke(recorder->rb_self, rb_intern("on_stop"));
+    }
+}
+
+static VALUE SoundRecorder_new(VALUE klass) {
+    SoundRecorder *ptr;
+    sfSoundRecorder *handle;
+    VALUE self;
+
+    ptr = malloc(sizeof(SoundRecorder));
+    ptr->rb_self = Qnil;
+    ptr->handle = NULL;
+
+    self = TypedData_Wrap_Struct(klass, &SoundRecorder_data_type, ptr);
+    ptr->rb_self = self;
+
+    if (!rb_respond_to(self, rb_intern("on_process"))) {
+        /* Ruby already owns the wrapper; SoundRecorder_free handles the NULL
+           handle, so let GC clean up after the raise. */
+        rb_raise(rb_eNotImpError, "subclass must define #on_process");
+    }
+
+    handle = sfSoundRecorder_create(SoundRecorder_on_start, SoundRecorder_on_process,
+                                    SoundRecorder_on_stop, ptr);
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create sound recorder (no capture device?)");
+    }
+
+    ptr->handle = handle;
+
+    return self;
+}
+
+static VALUE SoundRecorder_start(VALUE self, VALUE rb_sample_rate) {
+    return BOOL2RB(sfSoundRecorder_start(Get_SoundRecorder_Struct(self),
+                                         (unsigned int) NUM2INT(rb_sample_rate)));
+}
+
+static VALUE SoundRecorder_stop(VALUE self) {
+    sfSoundRecorder_stop(Get_SoundRecorder_Struct(self));
+    return self;
+}
+
+static VALUE SoundRecorder_sample_rate(VALUE self) {
+    return UINT2NUM(sfSoundRecorder_getSampleRate(Get_SoundRecorder_Struct(self)));
+}
+
+static VALUE SoundRecorder_available(VALUE klass) {
+    return BOOL2RB(sfSoundRecorder_isAvailable());
+}
+
+static VALUE SoundRecorder_available_devices(VALUE klass) {
+    size_t count = 0;
+    const char *const *devices = sfSoundRecorder_getAvailableDevices(&count);
+    VALUE rb_array;
+    size_t i;
+
+    if (devices == NULL) {
+        return rb_ary_new();
+    }
+
+    rb_array = rb_ary_new_capa((long) count);
+
+    for (i = 0; i < count; i++) {
+        rb_ary_push(rb_array, rb_str_new_cstr(devices[i]));
+    }
+
+    return rb_array;
+}
+
+static VALUE SoundRecorder_default_device(VALUE klass) {
+    return rb_str_new_cstr(sfSoundRecorder_getDefaultDevice());
+}
+
+static VALUE SoundRecorder_device(VALUE self) {
+    return rb_str_new_cstr(sfSoundRecorder_getDevice(Get_SoundRecorder_Struct(self)));
+}
+
+static VALUE SoundRecorder_set_device(VALUE self, VALUE rb_name) {
+    return BOOL2RB(
+        sfSoundRecorder_setDevice(Get_SoundRecorder_Struct(self), StringValueCStr(rb_name)));
+}
+
+static VALUE SoundRecorder_channel_count(VALUE self) {
+    return UINT2NUM(sfSoundRecorder_getChannelCount(Get_SoundRecorder_Struct(self)));
+}
+
+static VALUE SoundRecorder_set_channel_count(VALUE self, VALUE rb_count) {
+    sfSoundRecorder_setChannelCount(Get_SoundRecorder_Struct(self), (unsigned int) NUM2INT(rb_count));
+    return rb_count;
+}
+
+static VALUE SoundRecorder_channel_map(VALUE self) {
+    size_t count = 0;
+    sfSoundChannel *map = sfSoundRecorder_getChannelMap(Get_SoundRecorder_Struct(self), &count);
+    VALUE rb_array;
+    size_t i;
+
+    if (map == NULL) {
+        return rb_ary_new();
+    }
+
+    rb_array = rb_ary_new_capa((long) count);
+
+    for (i = 0; i < count; i++) {
+        rb_ary_push(rb_array, ID2SYM(rb_intern(sound_channel_name(map[i]))));
+    }
+
+    return rb_array;
+}
+
+void Init_SoundRecorder(VALUE rb_module) {
+    rb_cSoundRecorder = rb_define_class_under(rb_module, "SoundRecorder", rb_cObject);
+
+    rb_define_singleton_method(rb_cSoundRecorder, "new", SoundRecorder_new, 0);
+    rb_define_singleton_method(rb_cSoundRecorder, "available?", SoundRecorder_available, 0);
+    rb_define_singleton_method(rb_cSoundRecorder, "available_devices",
+                               SoundRecorder_available_devices, 0);
+    rb_define_singleton_method(rb_cSoundRecorder, "default_device", SoundRecorder_default_device, 0);
+
+    rb_define_method(rb_cSoundRecorder, "start", SoundRecorder_start, 1);
+    rb_define_method(rb_cSoundRecorder, "stop", SoundRecorder_stop, 0);
+    rb_define_method(rb_cSoundRecorder, "sample_rate", SoundRecorder_sample_rate, 0);
+    rb_define_method(rb_cSoundRecorder, "device", SoundRecorder_device, 0);
+    rb_define_method(rb_cSoundRecorder, "device=", SoundRecorder_set_device, 1);
+    rb_define_method(rb_cSoundRecorder, "channel_count", SoundRecorder_channel_count, 0);
+    rb_define_method(rb_cSoundRecorder, "channel_count=", SoundRecorder_set_channel_count, 1);
+    rb_define_method(rb_cSoundRecorder, "channel_map", SoundRecorder_channel_map, 0);
+}
+
+VALUE Get_Klass_SoundRecorder(void) {
+    return rb_cSoundRecorder;
+}
+
+void *Get_SoundRecorder_Struct(VALUE self) {
+    SoundRecorder *ptr;
+    TypedData_Get_Struct(self, SoundRecorder, &SoundRecorder_data_type, ptr);
+    return ptr->handle;
+}

data/ext/audio/sound_recorder.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_AUDIO_SOUND_RECORDER_H
+#define SFML_RB_AUDIO_SOUND_RECORDER_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_SoundRecorder(VALUE rb_module);
+
+VALUE Get_Klass_SoundRecorder(void);
+
+void *Get_SoundRecorder_Struct(VALUE self);
+
+#endif //SFML_RB_AUDIO_SOUND_RECORDER_H