music_player 0.9.0-universal-darwin-9

data/ext/music_player/util.h

@@ -0,0 +1,25 @@
+#include <ruby.h>
+#include <CoreFoundation/CoreFoundation.h>
+
+/* Test whether a VALUE is a primitive number type. */
+#define PRIM_NUM_P(num) (T_FIXNUM == TYPE(num) || \
+                          T_FLOAT == TYPE(num) || \
+                         T_BIGNUM == TYPE(num))
+
+/* Convert a C string to a Ruby Symbol. */
+#define CSTR2SYM(str) (ID2SYM(rb_intern(str)))
+
+/* Call ruby's === operator on the given lhs and rhs. */
+#define THRQL(lhs, rhs) (rb_funcall(lhs, rb_intern("==="), 1, rhs))
+
+/* Convert a Ruby String to a CFURLRef. */
+#define PATH2CFURL(path) (rb_path_to_cfurl(path))
+
+static CFURLRef
+rb_path_to_cfurl (VALUE rb_path)
+{
+    VALUE rb_abs_path = rb_file_expand_path(rb_path, Qnil);
+    char *path = StringValueCStr(rb_abs_path);
+    CFURLRef url = CFURLCreateFromFileSystemRepresentation(NULL, (const UInt8 *) path, strlen(path), false);
+    return url;
+}

data/lib/music_player.rb

@@ -0,0 +1,216 @@
+$:.unshift File.join(File.dirname(__FILE__), '../ext/music_player')
+require 'thread'
+require 'music_player.bundle'
+
+module AudioToolbox
+  class MusicSequence
+    attr :tracks
+    
+    def load(path)
+      @tracks.lock.synchronize do
+        load_internal(path)
+      end
+    end
+  end
+  
+  class MusicTrackCollection
+    include Enumerable
+    
+    attr :lock # :nodoc:
+    
+    def initialize(sequence)
+      @sequence = sequence
+      @tracks   = []
+      @lock     = Mutex.new
+    end
+    
+    def each
+      0.upto(size-1) { |i| yield self[i] }
+    end
+    
+    def new(options=nil)
+      @lock.synchronize do
+        track = MusicTrack.send(:new, @sequence, options)
+        @tracks << track
+        track
+      end
+    end
+    
+    def [](index)
+      @lock.synchronize do
+        @tracks[index] ||= ind_internal(index)
+      end
+    end
+    
+    def delete(track)
+      @lock.synchronize do
+        delete_internal(track)
+        @tracks.delete(track)
+        track.freeze
+      end
+      nil
+    end
+    
+    def tempo
+      @tempo ||= tempo_internal
+    end
+  end
+  
+  class MusicTrack
+    class << self
+      private :new
+    end
+    
+    def add(time, message)
+      message.add(time, self)
+    end
+    
+    def iterator
+      MusicEventIterator.new(self)
+    end
+    
+    include Enumerable
+    
+    def each
+      i = iterator
+      while i.current?
+        yield i.event
+        i.next
+      end
+      nil
+    end
+    
+    def each_with_time
+      i = iterator
+      while i.current?
+        yield [i.event, i.time]
+        i.next
+      end
+      nil
+    end
+  end
+  
+  class MIDINoteMessage
+    def ==(msg)
+      self.class       == msg.class &&
+      channel          == msg.channel &&
+      note             == msg.note &&
+      velocity         == msg.velocity &&
+      release_velocity == msg.release_velocity &&
+      duration         == msg.duration
+    end
+    
+    def add(time, track)
+      track.add_midi_note_message(time, self)
+    end
+  end
+  
+  class MIDIChannelMessage
+    def ==(msg)
+      self.class == msg.class &&
+      status     == msg.status &&
+      data1      == msg.data1 &&
+      data2      == msg.data2
+    end
+    
+    def channel
+      status ^ mask
+    end
+    
+    def mask
+      raise NotImplementedError, "Subclass responsibility."
+    end
+    
+    def add(time, track)
+      track.add_midi_channel_message(time, self)
+    end
+    
+    protected
+      def required_opts(opts, *keys)
+        keys.map do |key|
+          opts[key] or raise ArgumentError, "%s is required." % key.inspect
+        end
+      end
+  end
+  
+  class MIDIKeyPressureMessage < MIDIChannelMessage
+    alias :note :data1
+    alias :pressure :data2
+    
+    def mask; 0xA0 end
+    
+    def initialize(opts)
+      channel, note, pressure = required_opts(opts, :channel, :note, :pressure)
+      super(:status => mask | channel,
+            :data1  => note,
+            :data2  => pressure)
+    end
+  end
+  
+  class MIDIControlChangeMessage < MIDIChannelMessage
+    alias :number :data1
+    alias :value :data2
+    
+    def mask; 0xB0 end
+    
+    def initialize(opts)
+      channel, number, value = required_opts(opts, :channel, :number, :value)
+      super(:status => mask | channel,
+            :data1  => number,
+            :data2  => value)
+    end
+  end
+  
+  class MIDIProgramChangeMessage < MIDIChannelMessage
+    alias :program :data1
+    
+    def mask; 0xC0 end
+    
+    def initialize(opts)
+      channel, program = required_opts(opts, :channel, :program)
+      super(:status => mask | channel,
+            :data1  => program)
+    end
+  end
+  
+  class MIDIChannelPressureMessage < MIDIChannelMessage
+    alias :pressure :data1
+    
+    def mask; 0xD0 end
+    
+    def initialize(opts)
+      channel, pressure = required_opts(opts, :channel, :pressure)
+      super(:status => mask | channel,
+            :data1  => pressure)
+    end
+  end
+  
+  class MIDIPitchBendMessage < MIDIChannelMessage
+    alias :value :data1
+    
+    def mask; 0xE0 end
+    
+    def initialize(opts)
+      channel, value = required_opts(opts, :channel, :value)
+      super(:status => mask | channel,
+            :data1  => value)
+    end
+  end
+  
+  class ExtendedTempoEvent
+    attr :bpm
+    
+    def add(time, track)
+      track.add_extended_tempo_event(time, @bpm)
+    end
+    
+    def initialize(opts)
+      @bpm = opts[:bpm]
+    end
+
+    def ==(other)
+      self.class == other.class &&
+      bpm        == other.bpm
+    end
+  end
+end

