midi-topaz 0.1.2 → 0.2.1

data/lib/topaz/internal_tempo.rb

@@ -1,88 +0,0 @@
-module Topaz
-
-  class InternalTempo < Gamelan::Timer
-            
-    def initialize(events, tempo, options = {})
-      @events = events
-      @last = 0
-      @last_sync = 0
-      self.interval = options[:interval] || 4 
-      
-      super({:tempo => tempo})
-    end
-
-    # start the internal timer
-    # pass :background => true to keep the timer in a background thread
-    def start(options = {})
-      run
-      join unless !!options[:background]
-      self
-    end
-    
-    # change the timer's click interval    
-    def interval=(val)
-      @interval = val / 4
-    end
-    
-    def interval
-      @interval * 4
-    end
-    
-    # stop the timer
-    def stop(*a)
-      super()
-      self
-    end
-    
-    def join
-      super()
-      self
-    end
-    
-    protected
-
-    # Initialize the scheduler's clock, and begin executing tasks.
-    def run
-      return if @running
-      @running  = true
-      @thread   = Thread.new do
-        begin
-          @phase  = 0.0
-          @origin = @time = Time.now.to_f
-          loop { dispatch; advance }
-        rescue Exception => exception
-          Thread.main.raise(exception)
-        end
-      end
-      @thread.abort_on_exception = true
-    end 
-
-    # Run all ready tasks.
-    def dispatch
-      # stuff to do on every tick      
-      if time_for_midi_clock?
-        # look for stop
-        (stop and return) if @events.stop?
-        @events.do_midi_clock        
-        @last_sync = (@phase * 24).to_i
-      end
-      # stuff to do on @interval
-      if time_for_tick?
-        @events.do_tick
-        @last = (@phase * @interval).to_i
-      end      
-    end
-    
-    private
-    
-    def time_for_midi_clock?
-      !@last_sync.eql?((@phase * 24).to_i)
-    end
-    
-    def time_for_tick?
-      !@last.eql?((@phase * @interval).to_i)
-    end
-     
-  end
-  
-end

data/lib/topaz/midi_sync_output.rb

@@ -1,33 +0,0 @@
-module Topaz
-  
-  # Send clock messages via MIDI
-  class MIDISyncOutput
-    
-    attr_reader :output
-     
-    def initialize(output)
-      @output = output
-    end
-    
-    # Send a start message
-    def start(*a)
-      start = MIDIMessage::SystemRealtime["Start"].new.to_a
-      @output.puts(start)
-    end
-
-    # Send a stop message
-    def stop(*a)
-      p "hi"
-      stop = MIDIMessage::SystemRealtime["Stop"].new.to_a
-      @output.puts(stop)
-    end
-        
-    # Send a clock tick message
-    def clock(*a)
-      clock = MIDIMessage::SystemRealtime["Clock"].new.to_a
-      @output.puts(clock)
-    end
-    
-  end
-  
-end

data/lib/topaz/tempo.rb

