ruby-audio 0.2.1 → 1.0.0

data/ext/sndfile/sndfile.i

@@ -1,90 +0,0 @@
-// TODO: sf_command,
-%module "sndfile"
-%{
-#include <sndfile.h>
-#include <narray.h>
-%}
-
-// this bit brought to you by stdio.h
-#ifndef SEEK_SET
-#define SEEK_SET        0       /* set file offset to offset */
-#endif
-#ifndef SEEK_CUR
-#define SEEK_CUR        1       /* set file offset to current plus offset */
-#endif
-#ifndef SEEK_END
-#define SEEK_END        2       /* set file offset to EOF plus offset */
-#endif
-
-%include "typemaps.i"
-%typemap(out) int sf_format_check {
-  if ($1)
-    $result = Qtrue;
-  else
-    $result = Qfalse;
-}
-
-%typemap(out) sf_count_t {
-  $result = INT2NUM($1);
-}
-%typemap(in) sf_count_t {
-  $1 = (sf_count_t) NUM2INT($input);
-}
-
-// We have to do this or when a function like sf_get_string returns NULL it
-// will raise an exception when trying to create the string.
-%typemap(out) const char *{
-    if ($1 == 0) 
-	$result = Qnil;
-    else
-	$result = rb_str_new2($1);
-}
-
-%typemap(in) (short *ptr, sf_count_t),
-    (const short *ptr, sf_count_t)
-{
-if (!(NA_IsNArray($input) && NA_TYPE($input) == NA_SINT)) 
-    rb_raise(rb_eArgError, "Expected NArray.sint");
-$1 = NA_PTR_TYPE($input, $1_type); 
-$2 = NA_TOTAL($input);
-}
-%typemap(in) (int *ptr, sf_count_t),
-    (const int *ptr, sf_count_t)
-{
-if (!(NA_IsNArray($input) && NA_TYPE($input) == NA_LINT))
-	rb_raise(rb_eArgError, "Expected NArray.int");
-$1 = NA_PTR_TYPE($input, $1_type); 
-$2 = NA_TOTAL($input);
-}
-%typemap(in) (float *ptr, sf_count_t), 
-    (const float *ptr, sf_count_t)
-{
-if (!(NA_IsNArray($input) && NA_TYPE($input) == NA_SFLOAT))
-	rb_raise(rb_eArgError, "Expected NArray.sfloat");
-$1 = NA_PTR_TYPE($input, $1_type); 
-$2 = NA_TOTAL($input);
-}
-%typemap(in) (double *ptr, sf_count_t),
-    (const double *ptr, sf_count_t)
-{
-if (!(NA_IsNArray($input) && NA_TYPE($input) == NA_DFLOAT))
-	rb_raise(rb_eArgError, "Expected NArray.float");
-$1 = NA_PTR_TYPE($input, $1_type); 
-$2 = NA_TOTAL($input);
-}
-
-%typemap(in) (void *data, int datasize), (void *ptr, sf_count_t), 
-    (const void *ptr, sf_count_t)
-{
-if (!NA_IsNArray($input))
-    rb_raise(rb_eArgError, "Expected NArray");
-$1 = NA_STRUCT($input)->ptr;
-$2 = NA_TOTAL($input) * na_sizeof[NA_TYPE($input)];
-}
-
-
-// sf_perror and sf_error_str are deprecated. sf_error_str probably doesn't
-// work at all.
-
-%include "sndfile.h"
-// vim: filetype=c

data/lib/audio.rb

