sfml3-rb 0.2.2 → 0.3.0

data/ext/audio/sound_buffer.c

@@ -12,14 +12,14 @@
 #include "system/time.h"
 
 typedef struct {
-    sfSoundBuffer *buffer;
+    sfSoundBuffer* buffer;
     bool owns;
 } SoundBuffer;
 
 static VALUE rb_cSoundBuffer;
 
-static void SoundBuffer_free(void *ptr) {
-    SoundBuffer *sound_buffer = ptr;
+static void SoundBuffer_free(void* ptr) {
+    SoundBuffer* sound_buffer = ptr;
 
     if (sound_buffer->owns) {
         sfSoundBuffer_destroy(sound_buffer->buffer);
@@ -31,11 +31,10 @@ static void SoundBuffer_free(void *ptr) {
 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
-};
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
-static VALUE SoundBuffer_wrap(VALUE klass, sfSoundBuffer *buffer) {
-    SoundBuffer *ptr;
+static VALUE SoundBuffer_wrap(VALUE klass, sfSoundBuffer* buffer) {
+    SoundBuffer* ptr;
 
     if (buffer == NULL) {
         rb_raise(rb_eRuntimeError, "failed to create sound buffer");
@@ -48,36 +47,60 @@ static VALUE SoundBuffer_wrap(VALUE klass, sfSoundBuffer *buffer) {
     return TypedData_Wrap_Struct(klass, &SoundBuffer_data_type, ptr);
 }
 
-VALUE sound_buffer_from_borrowed(const sfSoundBuffer *buffer) {
-    SoundBuffer *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->buffer = (sfSoundBuffer*)buffer;
     ptr->owns = false;
 
     return TypedData_Wrap_Struct(rb_cSoundBuffer, &SoundBuffer_data_type, ptr);
 }
 
+/* call-seq:
+ *   SoundBuffer.from_file(path) -> SoundBuffer
+ *
+ * Loads and decodes an audio file into a buffer.
+ *
+ * @return [SoundBuffer]
+ * @raise [RuntimeError] if the file cannot be opened or decoded
+ */
 static VALUE SoundBuffer_from_file(VALUE klass, VALUE rb_path) {
     return SoundBuffer_wrap(klass, sfSoundBuffer_createFromFile(StringValueCStr(rb_path)));
 }
 
+/* call-seq:
+ *   SoundBuffer.from_memory(data) -> SoundBuffer
+ *
+ * Decodes audio held in a String into a buffer.
+ *
+ * @return [SoundBuffer]
+ * @raise [RuntimeError] if +data+ cannot be decoded
+ */
 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)));
+    return SoundBuffer_wrap(
+        klass, sfSoundBuffer_createFromMemory(RSTRING_PTR(rb_data), (size_t)RSTRING_LEN(rb_data)));
 }
 
+/* call-seq:
+ *   SoundBuffer.from_stream(stream) -> SoundBuffer
+ *
+ * Decodes audio read from an SFML InputStream into a buffer.
+ *
+ * @return [SoundBuffer]
+ * @raise [RuntimeError] if the stream cannot be decoded
+ */
 static VALUE SoundBuffer_from_stream(VALUE klass, VALUE rb_stream) {
     VALUE holder = Qnil;
-    sfInputStream *stream = input_stream_from_rb(rb_stream, &holder);
+    sfInputStream* stream = input_stream_from_rb(rb_stream, &holder);
 
-    (void) holder;
+    (void)holder;
 
     return SoundBuffer_wrap(klass, sfSoundBuffer_createFromStream(stream));
 }
@@ -85,12 +108,13 @@ static VALUE SoundBuffer_from_stream(VALUE klass, VALUE rb_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 void SoundBuffer_default_channel_map(unsigned int channel_count, sfSoundChannel* map) {
     static const sfSoundChannel surround[] = {
-        sfSoundChannelFrontLeft,      sfSoundChannelFrontRight,     sfSoundChannelFrontCenter,
-        sfSoundChannelLowFrequencyEffects, sfSoundChannelBackLeft,  sfSoundChannelBackRight,
-        sfSoundChannelSideLeft,       sfSoundChannelSideRight,      sfSoundChannelTopCenter
-    };
+        sfSoundChannelFrontLeft,   sfSoundChannelFrontRight,
+        sfSoundChannelFrontCenter, sfSoundChannelLowFrequencyEffects,
+        sfSoundChannelBackLeft,    sfSoundChannelBackRight,
+        sfSoundChannelSideLeft,    sfSoundChannelSideRight,
+        sfSoundChannelTopCenter};
     unsigned int i;
 
     for (i = 0; i < channel_count; i++) {
@@ -106,28 +130,76 @@ static void SoundBuffer_default_channel_map(unsigned int channel_count, sfSoundC
     }
 }
 
+typedef struct {
+    sfSoundChannel* channel_map;
+    VALUE rb_channel_map;
+    unsigned int channel_count;
+} ChannelMapFillContext;
+
+/* sound_channel_from_rb raises ArgumentError on an unrecognized entry; run
+   through rb_protect so the caller can free the samples/channel_map buffers
+   (already allocated by this point) before that exception propagates,
+   instead of leaking them. */
+static VALUE SoundBuffer_fill_channel_map(VALUE raw) {
+    ChannelMapFillContext* ctx = (ChannelMapFillContext*)raw;
+    long i;
+
+    for (i = 0; i < (long)ctx->channel_count; i++) {
+        ctx->channel_map[i] = sound_channel_from_rb(rb_ary_entry(ctx->rb_channel_map, i));
+    }
+
+    return Qnil;
+}
+
 /* 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) {
+   element by element, and a String's packed int16 samples are copied out of
+   the (possibly unaligned) Ruby storage. The channel map, when given, is
+   translated symbol by symbol. */
+/* call-seq:
+ *   SoundBuffer.from_samples(samples, channel_count, sample_rate)              -> SoundBuffer
+ *   SoundBuffer.from_samples(samples, channel_count, sample_rate, channel_map) -> SoundBuffer
+ *
+ * +samples+ is an Array of Integer samples or a packed String of int16
+ * samples, interleaved by channel. +channel_map+, if given, is an Array of
+ * channel Symbols (see SoundChannel), one per channel; if omitted, a
+ * conventional layout is assumed for 1 and 2 channels.
+ *
+ * @return [SoundBuffer]
+ * @raise [ArgumentError] if +channel_count+ is 0, +samples+ is neither an
+ *   Array nor a String, or +channel_map+ doesn't have exactly one entry per
+ *   channel
+ */
+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;
+    int16_t* samples;
+    sfSoundChannel* channel_map;
     unsigned int channel_count;
     uint64_t sample_count;
-    sfSoundBuffer *buffer;
+    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);
+    channel_count = (unsigned int)NUM2INT(rb_channel_count);
 
     if (channel_count == 0) {
         rb_raise(rb_eArgError, "channel count must be positive");
     }
 
+    /* channel_map's malloc below (sizeof(sfSoundChannel) * channel_count) can
+       wrap on the 32-bit targets this gem ships if channel_count is large
+       enough, allocating far less than the subsequent write loop assumes.
+       Check before any allocation happens, so there's nothing to clean up on
+       the raise path. (Written with channel_count as the divisor, not
+       compared directly against a constant bound, so this isn't optimized
+       away as tautological on 64-bit hosts where it can't actually trigger
+       -- it still does real work on the 32-bit targets.) */
+    if (SIZE_MAX / channel_count < sizeof(sfSoundChannel)) {
+        rb_raise(rb_eArgError, "channel count too large");
+    }
+
     if (RB_TYPE_P(rb_samples, T_STRING)) {
-        size_t bytes = (size_t) RSTRING_LEN(rb_samples);
+        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");
@@ -137,16 +209,21 @@ static VALUE SoundBuffer_from_samples(int argc, VALUE *argv, VALUE klass) {
         samples = malloc(bytes > 0 ? bytes : 1);
 
         if (bytes > 0) {
-            memcpy(samples, RSTRING_PTR(rb_samples), bytes);
+            const int16_t* src = (const int16_t*)RSTRING_PTR(rb_samples);
+            size_t i;
+
+            for (i = 0; i < sample_count; i++) {
+                samples[i] = src[i];
+            }
         }
     } 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));
+        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));
+        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");
@@ -158,23 +235,30 @@ static VALUE SoundBuffer_from_samples(int argc, VALUE *argv, VALUE klass) {
     if (NIL_P(rb_channel_map)) {
         SoundBuffer_default_channel_map(channel_count, channel_map);
     } else {
-        long i;
+        ChannelMapFillContext ctx = {.channel_map = channel_map,
+                                     .rb_channel_map = rb_channel_map,
+                                     .channel_count = channel_count};
+        int state = 0;
 
         if (!RB_TYPE_P(rb_channel_map, T_ARRAY) ||
-            (unsigned long) RARRAY_LEN(rb_channel_map) != channel_count) {
+            (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));
+        rb_protect(SoundBuffer_fill_channel_map, (VALUE)&ctx, &state);
+
+        if (state) {
+            free(samples);
+            free(channel_map);
+            rb_jump_tag(state);
         }
     }
 
     buffer = sfSoundBuffer_createFromSamples(samples, sample_count, channel_count,
-                                              (unsigned int) NUM2INT(rb_sample_rate), channel_map,
-                                              channel_count);
+                                             (unsigned int)NUM2INT(rb_sample_rate), channel_map,
+                                             channel_count);
 
     free(samples);
     free(channel_map);
