ruck-midi 0.2.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/README

@@ -0,0 +1,8 @@
+
+This ruck shreduler uses MIDIator and midilib to support
+real-time and offline MIDI generation.
+
+  $ ruck_midi MIDI_FILENAME NUM_TRACKS LIVE SCRIPT_FILENAME[S]
+
+where LIVE is "no" to only save the MIDI output, or "yes"
+to also play in real-time.

data/Rakefile

@@ -0,0 +1,24 @@
+require "rubygems"
+require "rake"
+
+begin
+  require "jeweler"
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ruck-midi"
+    gem.email = "tom@alltom.com"
+    gem.homepage = "http://github.com/alltom/ruck-midi"
+    gem.authors = ["Tom Lieber"]
+    gem.summary = %Q{real-time and offline ruck shredulers for MIDI (thanks midiator and midilib)}
+    gem.description = <<-EOF
+      Real-time and offline ruck shredulers for MIDI using midiator and midilib.
+    EOF
+    gem.has_rdoc = false
+    gem.add_dependency "ruck", ">= 0"
+    gem.add_dependency "midiator", ">= 0"
+    gem.add_dependency "midilib", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/bin/ruck_midi

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+
+# for testing inside gem dir
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require "ruck"
+require "ruck/midi"
+
+if ARGV.length < 4
+  puts "ruby midilib_runner.rb MIDI_FILENAME NUM_TRACKS LIVE SCRIPT_FILENAME [...]"
+  exit 1
+end
+
+MIDI_FILENAME = ARGV[0]
+NUM_TRACKS = ARGV[1].to_i
+ALSO_LIVE = ["yes", "true", "1", "yeah"].include? ARGV[2].downcase
+FILENAMES = ARGV[3..-1]
+
+# state
+$midi = Ruck::MIDI::MIDIOutput.new(ALSO_LIVE, MIDI_FILENAME, NUM_TRACKS)
+SHREDULER = Ruck::MIDI::MIDIShreduler.new($midi, ALSO_LIVE)
+
+at_exit { $midi.save }
+
+FILENAMES.each do |filename|
+  unless File.readable?(filename)
+    LOG.fatal "Cannot read file #{filename}"
+    exit
+  end
+end
+
+FILENAMES.each do |filename|
+  SHREDULER.spork(filename) do
+    include Ruck::MIDI::ShredLocal
+    require filename
+  end
+end
+
+SHREDULER.run
+
+$midi.save

data/examples/ex01.rb

@@ -0,0 +1,21 @@
+
+def maybe
+  rand >= 0.5
+end
+
+control_change(32, 1, 10)
+program_change(26, 10)
+
+def play(note, dur = 1.quarter_note)
+  return if maybe
+  note_on note, 100, 10
+  wait dur
+  note_off note, 10
+end
+
+30.times do
+  spork { play(rand(30) + 40, rand * 3.quarter_notes + 3.quarter_notes) }
+  wait 0.5.quarter_note
+end
+
+wait 2.quarter_notes; note_off 0 # end padding

data/examples/ex02.rb

@@ -0,0 +1,76 @@
+
+def maybe
+  rand >= 0.5
+end
+
+@base = 43
+@scale = 0
+@chord = 0
+
+major_scale = [0, 2, 4, 5, 7, 9, 11]
+minor_scale = [0, 2, 3, 5, 7, 8, 11]
+@scales = [major_scale, minor_scale]
+
+def scale(note, scale)
+  len = scale.length
+  oct = note / len
+  off = note % len
+  while off < 0
+    off += len
+    oct -= 1
+  end
+  oct * 12 + scale[off]
+end
+
+def play(note, dur = 1.beat)
+  midi_note = @base + scale(note, @scales[@scale])
+  note_on midi_note, 100
+  wait dur
+  note_off midi_note
+end
+
+def change_chords
+  loop do
+    wait 4.beats
+    @chord = rand(7)
+    if rand <= 0.1
+      @scale = (@scale + 1) % @scales.length
+    end
+  end
+end
+
+def play_chord(dur)
+  spork { play(@chord, dur) }
+  spork { play(@chord + 2, dur) }
+  spork { play(@chord + 4, dur) }
+end
+
+def play_chords
+  loop do
+    if maybe && maybe
+      play_chord 2.beats
+      wait 2.beats
+      play_chord 2.beats
+      wait 2.beats
+    else
+      play_chord 4.beats
+      wait 4.beats
+    end
+  end
+end
+
+def play_melody
+  loop do
+    len = ((rand(2) + 1) / 2.0).beats
+    play(@chord + 7 + 2 * rand(4), len)
+    wait len
+  end
+end
+
+shreds = []
+shreds << spork { change_chords }
+shreds << spork { play_chords }
+shreds << spork { play_melody }
+
+wait 16.beats
+shreds.each { |s| s.finish }

