ruby-audio 1.5.0 → 1.6.0

data/ext/rubyaudio_ext/extconf.rb

@@ -12,8 +12,8 @@ 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']
+INCLUDE_DIRS = ['/opt/local/include', '/usr/local/include', 'C:/Program Files (x86)/Mega-Nerd/libsndfile/include', 'C:/Program Files/Mega-Nerd/libsndfile/include']
+LIB_DIRS = ['/opt/local/lib', '/usr/local/lib', 'C:/Program Files (x86)/Mega-Nerd/libsndfile/bin', 'C:/Program Files/Mega-Nerd/libsndfile/bin']
 
 # libsndfile requirements
 find_header 'sndfile.h', *INCLUDE_DIRS

data/ext/rubyaudio_ext/ra_buffer.c

@@ -15,6 +15,7 @@ extern VALUE eRubyAudioError;
 void Init_ra_buffer() {
     VALUE mRubyAudio = rb_define_module("RubyAudio");
     VALUE cRABuffer = rb_define_class_under(mRubyAudio, "CBuffer", rb_cObject);
+    rb_include_module(cRABuffer, rb_mEnumerable);
     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);
@@ -23,6 +24,7 @@ void Init_ra_buffer() {
     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, "each",            ra_buffer_each, 0);
     rb_define_method(cRABuffer, "[]",              ra_buffer_aref, 1);
     rb_define_method(cRABuffer, "[]=",             ra_buffer_aset, 2);
 
@@ -210,6 +212,27 @@ static VALUE ra_buffer_type(VALUE self) {
     }
 }
 
+/*
+ * call-seq:
+ *   buf.each {|frame| block } => buf
+ *   buf.each => anEnumerator
+ *
+ * Iterates through each frame in the buffer. Each frame is either a number or
+ * an array of numbers if there are multiple channels.
+ */
+static VALUE ra_buffer_each(VALUE self) {
+    RA_BUFFER *buf;
+    Data_Get_Struct(self, RA_BUFFER, buf);
+
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    long i;
+    for(i = 0; i < buf->real_size; i++) {
+        rb_yield(ra_buffer_aref(self, LONG2FIX(i)));
+    }
+    return self;
+}
+
 /*
  * call-seq:
  *   buf[integer] => frame

data/ext/rubyaudio_ext/ra_buffer.h

@@ -32,6 +32,7 @@ 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_each(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);

data/ext/rubyaudio_ext/ra_sound.c

@@ -1,6 +1,11 @@
 #include "ra_sound.h"
 
 extern VALUE eRubyAudioError;
+ID id_size;
+ID id_seek;
+ID id_read;
+ID id_write;
+ID id_tell;
 
 /*
  * Class <code>CSound</code> is a very light wrapper around the
@@ -19,6 +24,13 @@ void Init_ra_sound() {
     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);
+
+    // Get refs to commonly used symbols and ids
+    id_size = rb_intern("size");
+    id_seek = rb_intern("seek");
+    id_read = rb_intern("read");
+    id_write = rb_intern("write");
+    id_tell = rb_intern("tell");
 }
 
 static VALUE ra_sound_allocate(VALUE klass) {
@@ -31,6 +43,7 @@ static VALUE ra_sound_allocate(VALUE klass) {
 static void ra_sound_mark(RA_SOUND *snd) {
     if(snd) {
         rb_gc_mark(snd->info);
+        if(snd->vio_source) rb_gc_mark(snd->vio_source);
     }
 }
 
@@ -56,15 +69,56 @@ static VALUE ra_sound_s_open(int argc, VALUE *argv, VALUE klass) {
     return rb_ensure(rb_yield, obj, ra_sound_close_safe, obj);
 }
 
+static sf_count_t ra_vir_size(void *user_data) {
+    VALUE io = (VALUE)user_data;
+    return NUM2OFFT(rb_funcall(io, id_size, 0));
+}
+
+static sf_count_t ra_vir_seek(sf_count_t offset, int whence, void *user_data) {
+    VALUE io = (VALUE)user_data;
+    rb_funcall(io, id_seek, 2, OFFT2NUM(offset), INT2FIX(whence));
+    return NUM2OFFT(rb_funcall(io, id_tell, 0));
+}
+
+static sf_count_t ra_vir_read(void *ptr, sf_count_t count, void *user_data) {
+    VALUE io = (VALUE)user_data;
+    if(count <= 0) return 0;
+
+    // It would be nice if we could create a fake buffer string with ptr as the target
+    VALUE read = rb_funcall(io, id_read, 1, OFFT2NUM(count));
+    sf_count_t len = RSTRING_LEN(read);
+    memcpy(ptr, RSTRING_PTR(read), RSTRING_LEN(read));
+    return len;
+}
+
+static sf_count_t ra_vir_write(const void *ptr, sf_count_t count, void *user_data) {
+    VALUE io = (VALUE)user_data;
+    if(count <= 0) return 0;
+
+    // It would be nice if we could create a fake string with ptr as the source
+    VALUE str = rb_str_new(ptr, count);
+    VALUE wrote = rb_funcall(io, id_write, 1, str);
+    return NUM2OFFT(wrote);
+}
+
+static sf_count_t ra_vir_tell(void *user_data) {
+    VALUE io = (VALUE)user_data;
+    return NUM2OFFT(rb_funcall(io, id_tell, 0));
+}
+
 /*
  * call-seq:
  *   CSound.new(path, mode, info) => snd
+ *   CSound.new(io, 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>.
+ * or using the given fixed-length IO-like object with the given mode. Valid modes
+ * are <code>"r"</code>, <code>"w"</code>, or <code>"rw"</code>.
+ * <code>StringIO</code> is the only valid IO-like object in the standard library,
+ * although any object that implements <code>size</code>, <code>seek</code>,
+ * <code>read</code>, <code>write</code>, and <code>tell</code> will work.
  */