@@ -182,17 +266,38 @@ static VALUE SoundBuffer_from_samples(int argc, VALUE *argv, VALUE klass) {
     return SoundBuffer_wrap(klass, buffer);
 }
 
+/* call-seq: copy -> SoundBuffer
+ *
+ * Creates an independent copy of the buffer.
+ *
+ * @return [SoundBuffer] an independent copy
+ */
 static VALUE SoundBuffer_copy(VALUE self) {
     return SoundBuffer_wrap(Get_Klass_SoundBuffer(),
                             sfSoundBuffer_copy(Get_SoundBuffer_Struct(self)));
 }
 
+/* call-seq:
+ *   save_to_file(path) -> true or false
+ *
+ * Writes the buffer to an audio file.
+ *
+ * @return [Boolean] whether the file was written successfully
+ */
 static VALUE SoundBuffer_save_to_file(VALUE self, VALUE rb_path) {
-    return BOOL2RB(sfSoundBuffer_saveToFile(Get_SoundBuffer_Struct(self), StringValueCStr(rb_path)));
+    return BOOL2RB(
+        sfSoundBuffer_saveToFile(Get_SoundBuffer_Struct(self), StringValueCStr(rb_path)));
 }
 
+/* call-seq: samples -> Array<Integer>
+ *
+ * Returns the buffer's raw audio samples as Integers.
+ *
+ * @return [Array<Integer>] the raw int16 audio samples, interleaved by
+ *   channel
+ */
 static VALUE SoundBuffer_samples(VALUE self) {
-    const int16_t *samples = sfSoundBuffer_getSamples(Get_SoundBuffer_Struct(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;
@@ -201,7 +306,7 @@ static VALUE SoundBuffer_samples(VALUE self) {
         return rb_ary_new();
     }
 
-    rb_array = rb_ary_new_capa((long) count);
+    rb_array = rb_ary_new_capa((long)count);
 
     for (i = 0; i < count; i++) {
         rb_ary_push(rb_array, INT2NUM(samples[i]));
@@ -210,21 +315,46 @@ static VALUE SoundBuffer_samples(VALUE self) {
     return rb_array;
 }
 
+/* call-seq: sample_count -> Integer
+ *
+ * Returns the total number of samples stored in the buffer.
+ *
+ * @return [Integer] total number of int16 samples, across all channels
+ */
 static VALUE SoundBuffer_sample_count(VALUE self) {
     return ULL2NUM(sfSoundBuffer_getSampleCount(Get_SoundBuffer_Struct(self)));
 }
 
+/* call-seq: sample_rate -> Integer
+ *
+ * Returns the buffer's sample rate in samples per second.
+ *
+ * @return [Integer]
+ */
 static VALUE SoundBuffer_sample_rate(VALUE self) {
     return UINT2NUM(sfSoundBuffer_getSampleRate(Get_SoundBuffer_Struct(self)));
 }
 
+/* call-seq: channel_count -> Integer
+ *
+ * Returns the number of audio channels in the buffer.
+ *
+ * @return [Integer]
+ */
 static VALUE SoundBuffer_channel_count(VALUE self) {
     return UINT2NUM(sfSoundBuffer_getChannelCount(Get_SoundBuffer_Struct(self)));
 }
 
+/* call-seq: channel_map -> Array<Symbol>
+ *
+ * Returns the channel layout of the buffer.
+ *
+ * @return [Array<Symbol>] one entry per channel, e.g.
+ *   +[:front_left, :front_right]+
+ */
 static VALUE SoundBuffer_channel_map(VALUE self) {
     size_t count = 0;
-    sfSoundChannel *map = sfSoundBuffer_getChannelMap(Get_SoundBuffer_Struct(self), &count);
+    sfSoundChannel* map = sfSoundBuffer_getChannelMap(Get_SoundBuffer_Struct(self), &count);
     VALUE rb_array;
     size_t i;
 
@@ -232,7 +362,7 @@ static VALUE SoundBuffer_channel_map(VALUE self) {
         return rb_ary_new();
     }
 
-    rb_array = rb_ary_new_capa((long) count);
+    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]))));
@@ -241,12 +371,24 @@ static VALUE SoundBuffer_channel_map(VALUE self) {
     return rb_array;
 }
 
