ruby-audio 1.5.0-x86-mingw32

data/ext/rubyaudio_ext/extconf.rb

@@ -0,0 +1,32 @@
+require 'mkmf'
+
+$CFLAGS.gsub!("-arch i386", "")
+$LDFLAGS.gsub!("-arch i386", "")
+
+dir_config('sndfile')
+
+# Mega-Nerd windows installer installs as libsndfile-1.dll
+if RUBY_PLATFORM =~ /(mswin|mingw|cygwin)/
+  sndfile_lib = 'sndfile-1'
+else
+  sndfile_lib = 'sndfile'
+end
+
+INCLUDE_DIRS = ['/opt/local/include', '/usr/local/include', 'C:/Program Files/Mega-Nerd/libsndfile/include', 'C:/Program Files (x86)/Mega-Nerd/libsndfile/include']
+LIB_DIRS = ['/opt/local/lib', '/usr/local/lib', 'C:/Program Files/Mega-Nerd/libsndfile', 'C:/Program Files (x86)/Mega-Nerd/libsndfile']
+
+# libsndfile requirements
+find_header 'sndfile.h', *INCLUDE_DIRS
+unless ['sndfile-1', 'sndfile'].any? {|lib| find_library lib, 'sf_open', *LIB_DIRS}
+  fail <<-EOM
+  Can't find libsndfile (http://www.mega-nerd.com/libsndfile/)
+
+  Try passing --with-sndfile-dir or --with-sndfile-lib and --with-sndfile-include
+  options to extconf. If there are spaces in the path on windows, it may not work.
+  EOM
+end
+
+# Check for format support
+have_const('SF_FORMAT_OGG', 'sndfile.h')
+
+create_makefile 'rubyaudio_ext'

data/ext/rubyaudio_ext/ra_buffer.c

