ruby-audio 1.0.0 → 1.1.0

data/Rakefile

@@ -6,7 +6,7 @@ require 'spec/rake/spectask'
 
 spec = Gem::Specification.new do |s|
   s.name    = 'ruby-audio'
-  s.version = '1.0.0'
+  s.version = '1.1.0'
   s.summary = 'ruby-audio wraps around libsndfile to provide simplified sound reading and writing support to ruby programs'
   s.authors  = ['Stephen Augenstein']
   s.email    = 'perl.programmer@gmail.com'

data/ext/ra_buffer.c

@@ -16,14 +16,15 @@ 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);
+    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");
@@ -43,6 +44,22 @@ static void ra_buffer_free(RA_BUFFER *buf) {
     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 int ra_buffer_alloc_data(RA_BUFFER *buf) {
+    int size;
+    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
@@ -80,26 +97,39 @@ static VALUE ra_buffer_init(int argc, VALUE *argv, VALUE self) {
     // 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);
-    }
+    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));
+    int size = ra_buffer_alloc_data(copy_struct);
+    memcpy(copy_struct->data, buf_struct->data, size);
+
+    return copy;
+}
+
 /*
  * call-seq:
  *   buf.channels => integer

data/ext/ra_buffer.h

@@ -26,6 +26,7 @@ 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);

data/ext/ra_sound.c

@@ -127,6 +127,238 @@ 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;
+
+    // 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, mix_sum;
+
+        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;
+
+    // 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, mix_sum;
+
+        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;
+
+    // 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, mix_sum;
+
+        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;
+
+    // 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, mix_sum;
+
+        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
@@ -143,39 +375,35 @@ static VALUE ra_sound_read(VALUE self, VALUE buf, VALUE frames) {
     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;
+    // 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:
-            read = sf_readf_short(snd->snd, b->data, f);
+            ra_sound_read_short(snd, b, f);
             break;
         case RA_BUFFER_TYPE_INT:
-            read = sf_readf_int(snd->snd, b->data, f);
+            ra_sound_read_int(snd, b, f);
             break;
         case RA_BUFFER_TYPE_FLOAT:
-            read = sf_readf_float(snd->snd, b->data, f);
+            ra_sound_read_float(snd, b, f);
             break;
         case RA_BUFFER_TYPE_DOUBLE:
-            read = sf_readf_double(snd->snd, b->data, f);
+            ra_sound_read_double(snd, b, f);
             break;
     }
-    b->real_size = read;
 
+    // Return read
     return INT2FIX(b->real_size);
 }
 

data/spec/buffer_spec.rb

@@ -47,4 +47,16 @@ describe RubyAudio::Buffer do
     buf.real_size = 101
     buf.real_size.should == 100
   end
+
+  it "should support cloning/duping" do
+    buf = RubyAudio::Buffer.int(100)
+    buf[4] = 100
+
+    buf2 = buf.dup
+    buf2.size.should == buf.size
+    buf2[4].should == 100
+
+    buf[4] = 140
+    buf2[4].should == 100
+  end
 end

data/spec/sound_spec.rb

@@ -100,13 +100,38 @@ describe RubyAudio::Sound do
     buf[100].should == nil
   end
 
-  it "should raise exception for channel count mismatch on read" do
-    buf = RubyAudio::Buffer.float(1000, 1)
+  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|
+      snd.read(buf)
+      snd.seek(0)
+      snd.read(buf2)
+
+      f = buf2[99]
+      buf[99].should == (f[0] + f[1]) / 2
+    end
+  end
+
+  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|
+      snd.read(buf2)
+      snd.seek(0)
+      snd.read(buf)
+
+      buf2[99].should == [buf[99], buf[99]]
+    end
+  end
+
+  it "should fail read on unsupported up/downmixing" do
+    buf = RubyAudio::Buffer.float(100, 5)
     lambda {
       RubyAudio::Sound.open(STEREO_TEST_WAV) do |snd|
         snd.read(buf)
       end
-    }.should raise_error(RubyAudio::Error, "channel count mismatch: 1 vs 2")
+    }.should raise_error(RubyAudio::Error, "unsupported mix from 5 to 2")
   end
 
   it "should allow writing to a new sound" do
@@ -144,4 +169,14 @@ describe RubyAudio::Sound do
 
     out_buf[50].should == in_buf[50]
   end
+
+  it "should fail write on channel mismatch" 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|
+        snd.write(buf)
+      end
+    }.should raise_error(RubyAudio::Error, "channel count mismatch: 5 vs 2")
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-audio
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Stephen Augenstein
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-16 00:00:00 -04:00
+date: 2010-03-24 00:00:00 -04:00
 default_executable: 
 dependencies: []