mtk 0.0.2 → 0.0.3

data/bin/mtk

@@ -0,0 +1,215 @@
+#!/usr/bin/env ruby
+
+require 'mtk'
+require 'optparse'
+
+options = {}
+
+
+#######################################################################
+
+option_parser = OptionParser.new do |opts|
+
+  opts.banner = "Usage: #{$0} [options]"
+  opts.separator ''
+  opts.separator 'Options:'
+
+   opts.on('-c FILE', '--convert FILE', 'Convert a file containing MTK syntax to MIDI',
+          'if a --file is given, write the MIDI to a file',
+          'if an --output is given, play the MIDI',
+          'otherwise print the MIDI') {|file| options[:convert] = file }
+
+  opts.separator ''
+
+  opts.on('-e [syntax]', '--eval [syntax]', 'Convert the given MTK syntax String to MIDI',
+          'or start an interactive interpreter when [syntax] is omitted',
+          'if a --file is given, write the MIDI to a file',
+          'if an --output is given, play the MIDI',
+          'otherwise print the MIDI') {|syntax| options[:eval] = syntax }
+
+  opts.separator ''
+
+  opts.on('-f FILE', '--file FILE', 'Write the output of --convert, --eval, or --input to a file') {|file| options[:file] = file }
+
+  opts.separator ''
+
+  opts.on('-h', '--help', 'Show this message') { puts opts; exit }
+
+  opts.separator ''
+
+  opts.on('-i INPUT', '--input INPUT', 'Set MIDI input for recording',
+          'if no --file is specified, prints the recorded MIDI') {|input| options[:input] = input }
+
+  opts.separator ''
+
+  opts.on('-l', '--list', 'List available MIDI devices for --input and --output') { options[:list] = true }
+
+  opts.separator ''
+
+  opts.on('-m', '--monitor', 'Monitor MIDI input while recording') { options[:monitor] = true }
+
+  opts.separator ''
+
+  opts.on('-o OUTPUT', '--output OUTPUT', 'Set MIDI output for playing') {|output| options[:output] = output }
+
+  opts.separator ''
+
+  opts.on('-p FILE', '--play FILE', 'Play or print the contents of a MIDI file',
+          'if no --output is specified, print the MIDI file') {|file| options[:play] = file }
+
+  opts.separator ''
+
+  #opts.on('-t', '--tutorial', 'Start an interactive tutorial for the MTK syntax') { options[:tutorial] = true }
+  #
+  #opts.separator ''
+
+end
+
+
+#######################################################################
+
+puts option_parser and exit if ARGV.length == 0
+#p ARGV
+#p options
+
+ERROR_INVALID_COMMAND  = 1
+ERROR_FILE_NOT_FOUND   = 2
+ERROR_OUTPUT_NOT_FOUND = 3
+ERROR_INPUT_NOT_FOUND  = 4
+
+# Immediately trying to play output while Ruby is still "warming up" can cause timing issues with
+# the first couple notes. So we play this "empty" Timeline containing a rest to address that issue.
+WARMUP = MTK::Timeline.from_hash( {0 => MTK::Events::Note.new(MTK::Pitch(60), MTK::Duration(-1))} )
+
+#######################################################################
+
+begin
+  option_parser.parse!
+rescue OptionParser::MissingArgument, OptionParser::InvalidOption
+  puts "Invalid command, #{$!}"
+  puts "For command line help: #{$0} --help"
+  exit ERROR_INVALID_COMMAND
+end
+
+
+def setup_io
+  require 'mtk/midi/input'
+  require 'mtk/midi/output'
+end
+
+
+def convert(mtk_syntax)
+  sequencer = MTK::Lang::Parser.parse(mtk_syntax)
+  timeline = sequencer.to_timeline
+  output(timeline)
+end
+
+
+def output(timelines, print_header='Timeline')
+  timelines = [timelines] unless timelines.is_a? Array
+  if @output
+    @output.play WARMUP
+    @output.play timelines.first # TODO: support multiple timelines
+  elsif @file
+    require 'mtk/midi/file'
+    MTK::MIDI_File(@file).write timelines
+  else
+    puts print_header, timelines
+    puts
+  end
+end
+
+
+def record
+  if @input
+    print "Press Enter to begin recording MIDI input..."
+    gets
+    puts "Recording input. Press control-C to stop."
+    @input.record monitor:@monitor
+    Signal.trap("INT") do # SIGINT = control-C
+      @input.stop
+      output @input.to_timeline, "\nRecorded MIDI data"
+      exit
+    end
+    loop{ sleep 0.01 }
+  end
+end
+
+
+#######################################################################
+
+if options[:list]
+  setup_io
+  input_names  = MTK::MIDI::Input.devices_by_name.keys
+  output_names = MTK::MIDI::Output.devices_by_name.keys
+  puts
+  puts (['INPUTS:'] + input_names).join("\n * ")
+  puts
+  puts (['OUTPUTS:']+output_names).join("\n * ")
+  puts
+  puts 'When specifying --input INPUT or --output OUTPUT, the first substring match will be used.'
+  puts "For example: --output IAC will use 'Apple Inc. IAC Driver' if it's the first OUTPUT containing 'IAC'"
+  puts
+  exit
+end
+
+@monitor = true if options[:monitor]
+
+if options[:input]
+  setup_io
+  input_name = options[:input]
+  @input = MTK::MIDI::Input.find_by_name /#{input_name}/
+  if @input
+    puts "Using input '#{@input.name}'"
+  else
+    STDERR.puts "Input '#{input_name}' not found."
+    exit ERROR_INPUT_NOT_FOUND
+  end
+end
+
+if options[:output]
+  setup_io
+  output_name = options[:output]
+  @output = MTK::MIDI::Output.find_by_name /#{output_name}/
+  if @output
+    puts "Using output '#{@output.name}'"
+  else
+    STDERR.puts "Output '#{output_name}' not found."
+    exit ERROR_OUTPUT_NOT_FOUND
+  end
+end
+
+file = options[:file]
+@file = file if file
+
+if options[:play]
+  filename = options[:play]
+  require 'mtk/midi/file'
+  timelines = MTK::MIDI_File(filename).to_timelines
+  output(timelines, "Timeline for #{filename}")
+end
+
+if options.has_key? :eval
+  mtk_syntax = options[:eval]
+  if mtk_syntax.nil?
+    puts "Starting the interactive interpreter."
+    loop do
+      puts "Enter MTK syntax. Press Ctrl+C to exit."
+      convert(gets)
+    end
+  else
+    convert(mtk_syntax)
+  end
+end
+
+if options[:convert]
+  mtk_syntax_file = options[:convert]
+  mtk_syntax = IO.read(mtk_syntax_file)
+  convert(mtk_syntax)
+end
+
+#if options.has_key? :tutorial
+#  puts "TODO: tutorial"
+#end
+
+record if @input