@@ -0,0 +1,315 @@
+#include "ra_buffer.h"
+
+ID ra_short_sym, ra_int_sym, ra_float_sym, ra_double_sym;
+extern VALUE eRubyAudioError;
+
+// Before RFLOAT_VALUE, value was in a different place in the struct
+#ifndef RFLOAT_VALUE
+#define RFLOAT_VALUE(v) (RFLOAT(v)->value)
+#endif
+
+/*
+ * Class <code>CBuffer</code> is a very light wrapper around a standard C array
+ * that can be read from and written to by libsndfile.
+ */
+void Init_ra_buffer() {
+    VALUE mRubyAudio = rb_define_module("RubyAudio");
+    VALUE cRABuffer = rb_define_class_under(mRubyAudio, "CBuffer", rb_cObject);
+    rb_define_alloc_func(cRABuffer, ra_buffer_allocate);
+    rb_define_method(cRABuffer, "initialize",      ra_buffer_init, -1);
+    rb_define_method(cRABuffer, "initialize_copy", ra_buffer_init_copy, 1);
+    rb_define_method(cRABuffer, "channels",        ra_buffer_channels, 0);
+    rb_define_method(cRABuffer, "size",            ra_buffer_size, 0);
+    rb_define_method(cRABuffer, "real_size",       ra_buffer_real_size, 0);
+    rb_define_method(cRABuffer, "real_size=",      ra_buffer_real_size_set, 1);
+    rb_define_method(cRABuffer, "type",            ra_buffer_type, 0);
+    rb_define_method(cRABuffer, "[]",              ra_buffer_aref, 1);
+    rb_define_method(cRABuffer, "[]=",             ra_buffer_aset, 2);
+
+    ra_short_sym = rb_intern("short");
+    ra_int_sym = rb_intern("int");
+    ra_float_sym = rb_intern("float");
+    ra_double_sym = rb_intern("double");
+}
+
+static VALUE ra_buffer_allocate(VALUE klass) {
+    RA_BUFFER *buf = ALLOC(RA_BUFFER);
+    memset(buf, 0, sizeof(RA_BUFFER));
+    VALUE self = Data_Wrap_Struct(klass, NULL, ra_buffer_free, buf);
+    return self;
+}
+
+static void ra_buffer_free(RA_BUFFER *buf) {
+    if(buf->data != NULL) xfree(buf->data);
+    xfree(buf);
+}
+
+/*
+ * Uses size, channels, and type to allocate a properly sized array and set data
+ * to the pointer for that data. Returns size.
+ */
+static long ra_buffer_alloc_data(RA_BUFFER *buf) {
+    long size = 0;
+    switch(buf->type) {
+        case RA_BUFFER_TYPE_SHORT:
+            size = sizeof(short) * buf->size * buf->channels;
+            break;
+        case RA_BUFFER_TYPE_INT:
+            size = sizeof(int) * buf->size * buf->channels;
+            break;
+        case RA_BUFFER_TYPE_FLOAT:
+            size = sizeof(float) * buf->size * buf->channels;
+            break;
+        case RA_BUFFER_TYPE_DOUBLE:
+            size = sizeof(double) * buf->size * buf->channels;
+            break;
+    }
+    buf->data = (void*)xmalloc(size);
+    return size;
+}
+
+/*
+ * call-seq:
+ *   RubyAudio::CBuffer.new(type, size, channels=1) => buf
+ *
+ * Returns a new <code>CBuffer</code> object which can contain the given number
+ * of audio frames of the given data type.
+ *
+ *   buf = RubyAudio::CBuffer.new("float", 1000)
+ */
+static VALUE ra_buffer_init(int argc, VALUE *argv, VALUE self) {
+    RA_BUFFER *buf;
+    Data_Get_Struct(self, RA_BUFFER, buf);
+
+    // Check args
+    if(argc < 2) rb_raise(rb_eArgError, "At least 2 arguments required");
+
+    // Get type of object
+    const char *buf_type;
+    switch(TYPE(argv[0])) {
+        case T_SYMBOL:
+            buf_type = rb_id2name(SYM2ID(argv[0]));
+            if(!buf_type) rb_raise(rb_eArgError, "bad type");
+            break;
+        case T_STRING:
+            buf_type = RSTRING_PTR(argv[0]);
+            break;
+        default:
+            rb_raise(rb_eArgError, "bad type");
+            break;
+    }
+
+    // Populate channels
+    buf->channels = (argc == 3) ? FIX2INT(argv[2]) : 1;
+
+    // Allocate data array based on type
+    buf->size = FIX2LONG(argv[1]);
+    buf->real_size = 0;
+    if(strcmp(buf_type, "short") == 0) buf->type = RA_BUFFER_TYPE_SHORT;
+    else if(strcmp(buf_type, "int") == 0) buf->type = RA_BUFFER_TYPE_INT;
+    else if(strcmp(buf_type, "float") == 0) buf->type = RA_BUFFER_TYPE_FLOAT;
+    else if(strcmp(buf_type, "double") == 0) buf->type = RA_BUFFER_TYPE_DOUBLE;
+    else rb_raise(rb_eArgError, "Invalid type: %s", buf_type);
+    ra_buffer_alloc_data(buf);
+
+    // Return self
+    return self;
+}
+
+/* :nodoc: */
+static VALUE ra_buffer_init_copy(VALUE copy, VALUE buf) {
+    if (copy == buf) return copy;
+
+    // Checks
+    rb_check_frozen(copy);
+    if (!rb_obj_is_instance_of(buf, rb_obj_class(copy))) {
+        rb_raise(rb_eTypeError, "wrong argument class");
+    }
+
+    RA_BUFFER *copy_struct, *buf_struct;
+    Data_Get_Struct(copy, RA_BUFFER, copy_struct);
+    Data_Get_Struct(buf, RA_BUFFER, buf_struct);
+
+    // Clone data
+    memcpy(copy_struct, buf_struct, sizeof(RA_BUFFER));
+    long size = ra_buffer_alloc_data(copy_struct);
+    memcpy(copy_struct->data, buf_struct->data, size);
+
+    return copy;
+}
+
+/*
+ * call-seq:
+ *   buf.channels => integer
+ *
+ * Returns the number of channels in a frame of the buffer.
+ */
+static VALUE ra_buffer_channels(VALUE self) {
+    RA_BUFFER *buf;
+    Data_Get_Struct(self, RA_BUFFER, buf);
+    return INT2FIX(buf->channels);
+}
+
+/*
+ * call-seq:
+ *   buf.size => integer
+ *
+ * Returns the number of frames the buffer can store.
+ */
+static VALUE ra_buffer_size(VALUE self) {
+    RA_BUFFER *buf;
+    Data_Get_Struct(self, RA_BUFFER, buf);
+    return LONG2FIX(buf->size);
+}
+
+/*
+ * call-seq:
+ *   buf.real_size => integer
+ *
+ * Returns the number of frames of actual data are currently stored in the
+ * buffer.
+ */
+static VALUE ra_buffer_real_size(VALUE self) {
+    RA_BUFFER *buf;
+    Data_Get_Struct(self, RA_BUFFER, buf);
+    return LONG2FIX(buf->real_size);
+}
+
+/*:nodoc:*/
+static VALUE ra_buffer_real_size_set(VALUE self, VALUE real_size) {
+    RA_BUFFER *buf;
+    Data_Get_Struct(self, RA_BUFFER, buf);
+
+    long new_real_size = FIX2LONG(real_size);
+    if(new_real_size > buf->size) {
+        buf->real_size = buf->size;
+    } else if(new_real_size < 0) {
+        buf->real_size = 0;
+    } else {
+        buf->real_size = new_real_size;
+    }
+
+    return LONG2FIX(buf->real_size);
+}
+
+/*
+ * call-seq:
+ *   buf.type => symbol
+ *
+ * Returns the type of audio data being stored. <code>:short</code>,
+ * <code>:int</code>, <code>:float</code>, or <code>:double</code>.
+ */
+static VALUE ra_buffer_type(VALUE self) {
+    RA_BUFFER *buf;
+    Data_Get_Struct(self, RA_BUFFER, buf);
+    switch(buf->type) {
+        case RA_BUFFER_TYPE_SHORT: return ID2SYM(ra_short_sym);
+        case RA_BUFFER_TYPE_INT: return ID2SYM(ra_int_sym);
+        case RA_BUFFER_TYPE_FLOAT: return ID2SYM(ra_float_sym);
+        case RA_BUFFER_TYPE_DOUBLE: return ID2SYM(ra_double_sym);
+    }
+}
+
+/*
+ * call-seq:
+ *   buf[integer] => frame
+ *
+ * Returns a frame of audio data at the given offset.
+ *
+ *   buf = snd.read(:float, 100)     # Mono sound
+ *   buf[5]                          #=> 0.4
+ *
+ *   buf2 = snd2.read(:float, 100)   # Stereo sound
+ *   buf[5]                          #=> [0.4, 0.3]
+ */
+static VALUE ra_buffer_aref(VALUE self, VALUE index) {
+    RA_BUFFER *buf;
+    Data_Get_Struct(self, RA_BUFFER, buf);
+
+    // Bounds check
+    long f = FIX2LONG(index);
+    if(f < 0 || f >= buf->real_size) return Qnil;
+    long i = f * buf->channels;
+
+    if(buf->channels == 1) {
+        return ra_buffer_index_get(buf, i);
+    } else {
+        VALUE frame = rb_ary_new();
+        long j;
+        for(j = 0; j < buf->channels; j++) {
+            rb_ary_push(frame, ra_buffer_index_get(buf, i+j));
+        }
+        return frame;
+    }
+}
+
+static VALUE ra_buffer_index_get(RA_BUFFER *buf, long i) {
+    switch(buf->type) {
+        case RA_BUFFER_TYPE_SHORT: return INT2FIX((int)((short*)buf->data)[i]);
+        case RA_BUFFER_TYPE_INT: return INT2FIX(((int*)buf->data)[i]);
+        case RA_BUFFER_TYPE_FLOAT: return rb_float_new((double)((float*)buf->data)[i]);
+        case RA_BUFFER_TYPE_DOUBLE: return rb_float_new(((double*)buf->data)[i]);
+    }
+}
+
+/*
+ * call-seq:
+ *   buf[integer] = numeric => numeric
+ *   buf[integer] = array => array
+ *
+ * Sets the frame of audio data at the given offset to the value. For
+ * multi-channel audio, pass in an array of values.
+ *
+ *   buf = RubyAudio::Buffer.int(100, 1)
+ *   buf[0] = 5
+ *
+ *   buf = RubyAudio::Buffer.double(100, 2)
+ *   buf[0] = [0.5, 0.3]
+ */
+static VALUE ra_buffer_aset(VALUE self, VALUE index, VALUE val) {
+    RA_BUFFER *buf;
+    Data_Get_Struct(self, RA_BUFFER, buf);
+
+    // Bounds check
+    long f = FIX2LONG(index);
+    if(f < 0 || f >= buf->size) rb_raise(eRubyAudioError, "setting frame out of bounds");
+    long i = f * buf->channels;
+
+    // Set data
+    if(buf->channels == 1) {
+        ra_buffer_index_set(buf, i, val);
+    } else {
+        if(TYPE(val) != T_ARRAY) rb_raise(eRubyAudioError, "must pass in array for multi-channel buffer");
+        long length = RARRAY_LEN(val);
+        if(length != buf->channels) rb_raise(eRubyAudioError, "array length must match channel count");
+
+        long j;
+        for(j = 0; j < length; j++) {
+            ra_buffer_index_set(buf, i+j, rb_ary_entry(val, j));
+        }
+    }
+
+    // Bump real_size
+    if(f + 1 > buf->real_size) {
+        buf->real_size = f + 1;
+    }
+
+    return val;
+}
+
+static void ra_buffer_index_set(RA_BUFFER *buf, long i, VALUE val) {
+    switch(buf->type) {
+        case RA_BUFFER_TYPE_SHORT:
+            ((short*)buf->data)[i] = (short)FIX2INT(val);
+            break;
+        case RA_BUFFER_TYPE_INT:
+            ((int*)buf->data)[i] = FIX2INT(val);
+            break;
+        case RA_BUFFER_TYPE_FLOAT:
+            ((float*)buf->data)[i] = (float)RFLOAT_VALUE(val);
+            break;
+        case RA_BUFFER_TYPE_DOUBLE:
+            ((double*)buf->data)[i] = RFLOAT_VALUE(val);
+            break;
+    }
+}