+/* call-seq: duration -> Time
+ *
+ * Returns the buffer's total playing duration.
+ *
+ * @return [Time]
+ */
 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);
+/* Document-class: SFML::SoundBuffer
+ * Audio samples held fully decoded in memory, ready to be played through one
+ * or more Sound instances (a single buffer may back several simultaneous
+ * Sounds). For long audio, prefer Music, which streams instead of loading
+ * everything up front.
+ */
+void Init_SoundBuffer(VALUE rb_mSFML) {
+    rb_cSoundBuffer = rb_define_class_under(rb_mSFML, "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);
@@ -267,8 +409,8 @@ VALUE Get_Klass_SoundBuffer(void) {
     return rb_cSoundBuffer;
 }
 
-void *Get_SoundBuffer_Struct(VALUE self) {
-    SoundBuffer *ptr;
+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_recorder.c

@@ -8,13 +8,13 @@
 #include "core/macros.h"
 
 typedef struct {
-    sfSoundBufferRecorder *handle;
+    sfSoundBufferRecorder* handle;
 } SoundBufferRecorder;
 
 static VALUE rb_cSoundBufferRecorder;
 
-static void SoundBufferRecorder_free(void *ptr) {
-    SoundBufferRecorder *recorder = ptr;
+static void SoundBufferRecorder_free(void* ptr) {
+    SoundBufferRecorder* recorder = ptr;
 
     if (recorder->handle != NULL) {
         sfSoundBufferRecorder_destroy(recorder->handle);
@@ -26,11 +26,10 @@ static void SoundBufferRecorder_free(void *ptr) {
 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
-};
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
 
-static VALUE SoundBufferRecorder_wrap(VALUE klass, sfSoundBufferRecorder *handle) {
-    SoundBufferRecorder *ptr;
+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?)");
@@ -42,49 +41,115 @@ static VALUE SoundBufferRecorder_wrap(VALUE klass, sfSoundBufferRecorder *handle
     return TypedData_Wrap_Struct(klass, &SoundBufferRecorder_data_type, ptr);
 }
 
+/* call-seq:
+ *   SoundBufferRecorder.new -> SoundBufferRecorder
+ *
+ * Creates a recorder that captures into a SoundBuffer.
+ *
+ * @return [SoundBufferRecorder]
+ * @raise [RuntimeError] if no capture device is available
+ */
 static VALUE SoundBufferRecorder_new(VALUE klass) {
     return SoundBufferRecorder_wrap(klass, sfSoundBufferRecorder_create());
 }
 
+/* call-seq:
+ *   start(sample_rate) -> true or false
+ *
+ * Starts capturing audio at the given sample rate.
+ *
+ * @return [Boolean] whether recording started successfully
+ */
 static VALUE SoundBufferRecorder_start(VALUE self, VALUE rb_sample_rate) {
     return BOOL2RB(sfSoundBufferRecorder_start(Get_SoundBufferRecorder_Struct(self),
-                                               (unsigned int) NUM2INT(rb_sample_rate)));
+                                               (unsigned int)NUM2INT(rb_sample_rate)));
 }
 
+/* call-seq: stop -> self
+ *
+ * Stops capturing audio.
+ *
+ * @return [self]
+ */
 static VALUE SoundBufferRecorder_stop(VALUE self) {
     sfSoundBufferRecorder_stop(Get_SoundBufferRecorder_Struct(self));
     return self;
 }
 
+/* call-seq: sample_rate -> Integer
+ *
+ * Returns the sample rate used for capture.
+ *
+ * @return [Integer]
+ */
 static VALUE SoundBufferRecorder_sample_rate(VALUE self) {
     return UINT2NUM(sfSoundBufferRecorder_getSampleRate(Get_SoundBufferRecorder_Struct(self)));
 }
 
+/* call-seq: buffer -> SoundBuffer
+ *
+ * Returns the buffer holding the audio recorded so far.
+ *
+ * @return [SoundBuffer] the buffer containing the audio recorded so far
+ */
 static VALUE SoundBufferRecorder_buffer(VALUE self) {
-    return sound_buffer_from_borrowed(sfSoundBufferRecorder_getBuffer(Get_SoundBufferRecorder_Struct(self)));
+    return sound_buffer_from_borrowed(
+        sfSoundBufferRecorder_getBuffer(Get_SoundBufferRecorder_Struct(self)));
 }
 
+/* call-seq: device -> String
+ *
+ * Returns the name of the capture device in use.
+ *
+ * @return [String] the name of the capture device in use
+ */
 static VALUE SoundBufferRecorder_device(VALUE self) {
     return rb_str_new_cstr(sfSoundBufferRecorder_getDevice(Get_SoundBufferRecorder_Struct(self)));
 }
 
+/* call-seq:
+ *   device=(value) -> true or false
+ *
+ * Must be called while not recording. Get available names from
+ * SoundRecorder.available_devices.
+ *
+ * @return [Boolean] whether the device was set successfully
+ */
 static VALUE SoundBufferRecorder_set_device(VALUE self, VALUE rb_name) {
     return BOOL2RB(sfSoundBufferRecorder_setDevice(Get_SoundBufferRecorder_Struct(self),
                                                    StringValueCStr(rb_name)));
 }
 
+/* call-seq: channel_count -> Integer
+ *
+ * Returns the number of capture channels.
+ *
+ * @return [Integer]
+ */
 static VALUE SoundBufferRecorder_channel_count(VALUE self) {
     return UINT2NUM(sfSoundBufferRecorder_getChannelCount(Get_SoundBufferRecorder_Struct(self)));
 }
 
+/* call-seq:
+ *   channel_count=(value) -> Integer
+ *
+ * Must be called while not recording.
+ *
+ * @return [Integer] +value+
+ */
 static VALUE SoundBufferRecorder_set_channel_count(VALUE self, VALUE rb_count) {
     sfSoundBufferRecorder_setChannelCount(Get_SoundBufferRecorder_Struct(self),
-                                          (unsigned int) NUM2INT(rb_count));
+                                          (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);
+/* Document-class: SFML::SoundBufferRecorder
+ * Records audio from a capture device directly into a SoundBuffer. For
+ * custom processing of captured samples as they arrive, subclass
+ * SoundRecorder instead.
+ */
+void Init_SoundBufferRecorder(VALUE rb_mSFML) {
+    rb_cSoundBufferRecorder = rb_define_class_under(rb_mSFML, "SoundBufferRecorder", rb_cObject);
 
     rb_define_singleton_method(rb_cSoundBufferRecorder, "new", SoundBufferRecorder_new, 0);
 
@@ -94,16 +159,18 @@ void Init_SoundBufferRecorder(VALUE rb_module) {
     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);
+    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;
+void* Get_SoundBufferRecorder_Struct(VALUE self) {
+    SoundBufferRecorder* ptr;
     TypedData_Get_Struct(self, SoundBufferRecorder, &SoundBufferRecorder_data_type, ptr);
     return ptr->handle;
 }