@@ -1,134 +0,0 @@
-require 'rubygems'
-require 'narray'
-
-# TODO: libsamplerate, portaudio
-module Audio
-  
-  # A Sound is a NArray with some audio convenience methods. It should always
-  # have the shape <tt>[frames,channels]</tt>. (Even when m=1)
-  #
-  # *Notice* for NArray users: because most audio libraries do not agree with
-  # NArray on type names, Sound.float has a different meaning than
-  # NArray.float. Also, the shape of a new Sound is different than you might
-  # expect:
-  #   s = Sound.float(10)
-  #   n = NArray.float(10)
-  #   s.shape			#=> [10,1]
-  #   n.shape			#=> [10]
-  #   s.typecode		#=> 4
-  #   n.typecode		#=> 5
-  class Sound < NArray
-
-    # Mapping from typecode to type symbols
-    TYPES = [nil,:char,:short,:long,:float,:double]
-
-    # typecode:: Same as NArray, or a member of TYPES
-    # frames::   Number of frames
-    # channels:: Number of channels
-    #
-    # Note that the resulting shape is always [frames,channels].
-    def self.new(typecode,frames,channels=1)
-      case typecode
-      when String, Symbol
-	typecode = TYPES.index(typecode.to_sym)
-      end
-      super(typecode,frames,channels)
-    end
-
-    # One of TYPES
-    def type
-      TYPES[typecode]
-    end
-
-    # The number of frames
-    def frames
-      self.shape[0]
-    end
-
-    # The number of channels
-    def channels
-      self.shape[1]
-    end
-
-    # Returns a new Sound with the data from channel i
-    def channel(i)
-      self[true,i]
-    end
-
-    # A frame, i.e. an array containing the samples at position i from each
-    # channel. For a two-channel sound:
-    #   sound.frame(i) #=> [0.42, 0.12]
-    #
-    # You may prefer to do this the NArray way: s[i,false]
-    def frame(i)
-      unless (0...frames).include? i
-	raise IndexError, "Index out of range"
-      end
-      self[i,false]
-    end
-
-    # For a two-channel sound:
-    #   s.set_frame(i,[0.42,0.24])
-    #   s.set_frame(i,0.42) #=> s.set_frame(i,[0.42,0.42])
-    #
-    # You may prefer to do this the NArray way: s[i,false] = val
-    def set_frame(i,val)
-      self[i,false] = val
-    end
-
-    def each_frame
-      frames.times do |i|
-	yield frame(i)
-      end
-    end
-
-    # Return a Sound with the channels interleaved.
-    #   Sound[[0,1],[2,3]].interleaved #=> Sound[[0,2,1,3]]
-    def interleave
-      self.transpose(1,0).reshape!(self.size,1)
-    end
-    alias_method :interleaved, :interleave
-
-    # Fill this Sound's channels with deinterleaved data.
-    #   Sound[[0,0],[0,0]].interleaved = NArray[0,2,1,3] #=> Sound[[0,1],[2,3]]
-    def interleave=(o)
-      self[] = o.reshape(channels,frames).transpose(1,0)
-      self
-    end
-    alias_method :interleaved=, :interleave=
-
-
-    # Creates a new Sound with the specified number of channels from the
-    # interleaved data in narray. narray should be evenly divisible by
-    # channels.
-    def self.deinterleave(narray,channels)
-      unless narray.size % channels == 0
-	raise ArgumentError, "narray not evenly divisible by channels"
-      end
-      frames = narray.size/channels
-      s = Sound.new(narray.typecode,frames,channels)
-      s.interleaved = narray
-      s
-    end
-    def deinterleave(channels)
-      self.class.deinterleave(self,channels)
-    end
-    def deinterleave!(channels)
-      s = deinterleave(channels)
-      reshape!(*s.shape)
-      self[] = s
-    end
-
-    %w{char short long float double}.each_with_index do |t,i|
-      eval "def self.#{t}(frames,channels=1); self.new(#{i+1},frames,channels); end"
-    end
-
-    # alias class methods
-    class << self
-      alias_method :byte,   :char
-      alias_method :sint,   :short
-      alias_method :int,    :long
-      alias_method :sfloat, :float
-    end
-  end
-end

data/lib/audio/sndfile.rb