-static VALUE ra_sound_init(VALUE self, VALUE path, VALUE mode, VALUE info) {
+static VALUE ra_sound_init(VALUE self, VALUE source, VALUE mode, VALUE info) {
     RA_SOUND *snd;
     Data_Get_Struct(self, RA_SOUND, snd);
 
@@ -79,10 +133,25 @@ static VALUE ra_sound_init(VALUE self, VALUE path, VALUE mode, VALUE 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(TYPE(source) == T_STRING) {
+        // Open sound file at the path
+        const char *p = StringValueCStr(source);
+        snd->snd = sf_open(p, snd->mode, sf_info);
+    } else {
+        // Check if the source implements the right methods
+        if(!rb_respond_to(source, id_size)) rb_raise(eRubyAudioError, "source does not implement size");
+        if(!rb_respond_to(source, id_seek)) rb_raise(eRubyAudioError, "source does not implement seek");
+        if(!rb_respond_to(source, id_read)) rb_raise(eRubyAudioError, "source does not implement read");
+        if(!rb_respond_to(source, id_write)) rb_raise(eRubyAudioError, "source does not implement write");
+        if(!rb_respond_to(source, id_tell)) rb_raise(eRubyAudioError, "source does not implement tell");
+
+        // Open sound using the virtual IO API
+        snd->vio_source = source;
+        SF_VIRTUAL_IO vir_io = {ra_vir_size, ra_vir_seek, ra_vir_read, ra_vir_write, ra_vir_tell};
+        snd->snd = sf_open_virtual(&vir_io, snd->mode, sf_info, (void*)source);
+    }
     if(snd->snd == NULL) rb_raise(eRubyAudioError, sf_strerror(snd->snd));
     snd->closed = 0;
 
@@ -127,241 +196,69 @@ static VALUE ra_sound_seek(VALUE self, VALUE frames, VALUE whence) {
     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;
+#define DEFINE_RA_SOUND_READ_TYPE(itype) \
+static void ra_sound_read_##itype(RA_SOUND *snd, RA_BUFFER *buf, sf_count_t frames) { \
+    static itype temp[1024]; \
+    int temp_len = 1024; \
+    itype *data = (itype*)buf->data; \
+    itype 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_##itype(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_##itype(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_##itype(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; \
 }
+DEFINE_RA_SOUND_READ_TYPE(short);
+DEFINE_RA_SOUND_READ_TYPE(int);
+DEFINE_RA_SOUND_READ_TYPE(float);
+DEFINE_RA_SOUND_READ_TYPE(double);
 
 /*
  * call-seq:

data/ext/rubyaudio_ext/ra_sound.h

@@ -9,6 +9,7 @@
 typedef struct {
     SNDFILE *snd;
     VALUE info;
+    VALUE vio_source;
     int mode;
     int closed;
 } RA_SOUND;

data/lib/ruby-audio/buffer.rb

@@ -10,14 +10,6 @@ module RubyAudio
   #   buf = RubyAudio::Buffer.float(1000)
   #   buf = RubyAudio::Buffer.new("float", 1000, 1)
   class Buffer < CBuffer
-    include Enumerable
-
-    def each 
-      self.size.times do |i|
-        yield self[i]
-      end
-    end
-
     [:short, :int, :float, :double].each do |type|
       eval "def self.#{type}(frames, channels=1); self.new(:#{type}, frames, channels); end"
     end

data/lib/ruby-audio/sound_info.rb

@@ -24,7 +24,7 @@ module RubyAudio
       end
     end
 
-    # Returns a new <code>SoundInfo</code> object that is has the same channel
+    # Returns a new <code>SoundInfo</code> object that has the same channel
     # count, sample rate, and format. This is useful in creating a new sound with
     # the same format as an already existing sound.
     #
@@ -37,16 +37,33 @@ module RubyAudio
 
     alias_method :seekable?, :seekable
 
+    # Returns the main format constant as a string
+    #
+    # Example:
+    #    info = RubyAudio::SoundInfo.new :channels => 1, :samplerate => 48000, :format => RubyAudio::FORMAT_WAV|RubyAudio::FORMAT_PCM_16
+    #    info.main_format
+    #    #=> "FORMAT_WAV"
     def main_format
       calculate_format if @main_format.nil?
       @main_format
     end
 
+    # Returns the sub format constant as a string
+    #
+    # Example:
+    #    info = RubyAudio::SoundInfo.new :channels => 1, :samplerate => 48000, :format => RubyAudio::FORMAT_WAV|RubyAudio::FORMAT_PCM_16
+    #    info.sub_format
+    #    #=> "FORMAT_PCM_16"
     def sub_format
       calculate_format if @sub_format.nil?
       @sub_format
     end
 
+    # Returns the length of the audio file in seconds
+    def length
+      frames / samplerate.to_f
+    end
+
     private
     def calculate_format
       RubyAudio.constants.grep(/FORMAT_/).map(&:to_s).each do |f|

data/ruby-audio.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'ruby-audio'
-  s.version     = '1.5.0'
+  s.version     = '1.6.0'
   s.platform    = Gem::Platform::RUBY
   s.authors     = ['Stephen Augenstein']
   s.email       = ['perl.programmer@gmail.com']

data/spec/buffer_spec.rb

@@ -78,11 +78,16 @@ describe RubyAudio::Buffer do
     end
 
     it "shouldn't do anything on an empty buffer" do
-      buf = RubyAudio::Buffer.int(0, 2)
+      buf = RubyAudio::Buffer.int(50, 2)
 
       buf.each do
         fail "This shouldn't be executed"
       end
     end
+
+    it "should support usage through returned enumerable" do
+      enum = @buf.each
+      enum.any? {|frame| frame[0] == 5}.should == true
+    end
   end
 end

data/spec/sound_info_spec.rb

@@ -46,4 +46,10 @@ describe RubyAudio::SoundInfo do
     info.main_format.should == "FORMAT_WAVEX"
     info.sub_format.should == "FORMAT_MS_ADPCM"
   end
+
+  it "should return the length of an audio file" do
+    RubyAudio::Sound.open(fixture('what.wav')) do |snd|
+      snd.info.length.should == 26413 / 16000.0
+    end
+  end
 end

data/spec/sound_spec.rb

@@ -1,30 +1,31 @@
 require "spec_helper.rb"
 
 describe RubyAudio::Sound do
-  MONO_TEST_WAV = File.dirname(__FILE__)+'/data/what.wav'
-  STEREO_TEST_WAV = File.dirname(__FILE__)+'/data/what2.wav'
-  TEST_MP3 = File.dirname(__FILE__)+'/data/what.mp3'
-  OUT_WAV = File.dirname(__FILE__)+'/data/temp.wav'
-
   after :each do
-    File.delete(OUT_WAV) if File.exists?(OUT_WAV)
+    File.delete(fixture('temp.wav')) if File.exists?(fixture('temp.wav'))
   end
 
   it "should open a standard wav without issues" do
     lambda {
-      RubyAudio::Sound.open(MONO_TEST_WAV)
+      RubyAudio::Sound.open(fixture('what.wav'))
+    }.should_not raise_error
+  end
+
+  it "should open an IO conformer without issues" do
+    lambda {
+      RubyAudio::Sound.open(io_fixture('what.wav'))
     }.should_not raise_error
   end
 
   it "should raise an exception if the mode is invalid" do
     lambda {
-      RubyAudio::Sound.open(MONO_TEST_WAV, 'q')
+      RubyAudio::Sound.open(fixture('what.wav'), 'q')
     }.should raise_error(ArgumentError, 'invalid access mode q')
   end
 
   it "should close the sound on block exit" do
     s = nil
-    RubyAudio::Sound.open(MONO_TEST_WAV) do |snd|
+    RubyAudio::Sound.open(fixture('what.wav')) do |snd|
       snd.closed?.should be_false
       s = snd
     end
@@ -33,18 +34,18 @@ describe RubyAudio::Sound do
 
   it "should raise an exception for an unsupported file" do
     lambda {
-      RubyAudio::Sound.open(TEST_MP3)
+      RubyAudio::Sound.open(fixture('what.mp3'))
     }.should raise_error(RubyAudio::Error, "File contains data in an unknown format.")
   end
 
   it "should raise an exception if file does not exist" do
     lambda {
-      RubyAudio::Sound.open(TEST_MP3+'.not')
+      RubyAudio::Sound.open(fixture('what.mp3')+'.not')
     }.should raise_error(RubyAudio::Error, "System error : No such file or directory.")
   end
 
   it "should have the proper sound info" do
-    RubyAudio::Sound.open(MONO_TEST_WAV) do |snd|
+    RubyAudio::Sound.open(fixture('what.wav')) do |snd|
       snd.info.channels.should == 1
       snd.info.samplerate.should == 16000
       snd.info.format.should == RubyAudio::FORMAT_WAV|RubyAudio::FORMAT_PCM_16
@@ -53,7 +54,17 @@ describe RubyAudio::Sound do
 
   it "should allow seeking" do
     lambda {
-      RubyAudio::Sound.open(MONO_TEST_WAV) do |snd|
+      RubyAudio::Sound.open(fixture('what.wav')) do |snd|
+        snd.seek(100)
+        buf = snd.read(:float, 100)
+        buf[0].should > 0
+      end
+    }.should_not raise_error
+  end
+
+  it "should allow seeking in IO conformers" do
+    lambda {
+      RubyAudio::Sound.open(io_fixture('what.wav')) do |snd|
         snd.seek(100)
         buf = snd.read(:float, 100)
         buf[0].should > 0
@@ -63,15 +74,24 @@ describe RubyAudio::Sound do
 
   it "should raise exceptions for invalid seeks" do
     lambda {
-      RubyAudio::Sound.open(MONO_TEST_WAV) {|snd| snd.seek(-1)}
+      RubyAudio::Sound.open(fixture('what.wav')) {|snd| snd.seek(-1)}
     }.should raise_error(RubyAudio::Error, "invalid seek")
     lambda {
-      RubyAudio::Sound.open(MONO_TEST_WAV) {|snd| snd.seek(1000000)}
+      RubyAudio::Sound.open(fixture('what.wav')) {|snd| snd.seek(1000000)}
     }.should raise_error(RubyAudio::Error, "invalid seek")
   end
 
   it "should allow reading samples from the sound" do
-    RubyAudio::Sound.open(STEREO_TEST_WAV) do |snd|
+    RubyAudio::Sound.open(fixture('what2.wav')) do |snd|
+      buf = snd.read(:float, 1000)
+      buf.size.should == 1000
+      buf.real_size.should == 1000
+      buf[999].length.should == 2
+    end
+  end
+
+  it "should allow reading samples from IO conformers" do
+    RubyAudio::Sound.open(io_fixture('what2.wav')) do |snd|
       buf = snd.read(:float, 1000)
       buf.size.should == 1000
       buf.real_size.should == 1000
@@ -82,7 +102,7 @@ describe RubyAudio::Sound do
   it "should allow reading into an existing buffer" do
     buf = RubyAudio::Buffer.float(1000)
     buf.real_size.should == 0
-    RubyAudio::Sound.open(MONO_TEST_WAV) do |snd|
+    RubyAudio::Sound.open(fixture('what.wav')) do |snd|
       snd.read(buf)
     end
     buf.real_size.should == 1000
@@ -92,7 +112,7 @@ describe RubyAudio::Sound do
   it "should allow reading into an existing buffer partially" do
     buf = RubyAudio::Buffer.float(1000)
     buf.real_size.should == 0
-    RubyAudio::Sound.open(MONO_TEST_WAV) do |snd|
+    RubyAudio::Sound.open(fixture('what.wav')) do |snd|
       snd.read(buf, 100)
     end
     buf.real_size.should == 100
@@ -103,7 +123,7 @@ describe RubyAudio::Sound do
   it "should allow downmixing to mono on read" do
     buf = RubyAudio::Buffer.int(100, 1)
     buf2 = RubyAudio::Buffer.int(100, 2)
-    RubyAudio::Sound.open(STEREO_TEST_WAV, 'r') do |snd|
+    RubyAudio::Sound.open(fixture('what2.wav'), 'r') do |snd|
       snd.read(buf)
       snd.seek(0)
       snd.read(buf2)
@@ -116,7 +136,7 @@ describe RubyAudio::Sound do
   it "should allow upmixing from mono on read" do
     buf = RubyAudio::Buffer.int(100, 1)
     buf2 = RubyAudio::Buffer.int(100, 2)
-    RubyAudio::Sound.open(STEREO_TEST_WAV, 'r') do |snd|
+    RubyAudio::Sound.open(fixture('what2.wav'), 'r') do |snd|
       snd.read(buf2)
       snd.seek(0)
       snd.read(buf)
@@ -128,7 +148,7 @@ describe RubyAudio::Sound do
   it "should fail read on unsupported up/downmixing" do
     buf = RubyAudio::Buffer.float(100, 5)
     lambda {
-      RubyAudio::Sound.open(STEREO_TEST_WAV) do |snd|
+      RubyAudio::Sound.open(fixture('what2.wav')) do |snd|
         snd.read(buf)
       end
     }.should raise_error(RubyAudio::Error, "unsupported mix from 5 to 2")
@@ -138,12 +158,30 @@ describe RubyAudio::Sound do
     in_buf = RubyAudio::Buffer.float(100)
     out_buf = RubyAudio::Buffer.float(100)
     out_info = nil
-    RubyAudio::Sound.open(MONO_TEST_WAV) do |snd|
+    RubyAudio::Sound.open(fixture('what.wav')) do |snd|
+      snd.read(in_buf)
+      out_info = snd.info.clone
+    end
+
+    RubyAudio::Sound.open(fixture('temp.wav'), 'rw', out_info) do |snd|
+      snd.write(in_buf)
+      snd.seek(0)
+      snd.read(out_buf)
+    end
+
+    out_buf[50].should == in_buf[50]
+  end
+
+  it "should allow writing to an IO conformer" do
+    in_buf = RubyAudio::Buffer.float(100)
+    out_buf = RubyAudio::Buffer.float(100)
+    out_info = nil
+    RubyAudio::Sound.open(fixture('what.wav')) do |snd|
       snd.read(in_buf)
       out_info = snd.info.clone
     end
 
-    RubyAudio::Sound.open(OUT_WAV, 'rw', out_info) do |snd|
+    RubyAudio::Sound.open(io_fixture, 'rw', out_info) do |snd|
       snd.write(in_buf)
       snd.seek(0)
       snd.read(out_buf)
@@ -156,12 +194,12 @@ describe RubyAudio::Sound do
     in_buf = RubyAudio::Buffer.float(100)
     out_buf = RubyAudio::Buffer.float(100)
     out_info = nil
-    RubyAudio::Sound.open(MONO_TEST_WAV) do |snd|
+    RubyAudio::Sound.open(fixture('what.wav')) do |snd|
       snd.read(in_buf)
       out_info = snd.info.clone
     end
 
-    RubyAudio::Sound.open(OUT_WAV, 'rw', out_info) do |snd|
+    RubyAudio::Sound.open(fixture('temp.wav'), 'rw', out_info) do |snd|
       snd << in_buf
       snd.seek(0)
       snd.read(out_buf)
@@ -174,7 +212,7 @@ describe RubyAudio::Sound do
     buf = RubyAudio::Buffer.float(100, 5)
     info = RubyAudio::SoundInfo.new :channels => 2, :samplerate => 48000, :format => RubyAudio::FORMAT_WAV|RubyAudio::FORMAT_PCM_16
     lambda {
-      RubyAudio::Sound.open(OUT_WAV, 'w', info) do |snd|
+      RubyAudio::Sound.open(fixture('temp.wav'), 'w', info) do |snd|
         snd.write(buf)
       end
     }.should raise_error(RubyAudio::Error, "channel count mismatch: 5 vs 2")

data/spec/spec_helper.rb

@@ -8,4 +8,17 @@ end
 require 'spec/autorun'
 
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'ruby-audio'
+require 'ruby-audio'
+
+def fixture file_name
+  File.join(File.dirname(__FILE__), 'data', file_name)
+end
+
+def io_fixture file_name=nil
+  if file_name
+    path = fixture(file_name)
+    StringIO.new(File.read(path))
+  else
+    StringIO.new
+  end
+end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-audio
 version: !ruby/object:Gem::Version 
-  hash: 3
   prerelease: false
   segments: 
   - 1
-  - 5
+  - 6
   - 0
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors: 
 - Stephen Augenstein
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-06 00:00:00 -04:00
+date: 2011-11-19 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -69,27 +68,23 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: 
 - libsndfile (http://www.mega-nerd.com/libsndfile/)
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: libsndfile wrapper for ruby