@@ -1,164 +0,0 @@
-module Topaz
-  
-  # Main tempo class
-  class Tempo
-    
-    extend Forwardable
-    
-    attr_reader :source, :destinations
-    
-    def_delegators :source, :tempo, :interval, :interval=, :join
-  
-    def initialize(tempo_or_input, options = {}, &tick_event)
-      @paused = false
-      @destinations = [] 
-      @events = Events.new
-
-      configure(tempo_or_input, options, &tick_event)     
-    end
-    
-    # Change the tempo
-    #
-    # Caution that in the case that external MIDI tempo is being used, this will switch to internal 
-    # tempo at the desired rate.
-    #
-    def tempo=(val)
-      if @source.respond_to?(:tempo=)
-        @source.tempo = val
-      else
-        @source = InternalTempo.new(@events, val)
-      end 
-    end
-    
-    # Pause the clock
-    def pause
-      @pause = true
-    end
-    
-    # Unpause the clock
-    def unpause
-      @pause = false
-    end
-    
-    # Is this clock paused?
-    def paused?
-      @pause
-    end
-   
-    # Toggle pausing the clock
-    def toggle_pause
-      paused? ? unpause : pause      
-    end
-    
-    # Pass in a callback that is called when start is called
-    def on_start(&callback)
-      @events.start[0] = callback
-    end
-
-    # pass in a callback that is called when stop is called
-    def on_stop(&callback)
-      @events.stop[0] = callback
-    end
-    
-    # Pass in a callback which will stop the clock if it evaluates to true 
-    def stop_when(&callback)
-      @events.stop_when = callback
-    end
-    
-    # Pass in a callback which will be fired on each tick
-    def on_tick(&callback)
-      wrapper = proc do
-        unless paused?
-          yield
-        end
-      end
-      @events.tick[0] = wrapper
-    end
-        
-    # this will start the generator
-    #
-    # in the case that external midi tempo is being used, this will wait for a start 
-    # or clock message
-    #
-    def start(options = {})
-      begin
-        @start_time = Time.now
-        @events.do_start
-        @source.start(options)
-      rescue SystemExit, Interrupt => exception
-        stop
-      end
-    end
-    
-    # This will stop the clock
-    def stop(options = {})
-      @source.stop(options)
-      @events.do_stop
-      @start_time = nil
-    end
-    
-    # Seconds since start was called
-    def time
-      (Time.now - @start_time).to_f unless @start_time.nil?
-    end
-    alias_method :time_since_start, :time
-    
-    # Add a destination
-    # @param [Array<UniMIDI::Output>, UniMIDI::Output] destinations
-    def add_destination(destinations)
-      destinations = [destinations].flatten.compact
-      destinations.each do |destination|
-        output = MIDISyncOutput.new(destination) 
-        @destinations << output
-      end
-    end
-
-    # Remove a destination
-    # @param [Array<UniMIDI::Output>, UniMIDI::Output] destinations
-    def remove_destination(destinations)
-      destinations = [destinations].flatten.compact
-      destinations.each do |output|
-        @destinations.each do |sync_output|
-          @destinations.delete(sync_output) if sync_output.output == output
-        end
-      end
-    end
-            
-    private
-        
-    def initialize_destinations(midi_outputs)
-      midi_outputs = [midi_outputs].flatten.compact
-      midi_outputs.each do |output|
-        add_destination(output)
-      end
-    end
-
-    def initialize_midi_clock_output
-      [:clock, :start, :stop].each do |event|
-        action = proc do
-          @destinations.each { |destination| destination.send(event) }
-        end
-        @events.send("midi_#{event.to_s}=", action)
-      end
-    end
-
-    def initialize_tempo_source(tempo_or_input)
-      @source = case tempo_or_input
-        when Numeric then InternalTempo.new(@events, tempo_or_input)
-        when UniMIDI::Input then ExternalMIDITempo.new(@events, tempo_or_input)
-      else
-        raise "You must specify an internal tempo rate or an external tempo source"
-      end
-    end
-
-    def configure(tempo_or_input, options = {}, &tick_event)
-      initialize_tempo_source(tempo_or_input)     
-      initialize_destinations(options[:midi]) unless options[:midi].nil?
-      initialize_midi_clock_output
-      @source.interval = options[:interval] unless options[:interval].nil? 
-      on_tick(&tick_event)
-    end
-    
-  end
-  
-end

data/test/config.rb

@@ -1,11 +0,0 @@
-module TestHelper::Config
-
-  include UniMIDI
-
-  # Adjust these constants to suit your hardware configuration
-  # before running tests
-
-  TestInput = Input.gets # this is the device you wish to use to test input
-  TestOutput = Output.gets # likewise for output
-
-end

data/test/internal_tempo_test.rb

@@ -1,51 +0,0 @@
-require "helper"
-
-class InternalTempoTest < Test::Unit::TestCase
-
-  include Topaz
-  include TestHelper
-  
-  def test_stop_when
-    i = 0
-    count_to = 5
-    
-    tempo = Tempo.new(120) { i += 1 }
-    tempo.stop_when { i.eql?(count_to) }
-    tempo.start
-    
-    assert_equal(count_to, i)
-  end
-  
-  def test_change_on_tick
-    i = 0
-    count_to = 5
-    
-    tempo = Tempo.new(120) { i += 1 }
-    tempo.stop_when { i == count_to }
-    tempo.start
-    
-    assert_equal(count_to, i)
-    
-    i = 0
-    count_to = 1000
-    
-    tempo.on_tick { i += 100 }
-    tempo.stop_when { i == count_to }
-    tempo.start
-    
-    assert_equal(count_to, i)
-
-    
-  end
-
-  def test_internal_interval
-    tempo = Tempo.new(120)
-    
-    assert_equal(4, tempo.interval)
-
-    tempo.interval = 8
-    
-    assert_equal(8, tempo.interval)
-  end
-
-end