data/examples/crescendo.rb

@@ -5,15 +5,15 @@
 require 'mtk'
 require 'mtk/midi/file'
 include MTK
-include Pitches
-include Intensities
+include Constants::Pitches
+include Constants::Intensities
 
 file = ARGV[0] || 'MTK-crescendo.mid'
 
-scale = Pattern::PitchSequence C4,D4,E4,F4,G4,A4,B4,C5
-crescendo = Pattern::IntensityLines pp, [fff, scale.length-1] # step from pp to fff over the length of the scale
+scale = Patterns.Sequence C4,D4,E4,F4,G4,A4,B4,C5
+crescendo = Patterns.Lines pp, [fff, scale.length-1] # step from pp to fff over the length of the scale
 
-sequencer = Sequencer::StepSequencer.new [scale, crescendo]
+sequencer = Sequencers.StepSequencer scale, crescendo
 timeline = sequencer.to_timeline
 
 MIDI_File(file).write timeline

data/examples/drum_pattern1.rb

@@ -0,0 +1,23 @@
+require 'mtk'
+require 'mtk/midi/file'
+include MTK
+include Constants::Pitches
+include Constants::Intensities
+
+file = ARGV[0] || "MTK-#{File.basename(__FILE__,'.rb')}.mid"
+
+_ = nil # defines _ as a rest
+
+pattern = {# 0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15
+  C2  =>  [fff,  _,  _,  _, mf,  _,  _,  _,  o,  _,  _,  _, mp,  _,  _,  _], # kick
+  Db2 =>  [  _,  _,  o,  _,  _,  _, mp,  _,  _,  _,  o,  _,  _,  _, mf,  _], # snare
+  D2  =>  [  _, mp,  _, mp,  _, mp,  _, mf,  _, mp,  _, mp,  _, pp,  _, mf]  # hat
+}
+
+timeline = Timeline.new
+for pitch,intensities in pattern
+  track = Sequencers::StepSequencer( Patterns.Sequence(intensities), default_pitch: pitch )
+  timeline.merge track.to_timeline
+end
+
+MIDI_File(file).write timeline