data/test/extended_tempo_event_test.rb

@@ -0,0 +1,15 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class ExtendedTempoEventTest < Test::Unit::TestCase
+  def test_initialization
+    event = ExtendedTempoEvent.new(:bpm => 120)
+    assert_equal 120, event.bpm
+  end
+  
+  def test_add
+    sequence = MusicSequence.new
+    tempo = sequence.tracks.tempo
+    event = ExtendedTempoEvent.new(:bpm => 120)
+    assert_nothing_raised { event.add(0.0, tempo) }
+  end
+end

data/test/midi_channel_message_test.rb

@@ -0,0 +1,93 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class MIDIChannelMessageTest < Test::Unit::TestCase
+  def test_initialization
+    assert_raise(ArgumentError) { MIDIChannelMessage.new }
+    assert_raise(ArgumentError) { MIDIChannelMessage.new({}) }
+    assert_nothing_raised { MIDIChannelMessage.new :status => 42 }
+  end
+  
+  def test_eq
+    msg1 = make_msg
+    msg2 = make_msg
+    # Demonstrates that separate Ruby MIDIChannelMessage objects may be
+    # compared by value.
+    assert msg1.object_id != msg2.object_id
+    assert msg1 == msg2
+  end
+  
+  def test_accessors
+    msg = make_msg
+    assert_equal 42, msg.status
+    assert_equal 43, msg.data1
+    assert_equal 44, msg.data2
+  end
+  
+  def make_msg
+    MIDIChannelMessage.new(:status => 42, :data1  => 43, :data2  => 44)
+  end
+end
+
+class MIDIKeyPressureMessageTest < Test::Unit::TestCase
+  def test_initialization
+    msg = MIDIKeyPressureMessage.new(
+            :channel  => 1,
+            :note     => 60,
+            :pressure => 64)
+    
+    assert_equal 1, msg.channel
+    assert_equal 60, msg.note
+    assert_equal 64, msg.pressure
+    assert_equal msg.mask | msg.channel, msg.status
+  end
+end
+
+class MIDIControlChangeMessageTest < Test::Unit::TestCase
+  def test_initialization
+    msg = MIDIControlChangeMessage.new(
+            :channel => 1,
+            :number  => 8,
+            :value   => 64)
+    
+    assert_equal 1, msg.channel
+    assert_equal 8, msg.number
+    assert_equal 64, msg.value
+    assert_equal msg.mask | msg.channel, msg.status
+  end
+end
+
+class MIDIProgramChangeMessageTest < Test::Unit::TestCase
+  def test_initialization
+    msg = MIDIProgramChangeMessage.new(
+            :channel => 1,
+            :program => 2)
+    
+    assert_equal 1, msg.channel
+    assert_equal 2, msg.program
+    assert_equal msg.mask | msg.channel, msg.status
+  end
+end
+
+class MIDIChannelPressureMessageTest < Test::Unit::TestCase
+  def test_initialization
+    msg = MIDIChannelPressureMessage.new(
+            :channel  => 1,
+            :pressure => 64)
+    
+    assert_equal 1, msg.channel
+    assert_equal 64, msg.pressure
+    assert_equal msg.mask | msg.channel, msg.status
+  end
+end
+
+class MIDIPitchBendMessageTest < Test::Unit::TestCase
+  def test_initialization
+    msg = MIDIPitchBendMessage.new(
+            :channel => 1,
+            :value   => 64)
+    
+    assert_equal 1, msg.channel
+    assert_equal 64, msg.value
+    assert_equal msg.mask | msg.channel, msg.status
+  end
+end