@@ -1,156 +0,0 @@
-require 'audio'
-require 'sndfile.so'
-
-module Audio
-  # libsndfile[http://www.mega-nerd.com/libsndfile/]
-  #
-  # = Synopsis
-  #   require 'audio/sndfile'
-  #   
-  #   Audio::Soundfile.open('chunky_bacon.wav') do |sf|
-  #     sound = sf.readf_float(sf.frames)
-  #     puts "Maximum amplitude: #{sound.abs.max}"
-  #   end
-  #
-  # = Details
-  # Refer to the libsndfile api[http://www.mega-nerd.com/libsndfile/api.html].
-  #
-  # Usage is quite straightforward: drop the +sf_+ prefix, omit the
-  # <tt>SNDFILE*</tt> parameter, and use Sound or Numeric instead of
-  # (pointer, size) pairs. So, if you have a Soundfile object named +sf+, then
-  #   sf_read_float(SNDFILE, float *ptr, sf_count_t items) 
-  # becomes
-  #   buf = Sound.float(items)
-  #   sf.read_float(buf)
-  # or
-  #   buf = sf.read_float(items)  # creates a new Sound
-  # 
-  # Exceptions to this pattern are documented below.
-  #
-  # Constants are accessed as <tt>Soundfile::SF_FORMAT_WAV</tt>
-  class Soundfile
-    # SF_INFO
-    attr :info
-    attr_reader :mode
-
-    # mode:: One of %w{r w rw}
-    # info:: Instance of SF_INFO or nil
-    def initialize(path, mode='r', info=nil)
-      if info.nil?
-	info = SF_INFO.new
-      end
-      
-      modes = {:r => SFM_READ, :w => SFM_WRITE, :rw => SFM_RDWR}
-      unless Numeric === mode
-	mode = modes[mode.to_sym]
-      end
-      unless [SFM_READ, SFM_WRITE, SFM_RDWR].include? mode
-	raise ArgumentError, "Invalid mode" 
-      end
-
-      sf = Sndfile.sf_open(path.to_s, mode, info)
-      @sf = sf
-      @info = info
-      @mode = modes.invert[mode]
-      if block_given?
-	yield self
-	self.close
-      end
-    end
-
-    class << self
-      alias_method :open, :new
-    end
-
-    def frames
-      @info.frames
-    end
-    def samplerate
-      @info.samplerate
-    end
-    def channels
-      @info.channels
-    end
-    def format
-      @info.format
-    end
-    def sections
-      @info.sections
-    end
-    def seekable
-      @info.seekable
-    end
-
-    # The following are equivalent: 
-    #   sf_format_check(info) /* C */
-    #   sf.format_check       # ruby
-    def format_check
-      Sndfile.sf_format_check(@info)
-    end
-
-    TYPES = [nil,:char,:short,:int,:float,:double] #:nodoc:
-
-    # Automagic read method. Type is autodetected.
-    def read(na)
-      sym = "read_#{TYPES[na.typecode]}".to_sym
-      self.send sym, na
-    end
-
-    # Automagic write method. Type is autodetected.
-    def write(na)
-      sym = "write_#{TYPES[na.typecode]}".to_sym
-      self.send sym, na
-    end
-
-    %w{read readf}.each do |r|
-      %w{short int float double}.each do |t|
-	tc = TYPES.index(t.to_sym)
-	c = ', channels' if r == 'readf'
-	cmd = "#{r}_#{t}"
-	eval <<-EOF
-	  def #{cmd}(arg)
-	    if Numeric === arg
-	      na = NArray.new(#{tc}, arg#{c})
-	      n = Sndfile.sf_#{cmd}(@sf, na)
-	      Sound.deinterleave(na, channels)
-	    else
-	      na = arg
-	      n = Sndfile.sf_#{cmd}(@sf, na)
-	      na.deinterleave!(channels)
-	      n
-	    end
-	  end
-	EOF
-      end
-    end
-
-    %w{write writef}.each do |w|
-      %w{short int float double}.each do |t|
-	cmd = "#{w}_#{t}"
-	eval <<-EOF
-	  def #{cmd}(sound)
-	    raise "Format check failed: \#{perror}" unless format_check
-	    Sndfile.sf_#{cmd}(@sf, sound.interleave)
-	  end
-	EOF
-      end
-    end
-
-    def method_missing(name, *args) #:nodoc:
-      begin
-	Sndfile.send "sf_#{name}".to_sym, @sf, *args
-      rescue NameError
-	super
-      end
-    end
-
-    def self.const_missing(sym) #:nodoc:
-      begin
-	Sndfile.const_get(sym)
-      rescue NameError
-	super
-      end
-    end
-  end
-end
-

data/test/test_audio.rb

@@ -1,82 +0,0 @@
-require 'test/unit'
-require 'audio'
-
-class AudioTest < Test::Unit::TestCase
-  include Audio
-  def test_sound
-    %w{char short long float double}.each do |t|
-      eval "s = Sound.#{t}(10); assert_equal :#{t}, s.type"
-    end
-    s = Sound.float(6).indgen!
-    assert_equal [6,1], s.shape
-    assert_equal 1, s.channels
-    assert_equal 6, s.frames
-    s.reshape!(3,2)
-    assert_equal 2, s.channels
-    assert_equal 3, s.frames
-    assert_equal [[0.0,3.0,1.0,4.0,2.0,5.0]], s.interleave.to_a
-    assert_equal 6, s.size
-
-    s = Sound.byte(10); assert_equal :char, s.type
-    s = Sound.sint(10); assert_equal :short, s.type
-    s = Sound.int(10); assert_equal :long, s.type
-    s = Sound.sfloat(10); assert_equal :float, s.type
-
-    s = Sound.sfloat(10)
-    assert_equal 10, s.size
-    assert_equal 10, s.frames
-    assert_equal 1, s.channels
-    assert_equal :float, s.type
-    assert_kind_of NArray, s
-    s.channels.times do |i|
-      c = s.channel(i)
-      assert_kind_of NArray, c
-      assert_instance_of Sound, c
-      assert_equal 10, c.size
-    end
-
-    s = Sound.double(10,2)
-    assert_equal 2, s.channels
-    assert_equal 10, s.frames
-
-    c = s.channel(1)
-    assert_instance_of Sound, c
-    assert_equal 10, c.size
-
-    s.each_frame do |a|
-      assert_instance_of Sound, a
-      assert_kind_of Numeric, a[0]
-      assert_kind_of Numeric, a[1]
-    end
-
-    # test new
-    s = Sound.new(4,10)
-    assert_equal [10,1], s.shape
-    assert_equal 10, s.size
-    assert_equal 4, s.typecode
-    assert_equal :float, s.type
-    assert_equal 10, s.frames
-    assert_equal 1, s.channels
-
-    s = Sound.new(:long,10)
-    assert_equal [10,1], s.shape
-    assert_equal 10, s.size
-    assert_equal 3, s.typecode
-    assert_equal :long, s.type
-    assert_equal 10, s.frames
-    assert_equal 1, s.channels
-  end
-
-  def test_interleave
-    s = Sound.float(2,2).indgen!
-    i = s.interleave
-    assert_equal s[0,0], i[0]
-    assert_equal s[0,1], i[1]
-
-    s2 = Sound.deinterleave(i,2)
-    assert_equal s, s2
-
-    s2.interleave = i
-    assert_equal s, s2
-  end
-end