data/examples/dynamic_pattern.rb

@@ -5,11 +5,11 @@
 require 'mtk'
 require 'mtk/midi/file'
 include MTK
-include Pitches
-include Intensities
-include Intervals
+include MTK::Constants::Pitches
+include MTK::Constants::Intensities
+include MTK::Constants::Intervals
 
-file = ARGV[0] || "MTK-#{File.basename(__FILE__,'.rb')}.mid"
+file = ARGV[0] || "MTK-#{File.basename __FILE__,'.rb'}.mid"
 
 interval_generator = lambda do
   # Randomly return intervals
@@ -26,14 +26,11 @@ interval_generator = lambda do
   end
 end
 
-pitches = Pattern::Function.new interval_generator, :type => :pitch, :max_elements => 24
+pitches = Patterns.Function( interval_generator, max_elements: 24 )
 
 # we'll also use a weighted choice to generate the intensities
-intensities = Pattern::Choice.new [mp, mf, f, ff, fff], :type => :intensity, :weights => [1,2,3,2,1]
+intensities = Patterns.Choice( mp,mf,o,ff,fff, weights: [1,2,3,2,1], max_cycles: 24 )
 
+sequencer = Sequencers.StepSequencer( pitches,intensities, step_size: 0.5, max_interval: 17 )
 
-sequencer = Sequencer::StepSequencer.new [pitches, intensities], :step_size => 0.5
-timeline = sequencer.to_timeline
-
-MIDI_File(file).write timeline
-
+MIDI_File(file).write( sequencer.to_timeline )

data/examples/gets_and_play.rb

@@ -0,0 +1,26 @@
+# Enter space-separated pitch classes (A,B,C,D,E,F,G) at the prompt and hear them play.
+
+require 'mtk'
+require 'mtk/helpers/output_selector'
+include MTK
+
+output = Helpers::OutputSelector.ensure_output ARGV[0]
+
+def get_pitch_classes
+  puts "Enter pitch classes:"
+  input = STDIN.gets
+  input.strip.split(/\s+/).map{|name| PitchClass[name] } if input
+rescue
+  puts "Invalid input."
+end
+
+while (pitch_classes = get_pitch_classes)
+  sequence = Patterns.Sequence pitch_classes
+  sequencer = Sequencers.StepSequencer sequence
+  timeline = sequencer.to_timeline
+
+  puts "Playing: #{pitch_classes}"
+  puts "Timeline:\n#{timeline}"
+  output.play timeline
+end
+

data/examples/notation.rb

@@ -0,0 +1,22 @@
+require 'mtk'
+require 'mtk/helpers/lilypond'
+include MTK
+
+def arg_error(error)
+  puts "Usage: ruby #$0 syntax output_file"
+  puts error
+  exit 1
+end
+
+syntax = ARGV[0]
+arg_error "MTK syntax string not provided" unless syntax
+
+
+file = ARGV[1]
+arg_error "The output_file must end in '.png', '.pdf', or '.ps'" unless file
+
+
+sequencer = MTK::Lang::Parser.parse(syntax)
+timeline = sequencer.to_timeline
+# Helpers::Lilypond.open(file).write(timeline)
+Helpers::Lilypond.open(file, dpi:300).write(timeline) # higher resolution PNG

data/examples/play_midi.rb

@@ -1,19 +1,17 @@
 # Play a given MIDI file with the given MIDI output
