sfml3-rb 0.0.1 → 0.2.2

data/ext/audio/sound_stream.c

@@ -0,0 +1,294 @@
+#include "audio/sound_stream.h"
+
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "audio/audio_enums.h"
+#include "audio/effect_processor.h"
+#include "audio/sound_source.h"
+#include "core/exceptions.h"
+#include "core/foreign_thread.h"
+#include "system/time.h"
+
+#define SOUND_STREAM_CALLBACK_TIMEOUT_MS 50
+
+/* A subclassable stream. SFML calls the two C callbacks from its audio thread,
+   which was never created by Ruby, so calling back into Ruby directly (e.g.
+   via rb_thread_call_with_gvl) is a fatal VM error - only a genuine Ruby
+   thread may reacquire the GVL that way. Each callback instead hands off to
+   the shared foreign-thread worker (core/foreign_thread.h) and reports a
+   timeout or exception as "stop the stream" rather than unwinding into the
+   audio engine. The sample buffer lives in the wrapper and is reused across
+   callbacks, because SFML keeps the pointer it is handed until the next
+   onGetData. */
+typedef struct {
+    SoundSource source;
+    VALUE rb_self;
+    int16_t* samples;
+    size_t samples_capacity;
+} SoundStream;
+
+static VALUE rb_cSoundStream;
+
+static void SoundStream_mark(void* ptr) {
+    SoundStream* stream = ptr;
+
+    rb_gc_mark(stream->rb_self);
+}
+
+/* sfSoundStream_destroy() can block waiting on the audio thread, the same as
+   Sound_free/SS_METHOD(stop); release the GVL for the same reason. */
+static void* SoundStream_destroy_without_gvl(void* handle) {
+    sfSoundStream_destroy(handle);
+    return NULL;
+}
+
+static void SoundStream_free(void* ptr) {
+    SoundStream* stream = ptr;
+
+    effect_processor_release(stream->source.effect_slot);
+    rb_thread_call_without_gvl(SoundStream_destroy_without_gvl, stream->source.handle, RUBY_UBF_IO,
+                               NULL);
+    free(stream->samples);
+    free(stream);
+}
+
+static const rb_data_type_t SoundStream_data_type = {
+    .wrap_struct_name = "SFML::SoundStream",
+    .function = {.dmark = SoundStream_mark, .dfree = SoundStream_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+/* Expands the stream's sample buffer if needed, then copies either a packed
+   String of int16 or an Array of Integers into it. Returns the sample count. */
+static size_t SoundStream_store_samples(SoundStream* stream, VALUE rb_samples) {
+    size_t count;
+
+    if (RB_TYPE_P(rb_samples, T_STRING)) {
+        size_t bytes = (size_t)RSTRING_LEN(rb_samples);
+
+        count = bytes / sizeof(int16_t);
+    } else if (RB_TYPE_P(rb_samples, T_ARRAY)) {
+        count = (size_t)RARRAY_LEN(rb_samples);
+    } else {
+        rb_raise(rb_eTypeError,
+                 "on_get_data must return an Array of samples, a packed String, or nil");
+        return 0;
+    }
+
+    if (count > stream->samples_capacity) {
+        int16_t* grown = realloc(stream->samples, count * sizeof(int16_t));
+
+        if (grown == NULL) {
+            rb_raise(rb_eNoMemError, "could not grow sound stream buffer");
+        }
+
+        stream->samples = grown;
+        stream->samples_capacity = count;
+    }
+
+    if (RB_TYPE_P(rb_samples, T_STRING)) {
+        const int16_t* src = (const int16_t*)RSTRING_PTR(rb_samples);
+        size_t i;
+
+        for (i = 0; i < count; i++) {
+            stream->samples[i] = src[i];
+        }
+    } else {
+        size_t i;
+
+        for (i = 0; i < count; i++) {
+            stream->samples[i] = (int16_t)NUM2INT(rb_ary_entry(rb_samples, (long)i));
+        }
+    }
+
+    return count;
+}
+
+typedef struct {
+    SoundStream* stream;
+    sfSoundStreamChunk* chunk;
+    int ok;
+} GetDataContext;
+
+static VALUE SoundStream_get_data_body(VALUE raw) {
+    GetDataContext* ctx = (GetDataContext*)raw;
+    VALUE result = rb_funcall(ctx->stream->rb_self, rb_intern("on_get_data"), 0);
+
+    if (NIL_P(result) || result == Qfalse) {
+        ctx->ok = 0;
+        return Qnil;
+    }
+
+    ctx->chunk->sampleCount = (unsigned int)SoundStream_store_samples(ctx->stream, result);
+    ctx->chunk->samples = ctx->stream->samples;
+    ctx->ok = 1;
+
+    return Qnil;
+}
+
+static void SoundStream_get_data_run(void* raw) {
+    int state = 0;
+
+    rb_protect(SoundStream_get_data_body, (VALUE)raw, &state);
+
+    if (state) {
+        rb_set_errinfo(Qnil);
+        ((GetDataContext*)raw)->ok = 0;
+    }
+}
+
+static bool SoundStream_on_get_data(sfSoundStreamChunk* chunk, void* userData) {
+    SoundStream* stream = userData;
+    GetDataContext ctx = {.stream = stream, .chunk = chunk, .ok = 0};
+
+    /* On timeout ctx.ok stays 0, which reports "no data" below - the same
+       fallback already used for a raised exception. */
+    run_on_ruby_thread(SoundStream_get_data_run, &ctx, SOUND_STREAM_CALLBACK_TIMEOUT_MS);
+
+    return ctx.ok ? true : false;
+}
+
+typedef struct {
+    SoundStream* stream;
+    sfTime time;
+} SeekContext;
+
+static VALUE SoundStream_seek_body(VALUE raw) {
+    SeekContext* ctx = (SeekContext*)raw;
+
+    rb_funcall(ctx->stream->rb_self, rb_intern("on_seek"), 1, time_to_rb(ctx->time));
+
+    return Qnil;
+}
+
+static void SoundStream_seek_run(void* raw) {
+    int state = 0;
+
+    rb_protect(SoundStream_seek_body, (VALUE)raw, &state);
+
+    if (state) {
+        rb_set_errinfo(Qnil);
+    }
+}
+
+static void SoundStream_on_seek(sfTime time, void* userData) {
+    SoundStream* stream = userData;
+    SeekContext ctx = {.stream = stream, .time = time};
+
+    if (!rb_respond_to(stream->rb_self, rb_intern("on_seek"))) {
+        return;
+    }
+
+    run_on_ruby_thread(SoundStream_seek_run, &ctx, SOUND_STREAM_CALLBACK_TIMEOUT_MS);
+}
+
+static VALUE SoundStream_new(int argc, VALUE* argv, VALUE klass) {
+    VALUE rb_channel_count, rb_sample_rate, rb_channel_map;
+    sfSoundChannel* channel_map = NULL;
+    size_t channel_map_size = 0;
+    SoundStream* ptr;
+    VALUE self;
+    long i;
+
+    rb_scan_args(argc, argv, "21", &rb_channel_count, &rb_sample_rate, &rb_channel_map);
+
+    if (!NIL_P(rb_channel_map)) {
+        if (!RB_TYPE_P(rb_channel_map, T_ARRAY)) {
+            rb_raise(rb_eArgError, "channel map must be an Array");
+        }
+
+        channel_map_size = (size_t)RARRAY_LEN(rb_channel_map);
+        channel_map = malloc(sizeof(sfSoundChannel) * channel_map_size);
+
+        for (i = 0; i < (long)channel_map_size; i++) {
+            channel_map[i] = sound_channel_from_rb(rb_ary_entry(rb_channel_map, i));
+        }
+    }
+
+    ptr = malloc(sizeof(SoundStream));
+    ptr->source.handle = NULL;
+    ptr->source.effect_slot = -1;
+    ptr->rb_self = Qnil;
+    ptr->samples = NULL;
+    ptr->samples_capacity = 0;
+
+    self = TypedData_Wrap_Struct(klass, &SoundStream_data_type, ptr);
+    ptr->rb_self = self;
+
+    if (!rb_respond_to(self, rb_intern("on_get_data"))) {
+        /* The wrapper is already owned by Ruby; its dfree tolerates a NULL
+           handle, so raising here just leaves it to be collected. */
+        free(channel_map);
+        rb_raise(rb_eNotImpError, "subclass must define #on_get_data");
+    }
+
+    ptr->source.handle = sfSoundStream_create(
+        SoundStream_on_get_data, SoundStream_on_seek, (unsigned int)NUM2INT(rb_channel_count),
+        (unsigned int)NUM2INT(rb_sample_rate), channel_map, channel_map_size, ptr);
+
+    free(channel_map);
+
+    if (ptr->source.handle == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create sound stream");
+    }
+
+    return self;
+}
+
+static VALUE SoundStream_channel_count(VALUE self) {
+    return UINT2NUM(sfSoundStream_getChannelCount(Get_SoundStream_Struct(self)));
+}
+
+static VALUE SoundStream_sample_rate(VALUE self) {
+    return UINT2NUM(sfSoundStream_getSampleRate(Get_SoundStream_Struct(self)));
+}
+
+static VALUE SoundStream_channel_map(VALUE self) {
+    size_t count = 0;
+    sfSoundChannel* map = sfSoundStream_getChannelMap(Get_SoundStream_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;
+}
+
+#define SS_FN(name) sfSoundStream_##name
+#define SS_METHOD(name) SoundStream_##name
+#include "audio/sound_source.inc"
+#undef SS_FN
+#undef SS_METHOD
+
+void Init_SoundStream(VALUE rb_module) {
+    rb_cSoundStream = rb_define_class_under(rb_module, "SoundStream", rb_cObject);
+
+    rb_define_singleton_method(rb_cSoundStream, "new", SoundStream_new, -1);
+
+    rb_define_method(rb_cSoundStream, "channel_count", SoundStream_channel_count, 0);
+    rb_define_method(rb_cSoundStream, "sample_rate", SoundStream_sample_rate, 0);
+    rb_define_method(rb_cSoundStream, "channel_map", SoundStream_channel_map, 0);
+
+    SoundStream_define_sound_source_methods(rb_cSoundStream);
+}
+
+VALUE Get_Klass_SoundStream(void) {
+    return rb_cSoundStream;
+}
+
+void* Get_SoundStream_Struct(VALUE self) {
+    SoundStream* ptr;
+    TypedData_Get_Struct(self, SoundStream, &SoundStream_data_type, ptr);
+    return ptr->source.handle;
+}

data/ext/audio/sound_stream.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_AUDIO_SOUND_STREAM_H
+#define SFML_RB_AUDIO_SOUND_STREAM_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_SoundStream(VALUE rb_module);
+
+VALUE Get_Klass_SoundStream(void);
+
+void *Get_SoundStream_Struct(VALUE self);
+
+#endif //SFML_RB_AUDIO_SOUND_STREAM_H

data/ext/{exceptions.c → core/exceptions.c}

@@ -1,11 +1,13 @@
-#include "ext/exceptions.h"
+#include "core/exceptions.h"
+
+#include <string.h>
 
 #define MSG_LENGTH      86
 
 void raise_invalid_argument_type(const char *type) {
     char msg[MSG_LENGTH];
 
-    sprintf(msg, "invalid argument, expected a %s object", type);
+    snprintf(msg, MSG_LENGTH, "invalid argument, expected a %s object", type);
 
     rb_raise(rb_eArgError, "%s", msg);
 }
@@ -18,9 +20,9 @@ void raise_invalid_arguments_excepted(int expected, size_t given) {
     char msg[MSG_LENGTH];
 
     if (expected > 0) {
-        sprintf(msg, "wrong number of arguments (given %lu, expected %i)", given, expected);
+        snprintf(msg, MSG_LENGTH, "wrong number of arguments (given %lu, expected %i)", given, expected);
     } else {
-        sprintf(msg, "wrong number of arguments (given %lu)", given);
+        snprintf(msg, MSG_LENGTH, "wrong number of arguments (given %lu)", given);
     }
 
 
@@ -30,15 +32,15 @@ void raise_invalid_arguments_excepted(int expected, size_t given) {
 void raise_invalid_array_length(size_t length) {
     char msg[MSG_LENGTH];
 
-    sprintf(msg, "invalid array length, expected length of %lu", length);
+    snprintf(msg, MSG_LENGTH, "invalid array length, expected length of %lu", length);
 
     rb_raise(rb_eArgError, "%s", msg);
 }
 
 void raise_method_no_implemented(const char *method) {
-    if (strlen(method) == 0) {
-        rb_raise(rb_eArgError, "%s", "method no implemented");
+    if (method != NULL && strlen(method) > 0) {
+        rb_raise(rb_eNotImpError, "method not implemented: %s", method);
     } else {
-
+        rb_raise(rb_eNotImpError, "method not implemented");
     }
 }

data/ext/{ext → core}/exceptions.h

@@ -1,5 +1,5 @@
-#ifndef SFML_RB_EXCEPTIONS_H
-#define SFML_RB_EXCEPTIONS_H
+#ifndef SFML_RB_CORE_EXCEPTIONS_H
+#define SFML_RB_CORE_EXCEPTIONS_H
 
 #include <ruby.h>
 
@@ -13,4 +13,4 @@ void raise_invalid_array_length(size_t length);
 
 void raise_method_no_implemented(const char *method);
 
-#endif //SFML_RB_EXCEPTIONS_H
+#endif //SFML_RB_CORE_EXCEPTIONS_H

data/ext/core/foreign_thread.c

@@ -0,0 +1,149 @@
+#include "core/foreign_thread.h"
+
+#include <pthread.h>
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <time.h>
+
+typedef enum {
+    FT_IDLE = 0,
+    FT_POSTED,  /* job handed off, worker has not claimed it yet */
+    FT_RUNNING, /* worker has claimed the job and is running fn(ctx) */
+    FT_DONE
+} ForeignThreadState;
+
+typedef struct {
+    void (*fn)(void*);
+    void* ctx;
+} ForeignJob;
+
+static pthread_mutex_t ft_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t ft_cond = PTHREAD_COND_INITIALIZER;
+static ForeignJob* volatile ft_job = NULL;
+static volatile ForeignThreadState ft_state = FT_IDLE;
+static volatile int ft_shutdown = 0;
+
+static VALUE ft_worker_main(void* unused);
+
+void Init_ForeignThread(void) {
+    rb_thread_create(ft_worker_main, NULL);
+}
+
+/* Runs without the GVL on the worker thread. Blocks until a job is posted or
+   shutdown is requested. */
+static void* ft_wait_for_post(void* unused) {
+    (void)unused;
+
+    pthread_mutex_lock(&ft_mutex);
+    while (ft_state != FT_POSTED && !ft_shutdown) {
+        pthread_cond_wait(&ft_cond, &ft_mutex);
+    }
+    pthread_mutex_unlock(&ft_mutex);
+
+    return NULL;
+}
+
+/* Called by Ruby to interrupt ft_wait_for_post (e.g. at VM shutdown). */
+static void ft_unblock(void* unused) {
+    (void)unused;
+
+    pthread_mutex_lock(&ft_mutex);
+    ft_shutdown = 1;
+    pthread_cond_broadcast(&ft_cond);
+    pthread_mutex_unlock(&ft_mutex);
+}
+
+static VALUE ft_worker_main(void* unused) {
+    (void)unused;
+
+    for (;;) {
+        ForeignJob* job;
+
+        rb_thread_call_without_gvl(ft_wait_for_post, NULL, ft_unblock, NULL);
+
+        pthread_mutex_lock(&ft_mutex);
+
+        if (ft_shutdown) {
+            pthread_mutex_unlock(&ft_mutex);
+            break;
+        }
+
+        if (ft_state != FT_POSTED) {
+            /* Spurious wake, or the caller already abandoned this job while
+               it was still only posted - nothing to do. */
+            pthread_mutex_unlock(&ft_mutex);
+            continue;
+        }
+
+        job = ft_job;
+        ft_state = FT_RUNNING;
+        pthread_mutex_unlock(&ft_mutex);
+
+        job->fn(job->ctx);
+
+        pthread_mutex_lock(&ft_mutex);
+        ft_state = FT_DONE;
+        pthread_cond_broadcast(&ft_cond);
+        pthread_mutex_unlock(&ft_mutex);
+    }
+
+    return Qnil;
+}
+
+int run_on_ruby_thread(void (*fn)(void* ctx), void* ctx, unsigned long timeout_ms) {
+    ForeignJob job = {.fn = fn, .ctx = ctx};
+    struct timespec deadline;
+    int completed;
+    int use_timeout = (timeout_ms > 0);
+
+    if (use_timeout) {
+        clock_gettime(CLOCK_REALTIME, &deadline);
+        deadline.tv_nsec += (long)(timeout_ms % 1000) * 1000000L;
+        deadline.tv_sec += (time_t)(timeout_ms / 1000) + deadline.tv_nsec / 1000000000L;
+        deadline.tv_nsec %= 1000000000L;
+    }
+
+    pthread_mutex_lock(&ft_mutex);
+
+    while (ft_state != FT_IDLE) {
+        pthread_cond_wait(&ft_cond, &ft_mutex);
+    }
+
+    ft_job = &job;
+    ft_state = FT_POSTED;
+    pthread_cond_broadcast(&ft_cond);
+
+    while (ft_state != FT_DONE) {
+        if (use_timeout) {
+            int rc = pthread_cond_timedwait(&ft_cond, &ft_mutex, &deadline);
+
+            if (rc != 0 && ft_state == FT_POSTED) {
+                /* Still not claimed: safe to abandon, the worker has never
+                   touched job/ctx. */
+                ft_state = FT_IDLE;
+                ft_job = NULL;
+                pthread_cond_broadcast(&ft_cond);
+                pthread_mutex_unlock(&ft_mutex);
+                return 0;
+            }
+
+            if (rc != 0) {
+                /* Already claimed (FT_RUNNING): job/ctx are in use on the
+                   worker thread now, so it is no longer safe to abandon.
+                   Fall back to an unbounded wait for FT_DONE. */
+                use_timeout = 0;
+            }
+        } else {
+            pthread_cond_wait(&ft_cond, &ft_mutex);
+        }
+    }
+
+    completed = (ft_state == FT_DONE);
+    ft_state = FT_IDLE;
+    ft_job = NULL;
+    pthread_cond_broadcast(&ft_cond);
+
+    pthread_mutex_unlock(&ft_mutex);
+
+    return completed;
+}

data/ext/core/foreign_thread.h

@@ -0,0 +1,31 @@
+#ifndef SFML_RB_CORE_FOREIGN_THREAD_H
+#define SFML_RB_CORE_FOREIGN_THREAD_H
+
+/* SFML's audio thread is a foreign native thread Ruby never created, so it
+   cannot legally call back into Ruby: rb_thread_call_with_gvl() requires the
+   calling thread to have previously released the GVL via
+   rb_thread_call_without_gvl(), which only a genuine Ruby thread can do -
+   calling it from a foreign thread is a fatal VM error ("rb_thread_call_with_
+   gvl() is called by non-ruby thread"). This module starts one persistent
+   Ruby-owned worker thread that a foreign thread can safely hand jobs to. */
+
+/* Starts the worker thread. Must be called once, with the GVL held, before
+   any foreign thread calls run_on_ruby_thread(). */
+void Init_ForeignThread(void);
+
+/* Runs fn(ctx) on the worker thread and blocks the calling (foreign) thread
+   until it completes, or until timeout_ms elapses (0 disables the timeout).
+   Safe to call from any thread, including ones Ruby has never seen.
+
+   On timeout, the job is only abandoned if the worker has not yet started
+   running it; once running, this function waits for it to finish regardless
+   of the timeout, so ctx is never touched by the worker after this function
+   returns - the timeout exists to bound waiting on a merely slow-to-schedule
+   worker (e.g. GVL contention), not to allow ctx to be freed out from under
+   an in-flight job.
+
+   Returns 1 if fn ran to completion, 0 if the job was abandoned on timeout
+   before the worker claimed it. */
+int run_on_ruby_thread(void (*fn)(void* ctx), void* ctx, unsigned long timeout_ms);
+
+#endif // SFML_RB_CORE_FOREIGN_THREAD_H

data/ext/core/macros.h

@@ -0,0 +1,8 @@
+#ifndef SFML_RB_CORE_MACROS_H
+#define SFML_RB_CORE_MACROS_H
+
+#include <ruby.h>
+
+#define BOOL2RB(value) value? Qtrue: Qfalse
+
+#endif //SFML_RB_CORE_MACROS_H

data/ext/{ext → core}/sfml.h

@@ -1,5 +1,5 @@
-#ifndef SFML_H
-#define SFML_H
+#ifndef SFML_RB_CORE_SFML_H
+#define SFML_RB_CORE_SFML_H
 
 #include <CSFML/Config.h>
 
@@ -9,8 +9,10 @@
 
 #include <CSFML/Graphics.h>
 #include <CSFML/Window.h>
+#include <CSFML/Audio.h>
+#include <CSFML/Network.h>
 #include <CSFML/System.h>
 #include <CSFML/System/Vector2.h>
 #include <CSFML/Graphics/RenderStates.h>
 
-#endif //SFML_H
+#endif //SFML_RB_CORE_SFML_H

data/ext/core/unicode.c

@@ -0,0 +1,46 @@
+#include "core/unicode.h"
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+
+VALUE utf32_from_rb(VALUE rb_string) {
+    rb_encoding* utf8 = rb_utf8_encoding();
+    VALUE string = rb_str_export_to_enc(rb_string, utf8);
+    const char* cursor = RSTRING_PTR(string);
+    const char* end = cursor + RSTRING_LEN(string);
+    VALUE buffer;
+    sfChar32* out;
+    long length = 0;
+
+    /* One code point per byte is the worst case, plus the terminator. */
+    buffer = rb_str_tmp_new((RSTRING_LEN(string) + 1) * (long)sizeof(sfChar32));
+    out = (sfChar32*)RSTRING_PTR(buffer);
+
+    while (cursor < end) {
+        int width = 0;
+
+        out[length++] = (sfChar32)rb_enc_codepoint_len(cursor, end, &width, utf8);
+        cursor += width;
+    }
+
+    out[length] = 0;
+
+    RB_GC_GUARD(string);
+
+    return buffer;
+}
+
+VALUE utf32_to_rb(const sfChar32* string) {
+    VALUE out = rb_utf8_str_new_cstr("");
+    size_t i;
+
+    if (string == NULL) {
+        return out;
+    }
+
+    for (i = 0; string[i] != 0; i++) {
+        rb_str_concat(out, UINT2NUM(string[i]));
+    }
+
+    return out;
+}

data/ext/core/unicode.h

@@ -0,0 +1,25 @@
+#ifndef SFML_RB_CORE_UNICODE_H
+#define SFML_RB_CORE_UNICODE_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+/* CSFML's plain `const char*` entry points hand the bytes to sf::String's
+   narrow-character constructor, which decodes them with the C locale -- so a
+   UTF-8 Ruby String arrives mangled. The *Unicode* entry points take UTF-32
+   instead, which is lossless, and these two functions are the bridge.
+
+   utf32_from_rb returns a hidden Ruby String owning the code units; read it
+   with UTF32_PTR and keep the VALUE alive (RB_GC_GUARD) until the sf* call has
+   returned. Ruby frees it, so an exception in between leaks nothing.
+
+   Deliberately not ALLOCV: that allocates on the stack for small sizes, so its
+   pointer cannot outlive the frame that created it. */
+VALUE utf32_from_rb(VALUE rb_string);
+
+#define UTF32_PTR(buffer) ((const sfChar32*)RSTRING_PTR(buffer))
+
+VALUE utf32_to_rb(const sfChar32* string);
+
+#endif // SFML_RB_CORE_UNICODE_H