data/test/midi_note_message_test.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class MIDINoteMessageTest < Test::Unit::TestCase
+  include AudioToolbox
+  
+  def test_initialization
+    assert_raise(ArgumentError) { MIDINoteMessage.new }
+    assert_raise(ArgumentError) { MIDINoteMessage.new({}) }
+    assert_nothing_raised { MIDINoteMessage.new :note => 60 }
+    assert_nothing_raised do
+      # Do your own range-checking. This is harmless.
+      oob = rand(10000)
+      msg = MIDINoteMessage.new :note => oob
+      assert_equal (oob%256), msg.note
+    end
+  end
+  
+  def test_defaults
+    msg = MIDINoteMessage.new :note => 60 # No default for :note.
+    assert_equal 1, msg.channel
+    assert_equal 64, msg.velocity
+    assert_equal 0, msg.release_velocity
+    assert_equal 1.0, msg.duration
+  end
+  
+  def test_accessors
+    msg = make_msg
+    assert_equal 50, msg.note
+    assert_equal 40, msg.velocity
+    assert_equal 30, msg.release_velocity
+    assert_equal 2.0, msg.duration
+  end
+  
+  def test_eq
+    msg1 = make_msg
+    msg2 = make_msg
+    # Demonstrates that separate Ruby MIDIChannelMessage objects may be
+    # compared by value.
+    assert msg1.object_id != msg2.object_id
+    assert msg1 == msg2
+  end
+  
+  def make_msg
+    MIDINoteMessage.new(
+      :note             => 50,
+      :velocity         => 40,
+      :release_velocity => 30,
+      :duration         => 2.0)
+  end
+end

data/test/music_event_iterator_test.rb