-#
-# NOTE: this example only runs under JRuby with the jsound and gamelan gems installed
 
-file, output = ARGV[0], ARGV[1]
-unless file and output
-  puts "Usage: ruby #$0 midi_file output_device"
+file, output_name = ARGV[0], ARGV[1]
+unless file
+  puts "Usage: ruby #$0 midi_file [output_device]"
   exit 1
 end
 
 require 'mtk'
 require 'mtk/midi/file'
-require 'mtk/midi/jsound_output'
-include MTK
+require 'mtk/helpers/output_selector'
 
-timeline = MIDI_File(file).to_timelines.first # for now this example just plays the first track (JSoundOutput needs to be enhanced to support multiple timelines)
-player = MTK::MIDI::JSoundOutput.new output
+output = MTK::Helpers::OutputSelector.ensure_output(output_name)
 
-player.play timeline
+timeline = MTK.MIDI_File(file).to_timelines
+
+output.play(timeline)

data/examples/random_tone_row.rb

@@ -9,9 +9,9 @@ include MTK
 file = ARGV[0] || 'MTK-random_tone_row.mid'
 
 row = PitchClassSet.random_row
-sequence = Pattern::PitchSequence *row.to_a
+sequence = Patterns.Sequence *row
 
-sequencer = Sequencer::StepSequencer.new [sequence]
+sequencer = Sequencers.StepSequencer sequence
 timeline = sequencer.to_timeline
 
 MIDI_File(file).write timeline

data/examples/syntax_to_midi.rb

@@ -0,0 +1,28 @@
+# Generate a MIDI file by reading in a file containing the MTK custom syntax (see mtk_grammar.citrus and grammar_spec.rb)
+#
+# NOTE: this blindly overwrites any existing MTK-syntax_to_midi.mid file, unless a second argument is provided
+
+require 'mtk'
+require 'mtk/midi/file'
+
+input = ARGV[0]
+if input.nil?
+  STDERR.puts "Input file is required."
+  STDERR.puts "Usage: #{$0} input [output]"
+  exit 1
+end
+
+unless File.exists? input
+  STDERR.puts "Cannot read file: #{input}"
+  exit 2
+end
+
+output = ARGV[1] || "MTK-#{File.basename(__FILE__,'.rb')}.mid"
+
+
+syntax = IO.read(input)
+sequencer = MTK::Lang::Parser.parse(syntax)
+timeline = sequencer.to_timeline
+
+MTK::MIDI_File(output).write timeline
+

data/examples/test_output.rb

@@ -0,0 +1,8 @@
+require 'mtk'
+require 'mtk/helpers/output_selector'
+include MTK
+include Constants::Pitches
+
+output = Helpers::OutputSelector.ensure_output ARGV[0]
+
+output.play Note(C4,1,2)

data/examples/tone_row_melody.rb

@@ -5,16 +5,16 @@
 require 'mtk'
 require 'mtk/midi/file'
 include MTK
-include PitchClasses
-include Durations
+include MTK::Constants::PitchClasses
+include MTK::Constants::Durations
 
 file = ARGV[0] || 'MTK-tone_row_melody.mid'
 
-row = PitchClassSet(Db, G, Ab, F, Eb, E, D, C, B, Gb, A, Bb)
-pitch_pattern = Pattern.PitchCycle *row
-rhythm_pattern = Pattern.RhythmCycle(Pattern.Choice s, e, e+s, q) # choose between sixteenth, eighth, dotted eighth, and quarter
+row = PitchClassSet Db, G, Ab, F, Eb, E, D, C, B, Gb, A, Bb
+pitch_pattern = Patterns.Cycle *row
+rhythm_pattern = Patterns.Choice s, i, i+s, q # choose between sixteenth, eighth, dotted eighth, and quarter
 
-sequencer = Sequencer::RhythmicSequencer.new [pitch_pattern, rhythm_pattern], :max_steps => 36
+sequencer = Sequencers.LegatoSequencer pitch_pattern, rhythm_pattern, max_steps: 36
 timeline = sequencer.to_timeline
 
 MIDI_File(file).write timeline