ruby-audio 0.2.1 → 1.0.0

data/README.rdoc

@@ -1,9 +1,11 @@
 = ruby-audio
 
-Gemified release of ruby/audio. ruby-audio wraps around libsndfile to provide
-simplified sound reading and writing support to ruby programs. The core is the
-Audio::Sound class, which is a subclass of NArray. Also provided is the
-Audio::Soundfile class, which is a wrapper around the wonderful libsndfile.
+Gemified release of ruby/audio. ruby-audio wraps around
+libsndfile[http://www.mega-nerd.com/libsndfile/] to provide simplified sound
+reading and writing support to ruby programs. The core is the RubyAudio::Sound
+class, which is a subclass of RubyAudio::CSound. RubyAudio::Buffer contains
+sound data and RubyAudio::SoundInfo contains information about the format of a
+sound file.
 
 == About This Release
 
@@ -17,11 +19,10 @@ Please contact me with any questions or comments.
 === Prerequisites
 
 - libsndfile[http://www.mega-nerd.com/libsndfile/]
-- SWIG[http://www.swig.org/]
 
 == License
 
-Copyright (C) 2010  Hans Fugal and Stephen Augenstein
+Copyright (C) 2010  Stephen Augenstein
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by

data/Rakefile

@@ -1,48 +1,41 @@
 require 'rubygems'
 require 'rake'
-require 'rake/testtask'
 require 'rake/rdoctask'
 require 'rake/gempackagetask'
+require 'spec/rake/spectask'
 
 spec = Gem::Specification.new do |s|
   s.name    = 'ruby-audio'
-  s.version = '0.2.1'
+  s.version = '1.0.0'
   s.summary = 'ruby-audio wraps around libsndfile to provide simplified sound reading and writing support to ruby programs'
-  s.authors  = ['Hans Fugal <hans@fugal.net>', 'Stephen Augenstein']
+  s.authors  = ['Stephen Augenstein']
   s.email    = 'perl.programmer@gmail.com'
   s.homepage = 'http://github.com/warhammerkid/ruby-audio'
 
-  s.platform     = Gem::Platform::RUBY
-  s.has_rdoc     = true
-  s.files        = FileList['README.rdoc', 'Rakefile', 'LICENSE', 'TODO', 'examples/**/*.rb', 'examples/**/*.wav', 'lib/**/*.rb', 'test/*.rb', 'test/*.wav', 'ext/sndfile/extconf.rb', 'ext/sndfile/sndfile.i']
-  s.require_path = 'lib'
-  s.extensions   = ["ext/sndfile/extconf.rb"]
-  s.test_files   = Dir[*['test/*.rb']]
+  s.platform      = Gem::Platform::RUBY
+  s.rdoc_options  << '--line-numbers' << '--main' << 'README.rdoc'
+  s.rdoc_options  += FileList['ext/**/*.c', 'README.rdoc']
+  s.files         = FileList['README.rdoc', 'Rakefile', 'LICENSE', 'lib/**/*.rb', 'spec/**/*.{rb,opts,wav,mp3}', 'ext/extconf.rb', 'ext/*.{c,h}']
+  s.extensions    = ["ext/extconf.rb"]
+  s.test_files    = Dir[*['spec/**/*_spec.rb']]
 
-  s.add_dependency('narray')
   s.requirements << 'libsndfile (http://www.mega-nerd.com/libsndfile/)'
-  s.requirements << 'SWIG (http://www.swig.org/)'
 end
 
 desc 'Default: Run the tests'
-task :default => :test
+task :default => :spec
 
 # Rake gem & package routines
-Rake::GemPackageTask.new spec do |pkg|
-  pkg.need_tar = true
-  pkg.need_zip = true
-end
+Rake::GemPackageTask.new(spec).define
 
 desc "Generate documentation"
 Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title    = 'ruby-audio'
-  rdoc.options << '--line-numbers' << '--main' << 'README.rdoc'
-  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.options  = spec.rdoc_options
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-desc "Run tests"
-Rake::TestTask.new do |t|
-  t.libs += ['ext/sndfile']
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', 'spec/spec.opts']
 end

data/ext/extconf.rb

@@ -0,0 +1,12 @@
+require 'mkmf'
+
+$CFLAGS = '-I/opt/local/include'
+$LDFLAGS = '-L/opt/local/lib -L/usr/local/lib'
+
+# libsndfile requirements
+unless find_library 'sndfile', 'sf_open'
+  raise 'You need to install libsndfile (http://www.mega-nerd.com/libsndfile/)'
+  exit
+end
+
+create_makefile 'rubyaudio_ext'

data/ext/ra_buffer.c

@@ -0,0 +1,277 @@
+#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, "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);
+}
+
+/*
+ * 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 = FIX2INT(argv[1]);
+    buf->real_size = 0;
+    if(strcmp(buf_type, "short") == 0) {
+        buf->type = RA_BUFFER_TYPE_SHORT;
+        buf->data = ALLOC_N(short, buf->size * buf->channels);
+    } else if(strcmp(buf_type, "int") == 0) {
+        buf->type = RA_BUFFER_TYPE_INT;
+        buf->data = ALLOC_N(int, buf->size * buf->channels);
+    } else if(strcmp(buf_type, "float") == 0) {
+        buf->type = RA_BUFFER_TYPE_FLOAT;
+        buf->data = ALLOC_N(float, buf->size * buf->channels);
+    } else if(strcmp(buf_type, "double") == 0) {
+        buf->type = RA_BUFFER_TYPE_DOUBLE;
+        buf->data = ALLOC_N(double, buf->size * buf->channels);
+    } else {
+        rb_raise(rb_eArgError, "Invalid type: %s", buf_type);
+    }
+
+    // Return self
+    return self;
+}
+
+/*
+ * 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 INT2FIX(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 INT2FIX(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);
+
+    int new_real_size = FIX2INT(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 INT2FIX(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
+    int f = FIX2INT(index);
+    if(f < 0 || f >= buf->real_size) return Qnil;
+    int i = f * buf->channels;
+
+    if(buf->channels == 1) {
+        return ra_buffer_index_get(buf, i);
+    } else {
+        VALUE frame = rb_ary_new();
+        int 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, int 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
+    int f = FIX2INT(index);
+    if(f < 0 || f >= buf->size) rb_raise(eRubyAudioError, "setting frame out of bounds");
+    int 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");
+
+        int 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, int 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/ra_buffer.h

@@ -0,0 +1,39 @@
+#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;
+    int size;
+    int 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_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, int i);
+static VALUE ra_buffer_aset(VALUE self, VALUE index, VALUE val);
+static void ra_buffer_index_set(RA_BUFFER *buf, int i, VALUE val);
+
+#endif        //  #ifndef RA_BUFFER_H

data/ext/ra_sound.c

@@ -0,0 +1,274 @@
+#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);
+}
+
+/*
+ * 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);
+
+    // 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);
+    }
+
+    // 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");
+    }
+
+    // Read data
+    sf_count_t read;
+    switch(b->type) {
+        case RA_BUFFER_TYPE_SHORT:
+            read = sf_readf_short(snd->snd, b->data, f);
+            break;
+        case RA_BUFFER_TYPE_INT:
+            read = sf_readf_int(snd->snd, b->data, f);
+            break;
+        case RA_BUFFER_TYPE_FLOAT:
+            read = sf_readf_float(snd->snd, b->data, f);
+            break;
+        case RA_BUFFER_TYPE_DOUBLE:
+            read = sf_readf_double(snd->snd, b->data, f);
+            break;
+    }
+    b->real_size = 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;
+    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;
+}