sfml3-rb 0.0.1 → 0.2.1

data/ext/audio/audio_enums.c

@@ -0,0 +1,131 @@
+#include "audio/audio_enums.h"
+
+#include <ruby.h>
+#include <string.h>
+
+static const char *sound_status_names[] = {"stopped", "paused", "playing"};
+
+/* Designated initializers, indexed by the enum constant rather than by
+   position: CSFML 3 defines the channel order, and a positional table would
+   silently return the wrong name if a future release inserted a value. */
+static const char *sound_channel_names[] = {
+    [sfSoundChannelUnspecified] = "unspecified",
+    [sfSoundChannelMono] = "mono",
+    [sfSoundChannelFrontLeft] = "front_left",
+    [sfSoundChannelFrontRight] = "front_right",
+    [sfSoundChannelFrontCenter] = "front_center",
+    [sfSoundChannelFrontLeftOfCenter] = "front_left_of_center",
+    [sfSoundChannelFrontRightOfCenter] = "front_right_of_center",
+    [sfSoundChannelLowFrequencyEffects] = "low_frequency_effects",
+    [sfSoundChannelBackLeft] = "back_left",
+    [sfSoundChannelBackRight] = "back_right",
+    [sfSoundChannelBackCenter] = "back_center",
+    [sfSoundChannelSideLeft] = "side_left",
+    [sfSoundChannelSideRight] = "side_right",
+    [sfSoundChannelTopCenter] = "top_center",
+    [sfSoundChannelTopFrontLeft] = "top_front_left",
+    [sfSoundChannelTopFrontRight] = "top_front_right",
+    [sfSoundChannelTopFrontCenter] = "top_front_center",
+    [sfSoundChannelTopBackLeft] = "top_back_left",
+    [sfSoundChannelTopBackRight] = "top_back_right",
+    [sfSoundChannelTopBackCenter] = "top_back_center"
+};
+
+static int symbol_index(VALUE rb_symbol, const char *const *names, size_t count) {
+    const char *name;
+    size_t i;
+
+    if (!SYMBOL_P(rb_symbol)) {
+        return -1;
+    }
+
+    name = rb_id2name(SYM2ID(rb_symbol));
+
+    for (i = 0; i < count; i++) {
+        if (names[i] != NULL && strcmp(name, names[i]) == 0) {
+            return (int) i;
+        }
+    }
+
+    return -1;
+}
+
+const char *sound_status_name(sfSoundStatus status) {
+    if (status >= sfStopped && status <= sfPlaying) {
+        return sound_status_names[status];
+    }
+
+    return "stopped";
+}
+
+sfSoundStatus sound_status_from_rb(VALUE rb_status) {
+    int index;
+
+    if (RB_INTEGER_TYPE_P(rb_status)) {
+        return (sfSoundStatus) NUM2INT(rb_status);
+    }
+
+    index = symbol_index(rb_status, sound_status_names, 3);
+
+    if (index < 0) {
+        rb_raise(rb_eArgError, "unknown sound status");
+    }
+
+    return (sfSoundStatus) index;
+}
+
+const char *sound_channel_name(sfSoundChannel channel) {
+    if (channel >= sfSoundChannelUnspecified && channel <= sfSoundChannelTopBackCenter &&
+        sound_channel_names[channel] != NULL) {
+        return sound_channel_names[channel];
+    }
+
+    return "unspecified";
+}
+
+sfSoundChannel sound_channel_from_rb(VALUE rb_channel) {
+    int index;
+
+    if (RB_INTEGER_TYPE_P(rb_channel)) {
+        return (sfSoundChannel) NUM2INT(rb_channel);
+    }
+
+    index = symbol_index(rb_channel, sound_channel_names,
+                         sizeof(sound_channel_names) / sizeof(sound_channel_names[0]));
+
+    if (index < 0) {
+        rb_raise(rb_eArgError, "unknown sound channel");
+    }
+
+    return (sfSoundChannel) index;
+}
+
+void Init_AudioEnums(VALUE rb_module) {
+    VALUE rb_mSoundStatus = rb_define_module_under(rb_module, "SoundStatus");
+    VALUE rb_mSoundChannel = rb_define_module_under(rb_module, "SoundChannel");
+
+    rb_define_const(rb_mSoundStatus, "STOPPED", INT2NUM(sfStopped));
+    rb_define_const(rb_mSoundStatus, "PAUSED", INT2NUM(sfPaused));
+    rb_define_const(rb_mSoundStatus, "PLAYING", INT2NUM(sfPlaying));
+
+    rb_define_const(rb_mSoundChannel, "UNSPECIFIED", INT2NUM(sfSoundChannelUnspecified));
+    rb_define_const(rb_mSoundChannel, "MONO", INT2NUM(sfSoundChannelMono));
+    rb_define_const(rb_mSoundChannel, "FRONT_LEFT", INT2NUM(sfSoundChannelFrontLeft));
+    rb_define_const(rb_mSoundChannel, "FRONT_RIGHT", INT2NUM(sfSoundChannelFrontRight));
+    rb_define_const(rb_mSoundChannel, "FRONT_CENTER", INT2NUM(sfSoundChannelFrontCenter));
+    rb_define_const(rb_mSoundChannel, "FRONT_LEFT_OF_CENTER", INT2NUM(sfSoundChannelFrontLeftOfCenter));
+    rb_define_const(rb_mSoundChannel, "FRONT_RIGHT_OF_CENTER", INT2NUM(sfSoundChannelFrontRightOfCenter));
+    rb_define_const(rb_mSoundChannel, "LOW_FREQUENCY_EFFECTS", INT2NUM(sfSoundChannelLowFrequencyEffects));
+    rb_define_const(rb_mSoundChannel, "BACK_LEFT", INT2NUM(sfSoundChannelBackLeft));
+    rb_define_const(rb_mSoundChannel, "BACK_RIGHT", INT2NUM(sfSoundChannelBackRight));
+    rb_define_const(rb_mSoundChannel, "BACK_CENTER", INT2NUM(sfSoundChannelBackCenter));
+    rb_define_const(rb_mSoundChannel, "SIDE_LEFT", INT2NUM(sfSoundChannelSideLeft));
+    rb_define_const(rb_mSoundChannel, "SIDE_RIGHT", INT2NUM(sfSoundChannelSideRight));
+    rb_define_const(rb_mSoundChannel, "TOP_CENTER", INT2NUM(sfSoundChannelTopCenter));
+    rb_define_const(rb_mSoundChannel, "TOP_FRONT_LEFT", INT2NUM(sfSoundChannelTopFrontLeft));
+    rb_define_const(rb_mSoundChannel, "TOP_FRONT_RIGHT", INT2NUM(sfSoundChannelTopFrontRight));
+    rb_define_const(rb_mSoundChannel, "TOP_FRONT_CENTER", INT2NUM(sfSoundChannelTopFrontCenter));
+    rb_define_const(rb_mSoundChannel, "TOP_BACK_LEFT", INT2NUM(sfSoundChannelTopBackLeft));
+    rb_define_const(rb_mSoundChannel, "TOP_BACK_RIGHT", INT2NUM(sfSoundChannelTopBackRight));
+    rb_define_const(rb_mSoundChannel, "TOP_BACK_CENTER", INT2NUM(sfSoundChannelTopBackCenter));
+}

