sfml3-rb 0.0.1 → 0.2.1

data/ext/audio/sound.c

@@ -0,0 +1,139 @@
+#include "audio/sound.h"
+
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <stdlib.h>
+
+#include "audio/effect_processor.h"
+#include "audio/sound_buffer.h"
+#include "audio/sound_source.h"
+#include "core/exceptions.h"
+
+typedef struct {
+    SoundSource source;
+    VALUE rb_buffer;
+} Sound;
+
+static VALUE rb_cSound;
+
+static void Sound_mark(void* ptr) {
+    Sound* sound = ptr;
+
+    rb_gc_mark(sound->rb_buffer);
+}
+
+/* sfSound_destroy() calls Sound::stop(), which can block waiting on the audio
+   thread (see the matching comment on SS_METHOD(stop) in sound_source.inc);
+   release the GVL for the same reason. */
+static void* Sound_destroy_without_gvl(void* handle) {
+    sfSound_destroy(handle);
+    return NULL;
+}
+
+static void Sound_free(void* ptr) {
+    Sound* sound = ptr;
+
+    effect_processor_release(sound->source.effect_slot);
+    rb_thread_call_without_gvl(Sound_destroy_without_gvl, sound->source.handle, RUBY_UBF_IO, NULL);
+    free(sound);
+}
+
+static const rb_data_type_t Sound_data_type = {
+    .wrap_struct_name = "SFML::Sound",
+    .function = {.dmark = Sound_mark, .dfree = Sound_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+static VALUE Sound_wrap(VALUE klass, sfSound* handle, VALUE rb_buffer) {
+    Sound* ptr;
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create sound");
+    }
+
+    ptr = malloc(sizeof(Sound));
+    ptr->source.handle = handle;
+    ptr->source.effect_slot = -1;
+    ptr->rb_buffer = rb_buffer;
+
+    return TypedData_Wrap_Struct(klass, &Sound_data_type, ptr);
+}
+
+static VALUE Sound_new(VALUE klass, VALUE rb_buffer) {
+    if (!rb_obj_is_kind_of(rb_buffer, Get_Klass_SoundBuffer())) {
+        raise_invalid_argument_class(Get_Klass_SoundBuffer());
+    }
+
+    return Sound_wrap(klass, sfSound_create(Get_SoundBuffer_Struct(rb_buffer)), rb_buffer);
+}
+
+static VALUE Sound_copy(VALUE self) {
+    Sound* sound = (Sound*)Get_Sound_Struct(self);
+
+    return Sound_wrap(Get_Klass_Sound(), sfSound_copy((const sfSound*)sound->source.handle),
+                      sound->rb_buffer);
+}
+
+static VALUE Sound_get_buffer(VALUE self) {
+    return ((Sound*)Get_Sound_Struct(self))->rb_buffer;
+}
+
+typedef struct {
+    sfSound* handle;
+    const sfSoundBuffer* buffer;
+} SoundSetBufferArgs;
+
+/* sfSound_setBuffer() calls Sound::stop() when a buffer is already attached,
+   which can block waiting on the audio thread; release the GVL for the same
+   reason as Sound_free/SS_METHOD(stop). */
+static void* Sound_set_buffer_without_gvl(void* raw) {
+    SoundSetBufferArgs* args = raw;
+
+    sfSound_setBuffer(args->handle, args->buffer);
+
+    return NULL;
+}
+
+static VALUE Sound_set_buffer(VALUE self, VALUE rb_buffer) {
+    Sound* sound = (Sound*)Get_Sound_Struct(self);
+    SoundSetBufferArgs args;
+
+    if (!rb_obj_is_kind_of(rb_buffer, Get_Klass_SoundBuffer())) {
+        raise_invalid_argument_class(Get_Klass_SoundBuffer());
+    }
+
+    args.handle = sound->source.handle;
+    args.buffer = Get_SoundBuffer_Struct(rb_buffer);
+
+    rb_thread_call_without_gvl(Sound_set_buffer_without_gvl, &args, RUBY_UBF_IO, NULL);
+    sound->rb_buffer = rb_buffer;
+
+    return rb_buffer;
+}
+
+#define SS_FN(name) sfSound_##name
+#define SS_METHOD(name) Sound_##name
+#include "audio/sound_source.inc"
+#undef SS_FN
+#undef SS_METHOD
+
+void Init_Sound(VALUE rb_module) {
+    rb_cSound = rb_define_class_under(rb_module, "Sound", rb_cObject);
+
+    rb_define_singleton_method(rb_cSound, "new", Sound_new, 1);
+
+    rb_define_method(rb_cSound, "copy", Sound_copy, 0);
+    rb_define_method(rb_cSound, "buffer", Sound_get_buffer, 0);
+    rb_define_method(rb_cSound, "buffer=", Sound_set_buffer, 1);
+
+    Sound_define_sound_source_methods(rb_cSound);
+}
+
+VALUE Get_Klass_Sound(void) {
+    return rb_cSound;
+}
+
+void* Get_Sound_Struct(VALUE self) {
+    Sound* ptr;
+    TypedData_Get_Struct(self, Sound, &Sound_data_type, ptr);
+    return ptr;
+}

data/ext/audio/sound.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_AUDIO_SOUND_H
+#define SFML_RB_AUDIO_SOUND_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_Sound(VALUE rb_module);
+
+VALUE Get_Klass_Sound(void);
+
+void *Get_Sound_Struct(VALUE self);
+
+#endif //SFML_RB_AUDIO_SOUND_H

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