data/lib/ruck/midi.rb

@@ -0,0 +1,2 @@
+
+require File.join(File.dirname(__FILE__), "midi", "midi")

data/lib/ruck/midi/midi.rb

@@ -0,0 +1,192 @@
+
+require "midilib"
+require "midiator"
+
+module Ruck
+  module MIDI
+    
+    class MIDIShreduler < Ruck::Shreduler
+      attr_reader :midi
+      
+      def initialize(midi, real_time)
+        super()
+        @midi = midi
+        @real_time = real_time
+      end
+      
+      def run
+        @start_time = Time.now
+        super
+      end
+  
+      def sim_to(new_now)
+        d = new_now - @now
+    
+        @midi.tick(d)
+    
+        # sync with wall clock
+        if @real_time
+          actual_now = Time.now
+          simulated_now = @start_time + (new_now.to_f / @midi.ppqn / @midi.bpm * 60.0)
+          if simulated_now > actual_now
+            sleep(simulated_now - actual_now)
+          end
+        end
+    
+        @now = new_now
+      end
+    end
+
+    class MIDIOutput
+      def initialize(real_time, save_filename = nil, num_tracks = 1)
+        if save_filename
+          @filename = save_filename
+          @sequence = ::MIDI::Sequence.new
+          @tracks = (1..num_tracks).map { ::MIDI::Track.new(@sequence) }
+          @track_deltas = @tracks.map { 0 }
+      
+          @tracks.each do |track|
+            @sequence.tracks << track
+            #track.events << ::MIDI::Tempo.new(::MIDI::Tempo.bpm_to_mpq(120))
+          end
+        end
+    
+        if real_time
+          @player = MIDIator::Interface.new
+          @player.use :dls_synth
+          @player.instruct_user!
+        end
+      end
+      
+      def ppqn
+        @sequence.ppqn
+      end
+      
+      def bpm
+        @sequence.bpm
+      end
+  
+      def tick(delta)
+        if @sequence
+          @track_deltas.each_with_index do |track_delta, i|
+            @track_deltas[i] = track_delta + delta
+          end
+        end
+      end
+  
+      def note_on(note, velocity = 127, channel = 0, track = 0)
+        if @sequence
+          @tracks[track].events << ::MIDI::NoteOnEvent.new(channel, note, velocity, @track_deltas[track].to_i)
+          @track_deltas[track] = 0
+        end
+        
+        if @player
+          @player.driver.note_on(note, channel, velocity)
+        end
+      end
+  
+      def note_off(note, channel = 0, track = 0)
+        if @sequence
+          @tracks[track].events << ::MIDI::NoteOffEvent.new(channel, note, 0, @track_deltas[track].to_i)
+          @track_deltas[track] = 0
+        end
+        
+        if @player
+          @player.driver.note_on(note, channel, 0)
+        end
+      end
+      
+      def control_change(controller, value, channel = 0, track = 0)
+        if @sequence
+          @tracks[track].events << ::MIDI::Controller.new(channel, controller, value)
+        end
+        
+        if @player
+          @player.driver.control_change(controller, channel, value)
+        end
+      end
+      
+      def program_change(program, channel = 0, track = 0)
+        if @sequence
+          @tracks[track].events << ::MIDI::ProgramChange.new(channel, program)
+        end
+        
+        if @player
+          @player.driver.program_change(channel, program)
+        end
+      end
+  
+      def save
+        return if @saved
+        return unless @sequence
+    
+        @saved = true
+    
+        File.open(@filename, "wb") do |file|
+          @sequence.write(file)
+        end
+      end
+    end
+
+    # stuff accessible in a shred
+    module ShredLocal
+      def now
+        SHREDULER.now
+      end
+
+      def spork(name = "unnamed", &shred)
+        SHREDULER.spork(name, &shred)
+      end
+
+      def wait(pulses)
+        SHREDULER.current_shred.yield(pulses)
+      end
+
+      def finish
+        shred = SHREDULER.current_shred
+        SHREDULER.remove_shred shred
+        shred.finish
+      end
+  
+      def note_on(note, velocity = 127, channel = 0, track = 0)
+        SHREDULER.midi.note_on(note, velocity, channel, track)
+      end
+  
+      def note_off(note, channel = 0, track = 0)
+        SHREDULER.midi.note_off(note, channel, track)
+      end
+      
+      def control_change(controller, value, channel = 0, track = 0)
+        SHREDULER.midi.control_change(controller, value, channel, track)
+      end
+      
+      def program_change(program, channel = 0, track = 0)
+        SHREDULER.midi.program_change(program, channel, track)
+      end
+    end
+    
+  end
+end
+
+# set up some useful time helpers
+module MIDITime
+  def pulse
+    self
+  end
+  alias_method :pulses, :pulse
+  
+  def quarter_note
+    self * SHREDULER.midi.ppqn
+  end
+  alias_method :quarter_notes, :quarter_note
+  alias_method :beat, :quarter_note
+  alias_method :beats, :quarter_note
+end
+
+class Fixnum
+  include MIDITime
+end
+
+class Float
+  include MIDITime
+end

