jmtk 0.0.3.3-java

data/bin/mtk

@@ -0,0 +1,250 @@
+#!/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',
+          'Behaves like --convert when a --file or --output is given') {|syntax| options[:eval] = syntax }
+
+  opts.separator ''
+
+  opts.on('-f FILE', '--file FILE', 'Write the output of --convert, --eval, --input, or --watch 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 ''
+
+  opts.on('-w FILE', '--watch FILE', 'Watch an MTK syntax file for changes and automatically convert to MIDI',
+          'Behaves like --convert when a --file or --output is given') {|file| options[:watch] = file }
+
+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::Events::Timeline.from_h( {0 => MTK.Note(60,-1)} )
+
+#######################################################################
+
+begin
+  option_parser.parse!
+rescue OptionParser::MissingArgument, OptionParser::InvalidOption
+  puts "Invalid command, #{$!}"
+  puts "For command line help: #{$0} --help"
+  puts "For command line help: #{$0} --help"
+  exit ERROR_INVALID_COMMAND
+end
+
+
+def setup_io
+  require 'mtk/io/midi_input'
+  require 'mtk/io/midi_output'
+end
+
+
+def convert(mtk_syntax)
+  sequencer = MTK::Lang::Parser.parse(mtk_syntax)
+  if sequencer
+    timeline = sequencer.to_timeline
+    output(timeline)
+  end
+rescue Citrus::ParseError
+  STDERR.puts $!
+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/io/midi_file'
+    MTK.MIDIFile(@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
+
+
+def watch_file_updated?
+  mtime = File.stat(@watch_file).mtime
+  updated = @watch_file_mtime.nil? || @watch_file_mtime < mtime
+  @watch_file_mtime = mtime
+  updated
+end
+
+
+#######################################################################
+
+if options[:list]
+  setup_io
+  input_names  = MTK::IO::MIDIInput.devices_by_name.keys
+  output_names = MTK::IO::MIDIOutput.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::IO::MIDIInput.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::IO::MIDIOutput.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/io/midi_file'
+  timelines = MTK.MIDIFile(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."
+    begin
+      loop do
+        puts "Enter MTK syntax. Press Ctrl+C to exit."
+        convert(gets)
+      end
+    rescue SystemExit,Interrupt
+      Kernel.exit
+    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[:watch]
+  @watch_file = options[:watch]
+  puts "Watching #{@watch_file}. Press Ctrl+C to exit."
+  watch_file_updated? # prime the watcher
+  begin
+    loop do
+      mtk_syntax = IO.read(@watch_file)
+      convert(mtk_syntax)
+      Kernel.sleep(0.5) until watch_file_updated?
+      puts "#{Time.new}: #{@watch_file} updated"
+    end
+  rescue SystemExit,Interrupt
+    Kernel.exit
+  end
+end
+
+#if options.has_key? :tutorial
+#  puts "TODO: tutorial"
+#end
+
+record if @input

data/examples/crescendo.rb

@@ -0,0 +1,20 @@
+# Generate a MIDI file of the C-major scale with a crescendo (it increases in intensity)
+#
+# NOTE: this blindly overwrites any existing MTK-crescendo.mid file, unless an argument is provided
+
+require 'mtk'
+require 'mtk/io/midi_file'
+include MTK
+include Lang::Pitches
+include Lang::Intensities
+
+file = ARGV[0] || 'MTK-crescendo.mid'
+
+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 = Sequencers.StepSequencer scale, crescendo
+timeline = sequencer.to_timeline
+
+MIDIFile(file).write timeline
+

data/examples/drum_pattern.rb

@@ -0,0 +1,23 @@
+require 'mtk'
+require 'mtk/io/midi_file'
+include MTK
+include Lang::Pitches
+include Lang::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,  _], # rim shot
+  D2  =>  [  _, mp,  _, mp,  _, mp,  _, mf,  _, mp,  _, mp,  _, pp,  _, mf]  # snare
+}
+
+timeline = Events::Timeline.new
+for pitch,intensities in pattern
+  track = Sequencers::StepSequencer( Patterns.Sequence(intensities), default_pitch:pitch, channel:10 )
+  timeline.merge track.to_timeline
+end
+
+MIDIFile(file).write timeline

data/examples/dynamic_pattern.rb

@@ -0,0 +1,36 @@
+# Generate a MIDI file using a lambda to dynamically generate the pitches
+#
+# NOTE: this blindly overwrites any existing MTK-dynamic_pattern.mid file, unless an argument is provided
+
+require 'mtk'
+require 'mtk/io/midi_file'
+include MTK
+include MTK::Lang::Pitches
+include MTK::Lang::Intensities
+include MTK::Lang::Intervals
+
+file = ARGV[0] || "MTK-#{File.basename __FILE__,'.rb'}.mid"
+
+interval_generator = lambda do
+  # Randomly return intervals
+  r = rand
+  case
+    when r < 0.1 then m2
+    when r < 0.4 then M2
+    when r < 0.5 then m3
+    when r < 0.6 then M3
+    when r < 0.7 then P4
+    when r < 0.8 then -M3
+    when r < 0.95 then -P5
+    else -P8
+  end
+end
+
+pitches = Patterns.Function( interval_generator, max_elements: 24 )
+
+# we'll also use a weighted choice to generate the intensities
+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 )
+
+MIDIFile(file).write( sequencer.to_timeline )

data/examples/gets_and_play.rb

@@ -0,0 +1,27 @@
+# Enter space-separated pitch classes (A,B,C,D,E,F,G) at the prompt and hear them play.
+
+require 'mtk'
+require_relative 'helpers/output_selector'
+include MTK
+include MTK::Core
+
+output = 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/io/notation'
+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
+# MTK::IO::Notation.open(file).write(timeline)
+MTK::IO::Notation.open(file, dpi:300).write(timeline) # higher resolution PNG

data/examples/play_midi.rb

@@ -0,0 +1,17 @@
+# Play a given MIDI file with the given MIDI output
+
+file, output_name = ARGV[0], ARGV[1]
+unless file
+  puts "Usage: ruby #$0 midi_file [output_device]"
+  exit 1
+end
+
+require 'mtk'
+require 'mtk/io/midi_file'
+require_relative 'helpers/output_selector'
+
+output = OutputSelector.ensure_output(output_name)
+
+timeline = MTK.MIDIFile(file).to_timelines
+
+output.play(timeline)

data/examples/print_midi.rb

@@ -0,0 +1,13 @@
+# Print the notes in a MIDI file
+
+file = ARGV[0]
+unless file
+  puts "Usage: ruby #$0 midi_file"
+  exit 1
+end
+
+require 'mtk'
+require 'mtk/io/midi_file'
+include MTK
+
+puts MIDIFile(file).to_timelines

data/examples/random_tone_row.rb

@@ -0,0 +1,18 @@
+# Generate a MIDI file of a random 12-tone row
+#
+# NOTE: this blindly overwrites any existing MTK-random_tone_row.mid file, unless an argument is provided
+
+require 'mtk'
+require 'mtk/io/midi_file'
+include MTK
+
+file = ARGV[0] || 'MTK-random_tone_row.mid'
+
+row = Groups::PitchClassSet.random_row
+sequence = Patterns.Sequence *row
+
+sequencer = Sequencers.StepSequencer sequence
+timeline = sequencer.to_timeline
+
+MIDIFile(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/io/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::MIDIFile(output).write timeline
+