ruby-audio 0.2.1 → 1.0.0

data/ext/ra_sound.h

@@ -0,0 +1,37 @@
+#ifndef RA_SOUND_H
+#define RA_SOUND_H
+
+#include <ruby.h>
+#include <sndfile.h>
+#include "ra_soundinfo.h"
+#include "ra_buffer.h"
+
+typedef struct {
+    SNDFILE *snd;
+    VALUE info;
+    int mode;
+    int closed;
+} RA_SOUND;
+
+void Init_ra_sound();
+
+/*** Initialization and Memory Manangement ***/
+static VALUE ra_sound_allocate(VALUE klass);
+static void  ra_sound_mark(RA_SOUND *snd);
+static void  ra_sound_free(RA_SOUND *snd);
+
+/*** Singleton Methods ***/
+static VALUE ra_sound_s_open(int argc, VALUE *argv, VALUE klass);
+
+/*** Instance Methods ***/
+static VALUE ra_sound_init(VALUE self, VALUE path, VALUE mode, VALUE info);
+static VALUE ra_sound_info(VALUE self);
+static VALUE ra_sound_seek(VALUE self, VALUE frames, VALUE whence);
+static VALUE ra_sound_read(VALUE self, VALUE buf, VALUE frames);
+static VALUE ra_sound_write(VALUE self, VALUE buf);
+static VALUE ra_sound_addbuf(VALUE self, VALUE buf);
+static VALUE ra_sound_close(VALUE self);
+static VALUE ra_sound_close_safe(VALUE self);
+static VALUE ra_sound_closed(VALUE self);
+
+#endif        //  #ifndef RA_SOUND_H

data/ext/ra_soundinfo.c