data/ext/rubyaudio_ext/ra_buffer.h

@@ -0,0 +1,40 @@
+#ifndef RA_BUFFER_H
+#define RA_BUFFER_H
+
+#include <ruby.h>
+
+typedef enum {
+    RA_BUFFER_TYPE_SHORT,
+    RA_BUFFER_TYPE_INT,
+    RA_BUFFER_TYPE_FLOAT,
+    RA_BUFFER_TYPE_DOUBLE
+} BUFFER_TYPE;
+
+typedef struct {
+    BUFFER_TYPE type;
+    void *data;
+    long size;
+    long real_size;
+    int channels;
+} RA_BUFFER;
+
+void Init_ra_buffer();
+
+/*** Initialization and Memory Manangement ***/
+static VALUE ra_buffer_allocate(VALUE klass);
+static void  ra_buffer_free(RA_BUFFER *buf);
+
+/*** Instance Methods ***/
+static VALUE ra_buffer_init(int argc, VALUE *argv, VALUE self);
+static VALUE ra_buffer_init_copy(VALUE copy, VALUE buf);
+static VALUE ra_buffer_channels(VALUE self);
+static VALUE ra_buffer_size(VALUE self);
+static VALUE ra_buffer_real_size(VALUE self);
+static VALUE ra_buffer_real_size_set(VALUE self, VALUE new_real_size);
+static VALUE ra_buffer_type(VALUE self);
+static VALUE ra_buffer_aref(VALUE self, VALUE index);
+static VALUE ra_buffer_index_get(RA_BUFFER *buf, long i);
+static VALUE ra_buffer_aset(VALUE self, VALUE index, VALUE val);
+static void ra_buffer_index_set(RA_BUFFER *buf, long i, VALUE val);
+
+#endif        //  #ifndef RA_BUFFER_H

