ruby-audio-heroku 1.6.1

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,83 @@
+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 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
+
+    # 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|
+        next if f.include?('MASK') # Skip mask constants
+
+        val = RubyAudio.const_get(f)
+        if val > RubyAudio::FORMAT_SUBMASK
+          # Main format
+          @main_format = f if format & RubyAudio::FORMAT_TYPEMASK == val
+        else
+          # Sub format
+          @sub_format = f if format & RubyAudio::FORMAT_SUBMASK == val
+        end
+      end
+    end
+  end
+end

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/ruby-audio-heroku.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name        = 'ruby-audio-heroku'
+  s.version     = '1.6.1'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Khurram Zaman']
+  s.email       = ['khurram.zaman@gmail.com']
+  s.homepage    = 'https://github.com/khurramzaman/ruby-audio-heroku'
+  s.summary     = 'libsndfile wrapper for ruby that works on heroku'
+  s.description = 'ruby-audio-heroku wraps around libsndfile to provide simplified sound reading and writing support to ruby programs. it works on heroku.'
+
+  s.files         = Dir['ruby-audio-heroku.gemspec', 'README.rdoc', 'LICENSE', 'Rakefile', 'lib/**/*.rb', 'spec/**/*.{rb,opts,wav,mp3}', 'ext/**/*.{c,h,rb}']
+  s.test_files    = Dir['spec/**/*_spec.rb']
+  s.extensions    = Dir["ext/**/extconf.rb"]
+
+  s.requirements << ''
+
+  s.has_rdoc         = true
+  s.extra_rdoc_files = Dir['README.rdoc', 'ext/**/*.c']
+  s.rdoc_options     = ['--line-numbers', '--main', 'README.rdoc']
+end

data/spec/buffer_spec.rb

@@ -0,0 +1,107 @@
+require "spec_helper.rb"
+
+describe RubyAudio::Buffer do
+  it "should initialize properly" do
+    buf = RubyAudio::Buffer.new('float', 100, 2)
+    buf.channels.should == 2
+    buf.size.should == 100
+    buf.real_size.should == 0
+    buf.type.should == :float
+  end
+
+  it "should support pretty typed constructors" do
+    lambda {
+      [:short, :int, :float, :double].each do |type|
+        buf = RubyAudio::Buffer.send(type, 100)
+      end
+    }.should_not raise_error
+  end
+
+  it "should allow [] access on integer single channel buffers" do
+    buf = RubyAudio::Buffer.int(100, 1)
+    buf[0] = 1.3
+    buf[0].should == 1
+
+    buf = RubyAudio::Buffer.short(100, 1)
+    buf[20] = 614
+    buf[20].should == 614
+  end
+
+  it "should allow [] access on floating point single channel buffers" do
+    buf = RubyAudio::Buffer.double(100, 1)
+    buf[30] = 1.375
+    buf[30].should == 1.375
+
+    buf = RubyAudio::Buffer.float(100, 1)
+    buf[12] = 5
+    buf[12].should == 5.0
+  end
+
+  it "should allow [] access on multi-channel buffers" do
+    buf = RubyAudio::Buffer.double(100, 2)
+    buf[0] = [0.5, 0.3]
+    buf[0].should == [0.5, 0.3]
+  end
+
+  it "should raise exception if channel count of set frame does not match buffer's" do
+    lambda {
+      buf = RubyAudio::Buffer.double(100, 2)
+      buf[0] = [0.4, 0.8, 0.8]
+    }.should raise_error(RubyAudio::Error, "array length must match channel count")
+  end
+
+  it "should return nil on out-of-bounds [] access" do
+    buf = RubyAudio::Buffer.float(100)
+    buf[101].should == nil
+    buf[-1].should == nil
+  end
+
+  it "should truncate invalid real size" do
+    buf = RubyAudio::Buffer.float(100)
+    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
+
+  context ".each" do
+    before(:each) do
+      @buf = RubyAudio::Buffer.int(10, 2)
+      10.times do |i|
+        @buf[i] = [i, i]
+      end
+    end
+
+    it "should yield the elements in order" do
+      i = 0
+      @buf.each do |left, right|
+        left.should == i
+        right.should == i
+        i += 1
+      end
+    end
+
+    it "shouldn't do anything on an empty buffer" do
+      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