data/ext/audio/audio_enums.h

@@ -0,0 +1,18 @@
+#ifndef SFML_RB_AUDIO_AUDIO_ENUMS_H
+#define SFML_RB_AUDIO_AUDIO_ENUMS_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_AudioEnums(VALUE rb_module);
+
+const char *sound_status_name(sfSoundStatus status);
+
+sfSoundStatus sound_status_from_rb(VALUE rb_status);
+
+const char *sound_channel_name(sfSoundChannel channel);
+
+sfSoundChannel sound_channel_from_rb(VALUE rb_channel);
+
+#endif //SFML_RB_AUDIO_AUDIO_ENUMS_H

data/ext/audio/effect_processor.c

@@ -0,0 +1,233 @@
+#include "audio/effect_processor.h"
+
+#include <ruby.h>
+#include <string.h>
+
+#include "core/foreign_thread.h"
+
+/* Slots are process-global because a C callback cannot carry context. Each
+   entry is either Qnil (free) or the Proc assigned to that slot. */
+static VALUE effect_processors[EFFECT_PROCESSOR_SLOTS];
+
+typedef struct {
+    int slot;
+    const float* input;
+    unsigned int input_count;
+    float* output;
+    unsigned int output_count;
+    unsigned int requested_output_count;
+    unsigned int channels;
+} EffectContext;
+
+/* Fills the output buffer with silence for the full frame count the audio
+   engine asked for. Used whenever the processor cannot produce real output
+   (an exception, or a timed-out worker): reporting output_count 0 instead of
+   this was observed to make miniaudio's node graph re-invoke this callback
+   in an immediate, unbounded retry loop (tens of thousands of calls/second)
+   rather than treat it as one completed (silent) buffer - which in turn
+   starved SFML's AudioDevice::waitForReadingComplete() on the main thread,
+   since the audio thread never stopped re-acquiring its internal mutex. */
+static void effect_output_silence(EffectContext* ctx) {
+    unsigned int i;
+
+    for (i = 0; i < ctx->requested_output_count * ctx->channels; i++) {
+        ctx->output[i] = 0.0f;
+    }
+
+    ctx->output_count = ctx->requested_output_count;
+}
+
+#define EFFECT_JOB_TIMEOUT_MS 50
+
+void Init_EffectProcessor(void) {
+    int i;
+
+    for (i = 0; i < EFFECT_PROCESSOR_SLOTS; i++) {
+        effect_processors[i] = Qnil;
+        rb_gc_register_address(&effect_processors[i]);
+    }
+}
+
+static VALUE effect_yield(VALUE raw) {
+    EffectContext* ctx = (EffectContext*)raw;
+    VALUE rb_input;
+    VALUE rb_result;
+    unsigned int i;
+    unsigned int c;
+    long produced;
+
+    rb_input = rb_ary_new_capa((long)ctx->input_count);
+
+    for (i = 0; i < ctx->input_count; i++) {
+        VALUE frame = rb_ary_new_capa((long)ctx->channels);
+
+        for (c = 0; c < ctx->channels; c++) {
+            rb_ary_push(frame, DBL2NUM((double)ctx->input[i * ctx->channels + c]));
+        }
+
+        rb_ary_push(rb_input, frame);
+    }
+
+    rb_result = rb_funcall(effect_processors[ctx->slot], rb_intern("call"), 2, rb_input,
+                           UINT2NUM(ctx->channels));
+
+    if (!RB_TYPE_P(rb_result, T_ARRAY)) {
+        rb_raise(rb_eTypeError, "effect processor must return an Array of frames");
+    }
+
+    produced = RARRAY_LEN(rb_result);
+
+    if (produced > (long)ctx->output_count) {
+        produced = (long)ctx->output_count;
+    }
+
+    for (i = 0; i < (unsigned int)produced; i++) {
+        VALUE frame = rb_ary_entry(rb_result, (long)i);
+
+        if (!RB_TYPE_P(frame, T_ARRAY)) {
+            rb_raise(rb_eTypeError, "effect processor frames must be Arrays");
+        }
+
+        for (c = 0; c < ctx->channels; c++) {
+            ctx->output[i * ctx->channels + c] = (float)NUM2DBL(rb_ary_entry(frame, (long)c));
+        }
+    }
+
+    ctx->output_count = (unsigned int)produced;
+
+    return Qnil;
+}
+
+/* Runs on the shared foreign-thread worker, which holds the GVL. */
+static void effect_run(void* raw) {
+    EffectContext* ctx = (EffectContext*)raw;
+    int state = 0;
+
+    rb_protect(effect_yield, (VALUE)ctx, &state);
+
+    if (state) {
+        /* An exception must not unwind through the audio engine: drop the
+           output and let playback continue silently. */
+        rb_set_errinfo(Qnil);
+        effect_output_silence(ctx);
+    }
+}
+
+static void effect_invoke(int slot, const float* input, unsigned int* input_count, float* output,
+                          unsigned int* output_count, unsigned int channels) {
+    EffectContext ctx;
+
+    if (slot < 0 || slot >= EFFECT_PROCESSOR_SLOTS || NIL_P(effect_processors[slot]) ||
+        *output_count == 0) {
+        *output_count = 0;
+        return;
+    }
+
+    ctx.slot = slot;
+    ctx.input = input;
+    ctx.input_count = (input != NULL) ? *input_count : 0;
+    ctx.output = output;
+    ctx.output_count = *output_count;
+    ctx.requested_output_count = *output_count;
+    ctx.channels = channels;
+
+    if (!run_on_ruby_thread(effect_run, &ctx, EFFECT_JOB_TIMEOUT_MS)) {
+        /* Timed out before the worker even claimed the job (e.g. GVL
+           contention): degrade to silence for this callback rather than
+           stall the audio thread. */
+        effect_output_silence(&ctx);
+    }
+
+    /* The processor consumed every input frame it was offered. */
+    *input_count = ctx.input_count;
+    *output_count = ctx.output_count;
+}
+
+#define EFFECT_THUNK(n)                                                                            \
+    static void effect_thunk_##n(const float* input, unsigned int* input_count, float* output,     \
+                                 unsigned int* output_count, unsigned int channels) {              \
+        effect_invoke(n, input, input_count, output, output_count, channels);                      \
+    }
+
+EFFECT_THUNK(0)
+EFFECT_THUNK(1)
+EFFECT_THUNK(2)
+EFFECT_THUNK(3)
+EFFECT_THUNK(4)
+EFFECT_THUNK(5)
+EFFECT_THUNK(6)
+EFFECT_THUNK(7)
+EFFECT_THUNK(8)
+EFFECT_THUNK(9)
+EFFECT_THUNK(10)
+EFFECT_THUNK(11)
+EFFECT_THUNK(12)
+EFFECT_THUNK(13)
+EFFECT_THUNK(14)
+EFFECT_THUNK(15)
+EFFECT_THUNK(16)
+EFFECT_THUNK(17)
+EFFECT_THUNK(18)
+EFFECT_THUNK(19)
+EFFECT_THUNK(20)
+EFFECT_THUNK(21)
+EFFECT_THUNK(22)
+EFFECT_THUNK(23)
+EFFECT_THUNK(24)
+EFFECT_THUNK(25)
+EFFECT_THUNK(26)
+EFFECT_THUNK(27)
+EFFECT_THUNK(28)
+EFFECT_THUNK(29)
+EFFECT_THUNK(30)
+EFFECT_THUNK(31)
+
+static sfEffectProcessor effect_thunks[EFFECT_PROCESSOR_SLOTS] = {
+    effect_thunk_0,  effect_thunk_1,  effect_thunk_2,  effect_thunk_3,  effect_thunk_4,
+    effect_thunk_5,  effect_thunk_6,  effect_thunk_7,  effect_thunk_8,  effect_thunk_9,
+    effect_thunk_10, effect_thunk_11, effect_thunk_12, effect_thunk_13, effect_thunk_14,
+    effect_thunk_15, effect_thunk_16, effect_thunk_17, effect_thunk_18, effect_thunk_19,
+    effect_thunk_20, effect_thunk_21, effect_thunk_22, effect_thunk_23, effect_thunk_24,
+    effect_thunk_25, effect_thunk_26, effect_thunk_27, effect_thunk_28, effect_thunk_29,
+    effect_thunk_30, effect_thunk_31};
+
+sfEffectProcessor effect_processor_acquire(VALUE rb_proc, int* slot) {
+    int i;
+
+    /* Replacing the processor on a source that already has one reuses its
+       slot, so a source never leaks slots across repeated assignment. */
+    if (*slot >= 0 && *slot < EFFECT_PROCESSOR_SLOTS) {
+        if (NIL_P(rb_proc)) {
+            effect_processors[*slot] = Qnil;
+            return NULL;
+        }
+
+        effect_processors[*slot] = rb_proc;
+
+        return effect_thunks[*slot];
+    }
+
+    if (NIL_P(rb_proc)) {
+        *slot = -1;
+        return NULL;
+    }
+
+    for (i = 0; i < EFFECT_PROCESSOR_SLOTS; i++) {
+        if (NIL_P(effect_processors[i])) {
+            effect_processors[i] = rb_proc;
+            *slot = i;
+
+            return effect_thunks[i];
+        }
+    }
+
+    rb_raise(rb_eRuntimeError, "all %d effect-processor slots are in use", EFFECT_PROCESSOR_SLOTS);
+
+    return NULL;
+}
+
+void effect_processor_release(int slot) {
+    if (slot >= 0 && slot < EFFECT_PROCESSOR_SLOTS) {
+        effect_processors[slot] = Qnil;
+    }
+}