data/ext/rubyaudio_ext/ra_sound.c

@@ -0,0 +1,506 @@
+#include "ra_sound.h"
+
+extern VALUE eRubyAudioError;
+
+/*
+ * Class <code>CSound</code> is a very light wrapper around the
+ * <code>SNDFILE</code> struct exposed by libsndfile.
+ */
+void Init_ra_sound() {
+    VALUE mRubyAudio = rb_define_module("RubyAudio");
+    VALUE cRASound = rb_define_class_under(mRubyAudio, "CSound", rb_cObject);
+    rb_define_alloc_func(cRASound, ra_sound_allocate);
+    rb_define_singleton_method(cRASound, "open", ra_sound_s_open, -1);
+    rb_define_method(cRASound, "initialize", ra_sound_init, 3);
+    rb_define_method(cRASound, "info", ra_sound_info, 0);
+    rb_define_method(cRASound, "seek", ra_sound_seek, 2);
+    rb_define_method(cRASound, "read", ra_sound_read, 2);
+    rb_define_method(cRASound, "write", ra_sound_write, 1);
+    rb_define_method(cRASound, "<<", ra_sound_addbuf, 1);
+    rb_define_method(cRASound, "close", ra_sound_close, 0);
+    rb_define_method(cRASound, "closed?", ra_sound_closed, 0);
+}
+
+static VALUE ra_sound_allocate(VALUE klass) {
+    RA_SOUND *snd = ALLOC(RA_SOUND);
+    memset(snd, 0, sizeof(RA_SOUND));
+    VALUE self = Data_Wrap_Struct(klass, ra_sound_mark, ra_sound_free, snd);
+    return self;
+}
+
+static void ra_sound_mark(RA_SOUND *snd) {
+    if(snd) {
+        rb_gc_mark(snd->info);
+    }
+}
+
+static void ra_sound_free(RA_SOUND *snd) {
+    if(!snd->closed && snd->snd != NULL) sf_close(snd->snd);
+    xfree(snd);
+}
+
+/*
+ * call-seq:
+ *   CSound.open(...)                => snd
+ *   CSound.open(...) {|snd| block } => obj
+ *
+ * With no associated block, <code>open</code> is a synonym for
+ * <code>CSound.new</code>. If the optional code block is given, it will be
+ * passed <i>snd</i> as an argument, and the CSound object will automatically be
+ * closed when the block terminates. In this instance, <code>CSound.open</code>
+ * returns the value of the block.
+ */
+static VALUE ra_sound_s_open(int argc, VALUE *argv, VALUE klass) {
+    VALUE obj = rb_class_new_instance(argc, argv, klass);
+    if(!rb_block_given_p()) return obj;
+    return rb_ensure(rb_yield, obj, ra_sound_close_safe, obj);
+}
+
+/*
+ * call-seq:
+ *   CSound.new(path, mode, info) => snd
+ *
+ * Returns a new <code>CSound</code> object for the audio file at the given path
+ * with the given mode. Valid modes are <code>"r"</code>, <code>"w"</code>, or
+ * <code>"rw"</code>.
+ */
+static VALUE ra_sound_init(VALUE self, VALUE path, VALUE mode, VALUE info) {
+    RA_SOUND *snd;
+    Data_Get_Struct(self, RA_SOUND, snd);
+
+    // Get mode
+    const char *m = StringValueCStr(mode);
+    if(strcmp(m,      "rw") == 0) snd->mode = SFM_RDWR;
+    else if(strcmp(m, "r") == 0)  snd->mode = SFM_READ;
+    else if(strcmp(m, "w") == 0)  snd->mode = SFM_WRITE;
+    else rb_raise(rb_eArgError, "invalid access mode %s", m);
+
+    // Set info
+    snd->info = info;
+
+    // Open sound file
+    const char *p = StringValueCStr(path);
+    SF_INFO *sf_info;
+    Data_Get_Struct(info, SF_INFO, sf_info);
+    snd->snd = sf_open(p, snd->mode, sf_info);
+    if(snd->snd == NULL) rb_raise(eRubyAudioError, sf_strerror(snd->snd));
+    snd->closed = 0;
+
+    return self;
+}
+
+/*
+ * call-seq:
+ *   snd.info => CSoundInfo
+ *
+ * Returns the info object associated with the sound.
+ */
+static VALUE ra_sound_info(VALUE self) {
+    RA_SOUND *snd;
+    Data_Get_Struct(self, RA_SOUND, snd);
+    return snd->info;
+}
+
+/*
+ * call-seq:
+ *   snd.seek(frames, whence) => 0
+ *
+ * Seeks to a given offset <i>anInteger</i> in the sound according to the value
+ * of <i>whence</i>:
+ *
+ *   IO::SEEK_CUR  | Seeks to _frames_ plus current position
+ *   --------------+----------------------------------------------------
+ *   IO::SEEK_END  | Seeks to _frames_ plus end of stream (you probably
+ *                 | want a negative value for _frames_)
+ *   --------------+----------------------------------------------------
+ *   IO::SEEK_SET  | Seeks to the absolute location given by _frames_
+ */
+static VALUE ra_sound_seek(VALUE self, VALUE frames, VALUE whence) {
+    RA_SOUND *snd;
+    Data_Get_Struct(self, RA_SOUND, snd);
+    if(snd->closed) rb_raise(eRubyAudioError, "closed sound");
+
+    if(sf_seek(snd->snd, (sf_count_t)NUM2OFFT(frames), FIX2INT(whence)) == -1) {
+        rb_raise(eRubyAudioError, "invalid seek");
+    }
+
+    return INT2FIX(0);
+}
+
+static void ra_sound_read_short(RA_SOUND *snd, RA_BUFFER *buf, sf_count_t frames) {
+    static short temp[1024];
+    int temp_len = 1024;
+    short *data = (short*)buf->data;
+    short mix_sum;
+
+    // Get info struct
+    SF_INFO *info;
+    Data_Get_Struct(snd->info, SF_INFO, info);
+
+    // Up/Downmix based on channel matching
+    sf_count_t read = 0, r, amount;
+    int i, k;
+    if(buf->channels == info->channels) { // Simply read data without mix
+        read = sf_readf_short(snd->snd, data, frames);
+    } else if(buf->channels == 1) { // Downmix to mono
+        sf_count_t max = temp_len / info->channels;
+        int channels;
+
+        while(read < frames) {
+            // Calculate # of frames to read
+            amount = frames - read;
+            if(amount > max) amount = max;
+
+            r = sf_readf_short(snd->snd, temp, amount);
+            if(r == 0) break;
+
+            // Mix channels together by averaging all channels and store to buffer
+            for(i = 0; i < r; i++) {
+                mix_sum = 0;
+                for(k = 0; k < info->channels; k++) mix_sum += temp[i * info->channels + k];
+                data[read] = mix_sum/info->channels;
+                read++;
+            }
+        }
+    } else if(info->channels == 1) { // Upmix from mono by copying channel
+        while(read < frames) {
+            // Calculate # of frames to read
+            amount = frames - read;
+            if(amount > temp_len) amount = temp_len;
+
+            r = sf_readf_short(snd->snd, temp, amount);
+            if(r == 0) break;
+
+            // Write every frame channel times to the buffer
+            for(i = 0; i < r; i++) {
+                for(k = 0; k < buf->channels; k++) {
+                    data[read * buf->channels + k] = temp[i];
+                }
+                read++;
+            }
+        }
+    } else {
+        rb_raise(eRubyAudioError, "unsupported mix from %d to %d", buf->channels, info->channels);
+    }
+
+    buf->real_size = read;
+}
+
+static void ra_sound_read_int(RA_SOUND *snd, RA_BUFFER *buf, sf_count_t frames) {
+    static int temp[1024];
+    int temp_len = 1024;
+    int *data = (int*)buf->data;
+    int mix_sum;
+
+    // Get info struct
+    SF_INFO *info;
+    Data_Get_Struct(snd->info, SF_INFO, info);
+
+    // Up/Downmix based on channel matching
+    sf_count_t read = 0, r, amount;
+    int i, k;
+    if(buf->channels == info->channels) { // Simply read data without mix
+        read = sf_readf_int(snd->snd, data, frames);
+    } else if(buf->channels == 1) { // Downmix to mono
+        sf_count_t max = temp_len / info->channels;
+        int channels;
+
+        while(read < frames) {
+            // Calculate # of frames to read
+            amount = frames - read;
+            if(amount > max) amount = max;
+
+            r = sf_readf_int(snd->snd, temp, amount);
+            if(r == 0) break;
+
+            // Mix channels together by averaging all channels and store to buffer
+            for(i = 0; i < r; i++) {
+                mix_sum = 0;
+                for(k = 0; k < info->channels; k++) mix_sum += temp[i * info->channels + k];
+                data[read] = mix_sum/info->channels;
+                read++;
+            }
+        }
+    } else if(info->channels == 1) { // Upmix from mono by copying channel
+        while(read < frames) {
+            // Calculate # of frames to read
+            amount = frames - read;
+            if(amount > temp_len) amount = temp_len;
+
+            r = sf_readf_int(snd->snd, temp, amount);
+            if(r == 0) break;
+
+            // Write every frame channel times to the buffer
+            for(i = 0; i < r; i++) {
+                for(k = 0; k < buf->channels; k++) {
+                    data[read * buf->channels + k] = temp[i];
+                }
+                read++;
+            }
+        }
+    } else {
+        rb_raise(eRubyAudioError, "unsupported mix from %d to %d", buf->channels, info->channels);
+    }
+
+    buf->real_size = read;
+}
+
+static void ra_sound_read_float(RA_SOUND *snd, RA_BUFFER *buf, sf_count_t frames) {
+    static float temp[1024];
+    int temp_len = 1024;
+    float *data = (float*)buf->data;
+    float mix_sum;
+
+    // Get info struct
+    SF_INFO *info;
+    Data_Get_Struct(snd->info, SF_INFO, info);
+
+    // Up/Downmix based on channel matching
+    sf_count_t read = 0, r, amount;
+    int i, k;
+    if(buf->channels == info->channels) { // Simply read data without mix
+        read = sf_readf_float(snd->snd, data, frames);
+    } else if(buf->channels == 1) { // Downmix to mono
+        sf_count_t max = temp_len / info->channels;
+        int channels;
+
+        while(read < frames) {
+            // Calculate # of frames to read
+            amount = frames - read;
+            if(amount > max) amount = max;
+
+            r = sf_readf_float(snd->snd, temp, amount);
+            if(r == 0) break;
+
+            // Mix channels together by averaging all channels and store to buffer
+            for(i = 0; i < r; i++) {
+                mix_sum = 0;
+                for(k = 0; k < info->channels; k++) mix_sum += temp[i * info->channels + k];
+                data[read] = mix_sum/info->channels;
+                read++;
+            }
+        }
+    } else if(info->channels == 1) { // Upmix from mono by copying channel
+        while(read < frames) {
+            // Calculate # of frames to read
+            amount = frames - read;
+            if(amount > temp_len) amount = temp_len;
+
+            r = sf_readf_float(snd->snd, temp, amount);
+            if(r == 0) break;
+
+            // Write every frame channel times to the buffer
+            for(i = 0; i < r; i++) {
+                for(k = 0; k < buf->channels; k++) {
+                    data[read * buf->channels + k] = temp[i];
+                }
+                read++;
+            }
+        }
+    } else {
+        rb_raise(eRubyAudioError, "unsupported mix from %d to %d", buf->channels, info->channels);
+    }
+
+    buf->real_size = read;
+}
+
+static void ra_sound_read_double(RA_SOUND *snd, RA_BUFFER *buf, sf_count_t frames) {
+    static double temp[1024];
+    int temp_len = 1024;
+    double *data = (double*)buf->data;
+    double mix_sum;
+
+    // Get info struct
+    SF_INFO *info;
+    Data_Get_Struct(snd->info, SF_INFO, info);
+
+    // Up/Downmix based on channel matching
+    sf_count_t read = 0, r, amount;
+    int i, k;
+    if(buf->channels == info->channels) { // Simply read data without mix
+        read = sf_readf_double(snd->snd, data, frames);
+    } else if(buf->channels == 1) { // Downmix to mono
+        sf_count_t max = temp_len / info->channels;
+        int channels;
+
+        while(read < frames) {
+            // Calculate # of frames to read
+            amount = frames - read;
+            if(amount > max) amount = max;
+
+            r = sf_readf_double(snd->snd, temp, amount);
+            if(r == 0) break;
+
+            // Mix channels together by averaging all channels and store to buffer
+            for(i = 0; i < r; i++) {
+                mix_sum = 0;
+                for(k = 0; k < info->channels; k++) mix_sum += temp[i * info->channels + k];
+                data[read] = mix_sum/info->channels;
+                read++;
+            }
+        }
+    } else if(info->channels == 1) { // Upmix from mono by copying channel
+        while(read < frames) {
+            // Calculate # of frames to read
+            amount = frames - read;
+            if(amount > temp_len) amount = temp_len;
+
+            r = sf_readf_double(snd->snd, temp, amount);
+            if(r == 0) break;
+
+            // Write every frame channel times to the buffer
+            for(i = 0; i < r; i++) {
+                for(k = 0; k < buf->channels; k++) {
+                    data[read * buf->channels + k] = temp[i];
+                }
+                read++;
+            }
+        }
+    } else {
+        rb_raise(eRubyAudioError, "unsupported mix from %d to %d", buf->channels, info->channels);
+    }
+
+    buf->real_size = read;
+}
+
+/*
+ * call-seq:
+ *   snd.read(buf, frames) => integer
+ *
+ * Tries to read the given number of frames into the buffer and returns the
+ * number of frames actually read.
+ */
+static VALUE ra_sound_read(VALUE self, VALUE buf, VALUE frames) {
+    RA_SOUND *snd;
+    Data_Get_Struct(self, RA_SOUND, snd);
+    if(snd->closed) rb_raise(eRubyAudioError, "closed sound");
+
+    // Get buffer struct
+    RA_BUFFER *b;
+    Data_Get_Struct(buf, RA_BUFFER, b);
+
+    // Double-check frame count against buffer size
+    sf_count_t f = (sf_count_t)NUM2OFFT(frames);
+    if(f < 0 || f > b->size) {
+        rb_raise(eRubyAudioError, "frame count invalid");
+    }
+
+    // Shortcut for 0 frame reads
+    if(f == 0) {
+        b->real_size = 0;
+        return INT2FIX(b->real_size);;
+    }
+
+    // Read based on type
+    switch(b->type) {
+        case RA_BUFFER_TYPE_SHORT:
+            ra_sound_read_short(snd, b, f);
+            break;
+        case RA_BUFFER_TYPE_INT:
+            ra_sound_read_int(snd, b, f);
+            break;
+        case RA_BUFFER_TYPE_FLOAT:
+            ra_sound_read_float(snd, b, f);
+            break;
+        case RA_BUFFER_TYPE_DOUBLE:
+            ra_sound_read_double(snd, b, f);
+            break;
+    }
+
+    // Return read
+    return INT2FIX(b->real_size);
+}
+
+/*
+ * call-seq:
+ *   snd.write(buf) => integer
+ *
+ * Writes the entire contents of the given buffer to the sound and returns the
+ * number of frames written.
+ */
+static VALUE ra_sound_write(VALUE self, VALUE buf) {
+    RA_SOUND *snd;
+    Data_Get_Struct(self, RA_SOUND, snd);
+    if(snd->closed) rb_raise(eRubyAudioError, "closed sound");
+
+    // Get buffer struct
+    RA_BUFFER *b;
+    Data_Get_Struct(buf, RA_BUFFER, b);
+
+    // Get info struct
+    SF_INFO *info;
+    Data_Get_Struct(snd->info, SF_INFO, info);
+
+    // Check buffer channels matches actual channels
+    if(b->channels != info->channels) {
+        rb_raise(eRubyAudioError, "channel count mismatch: %d vs %d", b->channels, info->channels);
+    }
+
+    // Write data
+    sf_count_t written = 0;
+    switch(b->type) {
+        case RA_BUFFER_TYPE_SHORT:
+            written = sf_writef_short(snd->snd, b->data, b->real_size);
+            break;
+        case RA_BUFFER_TYPE_INT:
+            written = sf_writef_int(snd->snd, b->data, b->real_size);
+            break;
+        case RA_BUFFER_TYPE_FLOAT:
+            written = sf_writef_float(snd->snd, b->data, b->real_size);
+            break;
+        case RA_BUFFER_TYPE_DOUBLE:
+            written = sf_writef_double(snd->snd, b->data, b->real_size);
+            break;
+    }
+
+    return OFFT2NUM(written);
+}
+
+/*
+ * call-seq:
+ *   snd << buf => snd
+ *
+ * Writes the given buffer to the string.
+ *
+ *   snd << buf1 << buf2
+ */
+static VALUE ra_sound_addbuf(VALUE self, VALUE buf) {
+    ra_sound_write(self, buf);
+    return self;
+}
+
+/*
+ * call-seq:
+ *   snd.close => nil
+ *
+ * Closes <i>snd</i> and frees up all memory associated with the sound. The
+ * sound is unavailable for any further data operations; an error is raised if
+ * such an attempt is made. Sounds are automatically closed when they are claimed
+ * by the garbage collector.
+ */
+static VALUE ra_sound_close(VALUE self) {
+    RA_SOUND *snd;
+    Data_Get_Struct(self, RA_SOUND, snd);
+    if(snd->closed) rb_raise(eRubyAudioError, "closed sound");
+
+    sf_close(snd->snd);
+    snd->snd = NULL;
+    snd->closed = 1;
+    return Qnil;
+}
+
+static VALUE ra_sound_close_safe(VALUE self) {
+    return rb_rescue(ra_sound_close, self, 0, 0);
+}
+
+/*
+ * call-seq:
+ *   snd.closed? => true or false
+ *
+ * Whether or not the current sound is closed to further operations.
+ */
+static VALUE ra_sound_closed(VALUE self) {
+    RA_SOUND *snd;
+    Data_Get_Struct(self, RA_SOUND, snd);
+    return snd->closed ? Qtrue : Qfalse;
+}