@@ -0,0 +1,160 @@
+require File.join(File.dirname(__FILE__), 'test_helper.rb')
+
+class MusicEventIteratorTest < Test::Unit::TestCase
+  def setup
+    @sequence = MusicSequence.new
+    @track = @sequence.tracks.new
+    @track.add 0, @ev1=MIDINoteMessage.new(:note => 60)
+    @track.add 1, @ev2=MIDINoteMessage.new(:note => 67)
+    @iter = @track.iterator
+  end
+  
+  def test_seek
+    assert_nothing_raised { @iter.seek(0) }
+    assert_equal @ev1, @iter.event
+    # Seeking to a point between event onsets causes
+    # the iterator to advance to the next onset.
+    @iter.seek(0.1) 
+    assert_equal @ev2, @iter.event
+  end
+  
+  def test_current?
+    assert @iter.current?
+    @iter.next
+    assert @iter.current?
+    @iter.next
+    assert !@iter.current?
+  end
+  
+  def test_next
+    assert_nothing_raised do
+      @iter.next; @iter.next
+    end
+    assert_raise(EndOfTrack) { @iter.next }
+  end
+  
+  def test_next?
+    assert @iter.next?
+    @iter.next
+    assert !@iter.next?
+    @iter.next # We may advance once beyond the last event.
+    assert_raise(EndOfTrack) { @iter.next }
+  end
+  
+  def test_prev
+    assert_nothing_raised do
+      @iter.next; @iter.prev
+    end
+    assert_raise(StartOfTrack) { @iter.prev }
+  end
+  
+  def test_prev?
+    assert !@iter.prev?
+    @iter.next
+    assert @iter.prev?
+  end
+
+  def test_time
+    assert_equal 0.0, @iter.time
+    @iter.next
+    assert_equal 1.0, @iter.time
+    @iter.next
+    assert_raise(EndOfTrack) { @iter.time }
+    @iter.seek(0.0)
+    assert_equal 0.0, @iter.time
+  end
+  
+  def test_set_time
+    # swap note onsets
+    assert_equal 0, @iter.time
+    @iter.time = 1
+    assert_equal 1, @iter.time
+    @iter.next
+    assert_equal 1, @iter.time
+    @iter.time = 0
+    
+    @iter.seek 0
+    assert_equal @ev2, @iter.event
+    @iter.next
+    assert_equal @ev1, @iter.event
+  end
+  
+  def test_event__note
+    assert_nothing_raised do
+      assert_equal @ev1, @iter.event
+      @iter.next
+      assert_equal @ev2, @iter.event
+    end
+  end
+  
+  def test_event__channel
+    track = @sequence.tracks.new
+    track.add 0, ev1=MIDIKeyPressureMessage.new(:channel => 1, :note => 60, :pressure => 64)
+    track.add 0, ev2=MIDIControlChangeMessage.new(:channel => 1, :number => 1, :value => 127)
+    track.add 0, ev3=MIDIProgramChangeMessage.new(:channel => 1, :program => 42)
+    track.add 0, ev4=MIDIChannelPressureMessage.new(:channel => 1, :pressure => 37)
+    track.add 0, ev5=MIDIPitchBendMessage.new(:channel => 1, :value => 84)
+    iter = track.iterator
+    
+    assert_equal ev1, iter.event
+    iter.next
+    assert_equal ev2, iter.event
+    iter.next
+    assert_equal ev3, iter.event
+    iter.next
+    assert_equal ev4, iter.event
+    iter.next
+    assert_equal ev5, iter.event
+  end
+  
+  def test_event__tempo
+    track = @sequence.tracks.tempo
+    track.add 0, ev=ExtendedTempoEvent.new(:bpm => 120)
+    iter = track.iterator
+    assert_equal ev, iter.event
+  end
+  
+  def test_set_event
+    # swapping notes 
+    @iter.seek(0)
+    @iter.event = @ev2
+    @iter.next
+    @iter.event = @ev1
+    
+    @iter.seek(0)
+    assert_equal @ev2, @iter.event
+    @iter.next
+    assert_equal @ev1, @iter.event
+    
+    # Event types may be altered.
+    @iter.seek(0)
+    @iter.event = cc=MIDIControlChangeMessage.new(:channel => 1, :number => 2, :value => 3)
+    assert_equal cc, @iter.event
+    
+    # Assigning when there is no current event raises an exception.
+    # Use MusicTrack#add to add new events.
+    @iter.next until !@iter.current?
+    assert_raise(EndOfTrack) do
+      @iter.event = MIDINoteMessage.new(:note => 60)
+    end
+    
+    # Tempo tracks are iterable as well.
+    tempo = @sequence.tracks.tempo
+    tempo.add 0, ExtendedTempoEvent.new(:bpm => 120)
+    
+    iter = @sequence.tracks.tempo.iterator
+    assert_equal 120, iter.event.bpm
+    iter.event = ExtendedTempoEvent.new(:bpm => 60)
+    assert_equal 60, iter.event.bpm
+  end
+  
+  def test_delete
+    assert_equal @ev1, @iter.event
+    @iter.delete
+    assert_equal @ev2, @iter.event
+    @iter.delete
+    
+    assert !@iter.current?
+    assert_nothing_raised { @iter.delete }
+  end
+end