@@ -0,0 +1,55 @@
+require "spec_helper.rb"
+
+describe RubyAudio::SoundInfo do
+  it "should initialize with default properties" do
+    info = RubyAudio::SoundInfo.new
+    info.channels.should == 0
+    info.samplerate.should == 0
+    info.format.should == 0
+  end
+
+  it "should allow setting properties on initialize" do
+    info = RubyAudio::SoundInfo.new(:channels => 1, :samplerate => 48000, :format => RubyAudio::FORMAT_WAV|RubyAudio::FORMAT_PCM_16)
+    info.channels.should == 1
+    info.samplerate.should == 48000
+    info.format.should == RubyAudio::FORMAT_WAV|RubyAudio::FORMAT_PCM_16
+  end
+
+  it "should allow setting properties after initialize" do
+    info = RubyAudio::SoundInfo.new
+    info.channels = 3
+    info.channels.should == 3
+  end
+
+  it "should not be valid if properties invalid" do
+    info = RubyAudio::SoundInfo.new(:channels => 1, :samplerate => 48000, :format => RubyAudio::FORMAT_WAV)
+    info.valid?.should == false
+    info.format = RubyAudio::FORMAT_WAV|RubyAudio::FORMAT_PCM_16
+    info.valid?.should == true
+  end
+
+  it "should allow cloning" do
+    info = RubyAudio::SoundInfo.new(:channels => 1, :samplerate => 48000, :format => RubyAudio::FORMAT_WAV|RubyAudio::FORMAT_PCM_16)
+    info2 = info.clone
+    info.object_id.should_not == info2.object_id
+    info.channels.should == info2.channels
+    info.samplerate.should == info2.samplerate
+    info.format.should == info2.format
+  end
+
+  it "should calculate main and sub format from format" do
+    info = RubyAudio::SoundInfo.new(:format => RubyAudio::FORMAT_WAV|RubyAudio::FORMAT_PCM_16)
+    info.main_format.should == "FORMAT_WAV"
+    info.sub_format.should == "FORMAT_PCM_16"
+
+    info = RubyAudio::SoundInfo.new(:format => RubyAudio::FORMAT_WAVEX|RubyAudio::FORMAT_MS_ADPCM)
+    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

@@ -0,0 +1,220 @@
+require "spec_helper.rb"
+
+describe RubyAudio::Sound do
+  after :each do
+    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(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(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(fixture('what.wav')) do |snd|
+      snd.closed?.should be_false
+      s = snd
+    end
+    s.closed?.should be_true
+  end
+
+  it "should raise an exception for an unsupported file" do
+    lambda {
+      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(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(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
+    end
+  end
+
+  it "should allow seeking" do
+    lambda {
+      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
+      end
+    }.should_not raise_error
+  end
+
+  it "should raise exceptions for invalid seeks" do
+    lambda {
+      RubyAudio::Sound.open(fixture('what.wav')) {|snd| snd.seek(-1)}
+    }.should raise_error(RubyAudio::Error, "invalid seek")
+    lambda {
+      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(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
+      buf[999].length.should == 2
+    end
+  end
+
+  it "should allow reading into an existing buffer" do
+    buf = RubyAudio::Buffer.float(1000)
+    buf.real_size.should == 0
+    RubyAudio::Sound.open(fixture('what.wav')) do |snd|
+      snd.read(buf)
+    end
+    buf.real_size.should == 1000
+    buf[99].should > 0
+  end
+
+  it "should allow reading into an existing buffer partially" do
+    buf = RubyAudio::Buffer.float(1000)
+    buf.real_size.should == 0
+    RubyAudio::Sound.open(fixture('what.wav')) do |snd|
+      snd.read(buf, 100)
+    end
+    buf.real_size.should == 100
+    buf[99].should > 0
+    buf[100].should == nil
+  end
+
+  it "should allow downmixing to mono on read" do
+    buf = RubyAudio::Buffer.int(100, 1)
+    buf2 = RubyAudio::Buffer.int(100, 2)
+    RubyAudio::Sound.open(fixture('what2.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(fixture('what2.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(fixture('what2.wav')) do |snd|
+        snd.read(buf)
+      end
+    }.should raise_error(RubyAudio::Error, "unsupported mix from 5 to 2")
+  end
+
+  it "should allow writing to a new sound" 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(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(io_fixture, '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 a new sound using <<" 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(fixture('temp.wav'), 'rw', out_info) do |snd|
+      snd << in_buf
+      snd.seek(0)
+      snd.read(out_buf)
+    end
+
+    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(fixture('temp.wav'), 'w', info) do |snd|
+        snd.write(buf)
+      end
+    }.should raise_error(RubyAudio::Error, "channel count mismatch: 5 vs 2")
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--colour
+-f nested

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+require 'spec/autorun'
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+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