ruby-audio 1.5.0-x86-mingw32

data/ext/rubyaudio_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/rubyaudio_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/rubyaudio_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/rubyaudio_ext.c

@@ -0,0 +1,92 @@
+#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", /* 0x010000 */ INT2FIX(SF_FORMAT_WAV));
+    rb_define_const(mRubyAudio, "FORMAT_AIFF", /* 0x020000 */ INT2FIX(SF_FORMAT_AIFF));
+    rb_define_const(mRubyAudio, "FORMAT_AU", /* 0x030000 */ INT2FIX(SF_FORMAT_AU));
+    rb_define_const(mRubyAudio, "FORMAT_RAW", /* 0x040000 */ INT2FIX(SF_FORMAT_RAW));
+    rb_define_const(mRubyAudio, "FORMAT_PAF", /* 0x050000 */ INT2FIX(SF_FORMAT_PAF));
+    rb_define_const(mRubyAudio, "FORMAT_SVX", /* 0x060000 */ INT2FIX(SF_FORMAT_SVX));
+    rb_define_const(mRubyAudio, "FORMAT_NIST", /* 0x070000 */ INT2FIX(SF_FORMAT_NIST));
+    rb_define_const(mRubyAudio, "FORMAT_VOC", /* 0x080000 */ INT2FIX(SF_FORMAT_VOC));
+    rb_define_const(mRubyAudio, "FORMAT_IRCAM", /* 0x0A0000 */ INT2FIX(SF_FORMAT_IRCAM));
+    rb_define_const(mRubyAudio, "FORMAT_W64", /* 0x0B0000 */ INT2FIX(SF_FORMAT_W64));
+    rb_define_const(mRubyAudio, "FORMAT_MAT4", /* 0x0C0000 */ INT2FIX(SF_FORMAT_MAT4));
+    rb_define_const(mRubyAudio, "FORMAT_MAT5", /* 0x0D0000 */ INT2FIX(SF_FORMAT_MAT5));
+    rb_define_const(mRubyAudio, "FORMAT_PVF", /* 0x0E0000 */ INT2FIX(SF_FORMAT_PVF));
+    rb_define_const(mRubyAudio, "FORMAT_XI", /* 0x0F0000 */ INT2FIX(SF_FORMAT_XI));
+    rb_define_const(mRubyAudio, "FORMAT_HTK", /* 0x100000 */ INT2FIX(SF_FORMAT_HTK));
+    rb_define_const(mRubyAudio, "FORMAT_SDS", /* 0x110000 */ INT2FIX(SF_FORMAT_SDS));
+    rb_define_const(mRubyAudio, "FORMAT_AVR", /* 0x120000 */ INT2FIX(SF_FORMAT_AVR));
+    rb_define_const(mRubyAudio, "FORMAT_WAVEX", /* 0x130000 */ INT2FIX(SF_FORMAT_WAVEX));
+    rb_define_const(mRubyAudio, "FORMAT_SD2", /* 0x160000 */ INT2FIX(SF_FORMAT_SD2));
+    rb_define_const(mRubyAudio, "FORMAT_FLAC", /* 0x170000 */ INT2FIX(SF_FORMAT_FLAC));
+    rb_define_const(mRubyAudio, "FORMAT_CAF", /* 0x180000 */ INT2FIX(SF_FORMAT_CAF));
+#ifdef HAVE_CONST_SF_FORMAT_OGG
+    rb_define_const(mRubyAudio, "FORMAT_OGG", /* 0x200000 */ INT2FIX(SF_FORMAT_OGG));
+#endif
+
+    // Subtypes from here on
+    rb_define_const(mRubyAudio, "FORMAT_PCM_S8", /* 0x0001 */ INT2FIX(SF_FORMAT_PCM_S8));
+    rb_define_const(mRubyAudio, "FORMAT_PCM_16", /* 0x0002 */ INT2FIX(SF_FORMAT_PCM_16));
+    rb_define_const(mRubyAudio, "FORMAT_PCM_24", /* 0x0003 */ INT2FIX(SF_FORMAT_PCM_24));
+    rb_define_const(mRubyAudio, "FORMAT_PCM_32", /* 0x0004 */ INT2FIX(SF_FORMAT_PCM_32));
+    rb_define_const(mRubyAudio, "FORMAT_PCM_U8", /* 0x0005 */ INT2FIX(SF_FORMAT_PCM_U8));
+    rb_define_const(mRubyAudio, "FORMAT_FLOAT", /* 0x0006 */ INT2FIX(SF_FORMAT_FLOAT));
+    rb_define_const(mRubyAudio, "FORMAT_DOUBLE", /* 0x0007 */ INT2FIX(SF_FORMAT_DOUBLE));
+    rb_define_const(mRubyAudio, "FORMAT_ULAW", /* 0x0010 */ INT2FIX(SF_FORMAT_ULAW));
+    rb_define_const(mRubyAudio, "FORMAT_ALAW", /* 0x0011 */ INT2FIX(SF_FORMAT_ALAW));
+    rb_define_const(mRubyAudio, "FORMAT_IMA_ADPCM", /* 0x0012 */ INT2FIX(SF_FORMAT_IMA_ADPCM));
+    rb_define_const(mRubyAudio, "FORMAT_MS_ADPCM", /* 0x0013 */ INT2FIX(SF_FORMAT_MS_ADPCM));
+    rb_define_const(mRubyAudio, "FORMAT_GSM610", /* 0x0020 */ INT2FIX(SF_FORMAT_GSM610));
+    rb_define_const(mRubyAudio, "FORMAT_VOX_ADPCM", /* 0x0021 */ INT2FIX(SF_FORMAT_VOX_ADPCM));
+    rb_define_const(mRubyAudio, "FORMAT_G721_32", /* 0x0030 */ INT2FIX(SF_FORMAT_G721_32));
+    rb_define_const(mRubyAudio, "FORMAT_G723_24", /* 0x0031 */ INT2FIX(SF_FORMAT_G723_24));
+    rb_define_const(mRubyAudio, "FORMAT_G723_40", /* 0x0032 */ INT2FIX(SF_FORMAT_G723_40));
+    rb_define_const(mRubyAudio, "FORMAT_DWVW_12", /* 0x0040 */ INT2FIX(SF_FORMAT_DWVW_12));
+    rb_define_const(mRubyAudio, "FORMAT_DWVW_16", /* 0x0041 */ INT2FIX(SF_FORMAT_DWVW_16));
+    rb_define_const(mRubyAudio, "FORMAT_DWVW_24", /* 0x0042 */ INT2FIX(SF_FORMAT_DWVW_24));
+    rb_define_const(mRubyAudio, "FORMAT_DWVW_N", /* 0x0043 */ INT2FIX(SF_FORMAT_DWVW_N));
+    rb_define_const(mRubyAudio, "FORMAT_DPCM_8", /* 0x0050 */ INT2FIX(SF_FORMAT_DPCM_8));
+    rb_define_const(mRubyAudio, "FORMAT_DPCM_16", /* 0x0051 */ INT2FIX(SF_FORMAT_DPCM_16));
+#ifdef HAVE_CONST_SF_FORMAT_OGG
+    rb_define_const(mRubyAudio, "FORMAT_VORBIS", /* 0x0060 */ INT2FIX(SF_FORMAT_VORBIS));
+#endif
+
+    // Endian-ness options
+    rb_define_const(mRubyAudio, "ENDIAN_FILE", /* 0x00000000 */ INT2FIX(SF_ENDIAN_FILE));
+    rb_define_const(mRubyAudio, "ENDIAN_LITTLE", /* 0x10000000 */ INT2FIX(SF_ENDIAN_LITTLE));
+    rb_define_const(mRubyAudio, "ENDIAN_BIG", /* 0x20000000 */ INT2FIX(SF_ENDIAN_BIG));
+    rb_define_const(mRubyAudio, "ENDIAN_CPU", /* 0x30000000 */ INT2FIX(SF_ENDIAN_CPU));
+
+    // Format masks
+    rb_define_const(mRubyAudio, "FORMAT_SUBMASK", /* 0x0000FFFF */ INT2FIX(SF_FORMAT_SUBMASK));
+    rb_define_const(mRubyAudio, "FORMAT_TYPEMASK", /* 0x0FFF0000 */ INT2FIX(SF_FORMAT_TYPEMASK));
+    rb_define_const(mRubyAudio, "FORMAT_ENDMASK", /* 0x30000000 */ INT2FIX(SF_FORMAT_ENDMASK));
+}

data/lib/ruby-audio.rb

@@ -0,0 +1,10 @@
+begin
+  # Fat binaries for Windows
+  RUBY_VERSION =~ /(\d+.\d+)/
+  require "#{$1}/rubyaudio_ext"
+rescue LoadError
+  require "rubyaudio_ext"
+end
+require 'ruby-audio/buffer'
+require 'ruby-audio/sound_info'
+require 'ruby-audio/sound'

data/lib/ruby-audio/buffer.rb

@@ -0,0 +1,25 @@
+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
+    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
+  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