data/ext/audio/effect_processor.h

@@ -0,0 +1,25 @@
+#ifndef SFML_RB_AUDIO_EFFECT_PROCESSOR_H
+#define SFML_RB_AUDIO_EFFECT_PROCESSOR_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+/* sfEffectProcessor carries no userData, so a single C callback cannot tell
+   which sound source invoked it. Instead the binding keeps a fixed pool of
+   identical C thunks, each hard-wired to one slot; assigning a processor to a
+   source hands it the thunk for that source's slot. Slots are bounded, and
+   exceeding the pool raises rather than silently sharing one callback. */
+#define EFFECT_PROCESSOR_SLOTS 32
+
+/* Registers every slot as a GC root. Must run before any acquire. */
+void Init_EffectProcessor(void);
+
+/* Stores rb_proc in a free slot, writes its index to *slot and returns the
+   matching thunk. Passing nil returns NULL (no processor). */
+sfEffectProcessor effect_processor_acquire(VALUE rb_proc, int *slot);
+
+/* Frees a slot previously handed out, clearing the Ruby reference. */
+void effect_processor_release(int slot);
+
+#endif //SFML_RB_AUDIO_EFFECT_PROCESSOR_H

data/ext/audio/listener.c

@@ -0,0 +1,83 @@
+#include "audio/listener.h"
+
+#include <ruby.h>
+
+#include "audio/sound_source_cone.h"
+#include "system/vec3.h"
+
+static VALUE Listener_global_volume(VALUE module) {
+    return DBL2NUM(sfListener_getGlobalVolume());
+}
+
+static VALUE Listener_set_global_volume(VALUE module, VALUE rb_value) {
+    sfListener_setGlobalVolume((float) NUM2DBL(rb_value));
+    return rb_value;
+}
+
+static VALUE Listener_position(VALUE module) {
+    return vec3f_to_rb(sfListener_getPosition());
+}
+
+static VALUE Listener_set_position(VALUE module, VALUE rb_value) {
+    sfListener_setPosition(vec3f_from_rb(rb_value));
+    return rb_value;
+}
+
+static VALUE Listener_direction(VALUE module) {
+    return vec3f_to_rb(sfListener_getDirection());
+}
+
+static VALUE Listener_set_direction(VALUE module, VALUE rb_value) {
+    sfListener_setDirection(vec3f_from_rb(rb_value));
+    return rb_value;
+}
+
+static VALUE Listener_velocity(VALUE module) {
+    return vec3f_to_rb(sfListener_getVelocity());
+}
+
+static VALUE Listener_set_velocity(VALUE module, VALUE rb_value) {
+    sfListener_setVelocity(vec3f_from_rb(rb_value));
+    return rb_value;
+}
+
+static VALUE Listener_up_vector(VALUE module) {
+    return vec3f_to_rb(sfListener_getUpVector());
+}
+
+static VALUE Listener_set_up_vector(VALUE module, VALUE rb_value) {
+    sfListener_setUpVector(vec3f_from_rb(rb_value));
+    return rb_value;
+}
+
+static VALUE Listener_cone(VALUE module) {
+    sfListenerCone cone = sfListener_getCone();
+
+    return sound_source_cone_to_rb((sfSoundSourceCone) {cone.innerAngle, cone.outerAngle,
+                                                        cone.outerGain});
+}
+
+static VALUE Listener_set_cone(VALUE module, VALUE rb_value) {
+    sfSoundSourceCone cone = sound_source_cone_from_rb(rb_value);
+
+    sfListener_setCone((sfListenerCone) {cone.innerAngle, cone.outerAngle, cone.outerGain});
+
+    return rb_value;
+}
+
+void Init_Listener(VALUE rb_module) {
+    VALUE rb_mListener = rb_define_module_under(rb_module, "Listener");
+
+    rb_define_module_function(rb_mListener, "global_volume", Listener_global_volume, 0);
+    rb_define_module_function(rb_mListener, "global_volume=", Listener_set_global_volume, 1);
+    rb_define_module_function(rb_mListener, "position", Listener_position, 0);
+    rb_define_module_function(rb_mListener, "position=", Listener_set_position, 1);
+    rb_define_module_function(rb_mListener, "direction", Listener_direction, 0);
+    rb_define_module_function(rb_mListener, "direction=", Listener_set_direction, 1);
+    rb_define_module_function(rb_mListener, "velocity", Listener_velocity, 0);
+    rb_define_module_function(rb_mListener, "velocity=", Listener_set_velocity, 1);
+    rb_define_module_function(rb_mListener, "up_vector", Listener_up_vector, 0);
+    rb_define_module_function(rb_mListener, "up_vector=", Listener_set_up_vector, 1);
+    rb_define_module_function(rb_mListener, "cone", Listener_cone, 0);
+    rb_define_module_function(rb_mListener, "cone=", Listener_set_cone, 1);
+}