@@ -0,0 +1,165 @@
+#include "ra_soundinfo.h"
+
+extern VALUE eRubyAudioError;
+
+/*
+ * Class <code>CSoundInfo</code> is a very light wrapper around the
+ * <code>SF_INFO</code> struct exposed by libsndfile. It provides information
+ * about open sound files like format, length, samplerate, channels, and other
+ * things. In addition it can be used to specify the format of new sound files.
+ */
+void Init_ra_soundinfo() {
+    VALUE mRubyAudio = rb_define_module("RubyAudio");
+    VALUE cRASoundInfo = rb_define_class_under(mRubyAudio, "CSoundInfo", rb_cObject);
+    rb_define_alloc_func(cRASoundInfo, ra_soundinfo_allocate);
+    rb_define_method(cRASoundInfo, "valid?",      ra_soundinfo_valid, 0);
+    rb_define_method(cRASoundInfo, "frames",      ra_soundinfo_frames, 0);
+    rb_define_method(cRASoundInfo, "samplerate",  ra_soundinfo_samplerate, 0);
+    rb_define_method(cRASoundInfo, "samplerate=", ra_soundinfo_samplerate_set, 1);
+    rb_define_method(cRASoundInfo, "channels",    ra_soundinfo_channels, 0);
+    rb_define_method(cRASoundInfo, "channels=",   ra_soundinfo_channels_set, 1);
+    rb_define_method(cRASoundInfo, "format",      ra_soundinfo_format, 0);
+    rb_define_method(cRASoundInfo, "format=",     ra_soundinfo_format_set, 1);
+    rb_define_method(cRASoundInfo, "sections",    ra_soundinfo_sections, 0);
+    rb_define_method(cRASoundInfo, "seekable",    ra_soundinfo_seekable, 0);
+}
+
+static VALUE ra_soundinfo_allocate(VALUE klass) {
+    SF_INFO *info = ALLOC(SF_INFO);
+    memset(info, 0, sizeof(SF_INFO));
+    VALUE self = Data_Wrap_Struct(klass, NULL, ra_soundinfo_free, info);
+    return self;
+}
+
+static void ra_soundinfo_free(SF_INFO *info) {
+    xfree(info);
+}
+
+/*
+ * call-seq:
+ *   info.valid? => true or false
+ *
+ * Calls <code>sf_format_check</code> on the underlying <code>SF_INFO</code>
+ * struct and returns true or false based on validity. Used when creating a new
+ * sound file to check that the format has enough information to properly create
+ * a new sound.
+ */
+static VALUE ra_soundinfo_valid(VALUE self) {
+    SF_INFO *info;
+    Data_Get_Struct(self, SF_INFO, info);
+    return sf_format_check(info) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   info.frames => integer
+ *
+ * Returns the number of frames in the associated sound file.
+ */
+static VALUE ra_soundinfo_frames(VALUE self) {
+    SF_INFO *info;
+    Data_Get_Struct(self, SF_INFO, info);
+    return OFFT2NUM(info->frames);
+}
+
+/*
+ * call-seq:
+ *   info.samplerate => integer
+ *
+ * Returns the samplerate of the associated sound file.
+ */
+static VALUE ra_soundinfo_samplerate(VALUE self) {
+    SF_INFO *info;
+    Data_Get_Struct(self, SF_INFO, info);
+    return INT2FIX(info->samplerate);
+}
+
+/*
+ * call-seq:
+ *   info.samplerate = integer => integer
+ *
+ * Set the samplerate for a new sound created with the given info object.
+ */
+static VALUE ra_soundinfo_samplerate_set(VALUE self, VALUE new_samplerate) {
+    SF_INFO *info;
+    Data_Get_Struct(self, SF_INFO, info);
+    info->samplerate = FIX2INT(new_samplerate);
+    return new_samplerate;
+}
+
+/*
+ * call-seq:
+ *   info.channels => integer
+ *
+ * Returns the number of channels in the associated sound file.
+ */
+static VALUE ra_soundinfo_channels(VALUE self) {
+    SF_INFO *info;
+    Data_Get_Struct(self, SF_INFO, info);
+    return INT2FIX(info->channels);
+}
+
+/*
+ * call-seq:
+ *   info.channels = integer => integer
+ *
+ * Set the number of channels for a new sound created with the given info object.
+ */
+static VALUE ra_soundinfo_channels_set(VALUE self, VALUE new_channels) {
+    SF_INFO *info;
+    Data_Get_Struct(self, SF_INFO, info);
+    info->channels = FIX2INT(new_channels);
+    return new_channels;
+}
+
+/*
+ * call-seq:
+ *   info.format => integer
+ *
+ * Returns the format as a combination of binary flags of the associated sound file.
+ */
+static VALUE ra_soundinfo_format(VALUE self) {
+    SF_INFO *info;
+    Data_Get_Struct(self, SF_INFO, info);
+    return INT2FIX(info->format);
+}
+
+/*
+ * call-seq:
+ *   info.format = integer => integer
+ *
+ * Set the format for a new sound created with the given info object.
+ *
+ *   info = RubyAudio::CSoundInfo.new
+ *   info.format = RubyAudio::FORMAT_WAV|RubyAudio::FORMAT_PCM_16
+ */
+static VALUE ra_soundinfo_format_set(VALUE self, VALUE new_format) {
+    SF_INFO *info;
+    Data_Get_Struct(self, SF_INFO, info);
+    info->format = FIX2INT(new_format);
+    return new_format;
+}
+
+/*
+ * call-seq:
+ *   info.sections => integer
+ *
+ * Returns the number of sections in the associated sound file.
+ */
+static VALUE ra_soundinfo_sections(VALUE self) {
+    SF_INFO *info;
+    Data_Get_Struct(self, SF_INFO, info);
+    return INT2FIX(info->sections);
+}
+
+/*
+ * call-seq:
+ *   info.seekable => true or false
+ *
+ * Whether seeking is supported for the associated sound file.
+ */
+static VALUE ra_soundinfo_seekable(VALUE self) {
+    SF_INFO *info;
+    Data_Get_Struct(self, SF_INFO, info);
+    return info->seekable ? Qtrue : Qfalse;
+}

data/ext/ra_soundinfo.h

@@ -0,0 +1,25 @@
+#ifndef RA_SOUNDINFO_H
+#define RA_SOUNDINFO_H
+
+#include <ruby.h>
+#include <sndfile.h>
+
+void Init_ra_soundinfo();
+
+/*** Initialization and Memory Manangement ***/
+static VALUE ra_soundinfo_allocate(VALUE klass);
+static void  ra_soundinfo_free(SF_INFO *info);
+
+/*** Instance Methods ***/
+static VALUE ra_soundinfo_valid(VALUE self);
+static VALUE ra_soundinfo_frames(VALUE self);
+static VALUE ra_soundinfo_samplerate(VALUE self);
+static VALUE ra_soundinfo_samplerate_set(VALUE self, VALUE new_samplerate);
+static VALUE ra_soundinfo_channels(VALUE self);
+static VALUE ra_soundinfo_channels_set(VALUE self, VALUE new_channels);
+static VALUE ra_soundinfo_format(VALUE self);
+static VALUE ra_soundinfo_format_set(VALUE self, VALUE new_format);
+static VALUE ra_soundinfo_sections(VALUE self);
+static VALUE ra_soundinfo_seekable(VALUE self);
+
+#endif        //  #ifndef RA_SOUNDINFO_H

data/ext/rubyaudio_ext.c

@@ -0,0 +1,91 @@
+#include <ruby.h>
+#include <sndfile.h>
+
+void Init_ra_buffer();
+void Init_ra_soundinfo();
+void Init_ra_sound();
+
+VALUE eRubyAudioError;
+
+/*
+ * Document-module: RubyAudio
+ */
+/*
+ * Document-class: RubyAudio::Error
+ *
+ * Error class for RubyAudio
+ */
+void Init_rubyaudio_ext() {
+    // Create RubyAudio module and other setup
+    VALUE mRubyAudio = rb_define_module("RubyAudio");
+    eRubyAudioError = rb_define_class_under(mRubyAudio, "Error", rb_eStandardError);
+
+    // Set up classes
+    Init_ra_buffer();
+    Init_ra_soundinfo();
+    Init_ra_sound();
+
+    // Export libsndfile constants
+    // Major formats
+    rb_define_const(mRubyAudio, "FORMAT_WAV", INT2FIX(SF_FORMAT_WAV));
+    rb_define_const(mRubyAudio, "FORMAT_AIFF", INT2FIX(SF_FORMAT_AIFF));
+    rb_define_const(mRubyAudio, "FORMAT_AU", INT2FIX(SF_FORMAT_AU));
+    rb_define_const(mRubyAudio, "FORMAT_RAW", INT2FIX(SF_FORMAT_RAW));
+    rb_define_const(mRubyAudio, "FORMAT_PAF", INT2FIX(SF_FORMAT_PAF));
+    rb_define_const(mRubyAudio, "FORMAT_SVX", INT2FIX(SF_FORMAT_SVX));
+    rb_define_const(mRubyAudio, "FORMAT_NIST", INT2FIX(SF_FORMAT_NIST));
+    rb_define_const(mRubyAudio, "FORMAT_VOC", INT2FIX(SF_FORMAT_VOC));
+    rb_define_const(mRubyAudio, "FORMAT_IRCAM", INT2FIX(SF_FORMAT_IRCAM));
+    rb_define_const(mRubyAudio, "FORMAT_W64", INT2FIX(SF_FORMAT_W64));
+    rb_define_const(mRubyAudio, "FORMAT_MAT4", INT2FIX(SF_FORMAT_MAT4));
+    rb_define_const(mRubyAudio, "FORMAT_MAT5", INT2FIX(SF_FORMAT_MAT5));
+    rb_define_const(mRubyAudio, "FORMAT_PVF", INT2FIX(SF_FORMAT_PVF));
+    rb_define_const(mRubyAudio, "FORMAT_XI", INT2FIX(SF_FORMAT_XI));
+    rb_define_const(mRubyAudio, "FORMAT_HTK", INT2FIX(SF_FORMAT_HTK));
+    rb_define_const(mRubyAudio, "FORMAT_SDS", INT2FIX(SF_FORMAT_SDS));
+    rb_define_const(mRubyAudio, "FORMAT_AVR", INT2FIX(SF_FORMAT_AVR));
+    rb_define_const(mRubyAudio, "FORMAT_WAVEX", INT2FIX(SF_FORMAT_WAVEX));
+    rb_define_const(mRubyAudio, "FORMAT_SD2", INT2FIX(SF_FORMAT_SD2));
+    rb_define_const(mRubyAudio, "FORMAT_FLAC", INT2FIX(SF_FORMAT_FLAC));
+    rb_define_const(mRubyAudio, "FORMAT_CAF", INT2FIX(SF_FORMAT_CAF));
+    rb_define_const(mRubyAudio, "FORMAT_WVE", INT2FIX(SF_FORMAT_WVE));
+    rb_define_const(mRubyAudio, "FORMAT_OGG", INT2FIX(SF_FORMAT_OGG));
+    rb_define_const(mRubyAudio, "FORMAT_MPC2K", INT2FIX(SF_FORMAT_MPC2K));
+    rb_define_const(mRubyAudio, "FORMAT_RF64", INT2FIX(SF_FORMAT_RF64));
+
+    // Subtypes from here on
+    rb_define_const(mRubyAudio, "FORMAT_PCM_S8", INT2FIX(SF_FORMAT_PCM_S8));
+    rb_define_const(mRubyAudio, "FORMAT_PCM_16", INT2FIX(SF_FORMAT_PCM_16));
+    rb_define_const(mRubyAudio, "FORMAT_PCM_24", INT2FIX(SF_FORMAT_PCM_24));
+    rb_define_const(mRubyAudio, "FORMAT_PCM_32", INT2FIX(SF_FORMAT_PCM_32));
+    rb_define_const(mRubyAudio, "FORMAT_PCM_U8", INT2FIX(SF_FORMAT_PCM_U8));
+    rb_define_const(mRubyAudio, "FORMAT_FLOAT", INT2FIX(SF_FORMAT_FLOAT));
+    rb_define_const(mRubyAudio, "FORMAT_DOUBLE", INT2FIX(SF_FORMAT_DOUBLE));
+    rb_define_const(mRubyAudio, "FORMAT_ULAW", INT2FIX(SF_FORMAT_ULAW));
+    rb_define_const(mRubyAudio, "FORMAT_ALAW", INT2FIX(SF_FORMAT_ALAW));
+    rb_define_const(mRubyAudio, "FORMAT_IMA_ADPCM", INT2FIX(SF_FORMAT_IMA_ADPCM));
+    rb_define_const(mRubyAudio, "FORMAT_MS_ADPCM", INT2FIX(SF_FORMAT_MS_ADPCM));
+    rb_define_const(mRubyAudio, "FORMAT_GSM610", INT2FIX(SF_FORMAT_GSM610));
+    rb_define_const(mRubyAudio, "FORMAT_VOX_ADPCM", INT2FIX(SF_FORMAT_VOX_ADPCM));
+    rb_define_const(mRubyAudio, "FORMAT_G721_32", INT2FIX(SF_FORMAT_G721_32));
+    rb_define_const(mRubyAudio, "FORMAT_G723_24", INT2FIX(SF_FORMAT_G723_24));
+    rb_define_const(mRubyAudio, "FORMAT_G723_40", INT2FIX(SF_FORMAT_G723_40));
+    rb_define_const(mRubyAudio, "FORMAT_DWVW_12", INT2FIX(SF_FORMAT_DWVW_12));
+    rb_define_const(mRubyAudio, "FORMAT_DWVW_16", INT2FIX(SF_FORMAT_DWVW_16));
+    rb_define_const(mRubyAudio, "FORMAT_DWVW_24", INT2FIX(SF_FORMAT_DWVW_24));
+    rb_define_const(mRubyAudio, "FORMAT_DWVW_N", INT2FIX(SF_FORMAT_DWVW_N));
+    rb_define_const(mRubyAudio, "FORMAT_DPCM_8", INT2FIX(SF_FORMAT_DPCM_8));
+    rb_define_const(mRubyAudio, "FORMAT_DPCM_16", INT2FIX(SF_FORMAT_DPCM_16));
+    rb_define_const(mRubyAudio, "FORMAT_VORBIS", INT2FIX(SF_FORMAT_VORBIS));
+
+    // Endian-ness options
+    rb_define_const(mRubyAudio, "ENDIAN_FILE", INT2FIX(SF_ENDIAN_FILE));
+    rb_define_const(mRubyAudio, "ENDIAN_LITTLE", INT2FIX(SF_ENDIAN_LITTLE));
+    rb_define_const(mRubyAudio, "ENDIAN_BIG", INT2FIX(SF_ENDIAN_BIG));
+    rb_define_const(mRubyAudio, "ENDIAN_CPU", INT2FIX(SF_ENDIAN_CPU));
+
+    // Format masks
+    rb_define_const(mRubyAudio, "FORMAT_SUBMASK", INT2FIX(SF_FORMAT_SUBMASK));
+    rb_define_const(mRubyAudio, "FORMAT_TYPEMASK", INT2FIX(SF_FORMAT_TYPEMASK));
+    rb_define_const(mRubyAudio, "FORMAT_ENDMASK", INT2FIX(SF_FORMAT_ENDMASK));
+}

data/lib/ruby-audio.rb

@@ -0,0 +1,4 @@
+require 'rubyaudio_ext'
+require 'ruby-audio/buffer'
+require 'ruby-audio/sound_info'
+require 'ruby-audio/sound'

data/lib/ruby-audio/buffer.rb

@@ -0,0 +1,17 @@
+module RubyAudio
+  # The <code>Buffer</code> class contains sound data read out of the sound. It
+  # can store a fixed maximum number of multi-channel audio frames of a specifi
+  # data type. Valid types are <code>short</code>, <code>int</code>,
+  # <code>float</code>, and <code>double</code>. The channel count must match up
+  # to the channel count of the sounds being read and written to. Trying to read
+  # into a buffer with the wrong number of channels will result in an error.
+  #
+  # Example:
+  #   buf = RubyAudio::Buffer.float(1000)
+  #   buf = RubyAudio::Buffer.new("float", 1000, 1)
+  class Buffer < CBuffer
+    [:short, :int, :float, :double].each do |type|
+      eval "def self.#{type}(frames, channels=1); self.new(:#{type}, frames, channels); end"
+    end
+  end
+end

data/lib/ruby-audio/sound.rb

@@ -0,0 +1,85 @@
+module RubyAudio
+  # Class <code>Sound</code> wraps libsndfile to provide simple reading and
+  # writing for a wide variety of file formats
+  #
+  # Reading Example:
+  #   RubyAudio::Sound.open('sound.wav') do |snd|
+  #     buf = snd.read(:float, 100)
+  #     puts buf.real_size                         #=> 100
+  #   end
+  #
+  # Writing Example:
+  #   buf = RubyAudio::Buffer.float(1000)
+  #   out = nil
+  #   ['snd1.wav', 'snd2.wav', 'snd3.wav'].each do |file|
+  #     RubyAudio::Sound.open(file) do |snd|
+  #       out = RubyAudio::Sound.open('out.wav', 'w', snd.info.clone) if out.nil?
+  #
+  #       while snd.read(buf) != 0
+  #         out.write(buf)
+  #       end
+  #     end
+  #   end
+  #   out.close if out
+  class Sound < CSound
+    # Creates a new <code>Sound</code> object for the audio file at the given path.
+    # Mode defaults to <code>"r"</code>, but valid modes are <code>"r"</code>,
+    # <code>"w"</code>, and <code>"rw"</code>.
+    #
+    # When creating a new sound, a valid <code>SoundInfo</code> object must be
+    # passed in, as libsndfile uses it to determine the output format.
+    #   info = RubyAudio::SoundInfo.new :channels => 1, :samplerate => 48000, :format => RubyAudio::FORMAT_WAV|RubyAudio::FORMAT_PCM_16
+    #   snd = RubyAudio::Sound.new "new.wav", 'r', info
+    def initialize(path, mode='r', info=nil)
+      info ||= SoundInfo.new
+      super(path, mode, info)
+    end
+
+    # 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_
+    def seek(frames, whence=IO::SEEK_SET)
+      super(frames, whence)
+    end
+
+    # Reads a given number of frames from the sound into a buffer
+    #
+    # When given a buffer as the first argument, it reads data into that buffer
+    # reading an optional number of frames as the second argument. It returns
+    # the number of frames read.
+    #
+    # Example:
+    #   buf = RubyAudio::Buffer.float(1000)
+    #   snd.read(buf)                        #=> 1000
+    #   snd.read(buf, 50)                    #=> 50
+    #
+    # When given a string or symbol as the first argument, it interprets this as
+    # the data type and creates a new buffer of the given size to read the data
+    # into. The buffer is correctly initialized with the proper number of channels
+    # to hold data from that sound.
+    #
+    # Example:
+    #   buf = snd.read("int", 1000)
+    def read(*args)
+      case args[0]
+      when Buffer
+        buf = args[0]
+        size = args[1] || buf.size
+        return super(buf, size)
+      when Symbol, String
+        type = args[0]
+        buf = Buffer.new(type, args[1], info.channels)
+        super(buf, buf.size)
+        return buf
+      else
+        raise ArgumentError, "invalid arguments"
+      end
+    end
+  end
+end

data/lib/ruby-audio/sound_info.rb

@@ -0,0 +1,40 @@
+module RubyAudio
+  # Class <code>SoundInfo</code>  provides information about open sound files'
+  # format, length, samplerate, channels, and other things.
+  #
+  # Example:
+  #   snd = RubyAudio::Sound.open("snd.wav")
+  #   puts snd.info.channels                  #=> 2
+  #   puts snd.info.samplerate                #=> 48000
+  #   snd.close
+  #
+  # In addition it can be used to specify the format of new sound files:
+  #
+  #   info = RubyAudio::SoundInfo.new :channels => 1, :samplerate => 48000, :format => RubyAudio::FORMAT_WAV|RubyAudio::FORMAT_PCM_16
+  #   snd = RubyAudio::Sound.open("new.wav", 'w', info)
+  class SoundInfo < CSoundInfo
+    # Creates a new SoundInfo object and populates it using the given data
+    #
+    # Example:
+    #    info = RubyAudio::SoundInfo.new :channels => 1, :samplerate => 48000, :format => RubyAudio::FORMAT_WAV|RubyAudio::FORMAT_PCM_16
+    def initialize options={}
+      # Populate from options if given
+      unless options.empty?
+        options.each {|key,value| send("#{key}=", value)}
+      end
+    end
+
+    # Returns a new <code>SoundInfo</code> object that is 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.
+    #
+    # Example:
+    #   snd1 = RubyAudio::Sound.open("snd.wav")
+    #   snd2 = RubyAudio::Sound.open("snd2.wav", 'w', snd1.info.clone)
+    def clone
+      SoundInfo.new(:channels => channels, :samplerate => samplerate, :format => format)
+    end
+
+    alias_method :seekable?, :seekable
+  end
+end