data/ruck-midi.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ruck-midi}
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tom Lieber"]
+  s.date = %q{2010-07-10}
+  s.default_executable = %q{ruck_midi}
+  s.description = %q{      Real-time and offline ruck shredulers for MIDI using midiator and midilib.
+}
+  s.email = %q{tom@alltom.com}
+  s.executables = ["ruck_midi"]
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "bin/ruck_midi",
+     "examples/ex01.rb",
+     "examples/ex02.rb",
+     "lib/ruck/midi.rb",
+     "lib/ruck/midi/midi.rb",
+     "ruck-midi.gemspec"
+  ]
+  s.homepage = %q{http://github.com/alltom/ruck-midi}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{real-time and offline ruck shredulers for MIDI (thanks midiator and midilib)}
+  s.test_files = [
+    "examples/ex01.rb",
+     "examples/ex02.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<ruck>, [">= 0"])
+      s.add_runtime_dependency(%q<midiator>, [">= 0"])
+      s.add_runtime_dependency(%q<midilib>, [">= 0"])
+    else
+      s.add_dependency(%q<ruck>, [">= 0"])
+      s.add_dependency(%q<midiator>, [">= 0"])
+      s.add_dependency(%q<midilib>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<ruck>, [">= 0"])
+    s.add_dependency(%q<midiator>, [">= 0"])
+    s.add_dependency(%q<midilib>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: ruck-midi
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Tom Lieber
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-10 00:00:00 -07:00
+default_executable: ruck_midi
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruck
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: midiator
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: midilib
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: "      Real-time and offline ruck shredulers for MIDI using midiator and midilib.\n"
+email: tom@alltom.com
+executables: 
+- ruck_midi
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- .document
+- .gitignore
+- README
+- Rakefile
+- VERSION
+- bin/ruck_midi
+- examples/ex01.rb
+- examples/ex02.rb
+- lib/ruck/midi.rb
+- lib/ruck/midi/midi.rb
+- ruck-midi.gemspec
+has_rdoc: true
+homepage: http://github.com/alltom/ruck-midi
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: real-time and offline ruck shredulers for MIDI (thanks midiator and midilib)
+test_files: 
+- examples/ex01.rb
+- examples/ex02.rb