data/ext/audio/listener.h

@@ -0,0 +1,8 @@
+#ifndef SFML_RB_AUDIO_LISTENER_H
+#define SFML_RB_AUDIO_LISTENER_H
+
+#include <ruby.h>
+
+void Init_Listener(VALUE rb_module);
+
+#endif //SFML_RB_AUDIO_LISTENER_H

data/ext/audio/music.c

@@ -0,0 +1,174 @@
+#include "audio/music.h"
+
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <stdlib.h>
+
+#include "audio/audio_enums.h"
+#include "audio/effect_processor.h"
+#include "audio/sound_source.h"
+#include "core/exceptions.h"
+#include "system/input_stream.h"
+#include "system/time.h"
+
+typedef struct {
+    SoundSource source;
+    /* Music streams from the InputStream lazily, so unlike Font/Image/Shader
+       the stream has to outlive the create call. The VALUE is both marked and
+       registered as a GC root: the root is what guarantees the InputStream's
+       sfInputStream is still alive when sfMusic_destroy runs in dfree, even if
+       the Music and the stream become unreachable in the same GC cycle. */
+    VALUE rb_stream;
+} Music;
+
+static VALUE rb_cMusic;
+
+static void Music_mark(void* ptr) {
+    Music* music = ptr;
+
+    rb_gc_mark(music->rb_stream);
+}
+
+/* sfMusic_destroy() calls Music::~Music(), which explicitly calls stop() and
+   can block waiting on the audio thread; release the GVL for the same reason
+   as Sound_free/SS_METHOD(stop). */
+static void* Music_destroy_without_gvl(void* handle) {
+    sfMusic_destroy(handle);
+    return NULL;
+}
+
+static void Music_free(void* ptr) {
+    Music* music = ptr;
+
+    effect_processor_release(music->source.effect_slot);
+    rb_thread_call_without_gvl(Music_destroy_without_gvl, music->source.handle, RUBY_UBF_IO, NULL);
+    rb_gc_unregister_address(&music->rb_stream);
+    free(music);
+}
+
+static const rb_data_type_t Music_data_type = {
+    .wrap_struct_name = "SFML::Music",
+    .function = {.dmark = Music_mark, .dfree = Music_free, .dsize = NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+static VALUE Music_wrap(VALUE klass, sfMusic* handle, VALUE rb_stream) {
+    Music* ptr;
+
+    if (handle == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create music");
+    }
+
+    ptr = malloc(sizeof(Music));
+    ptr->source.handle = handle;
+    ptr->source.effect_slot = -1;
+    ptr->rb_stream = rb_stream;
+
+    rb_gc_register_address(&ptr->rb_stream);
+
+    return TypedData_Wrap_Struct(klass, &Music_data_type, ptr);
+}
+
+static VALUE Music_from_file(VALUE klass, VALUE rb_path) {
+    return Music_wrap(klass, sfMusic_createFromFile(StringValueCStr(rb_path)), Qnil);
+}
+
+static VALUE Music_from_memory(VALUE klass, VALUE rb_data) {
+    StringValue(rb_data);
+
+    return Music_wrap(
+        klass, sfMusic_createFromMemory(RSTRING_PTR(rb_data), (size_t)RSTRING_LEN(rb_data)), Qnil);
+}
+
+static VALUE Music_from_stream(VALUE klass, VALUE rb_stream) {
+    VALUE holder = Qnil;
+    sfInputStream* stream = input_stream_from_rb(rb_stream, &holder);
+
+    return Music_wrap(klass, sfMusic_createFromStream(stream), holder);
+}
+
+static VALUE Music_duration(VALUE self) {
+    return time_to_rb(sfMusic_getDuration(Get_Music_Struct(self)));
+}
+
+static VALUE Music_channel_count(VALUE self) {
+    return UINT2NUM(sfMusic_getChannelCount(Get_Music_Struct(self)));
+}
+
+static VALUE Music_sample_rate(VALUE self) {
+    return UINT2NUM(sfMusic_getSampleRate(Get_Music_Struct(self)));
+}
+
+static VALUE Music_channel_map(VALUE self) {
+    size_t count = 0;
+    const sfSoundChannel* map = sfMusic_getChannelMap(Get_Music_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;
+}
+
+/* Loop points are an offset plus a length, matching sfTimeSpan. Returned as a
+   two-element [offset, length] pair of SFML::Time. */
+static VALUE Music_loop_points(VALUE self) {
+    sfTimeSpan span = sfMusic_getLoopPoints(Get_Music_Struct(self));
+
+    return rb_ary_new_from_args(2, time_to_rb(span.offset), time_to_rb(span.length));
+}
+
+static VALUE Music_set_loop_points(VALUE self, VALUE rb_span) {
+    sfTimeSpan span;
+
+    if (!RB_TYPE_P(rb_span, T_ARRAY) || RARRAY_LEN(rb_span) != 2) {
+        rb_raise(rb_eArgError, "loop points must be a two-element [offset, length] array");
+    }
+
+    span.offset = time_from_rb(rb_ary_entry(rb_span, 0));
+    span.length = time_from_rb(rb_ary_entry(rb_span, 1));
+
+    sfMusic_setLoopPoints(Get_Music_Struct(self), span);
+
+    return rb_span;
+}
+
+#define SS_FN(name) sfMusic_##name
+#define SS_METHOD(name) Music_##name
+#include "audio/sound_source.inc"
+#undef SS_FN
+#undef SS_METHOD
+
+void Init_Music(VALUE rb_module) {
+    rb_cMusic = rb_define_class_under(rb_module, "Music", rb_cObject);
+
+    rb_define_singleton_method(rb_cMusic, "from_file", Music_from_file, 1);
+    rb_define_singleton_method(rb_cMusic, "from_memory", Music_from_memory, 1);
+    rb_define_singleton_method(rb_cMusic, "from_stream", Music_from_stream, 1);
+
+    rb_define_method(rb_cMusic, "duration", Music_duration, 0);
+    rb_define_method(rb_cMusic, "channel_count", Music_channel_count, 0);
+    rb_define_method(rb_cMusic, "sample_rate", Music_sample_rate, 0);
+    rb_define_method(rb_cMusic, "channel_map", Music_channel_map, 0);
+    rb_define_method(rb_cMusic, "loop_points", Music_loop_points, 0);
+    rb_define_method(rb_cMusic, "loop_points=", Music_set_loop_points, 1);
+
+    Music_define_sound_source_methods(rb_cMusic);
+}
+
+VALUE Get_Klass_Music(void) {
+    return rb_cMusic;
+}
+
+void* Get_Music_Struct(VALUE self) {
+    Music* ptr;
+    TypedData_Get_Struct(self, Music, &Music_data_type, ptr);
+    return ptr->source.handle;
+}

data/ext/audio/music.h

@@ -0,0 +1,14 @@
+#ifndef SFML_RB_AUDIO_MUSIC_H
+#define SFML_RB_AUDIO_MUSIC_H
+
+#include <ruby.h>
+
+#include "core/sfml.h"
+
+void Init_Music(VALUE rb_module);
+
+VALUE Get_Klass_Music(void);
+
+void *Get_Music_Struct(VALUE self);
+
+#endif //SFML_RB_AUDIO_MUSIC_H