├── site ├── .gitignore ├── images │ └── pm_screen_shot.png ├── .htaccess ├── _layouts │ ├── page.html │ └── default.html ├── screenshots.md ├── _config.yml ├── _includes │ ├── head.html │ ├── header.html │ └── footer.html ├── changes.md ├── todo.md ├── index.md ├── patches.md ├── irb.md ├── tips-and-tricks.md ├── components.md ├── tutorial.md ├── css │ └── main.css └── file-format.md ├── .gitignore ├── test ├── test_helper.rb ├── support │ ├── test_connection.rb │ └── mock_ports.rb ├── sorted_song_list_test.rb ├── trigger_test.rb ├── predicates_test.rb ├── song_list_test.rb ├── binding_test.rb ├── instrument_test.rb ├── example_dsl.rb ├── patch_test.rb ├── connection_test.rb ├── dsl_test.rb └── patchmaster_test.rb ├── Gemfile ├── lib ├── patchmaster │ ├── sorted_song_list.rb │ ├── code_key.rb │ ├── curses │ │ ├── info_window_contents.txt │ │ ├── help_window.rb │ │ ├── trigger_window.rb │ │ ├── info_window.rb │ │ ├── prompt_window.rb │ │ ├── geometry.rb │ │ ├── list_window.rb │ │ ├── pm_window.rb │ │ ├── patch_window.rb │ │ └── main.rb │ ├── song.rb │ ├── code_chunk.rb │ ├── filter.rb │ ├── song_list.rb │ ├── irb │ │ ├── irb_help.txt │ │ └── irb.rb │ ├── trigger.rb │ ├── patch.rb │ ├── web │ │ ├── public │ │ │ ├── style.css │ │ │ ├── index.html │ │ │ └── js │ │ │ │ ├── patchmaster.coffee │ │ │ │ ├── jquery.hotkeys.js │ │ │ │ └── patchmaster.js │ │ └── sinatra_app.rb │ ├── predicates.rb │ ├── instrument.rb │ ├── connection.rb │ ├── patchmaster.rb │ ├── cursor.rb │ ├── dsl.rb │ └── consts.rb └── patchmaster.rb ├── examples ├── irb_example.rb ├── apps.rb └── example.rb ├── bin ├── irb_init.rb └── patchmaster ├── README.md ├── Gemfile.lock └── Rakefile /site/.gitignore: -------------------------------------------------------------------------------- 1 | _site -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .byebug_history 2 | .rbenv-version 3 | .ruby-version 4 | html 5 | pkg 6 | -------------------------------------------------------------------------------- /site/images/pm_screen_shot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jimm/patchmaster/HEAD/site/images/pm_screen_shot.png -------------------------------------------------------------------------------- /site/.htaccess: -------------------------------------------------------------------------------- 1 | 2 | header set X-Clacks-Overhead "GNU Terry Pratchett" 3 | 4 | -------------------------------------------------------------------------------- /test/test_helper.rb: -------------------------------------------------------------------------------- 1 | require 'test/unit' 2 | require 'patchmaster' 3 | require 'support/mock_ports' 4 | require 'support/test_connection' 5 | 6 | # For all tests, make sure mock I/O MIDI ports are used. 7 | PM::PatchMaster.instance.use_midi = false 8 | -------------------------------------------------------------------------------- /site/_layouts/page.html: -------------------------------------------------------------------------------- 1 | --- 2 | layout: default 3 | --- 4 |

5 | 6 |

7 |

8 |

9 | 10 |

11 | {{ content }} 12 |

13 | 14 |

-------------------------------------------------------------------------------- /Gemfile: -------------------------------------------------------------------------------- 1 | source "https://rubygems.org" 2 | 3 | gem 'unimidi' 4 | gem 'midi-eye' 5 | gem 'curses' 6 | gem 'sinatra' 7 | gem 'sinatra-contrib' 8 | 9 | group :development, :test do 10 | gem 'byebug' 11 | end 12 | 13 | group :test do 14 | gem 'alsa-rawmidi' 15 | gem 'midi-jruby' 16 | gem 'midi-winmm' 17 | end 18 | -------------------------------------------------------------------------------- /site/screenshots.md: -------------------------------------------------------------------------------- 1 | --- 2 | layout: page 3 | title: Screen Shots 4 | --- 5 | 6 | > Un bon croquis vaut mieux qu'un long discours.\\ 7 | > _A good sketch is better than a long speech._ 8 | > 9 | > -- Napoléon Bonaparte 10 | 11 | 12 | # Main Screen 13 | 14 | ![PatchMaster screen shot](/images/pm_screen_shot.png){:width='600'} 15 | -------------------------------------------------------------------------------- /test/support/test_connection.rb: -------------------------------------------------------------------------------- 1 | # A TestConnection records all bytes received and passes them straight 2 | # through. 3 | class TestConnection < PM::Connection 4 | attr_accessor :bytes_received 5 | 6 | def midi_in(bytes) 7 | @bytes_received ||= [] 8 | @bytes_received += bytes 9 | midi_out(bytes) 10 | end 11 | end 12 | -------------------------------------------------------------------------------- /lib/patchmaster/sorted_song_list.rb: -------------------------------------------------------------------------------- 1 | module PM 2 | 3 | class SortedSongList < SongList 4 | 5 | def <<(song) 6 | next_song_after = @songs.detect { |s| s.name > song.name } 7 | if next_song_after 8 | @songs.insert(@songs.index(next_song_after), song) 9 | else 10 | super(song) 11 | end 12 | end 13 | 14 | end 15 | end 16 | -------------------------------------------------------------------------------- /site/_layouts/default.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | {% include head.html %} 5 | 6 | 7 | 8 | {% include header.html %} 9 | 10 |

11 |

12 | {{ content }} 13 |

14 |

15 | 16 | {% include footer.html %} 17 | 18 | 19 | -------------------------------------------------------------------------------- /lib/patchmaster/code_key.rb: -------------------------------------------------------------------------------- 1 | module PM 2 | 3 | # A CodeKey holds a CodeChunk and remembers what key it is assigned to. 4 | class CodeKey 5 | 6 | attr_accessor :key, :code_chunk 7 | 8 | def initialize(key, code_chunk) 9 | @key, @code_chunk = key, code_chunk 10 | end 11 | 12 | def run 13 | @code_chunk.run 14 | end 15 | end 16 | end 17 | -------------------------------------------------------------------------------- /lib/patchmaster/curses/info_window_contents.txt: -------------------------------------------------------------------------------- 1 | j, down, space - next patch 2 | k, up - prev patch 3 | n, right - next song 4 | p, left - prev song 5 | 6 | g - goto song 7 | t - goto song list 8 | 9 | h, ? - help 10 | ESC - panic 11 | 12 | l - load 13 | s - save 14 | r - reload 15 | e - edit 16 | 17 | q - quit -------------------------------------------------------------------------------- /lib/patchmaster/song.rb: -------------------------------------------------------------------------------- 1 | module PM 2 | 3 | # A Song is a named list of Patches. 4 | class Song 5 | 6 | attr_accessor :name, :patches, :notes 7 | 8 | def initialize(name) 9 | @name = name 10 | @patches = [] 11 | PatchMaster.instance.all_songs << self 12 | end 13 | 14 | def <<(patch) 15 | @patches << patch 16 | end 17 | 18 | end 19 | end 20 | -------------------------------------------------------------------------------- /examples/irb_example.rb: -------------------------------------------------------------------------------- 1 | input 0, :mb, 'midiboard' 2 | input 1, :ws_in, 'WaveStation' 3 | output 1, :ws_out, 'WaveStation' 4 | output 2, :kz, 'K2000R' 5 | output 4, :sj # Name will come from UNIMidi 6 | 7 | def setup1 8 | connection :mb, :kz, 1 9 | connection :ws_in, :sj, 4 10 | end 11 | 12 | def setup2 13 | connection :mb, :sj, 4 14 | connection :ws_in, :kz, 1 15 | transpose 12 16 | end 17 | -------------------------------------------------------------------------------- /site/_config.yml: -------------------------------------------------------------------------------- 1 | # Site settings 2 | title: PatchMaster 3 | email: jim@jimmenard.com 4 | description: "PatchMaster is a MIDI processing and patching system that allows a musician to reconfigure a MIDI setup instantaneously and modify the MIDI data in real time." 5 | baseurl: "" 6 | url: "http://patchmaster.org" 7 | twitter_username: jmenard42 8 | github_username: jimm 9 | 10 | # Build settings 11 | markdown: kramdown 12 | -------------------------------------------------------------------------------- /lib/patchmaster/code_chunk.rb: -------------------------------------------------------------------------------- 1 | module PM 2 | 3 | # A CodeChunk holds a block of code (lambda, block, proc) and the text that 4 | # created it as read in from a PatchMaster file. 5 | class CodeChunk 6 | 7 | attr_accessor :block, :text 8 | 9 | def initialize(block, text=nil) 10 | @block, @text = block, text 11 | end 12 | 13 | def run(*args) 14 | block.call(*args) 15 | end 16 | 17 | def to_s 18 | "#" 19 | end 20 | end 21 | end 22 | -------------------------------------------------------------------------------- /lib/patchmaster.rb: -------------------------------------------------------------------------------- 1 | require_relative 'patchmaster/consts' 2 | require_relative 'patchmaster/predicates' 3 | require_relative 'patchmaster/song_list' 4 | require_relative 'patchmaster/song' 5 | require_relative 'patchmaster/patch' 6 | require_relative 'patchmaster/connection' 7 | require_relative 'patchmaster/filter' 8 | require_relative 'patchmaster/instrument' 9 | require_relative 'patchmaster/patchmaster' 10 | require_relative 'patchmaster/trigger' 11 | require_relative 'patchmaster/code_key' 12 | require_relative 'patchmaster/dsl' 13 | -------------------------------------------------------------------------------- /lib/patchmaster/filter.rb: -------------------------------------------------------------------------------- 1 | module PM 2 | 3 | # Filters are blocks of code executed by a Connection to modify incoming 4 | # MIDI bytes. Since we want to save them to files, we store the text 5 | # representation as well. 6 | class Filter 7 | 8 | attr_accessor :code_chunk 9 | 10 | def initialize(code_chunk) 11 | @code_chunk = code_chunk 12 | end 13 | 14 | def call(conn, bytes) 15 | @code_chunk.run(conn, bytes) 16 | end 17 | 18 | def to_s 19 | @code_chunk.text || '# no block text found' 20 | end 21 | 22 | end 23 | end 24 | -------------------------------------------------------------------------------- /bin/irb_init.rb: -------------------------------------------------------------------------------- 1 | # Set IRB prompt 2 | IRB.conf[:PROMPT][:CUSTOM] = { 3 | PROMPT_I: 'PatchMaster:%03n:%i> ', 4 | PROMPT_N: 'PatchMaster:%03n:%i> ', 5 | PROMPT_S: 'PatchMaster:%03n:%i%l ', 6 | PROMPT_C: 'PatchMaster:%03n:%i* ', 7 | RETURN: "=> %s\n" 8 | } 9 | IRB.conf[:PROMPT_MODE] = :CUSTOM 10 | 11 | # Load ./.patchmasterrc or $HOME/.patchmasterrc 12 | rc_file = File.join('.', '.patchmasterrc') 13 | rc_file = File.join(ENV['HOME'], '.patchmasterrc') unless File.exist?(rc_file) 14 | load(rc_file) if File.exist?(rc_file) 15 | 16 | puts 'PatchMaster loaded' 17 | puts 'Type "pm_help" for help' 18 | -------------------------------------------------------------------------------- /site/_includes/head.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | {% if page.title %}{{ page.title }}{% else %}{{ site.title }}{% endif %} 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /test/sorted_song_list_test.rb: -------------------------------------------------------------------------------- 1 | require 'test_helper' 2 | 3 | class SortedSongListTest < Test::Unit::TestCase 4 | def test_sorting 5 | ssl = PM::SortedSongList.new('') 6 | %w[c a b].each { |name| ssl << PM::Song.new(name) } 7 | %w[a b c].each_with_index { |name, i| assert_equal name, ssl.songs[i].name } 8 | end 9 | 10 | def test_pm_sorting 11 | ssl = PM::SortedSongList.new('') 12 | ssl << PM::Song.new('First Song') 13 | ssl << PM::Song.new('Second Song') 14 | assert_equal 'First Song', ssl.songs[0].name 15 | assert_equal 'Second Song', ssl.songs[1].name 16 | end 17 | end 18 | -------------------------------------------------------------------------------- /lib/patchmaster/curses/help_window.rb: -------------------------------------------------------------------------------- 1 | require 'curses' 2 | 3 | module PM 4 | class HelpWindow < PmWindow 5 | 6 | CONTENTS = File.join(File.dirname(__FILE__), 'info_window_contents.txt') 7 | 8 | include Curses 9 | 10 | attr_reader :text 11 | 12 | def initialize(rows, cols, row, col) 13 | super(rows, cols, row, col, nil) 14 | @text = IO.read(CONTENTS) 15 | @title = 'PatchMaster Help' 16 | end 17 | 18 | def draw 19 | super 20 | i = 0 21 | @text.each_line do |line| 22 | @win.setpos(i+2, 3) 23 | @win.addstr(make_fit(line.chomp)) 24 | i += 1 25 | end 26 | end 27 | 28 | end 29 | end 30 | -------------------------------------------------------------------------------- /test/trigger_test.rb: -------------------------------------------------------------------------------- 1 | require 'test_helper' 2 | 3 | class TriggerTest < Test::Unit::TestCase 4 | def setup 5 | @pm = PM::PatchMaster.instance 6 | @pm.load(DSLTest::EXAMPLE_DSL) 7 | @pm.start 8 | end 9 | 10 | def teardown 11 | @pm.stop 12 | @pm.init_data 13 | end 14 | 15 | def test_trigger_sends_when_bytes_match 16 | x = 0 17 | trigger = PM::Trigger.new([1, 2, 3], PM::CodeChunk.new(proc { x += 1 })) 18 | 19 | trigger.signal([4, 5, 6]) 20 | assert_equal 0, x 21 | 22 | trigger.signal([1, 2, 3]) 23 | assert_equal 1, x 24 | 25 | trigger.signal([1, 2, 3]) 26 | assert_equal 2, x 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /lib/patchmaster/curses/trigger_window.rb: -------------------------------------------------------------------------------- 1 | require 'curses' 2 | 3 | module PM 4 | class TriggerWindow < PmWindow 5 | 6 | include Curses 7 | 8 | def initialize(rows, cols, row, col) 9 | super(rows, cols, row, col, nil) 10 | @title = 'Triggers ' 11 | end 12 | 13 | def draw 14 | super 15 | pm = PM::PatchMaster.instance 16 | i = 0 17 | pm.inputs.each do |instrument| 18 | instrument.triggers.each do |trigger| 19 | if i < visible_height 20 | @win.setpos(i+1, 1) 21 | @win.addstr(make_fit(":#{instrument.sym} #{trigger.to_s}")) 22 | end 23 | i += 1 24 | end 25 | end 26 | end 27 | end 28 | end 29 | 30 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # PatchMaster 2 | 3 | PatchMaster is a MIDI processing and patching system. It allows a musician 4 | to reconfigure a MIDI setup instantaneously and modify the MIDI data in real 5 | time. 6 | 7 | With PatchMaster a performer can split controlling keyboards, layer MIDI 8 | channels, transpose them, send program changes and System Exclusive 9 | messages, limit controller and velocity values, and much more. At the stomp 10 | of a foot switch (or any other MIDI event), an entire MIDI system can be 11 | totally reconfigured. 12 | 13 | PatchMaster is totally programmable using Ruby. See the [examples](examples) 14 | for a few ideas. 15 | 16 | For more information please see the [documentation](site/index.md). 17 | -------------------------------------------------------------------------------- /lib/patchmaster/song_list.rb: -------------------------------------------------------------------------------- 1 | module PM 2 | 3 | # A SongList is a list of Songs. 4 | class SongList 5 | 6 | attr_accessor :name, :songs 7 | 8 | def initialize(name) 9 | @name = name 10 | @songs = [] 11 | end 12 | 13 | def <<(song) 14 | @songs << song 15 | end 16 | 17 | # Returns the first Song that matches +name+. +name+ may be either a 18 | # Regexp or a String. The match will be made case-insensitive. 19 | def find(name_regex) 20 | name_regex = Regexp.new(name_regex.to_s, true) # make case-insensitive 21 | @songs.detect { |s| s.name =~ name_regex } 22 | end 23 | 24 | %w(first prev curr next last).each do |dir| 25 | instance_eval("def #{dir}_patch; @songs.curr.#{dir}_patch; end") 26 | end 27 | end 28 | end 29 | -------------------------------------------------------------------------------- /test/support/mock_ports.rb: -------------------------------------------------------------------------------- 1 | # To help with testing, we replace PM::MockInputPort#gets and 2 | # PM::MockOutputPort#puts with versions that send what we want and save what 3 | # is received. 4 | module PM 5 | class MockInputPort 6 | attr_accessor :data_to_send 7 | 8 | alias old_initialize initialize 9 | def initialize(arg) 10 | @t0 = (Time.now.to_f * 1000).to_i 11 | @data_to_send = nil 12 | old_initialize(arg) 13 | end 14 | 15 | alias old_gets gets 16 | def gets 17 | retval = @data_to_send || [] 18 | @data_to_send = [] 19 | [{ data: retval, timestamp: (Time.now.to_f * 1000).to_i - @t0 }] 20 | end 21 | end 22 | 23 | class MockOutputPort 24 | alias old_puts puts 25 | def puts(bytes) 26 | @buffer += bytes 27 | old_puts(bytes) 28 | end 29 | end 30 | end 31 | -------------------------------------------------------------------------------- /lib/patchmaster/irb/irb_help.txt: -------------------------------------------------------------------------------- 1 | input num, :sym[, name] define an input instrument 2 | output num, :sym[, name] define an output instrument 3 | prog_chg [bank, ] prog send a program change 4 | conn :in_sym, [chan|nil], :out_sym, chan create a connection 5 | xpose num set transpose for connection 6 | zone zone_def set zone for connection 7 | filter { ... } set connection filter 8 | clear remove all connections 9 | panic panic 10 | panic! panic plus note-offs 11 | 12 | Alternate names: 13 | input inp 14 | output out 15 | conn c, connection 16 | prog_chg pc 17 | xpose x, transpose 18 | filter f 19 | -------------------------------------------------------------------------------- /lib/patchmaster/curses/info_window.rb: -------------------------------------------------------------------------------- 1 | require 'curses' 2 | 3 | module PM 4 | class InfoWindow < PmWindow 5 | 6 | CONTENTS = File.join(File.dirname(__FILE__), 'info_window_contents.txt') 7 | 8 | include Curses 9 | 10 | attr_reader :text 11 | 12 | def initialize(rows, cols, row, col) 13 | super(rows, cols, row, col, nil) 14 | @info_text = IO.read(CONTENTS) 15 | @text = nil 16 | end 17 | 18 | def text=(str) 19 | if str 20 | @text = str 21 | @title = 'Song Notes' 22 | else 23 | @text = @info_text 24 | @title = 'PatchMaster Help' 25 | end 26 | end 27 | 28 | def draw 29 | super 30 | i = 1 31 | @text.each_line do |line| 32 | break if i >= @win.maxy - 2 33 | @win.setpos(i+1, 1) 34 | @win.addstr(make_fit(" #{line.chomp}")) 35 | i += 1 36 | end 37 | end 38 | 39 | end 40 | end 41 | -------------------------------------------------------------------------------- /lib/patchmaster/trigger.rb: -------------------------------------------------------------------------------- 1 | module PM 2 | 3 | # A Trigger executes code when it sees a particular array of bytes. 4 | # Instruments have zero or more triggers. 5 | # 6 | # Since we want to save them to files, we store the text representation as 7 | # well. 8 | class Trigger 9 | 10 | attr_accessor :bytes, :code_chunk 11 | 12 | def initialize(bytes, code_chunk) 13 | @bytes, @code_chunk = bytes, code_chunk 14 | end 15 | 16 | def method_missing(sym, *args) 17 | PM::PatchMaster.instance.send(sym, *args) 18 | end 19 | 20 | # If +bytes+ matches our +@bytes+ array then run +@code_chunk+. 21 | def signal(bytes) 22 | if bytes == @bytes 23 | pm = PM::PatchMaster.instance 24 | @code_chunk.run(pm) 25 | pm.gui.refresh if pm.gui 26 | end 27 | end 28 | 29 | def to_s 30 | "#{@bytes.inspect} => #{(@code_chunk.text || '# no block text found').gsub(/\n\s*/, '; ')}" 31 | end 32 | end 33 | end 34 | -------------------------------------------------------------------------------- /lib/patchmaster/patch.rb: -------------------------------------------------------------------------------- 1 | module PM 2 | 3 | class Patch 4 | 5 | attr_accessor :name, :connections, :start_bytes, :stop_bytes 6 | 7 | def initialize(name, start_bytes=nil, stop_bytes=nil) 8 | @name, @start_bytes, @stop_bytes = name, start_bytes, stop_bytes 9 | @connections = [] 10 | @running = false 11 | end 12 | 13 | def <<(conn) 14 | @connections << conn 15 | end 16 | 17 | def inputs 18 | @connections.map(&:input).uniq 19 | end 20 | 21 | # Send start_bytes to each connection. 22 | def start 23 | unless @running 24 | @connections.each { |conn| conn.start(@start_bytes) } 25 | @running = true 26 | end 27 | end 28 | 29 | def running? 30 | @running 31 | end 32 | 33 | # Send stop_bytes to each connection, then call #stop on each connection. 34 | def stop 35 | if @running 36 | @running = false 37 | @connections.each { |conn| conn.stop(@stop_bytes) } 38 | end 39 | end 40 | end 41 | end 42 | -------------------------------------------------------------------------------- /lib/patchmaster/curses/prompt_window.rb: -------------------------------------------------------------------------------- 1 | require 'curses' 2 | 3 | module PM 4 | class PromptWindow 5 | 6 | MAX_WIDTH = 30 7 | 8 | include Curses 9 | 10 | def initialize(title, prompt) 11 | @title, @prompt = title, prompt 12 | width = cols() / 2 13 | width = MAX_WIDTH if width > MAX_WIDTH 14 | @win = Window.new(4, width, lines() / 3, (cols() - width) / 2) 15 | end 16 | 17 | def gets 18 | draw 19 | str = read_string 20 | cleanup 21 | str 22 | end 23 | 24 | def draw 25 | @win.box(?|, ?-) 26 | @win.setpos(0, 1) 27 | @win.attron(A_REVERSE) { 28 | @win.addstr(" #@title ") 29 | } 30 | 31 | @win.setpos(1, 1) 32 | @win.addstr(@prompt) 33 | 34 | @win.setpos(2, 1) 35 | @win.attron(A_REVERSE) { 36 | @win.addstr(' ' * (@win.maxx() - 2)) 37 | } 38 | 39 | @win.setpos(2, 1) 40 | @win.refresh 41 | end 42 | 43 | def read_string 44 | nocbreak 45 | echo 46 | curs_set(1) 47 | str = nil 48 | @win.attron(A_REVERSE) { 49 | str = @win.getstr 50 | } 51 | curs_set(0) 52 | noecho 53 | cbreak 54 | str 55 | end 56 | 57 | def cleanup 58 | @win.close 59 | end 60 | end 61 | end 62 | -------------------------------------------------------------------------------- /lib/patchmaster/curses/geometry.rb: -------------------------------------------------------------------------------- 1 | module PM 2 | 3 | # Defines positions and sizes of windows. Rects contain [height, width, top, 4 | # left], which is the order used by Curses::Window.new. 5 | class Geometry 6 | 7 | include Curses 8 | 9 | def initialize 10 | @top_height = (lines() - 1) * 2 / 3 11 | @bot_height = (lines() - 1) - @top_height 12 | @top_width = cols() / 3 13 | 14 | @sls_height = @top_height / 3 15 | @sl_height = @top_height - @sls_height 16 | 17 | @info_width = cols() - (@top_width * 2) 18 | @info_left = @top_width * 2 19 | end 20 | 21 | def song_list_rect 22 | [@sl_height, @top_width, 0, 0] 23 | end 24 | 25 | def song_rect 26 | [@sl_height, @top_width, 0, @top_width] 27 | end 28 | 29 | def song_lists_rect 30 | [@sls_height, @top_width, @sl_height, 0] 31 | end 32 | 33 | def trigger_rect 34 | [@sls_height, @top_width, @sl_height, @top_width] 35 | end 36 | 37 | def patch_rect 38 | [@bot_height, cols(), @top_height, 0] 39 | end 40 | 41 | def message_rect 42 | [1, cols(), lines()-1, 0] 43 | end 44 | 45 | def info_rect 46 | [@top_height, @info_width, 0, @info_left] 47 | end 48 | 49 | def help_rect 50 | [lines() - 6, cols() - 6, 3, 3] 51 | end 52 | end 53 | end 54 | -------------------------------------------------------------------------------- /lib/patchmaster/curses/list_window.rb: -------------------------------------------------------------------------------- 1 | require 'patchmaster/curses/pm_window' 2 | 3 | module PM 4 | class ListWindow < PmWindow 5 | 6 | attr_reader :list 7 | 8 | def initialize(rows, cols, row, col, title_prefix) 9 | super 10 | @offset = 0 11 | end 12 | 13 | # +curr_item_method_sym+ is a method symbol that is sent to 14 | # PM::PatchMaster to obtain the current item so we can highlight it. 15 | def set_contents(title, list, curr_item_method_sym) 16 | @title, @list, @curr_item_method_sym = title, list, curr_item_method_sym 17 | draw 18 | end 19 | 20 | def draw 21 | super 22 | return unless @list 23 | 24 | curr_item = PM::PatchMaster.instance.send(@curr_item_method_sym) 25 | return unless curr_item 26 | 27 | curr_index = @list.index(curr_item) 28 | if curr_index < @offset 29 | @offset = curr_index 30 | elsif curr_index >= @offset + visible_height 31 | @offset = curr_index - visible_height + 1 32 | end 33 | 34 | @list[@offset, visible_height].each_with_index do |thing, i| 35 | @win.setpos(i+1, 1) 36 | @win.attron(A_REVERSE) if thing == curr_item 37 | @win.addstr(make_fit(" #{thing.name} ")) 38 | @win.attroff(A_REVERSE) if thing == curr_item 39 | end 40 | end 41 | 42 | end 43 | end 44 | -------------------------------------------------------------------------------- /lib/patchmaster/curses/pm_window.rb: -------------------------------------------------------------------------------- 1 | require 'curses' 2 | require 'delegate' 3 | 4 | module PM 5 | class PmWindow < SimpleDelegator 6 | 7 | include Curses 8 | 9 | attr_reader :win, :title_prefix 10 | attr_accessor :title 11 | 12 | # If title is nil then list's name will be used 13 | def initialize(rows, cols, row, col, title_prefix) 14 | @win = Window.new(rows, cols, row, col) 15 | super(@win) 16 | @title_prefix = title_prefix 17 | set_max_contents_len(cols) 18 | end 19 | 20 | def move_and_resize(rect) 21 | @win.move(rect[2], rect[3]) 22 | @win.resize(rect[0], rect[1]) 23 | set_max_contents_len(rect[1]) 24 | end 25 | 26 | def draw 27 | @win.clear 28 | @win.box(?|, ?-) 29 | return unless @title_prefix || @title 30 | 31 | @win.setpos(0, 1) 32 | @win.attron(A_REVERSE) { 33 | @win.addch(' ') 34 | @win.addstr("#{@title_prefix}: ") if @title_prefix 35 | @win.addstr(@title) if @title 36 | @win.addch(' ') 37 | } 38 | end 39 | 40 | # Visible height is height of window minus 2 for the borders. 41 | def visible_height 42 | @win.maxy - 2 43 | end 44 | 45 | def set_max_contents_len(cols) 46 | @max_contents_len = cols - 3 # 2 for borders 47 | end 48 | 49 | def make_fit(str) 50 | str = str[0..@max_contents_len] if str.length > @max_contents_len 51 | str 52 | end 53 | end 54 | end 55 | -------------------------------------------------------------------------------- /test/predicates_test.rb: -------------------------------------------------------------------------------- 1 | require 'test_helper' 2 | 3 | # Not gonna test everything exhaustively. 4 | class PredicatesTest < Test::Unit::TestCase 5 | include PM 6 | 7 | def test_high_nibble 8 | assert_equal NOTE_ON, (NOTE_ON + 4).high_nibble 9 | end 10 | 11 | def test_channel 12 | assert_equal 5, (NOTE_OFF + 5).channel 13 | end 14 | 15 | def test_channel_p 16 | assert NOTE_ON.channel? 17 | assert (POLY_PRESSURE + 15).channel? 18 | assert (CONTROLLER + 3).channel? 19 | assert !SYSEX.channel? 20 | end 21 | 22 | def test_note_p 23 | assert NOTE_ON.note? 24 | assert (POLY_PRESSURE + 10).note? 25 | assert !CONTROLLER.note? 26 | end 27 | 28 | def test_realtime 29 | assert !0xf0.realtime? 30 | assert 0xf8.realtime? 31 | assert !0x100.realtime? 32 | end 33 | 34 | def test_array_high_nibble 35 | assert_equal NOTE_ON, [(NOTE_ON + 4), 34, 12].high_nibble 36 | end 37 | 38 | def test_array_channel 39 | assert_equal 5, [(NOTE_OFF + 5), 34, 12].channel 40 | end 41 | 42 | def test_array_channel_p 43 | assert [NOTE_ON + 3, 4, 5].channel? 44 | assert [(POLY_PRESSURE + 15), 0xfe].channel? 45 | assert ![SYSEX, 1, 2, 3, 4].channel? 46 | end 47 | 48 | def test_array_realtime 49 | assert ![0xf0, 1, 2, 3].realtime? 50 | assert [0xf8].realtime? 51 | assert ![0x100, 1, 2, 3].realtime? 52 | end 53 | end 54 | -------------------------------------------------------------------------------- /site/_includes/header.html: -------------------------------------------------------------------------------- 1 | 29 | -------------------------------------------------------------------------------- /lib/patchmaster/irb/irb.rb: -------------------------------------------------------------------------------- 1 | require 'patchmaster' 2 | require 'irb' 3 | require 'tempfile' 4 | 5 | $dsl = nil 6 | 7 | module PM 8 | class IRB 9 | 10 | include Singleton 11 | 12 | attr_reader :dsl 13 | 14 | def initialize 15 | @dsl = PM::DSL.new 16 | @dsl.song("IRB Song") 17 | @dsl.patch("IRB Patch") 18 | end 19 | 20 | # For bin/patchmaster. 21 | def run 22 | ::IRB.start 23 | end 24 | end 25 | end 26 | 27 | def dsl 28 | PM::IRB.instance.dsl 29 | end 30 | 31 | # Return the current (only) patch. 32 | def patch 33 | dsl.instance_variable_get(:@patch) 34 | end 35 | 36 | # Stop and delete all connections. 37 | def clear 38 | patch.stop 39 | patch.connections = [] 40 | patch.start 41 | end 42 | 43 | def pm_help 44 | puts IO.read(File.join(File.dirname(__FILE__), 'irb_help.txt')) 45 | end 46 | 47 | # The "panic" command is handled by the PM::DSL instance. This version 48 | # (+panic!+) tells that +panic+ to send all all-notes-off messages. 49 | def panic! 50 | PM::PatchMaster.instance.panic(true) 51 | end 52 | 53 | def method_missing(sym, *args) 54 | pm = PM::PatchMaster.instance 55 | if dsl.respond_to?(sym) 56 | patch.stop 57 | dsl.send(sym, *args) 58 | if sym == :input || sym == :inp 59 | pm.inputs.last.start 60 | end 61 | patch.start 62 | elsif pm.respond_to?(sym) 63 | pm.send(sym, *args) 64 | else 65 | super 66 | end 67 | end 68 | -------------------------------------------------------------------------------- /test/song_list_test.rb: -------------------------------------------------------------------------------- 1 | require 'test_helper' 2 | 3 | class SongListTest < Test::Unit::TestCase 4 | def setup 5 | @song_info = [] 6 | @song_list = PM::SongList.new('Song List') 7 | 2.times do |i| 8 | @song_info << create_song(i) 9 | @song_list << @song_info.last[:song] 10 | end 11 | end 12 | 13 | def test_find 14 | s = @song_info[1][:song] 15 | assert_equal s, @song_list.find('Untitled 1') 16 | assert_equal s, @song_list.find('untitled 1') 17 | assert_equal s, @song_list.find('1') 18 | end 19 | 20 | def create_song(n) 21 | song = PM::Song.new("Untitled #{n}") 22 | patch_info = [] 23 | 2.times do |i| 24 | patch_info << create_patch(i) 25 | song << patch_info.last[:patch] 26 | end 27 | { 28 | patch_info: patch_info, 29 | song: song 30 | } 31 | end 32 | 33 | def create_patch(n) 34 | name = "test_in_#{n}" 35 | in_instrument = PM::InputInstrument.new(name.to_sym, name, 0, false) 36 | name = "test_out_#{n}" 37 | out_instrument = PM::OutputInstrument.new(name.to_sym, name, 0, false) 38 | options = { pc_prog: n, zone: (40..60), xpose: 12 } 39 | conn = PM::Connection.new(in_instrument, nil, out_instrument, 2, nil, options) 40 | patch = PM::Patch.new("Untitled #{n}") 41 | patch << conn 42 | { 43 | in: in_instrument, 44 | out: out_instrument, 45 | patch: patch, 46 | connection: conn 47 | } 48 | end 49 | end 50 | -------------------------------------------------------------------------------- /test/binding_test.rb: -------------------------------------------------------------------------------- 1 | require 'test_helper' 2 | require 'patchmaster/curses/main' 3 | 4 | class BindingTest < Test::Unit::TestCase 5 | def setup 6 | $global_code_key_value = nil 7 | @pm = PM::PatchMaster.instance 8 | @old_pm_gui = @pm.gui 9 | @pm.load(DSLTest::EXAMPLE_DSL) 10 | @pm.start 11 | end 12 | 13 | def teardown 14 | @pm.gui = @old_pm_gui 15 | @pm.stop 16 | @pm.init_data 17 | $global_code_key_value = nil 18 | end 19 | 20 | def test_code_binding 21 | code_bindings = @pm.instance_variable_get('@code_bindings'.to_sym) 22 | code_key = code_bindings[Curses::Key::F3] 23 | code_key.run 24 | assert $global_code_key_value == 42 25 | end 26 | 27 | def test_message_binding 28 | message_bindings = @pm.instance_variable_get('@message_bindings'.to_sym) 29 | msg = message_bindings[Curses::Key::F1] 30 | assert_equal 'Tune Request', msg 31 | end 32 | 33 | def test_backward_message_key_args 34 | old_stderr = $stderr.dup 35 | $stderr.reopen('/dev/null', 'w') 36 | 37 | dsl = PM::DSL.new 38 | dsl.message_key('Tune Request', :f9) 39 | 40 | message_bindings = @pm.instance_variable_get('@message_bindings'.to_sym) 41 | msg = message_bindings[Curses::Key::F9] 42 | assert_equal 'Tune Request', msg 43 | 44 | $stderr = old_stderr 45 | end 46 | 47 | def test_ambiguous_message_key_args 48 | dsl = PM::DSL.new 49 | dsl.message_key('a', 'b') 50 | raise 'expected error to be raised' 51 | rescue StandardError 52 | assert true == true 53 | end 54 | end 55 | -------------------------------------------------------------------------------- /lib/patchmaster/web/public/style.css: -------------------------------------------------------------------------------- 1 | h1 { 2 | margin-bottom: 0; 3 | } 4 | ul { 5 | list-style: none; 6 | padding-left: 0; 7 | } 8 | table { 9 | border-collapse: collapse; 10 | width: 100%; 11 | } 12 | tr, td, th { 13 | border: 1px solid black; 14 | vertical-align: top; 15 | } 16 | th { 17 | background-color: black; 18 | color: white; 19 | border-right: 1px solid #888; 20 | } 21 | td#appname { 22 | text-align: center; 23 | width: 100%; 24 | } 25 | table h1, table li, table pre { 26 | padding: 0 0.5em 0 0.5em; 27 | } 28 | 29 | /* ================ black on white ================ */ 30 | .default { 31 | background-color: white; 32 | color: black; 33 | } 34 | .reverse-default { 35 | background-color: black; 36 | color: white; 37 | } 38 | .default-border { 39 | border: 1px solid black; 40 | } 41 | 42 | /* ================ green on black ================ */ 43 | .green { 44 | background-color: black; 45 | color: #0f0; 46 | } 47 | .reverse-green { 48 | background-color: #0f0; 49 | color: black; 50 | } 51 | .green-border { 52 | border: 1px solid #0f0; 53 | } 54 | 55 | /* ================ amber on black ================ */ 56 | .amber { 57 | background-color: black; 58 | color: #f80; 59 | } 60 | .reverse-amber { 61 | background-color: #f80; 62 | color: black; 63 | } 64 | .amber-border { 65 | border: 1px solid #f80; 66 | } 67 | 68 | /* ================ white on blue ================ */ 69 | .blue { 70 | background-color: blue; 71 | color: white; 72 | } 73 | .reverse-blue { 74 | background-color: white; 75 | color: blue; 76 | } 77 | .blue-border { 78 | border: 1px solid white; 79 | } 80 | -------------------------------------------------------------------------------- /lib/patchmaster/web/public/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | PatchMaster 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 15 | 16 | 17 | 25 | 30 | 52 | 53 | 54 | 59 | 60 | 61 | 62 | 63 |

13 |

PatchMaster

14 |

18 |

Song Lists

19 |

20 | 21 |

Songs

22 |

23 | 24 |

26 |

Song

27 |

28 | 29 |

31 |

Info

32 |

33 | j, down, space  - next patch
34 | k, up           - prev patch
35 | n, left         - next song
36 | p, right        - prev song
37 | 
38 | g   - goto song
39 | t   - goto song list
40 | 
41 | c   - cycle screen colors
42 | 
43 | h   - help
44 | ESC - panic
45 | 
46 | q   - quit
47 |

48 |

Triggers

49 |

50 | 51 |

55 |

Connections

56 | 57 |

58 |

64 | 65 | 66 | -------------------------------------------------------------------------------- /test/instrument_test.rb: -------------------------------------------------------------------------------- 1 | require 'test_helper' 2 | 3 | class InstrumentTest < Test::Unit::TestCase 4 | def setup 5 | @data = [1, 2, 3] 6 | @in_instrument = PM::InputInstrument.new(:tin, 'test_in', 0, false) 7 | @in_instrument.port.data_to_send = @data 8 | @out_instrument = PM::OutputInstrument.new(:tout, 'test_out', 0, false) 9 | @conn = TestConnection.new(@in_instrument, nil, @out_instrument, 2) 10 | end 11 | 12 | def test_name 13 | assert_equal 'test_in', @in_instrument.name 14 | @in_instrument.stop 15 | end 16 | 17 | def test_midi_in_sends_to_connection 18 | @in_instrument.add_connection(@conn) 19 | @in_instrument.midi_in(@data) 20 | assert_equal @data, @conn.bytes_received 21 | end 22 | 23 | def test_midi_in_sends_to_multiple_connections 24 | conn2 = TestConnection.new(@in_instrument, nil, PM::OutputInstrument.new(:tout2, 'test_out2', 0, false), 2) 25 | @in_instrument.add_connection(@conn) 26 | @in_instrument.add_connection(conn2) 27 | 28 | @in_instrument.midi_in(@data) 29 | assert_equal @data, @conn.bytes_received 30 | assert_equal @data, conn2.bytes_received 31 | end 32 | 33 | def test_output_sends_to_port 34 | @out_instrument.midi_out(@data) 35 | assert_equal @data, @out_instrument.port.buffer 36 | end 37 | 38 | def test_start_starts_thread 39 | @in_instrument.start 40 | assert_not_nil @in_instrument.listener, 'instrument listener should be created' 41 | @in_instrument.stop 42 | end 43 | 44 | def test_stop_stops_thread 45 | @in_instrument.start 46 | @in_instrument.stop 47 | assert_nil @in_instrument.listener, 'instrument listener should be destroyed' 48 | end 49 | end 50 | -------------------------------------------------------------------------------- /lib/patchmaster/curses/patch_window.rb: -------------------------------------------------------------------------------- 1 | require 'patchmaster/curses/pm_window' 2 | 3 | module PM 4 | class PatchWindow < PmWindow 5 | 6 | attr_reader :patch 7 | 8 | def patch=(patch) 9 | @title = patch ? patch.name : nil 10 | @patch = patch 11 | draw 12 | end 13 | 14 | def draw 15 | super 16 | @win.setpos(1, 1) 17 | draw_headers 18 | return unless @patch 19 | 20 | @patch.connections[0, visible_height].each_with_index do |connection, i| 21 | @win.setpos(i+2, 1) 22 | draw_connection(connection) 23 | end 24 | end 25 | 26 | def draw_headers 27 | @win.attron(A_REVERSE) { 28 | str = " Input Chan | Output Chan | Prog | Zone | Xpose | Filter" 29 | str << ' ' * (@win.maxx - 2 - str.length) 30 | @win.addstr(str) 31 | } 32 | end 33 | 34 | def draw_connection(connection) 35 | str = " #{'%16s' % connection.input.name}" 36 | str << " #{connection.input_chan ? ('%2d' % (connection.input_chan+1)) : ' '} |" 37 | str << " #{'%16s' % connection.output.name}" 38 | str << " #{'%2d' % (connection.output_chan+1)} |" 39 | str << if connection.pc? 40 | " #{'%3d' % connection.pc_prog} |" 41 | else 42 | " |" 43 | end 44 | str << if connection.zone 45 | " #{'%3s' % connection.note_num_to_name(connection.zone.begin)}" + 46 | " - #{'%3s' % connection.note_num_to_name(connection.zone.end)} |" 47 | else 48 | ' |' 49 | end 50 | str << if connection.xpose && connection.xpose != 0 51 | " #{connection.xpose < 0 ? '' : ' '}#{'%2d' % connection.xpose.to_i} |" 52 | else 53 | " |" 54 | end 55 | str << " #{filter_string(connection.filter)}" 56 | @win.addstr(make_fit(str)) 57 | end 58 | 59 | def filter_string(filter) 60 | filter.to_s.gsub(/\s*#.*/, '').gsub(/\n\s*/, "; ") 61 | end 62 | 63 | end 64 | end 65 | -------------------------------------------------------------------------------- /Gemfile.lock: -------------------------------------------------------------------------------- 1 | GEM 2 | remote: https://rubygems.org/ 3 | specs: 4 | alsa-rawmidi (0.4.0) 5 | ffi (~> 1.15, >= 1.15.5) 6 | base64 (0.3.0) 7 | byebug (12.0.0) 8 | curses (1.5.3) 9 | ffi (1.17.2-arm64-darwin) 10 | ffi (1.17.2-x86_64-darwin) 11 | ffi (1.17.2-x86_64-linux-gnu) 12 | ffi-coremidi (0.5.1) 13 | ffi (~> 1.15, >= 1.15.5) 14 | logger (1.7.0) 15 | midi-eye (0.3.10) 16 | midi-message (~> 0.4, >= 0.4.4) 17 | midi-nibbler (~> 0.2, >= 0.2.2) 18 | unimidi (~> 0.4, >= 0.4.6) 19 | midi-jruby (0.2.0) 20 | midi-message (0.4.9) 21 | midi-nibbler (0.2.4) 22 | midi-message (~> 0.4, >= 0.4.4) 23 | midi-winmm (0.1.10) 24 | ffi (>= 1.0) 25 | multi_json (1.18.0) 26 | mustermann (3.0.4) 27 | ruby2_keywords (~> 0.0.1) 28 | rack (3.2.4) 29 | rack-protection (4.2.1) 30 | base64 (>= 0.1.0) 31 | logger (>= 1.6.0) 32 | rack (>= 3.0.0, < 4) 33 | rack-session (2.1.1) 34 | base64 (>= 0.1.0) 35 | rack (>= 3.0.0) 36 | ruby2_keywords (0.0.5) 37 | sinatra (4.2.1) 38 | logger (>= 1.6.0) 39 | mustermann (~> 3.0) 40 | rack (>= 3.0.0, < 4) 41 | rack-protection (= 4.2.1) 42 | rack-session (>= 2.0.0, < 3) 43 | tilt (~> 2.0) 44 | sinatra-contrib (4.2.1) 45 | multi_json (>= 0.0.2) 46 | mustermann (~> 3.0) 47 | rack-protection (= 4.2.1) 48 | sinatra (= 4.2.1) 49 | tilt (~> 2.0) 50 | tilt (2.6.1) 51 | unimidi (0.5.1) 52 | alsa-rawmidi (~> 0.4, >= 0.4.0) 53 | ffi-coremidi (~> 0.5, >= 0.5.1) 54 | midi-jruby (~> 0.2, >= 0.2.0) 55 | midi-winmm (~> 0.1, >= 0.1.10) 56 | 57 | PLATFORMS 58 | arm64-darwin-21 59 | arm64-darwin-23 60 | arm64-darwin-24 61 | x86_64-darwin-18 62 | x86_64-linux 63 | 64 | DEPENDENCIES 65 | alsa-rawmidi 66 | byebug 67 | curses 68 | midi-eye 69 | midi-jruby 70 | midi-winmm 71 | sinatra 72 | sinatra-contrib 73 | unimidi 74 | 75 | BUNDLED WITH 76 | 2.3.11 77 | -------------------------------------------------------------------------------- /test/example_dsl.rb: -------------------------------------------------------------------------------- 1 | input 0, :mb, 'midiboard' 2 | inp 1, :ws_in, 'WaveStation' 3 | output 1, :ws_out, 'WaveStation' 4 | out 2, :kz, 'K2000R' 5 | output 4, :sj 6 | 7 | message 'Tune Request', [TUNE_REQUEST] 8 | 9 | full_volumes = (0...MIDI_CHANNELS).collect { |chan| [CONTROLLER + chan, CC_VOLUME, 127] }.flatten 10 | message 'Full Volume', full_volumes 11 | 12 | message_key :f1, 'Tune Request' 13 | message_key :f2, 'Full Volume' 14 | 15 | $global_code_key_value = nil 16 | 17 | code_key :f3 do 18 | $global_code_key_value = 42 19 | end 20 | code_key(:f4) { $global_code_key_value = 99 } 21 | 22 | trigger(:mb, [CONTROLLER, CC_GEN_PURPOSE_5, 0]) { next_patch } 23 | trigger(:mb, [CONTROLLER, CC_GEN_PURPOSE_6, 0]) { prev_patch } 24 | trigger(:mb, [CONTROLLER, CC_GEN_PURPOSE_7, 0]) { next_song } 25 | trigger(:mb, [CONTROLLER, CC_GEN_PURPOSE_8, 0]) { prev_song } 26 | trigger(:mb, [CONTROLLER, 126, 127]) { send_message 'Tune Request' } 27 | 28 | song 'First Song' do 29 | patch 'First Song, First Patch' do 30 | start_bytes [TUNE_REQUEST] 31 | stop_bytes [STOP] 32 | connection :mb, nil, :kz, 2 do # all chans from :mb, out to chan 2 on :kz 33 | prog_chg 64 34 | zone C4, B5 35 | transpose 12 36 | end 37 | connection :ws_in, 6, :sj, 4 do # only chan 6 from :ws_in, out to chan 4 on :sj 38 | prog_chg 2, 100 # bank 2, prog 100 39 | zone C4, B5 40 | filter do |connection, bytes| 41 | if bytes.note_off? && !(bytes[2] == 0) 42 | bytes[2] -= 1 # decrease velocity by 1 43 | end 44 | bytes 45 | end 46 | end 47 | conn :ws_in, 6, :ws_out, 6 48 | end 49 | patch 'First Song, Second Patch' 50 | end 51 | 52 | song 'Second Song' do 53 | patch 'Second Song, First Patch' do 54 | c :mb, :sj, 4 do 55 | pc 22 56 | z D4 57 | end 58 | c :ws_in, :ws_out, 6 do 59 | zone C4..B5 60 | filter { |c, b| b } # no-op 61 | end 62 | c :ws_in, :kz, 3 do 63 | filter do |c, b| 64 | b[0] += 1 65 | b 66 | end 67 | end 68 | end 69 | end 70 | 71 | song_list "Tonight's Song List", [ 72 | 'First Song', 73 | 'Second Song' 74 | ] 75 | -------------------------------------------------------------------------------- /examples/apps.rb: -------------------------------------------------------------------------------- 1 | # This simple example file shows how to connect two apps on the Mac. 2 | # 3 | # First, you must open the Audo MIDI Setup application, enable IAC, and add 4 | # two more ports. 5 | 6 | input 1, :app_in, 'IAC-in' # The first port you added 7 | output 2, :app_out, 'IAC-out' # The second port you added 8 | 9 | def full_volume 10 | start_bytes [CONTROLLER, CC_VOLUME, 127] 11 | end 12 | 13 | trigger(:app_in, [NOTE_ON + 2, 0, 127]) { next_patch } 14 | trigger(:app_in, [NOTE_ON + 2, 1, 127]) { prev_patch } 15 | 16 | song 'First Song' do 17 | patch 'Bass' do 18 | full_volume 19 | connection :app_in, 1, :app_out, 1 do 20 | prog_chg 34 21 | end 22 | end 23 | patch 'Piano' do 24 | full_volume 25 | connection :app_in, 1, :app_out, 1 do 26 | prog_chg 2 27 | end 28 | end 29 | patch 'Chords & Bass Layers' do 30 | full_volume 31 | # Chords 32 | connection :app_in, 1, :app_out, 1 do 33 | prog_chg 95 34 | filter do |conn, bytes| 35 | if bytes.note_on? 36 | bytes[2] = 64 unless bytes[2] == 0 37 | bytes += [bytes[0], bytes[1] + 5, bytes[2]] 38 | bytes + [bytes[0], bytes[1] - 5, bytes[2]] 39 | end 40 | end 41 | end 42 | # Bass 43 | connection :app_in, 1, :app_out, 2 do 44 | prog_chg 38 45 | filter do |conn, bytes| 46 | if bytes.note_on? 47 | bytes[1] -= 12 48 | bytes + [bytes[0], bytes[1] - 12, bytes[2]] 49 | end 50 | end 51 | end 52 | end 53 | end 54 | 55 | def time_based_volume 56 | t = Time.now.to_f # to_f gives sub-second accuracy 57 | unit_offset = Math.sin(t) # -1 .. 1 58 | volume = (unit_offset * 64) + 64 59 | volume = 127 if volume == 128 60 | volume 61 | end 62 | 63 | song 'LFO Volume' do 64 | notes <<~EOS 65 | The time_based_volume function 66 | outputs a value that changes 67 | over time. 68 | 69 | The filter injects volume 70 | commands after every MIDI 71 | message and calls 72 | time_based_volume. 73 | EOS 74 | patch "Up 'n Down" do 75 | connection :app_in, 1, :app_out, 1 do 76 | prog_chg 2 77 | transpose 0 78 | filter do |conn, bytes| 79 | # Add more bytes to outgoing b array (MIDI channel 1) 80 | bytes + [CONTROLLER + 0, CC_VOLUME, time_based_volume] 81 | end 82 | end 83 | stop_bytes [CONTROLLER, CC_VOLUME, 127] 84 | end 85 | end 86 | -------------------------------------------------------------------------------- /examples/example.rb: -------------------------------------------------------------------------------- 1 | input 0, :mb, 'midiboard' 2 | input 1, :ws_in, 'WaveStation' 3 | 4 | output 1, :ws_out, 'WaveStation' 5 | output 2, :kz, 'K2000R' 6 | output 4, :sj # Name will come from UNIMidi 7 | 8 | # In this setup, output 4 => SJ => MIDI thru => Drum machine. This lets me 9 | # refer to the same output as both :sj and :drums. There's an equivalent 10 | # alias_input command as well. 11 | alias_output :drums, :sj 12 | 13 | message 'Tune Request', [TUNE_REQUEST] 14 | 15 | full_volumes = (0...MIDI_CHANNELS).collect { |chan| [CONTROLLER + chan, CC_VOLUME, 127] }.flatten 16 | message 'Full Volume', full_volumes 17 | 18 | message_key :f1, 'Tune Request' 19 | message_key :f2, 'Full Volume' 20 | 21 | trigger(:mb, [CONTROLLER, CC_GEN_PURPOSE_5, 127]) { next_patch } 22 | trigger(:mb, [CONTROLLER, CC_GEN_PURPOSE_6, 127]) { prev_patch } 23 | trigger(:mb, [CONTROLLER, CC_GEN_PURPOSE_7, 127]) { next_song } 24 | trigger(:mb, [CONTROLLER, CC_GEN_PURPOSE_8, 127]) { prev_song } 25 | trigger(:mb, [CONTROLLER, 126, 127]) { send_message 'Tune Request' } 26 | 27 | song 'First Song' do 28 | notes <<~EOS 29 | C 30 | These are the words 31 | F C 32 | They are very clever words 33 | Ab mi 34 | And deep 35 | G7 36 | Oh, so deep 37 | 38 | C C/B 39 | This chorus does not 40 | C7/Bb Ami 41 | Refer to itself 42 | F 43 | Don't think too hard, or 44 | G7 45 | Your head 46 | Will 47 | C 48 | Explode 49 | EOS 50 | 51 | patch 'First Song, First Patch' do 52 | start_bytes [TUNE_REQUEST] 53 | connection :mb, :kz, 2 do # all chans from :mb, out to chan 2 on :kz 54 | prog_chg 64 55 | zone C4, B5 56 | transpose 12 57 | end 58 | connection :ws_in, 6, :sj, 4 do # only chan 6 from :ws_in, out to chan 4 on :sj 59 | prog_chg 100 60 | zone C4, B5 61 | filter do |conn, bytes| 62 | if bytes.note_off? && !(bytes[2] == 0) 63 | bytes[2] -= 1 # decrease velocity by 1 64 | end 65 | bytes 66 | end 67 | end 68 | conn :ws_in, 6, :ws_out, 6 69 | end 70 | patch 'First Song, Second Patch' 71 | end 72 | 73 | song 'Second Song' do 74 | patch 'Second Song, First Patch' do 75 | c :mb, :sj, 4 do 76 | pc 22 77 | z D4 78 | end 79 | c :ws_in, :ws_out, 6 do 80 | zone C4..B5 81 | filter { |c, b| b } # no-op 82 | end 83 | end 84 | end 85 | 86 | song_list "Tonight's Song List", [ 87 | 'First Song', 88 | 'Second Song' 89 | ] 90 | -------------------------------------------------------------------------------- /lib/patchmaster/web/public/js/patchmaster.coffee: -------------------------------------------------------------------------------- 1 | $ = jQuery 2 | CONN_HEADERS = """ 3 | 4 | Input 5 | Chan 6 | Output 7 | Chan 8 | Prog 9 | Zone 10 | Xpose 11 | Filter 12 | 13 | """ 14 | COLOR_SCHEMES = ['default', 'green', 'amber', 'blue']; 15 | color_scheme_index = 0; 16 | 17 | list_item = (val, highlighted_value) -> 18 | classes = if val == highlighted_value then "selected reverse-#{COLOR_SCHEMES[color_scheme_index]}" else '' 19 | "

#{val}

" 20 | 21 | list = (id, vals, highlighted_value) -> 22 | lis = (list_item(val, highlighted_value) for val in vals) 23 | $('#' + id).html(lis.join("\n")) 24 | 25 | connection_row = (conn) -> 26 | vals = (conn[key] for key in ['input', 'input_chan', 'output', 'output_chan', 'pc', 'zone', 'xpose', 'filter']) 27 | "#{vals.join('')}" 28 | 29 | connection_rows = (connections) -> 30 | rows = (connection_row(conn) for conn in connections) 31 | $('#patch').html(CONN_HEADERS + "\n" + rows.join("\n")) 32 | set_colors() 33 | 34 | maybe_name = (data, key) -> if data[key] then data[key]['name'] else '' 35 | 36 | message = (str) -> $('#message').html(str) 37 | 38 | kp = (action) -> 39 | $.getJSON(action, (data) -> 40 | list('song-lists', data['lists'], data['list']) 41 | list('songs', data['songs'], maybe_name(data, 'song')) 42 | list('triggers', data['triggers']) 43 | 44 | if data['song']? 45 | list('song', data['song']['patches'], maybe_name(data, 'patch')) 46 | if data['patch']? 47 | connection_rows(data['patch']['connections']) 48 | 49 | message(data['message']) if data['message']? 50 | ) 51 | 52 | remove_colors = () -> 53 | if color_scheme_index >= 0 54 | base_class = COLOR_SCHEMES[color_scheme_index] 55 | $('body').removeClass(base_class) 56 | $('.selected, th, td#appname').removeClass("reverse-#{base_class}") 57 | $('tr, td, th').removeClass("#{base_class}-border") 58 | 59 | set_colors = () -> 60 | base_class = COLOR_SCHEMES[color_scheme_index] 61 | $('body').addClass(base_class) 62 | $('.selected, th, td#appname').addClass("reverse-#{base_class}") 63 | $('tr, td, th').addClass("#{base_class}-border") 64 | 65 | cycle_colors = () -> 66 | remove_colors() 67 | color_scheme_index = (color_scheme_index + 1) % COLOR_SCHEMES.length 68 | set_colors() 69 | 70 | bindings = 71 | 'j': 'next_patch' 72 | 'down': 'next_patch' 73 | 'k': 'prev_patch' 74 | 'up': 'prev_patch' 75 | 'n': 'next_song' 76 | 'left': 'next_song' 77 | 'p': 'prev_song' 78 | 'right': 'prev_song' 79 | 'esc': 'panic' 80 | f = (key, val) -> $(document).bind('keydown', key, () -> kp(val)) 81 | f(key, val) for key, val of bindings 82 | $(document).bind('keydown', 'c', () -> cycle_colors()) 83 | 84 | kp('status') 85 | -------------------------------------------------------------------------------- /lib/patchmaster/predicates.rb: -------------------------------------------------------------------------------- 1 | require 'patchmaster/consts' 2 | 3 | class Integer 4 | 5 | def high_nibble 6 | self & 0xf0 7 | end 8 | 9 | def channel 10 | self & 0x0f 11 | end 12 | 13 | def channel? 14 | self >= PM::NOTE_OFF && self < PM::SYSEX 15 | end 16 | alias_method :chan?, :channel? 17 | 18 | def note_on? 19 | (self & 0xf0) == PM::NOTE_ON 20 | end 21 | alias_method :on?, :note_on? 22 | 23 | def note_off? 24 | (self & 0xf0) == PM::NOTE_OFF 25 | end 26 | alias_method :off?, :note_off? 27 | 28 | def poly_pressure? 29 | (self & 0xf0) == PM::POLY_PRESSURE 30 | end 31 | alias_method :poly_press?, :poly_pressure? 32 | 33 | # Returns true if self is a status byte for a message that targets a note 34 | # (note on, note off, or poly pressure). 35 | def note? 36 | self >= PM::NOTE_OFF && self < PM::CONTROLLER 37 | end 38 | 39 | def controller? 40 | (self & 0xf0) == PM::CONTROLLER 41 | end 42 | alias_method :ctrl?, :controller? 43 | 44 | def program_change? 45 | (self & 0xf0) == PM::PROGRAM_CHANGE 46 | end 47 | alias_method :pc?, :program_change? 48 | 49 | def pitch_bend? 50 | (self & 0xf0) == PM::PITCH_BEND 51 | end 52 | alias_method :pb?, :pitch_bend? 53 | 54 | def system? 55 | self >= PM::SYSEX && self <= PM::EOX 56 | end 57 | alias_method :sys?, :system? 58 | 59 | def realtime? 60 | self >= 0xf8 && self <= 0xff 61 | end 62 | alias_method :rt?, :realtime? 63 | end 64 | 65 | # All the methods here delegate to the first byte in the array, so for 66 | # example the following two are equivalent: 67 | # 68 | # my_array.note_on? 69 | # my_array[0].note_on? 70 | class Array 71 | 72 | def high_nibble 73 | self[0].high_nibble 74 | end 75 | 76 | def channel 77 | self[0].channel 78 | end 79 | 80 | def channel? 81 | self[0].channel? 82 | end 83 | alias_method :chan?, :channel? 84 | 85 | def note_on? 86 | self[0].note_on? 87 | end 88 | alias_method :on?, :note_on? 89 | 90 | def note_off? 91 | self[0].note_off? 92 | end 93 | alias_method :off?, :note_off? 94 | 95 | def poly_pressure? 96 | self[0].poly_pressure? 97 | end 98 | alias_method :poly_press?, :poly_pressure? 99 | 100 | # Returns true if self is a message that targets a note (note on, note 101 | # off, or poly pressure). 102 | def note? 103 | self[0].note? 104 | end 105 | 106 | def controller? 107 | self[0].controller? 108 | end 109 | alias_method :ctrl?, :controller? 110 | 111 | def program_change? 112 | self[0].program_change? 113 | end 114 | alias_method :pc?, :program_change? 115 | 116 | def pitch_bend? 117 | self[0].pitch_bend? 118 | end 119 | alias_method :pb?, :pitch_bend? 120 | 121 | def system? 122 | self[0].system? 123 | end 124 | alias_method :sys?, :system? 125 | 126 | def realtime? 127 | self[0].realtime? 128 | end 129 | alias_method :rt?, :realtime? 130 | end 131 | -------------------------------------------------------------------------------- /bin/patchmaster: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | # 3 | # usage: patchmaster [-l] [-v] [-n] [-i] [-w] [-p port] [-d] [pm_file] 4 | # 5 | # Starts PatchMaster and optionally loads pm_file. 6 | # 7 | # -l lists all available MIDI inputs and outputs and exits. This is exactply 8 | # -the same as running the `unimidi list` command from your shell. 9 | # 10 | # -v outputs the version number and exits. 11 | # 12 | # The -n flag tells PatchMaster to not use MIDI. All MIDI errors such as not 13 | # being able to connect to the MIDI instruments specified in pm_file are 14 | # ignored, and no MIDI data is sent/received. That is useful if you want to 15 | # run PatchMaster without actually talking to any MIDI instruments. 16 | # 17 | # To run PatchMaster from within an IRB session use -i. Reads 18 | # ./.patchmasterrc if it exists, $HOME/.patchmasterrc if not. See the 19 | # documentation for details on the commands that are available. 20 | # 21 | # To run PatchMaster using a Web browser GUI use -w and point your browser 22 | # at http://localhost:4567. To change the port, use -p. 23 | # 24 | # The -d flag turns on debug mode. The app becomes slightly more verbose and 25 | # logs everything to `/tmp/pm_debug.txt'. 26 | 27 | require 'optparse' 28 | 29 | use_midi = true 30 | gui = :curses 31 | port = nil 32 | OptionParser.new do |opts| 33 | opts.banner = 'usage: patchmaster [options] [pm_file]' 34 | opts.on('-d', '--debug', 'Turn on debug mode') { $DEBUG = true } 35 | opts.on('-l', '--list', 'List MIDI inputs and outputs and exit') do 36 | require 'unimidi' 37 | puts 'Inputs:' 38 | UniMIDI::Input.list 39 | puts 40 | puts 'Outputs:' 41 | UniMIDI::Output.list 42 | exit 0 43 | end 44 | opts.on('-n', '--no-midi', 'Turn off MIDI processing') { use_midi = false } 45 | opts.on('-i', '--irb', 'Use an IRB console') { gui = :irb } 46 | opts.on('-w', '--web', 'Use a Web browser GUI') { gui = :web } 47 | opts.on('-p', '--port PORT', 'Web browser GUI port number') { |opt| port = opt.to_i } 48 | opts.on('-v', '--version', 'Show version number and exit') do 49 | version_line = IO.readlines(File.join(File.dirname(__FILE__), '../Rakefile')).grep(/GEM_VERSION\s*=/).first 50 | version_line =~ /(\d+\.\d+\.\d+)/ 51 | puts "patchmaster #{Regexp.last_match(1)}" 52 | exit 0 53 | end 54 | opts.on_tail('-h', '-?', '--help', 'Show this message') do 55 | puts opts 56 | exit 0 57 | end 58 | end.parse!(ARGV) 59 | 60 | # Must require patchmaster here, after handling options, because Singleton 61 | # initialize code checks $DEBUG. 62 | begin 63 | require 'patchmaster' 64 | require 'patchmaster/curses/main' # for function key symbols 65 | rescue LoadError 66 | $LOAD_PATH << File.join(__dir__, '../lib') 67 | retry 68 | end 69 | 70 | pm = PM::PatchMaster.instance 71 | pm.use_midi = use_midi 72 | case gui 73 | when :curses 74 | pm.gui = PM::Main.instance 75 | when :irb 76 | require 'patchmaster/irb/irb' 77 | pm.gui = PM::IRB.instance 78 | when :web 79 | require 'patchmaster/web/sinatra_app' 80 | app = PM::SinatraApp.instance 81 | app.port = port if port 82 | pm.gui = app 83 | end 84 | pm.load(ARGV[0]) if ARGV[0] 85 | pm.run 86 | -------------------------------------------------------------------------------- /site/changes.md: -------------------------------------------------------------------------------- 1 | --- 2 | layout: page 3 | title: Changes 4 | --- 5 | 6 | > In programming, do, or undo. There is always try. 7 | > 8 | > -- Yoda (via Ron Jeffries) 9 | 10 | # 2.0.0 11 | 12 | - Supports Ruby 2.4.x and the latest versions of the MIDI libs on which it 13 | depends such as [Unimidi](https://github.com/arirusso/unimidi]) and 14 | [MIDIEye](https://github.com/arirusso/midi-eye) by Ari Russo. 15 | 16 | # 1.2.1 17 | 18 | - Fixed `channel?` predicate method. 19 | 20 | - Fixed `Connection.accept_from_input?`. 21 | 22 | # 1.2.0 23 | 24 | - New `code_key` command. 25 | 26 | - `message_key` argument orders have been reversed, to match `code_key`. The 27 | old order will be accepted for a while. 28 | 29 | - Switch to [Jekyll](http://jekyllrb.com/) version of the site. 30 | 31 | - New `-l` (`--list`) argument to `bin/patchmaster` lists all MIDI inputs 32 | and outputs. This is the same as running `unimidi list` in your shell. 33 | 34 | # 1.1.2 35 | 36 | - Fixed triggers. 37 | 38 | - When a trigger runs, the curses GUI is updated. Unfortunately, the web app 39 | still isn't updated. See the To Do list. 40 | 41 | # 1.1.1 42 | 43 | - Heeded a few runtime warnings. 44 | 45 | # 1.1.0 46 | 47 | - Removed `-t` command line switch from bin/patchmaster. 48 | 49 | # 1.0.0 50 | 51 | - Start of IRB interface. 52 | 53 | # 0.0.7 54 | 55 | - Added -p PORT option to bin/patchmaster. 56 | 57 | - Handle display and reading of missing block text for triggers and filters 58 | more gracefully. (Blocks are always loaded properly but the text 59 | representation sometimes isn't. See the "Editing PatchMaster File" section 60 | of the "PatchMaster Files" help file.) 61 | 62 | - Added a Gemfile, thanks to shaiguitar (https://github.com/shaiguitar). 63 | 64 | - The beginnings of a browser-based GUI. 65 | 66 | - Colors scheme selections in the browser GUI. 67 | 68 | # 0.0.6 69 | 70 | - Added missing note const definitions. 71 | 72 | - Made message lookup case-insensitive. 73 | 74 | # 0.0.5 75 | 76 | - Program change command can now take optional bank number. 77 | 78 | - More MIDI constants defined in consts.rb. Removed erroneous note constant 79 | definitions that used '#'. 80 | 81 | - Obtained http://www.patchmaster.org and moved docs to org files in 82 | www/org. 83 | 84 | # 0.0.4 85 | 86 | - Added user-defined messages and the ability to bind them to keys. 87 | 88 | - Fixed no-file edit bug. 89 | 90 | - Fixed gem dependency in Rakefile. 91 | 92 | - Added a way to run the app without windows. 93 | 94 | - Get default instrument name from UNIMidi, instead of using symbol defined 95 | in input file. 96 | 97 | - Instrument symbols must be unique within type (input or output). 98 | 99 | - Internal changes that shouldn't matter to anybody: 100 | 101 | - Store instrument symbol in instrument. 102 | 103 | - In Rakefile, current date is used when publishing gem. 104 | 105 | - More documentation. 106 | 107 | # 0.0.3 108 | 109 | - Added missing DSL stop_bytes method so PatchMaster files can now specify 110 | stop_bytes in a patch. 111 | 112 | # 0.0.1 113 | 114 | - Initial release. 115 | -------------------------------------------------------------------------------- /Rakefile: -------------------------------------------------------------------------------- 1 | require 'rake' 2 | require 'rake/testtask' 3 | require 'rdoc/task' 4 | require 'rubygems' 5 | require 'rubygems/package_task' 6 | 7 | HERE = File.dirname(__FILE__) 8 | PROJECT_NAME = 'patchmaster' 9 | GEM_VERSION = '2.0.1' 10 | GEM_DATE = Time.now.strftime('%Y-%m-%d') 11 | WEB_SERVER = 'jimmenard.com' 12 | WEB_DIR = "webapps/#{PROJECT_NAME}" 13 | LOCAL_HTML_TARGET = "/tmp/#{PROJECT_NAME}" 14 | LOCAL_CGI_TARGET = '/Library/WebServer/CGI-Executables' 15 | 16 | ORGS = Dir[File.join(HERE, 'www/org/*.org')] 17 | 18 | def html_for(orgfile) 19 | File.join(HERE, 'www/public_html', File.basename(orgfile)).sub(/\.org$/, '.html') 20 | end 21 | 22 | def web_build_needed? 23 | ORGS.detect do |orgfile| 24 | htmlfile = html_for(orgfile) 25 | File.mtime(htmlfile) < File.mtime(orgfile) 26 | end 27 | end 28 | 29 | # Default is defined below after namespace definitions. 30 | 31 | Rake::TestTask.new do |t| 32 | t.libs << File.join(HERE, 'test') 33 | t.libs << File.join(HERE, 'lib') 34 | t.pattern = 'test/**/*_test.rb' 35 | end 36 | 37 | doc_ns = namespace :doc do 38 | Rake::RDocTask.new do |rd| 39 | rd.main = 'README.rdoc' 40 | rd.title = 'PatchMaster' 41 | rd.rdoc_files.include('README.rdoc', 'lib/**/*.rb') 42 | end 43 | end 44 | 45 | spec = Gem::Specification.new do |s| 46 | s.name = PROJECT_NAME 47 | s.version = GEM_VERSION 48 | s.date = GEM_DATE 49 | s.summary = 'Realtime MIDI setup configuration and MIDI filtering' 50 | s.description = <<~EOS 51 | PatchMaster is a MIDI processing and patching system. It allows a musician to 52 | reconfigure a MIDI setup instantaneously and modify the MIDI data in real time. 53 | EOS 54 | s.author = 'Jim Menard' 55 | s.email = 'jim@jimmenard.com' 56 | s.executables << PROJECT_NAME 57 | s.files = FileList['bin/*', 'lib/**/*'].to_a 58 | s.test_files = FileList['test/**/test*.rb'].to_a 59 | s.homepage = "http://www.#{PROJECT_NAME}.org/" 60 | s.add_runtime_dependency 'midi-eye' 61 | s.license = 'Ruby' 62 | end 63 | 64 | gem_ns = namespace :gem do 65 | # Creates a :package task (also named :gem). Also useful are 66 | # :clobber_package and :repackage. 67 | Gem::PackageTask.new(spec) do |package| 68 | end 69 | 70 | desc 'Publish the gem to RubyGems.org' 71 | task publish: [doc_ns[:rdoc], :package] do 72 | system "gem push pkg/#{PROJECT_NAME}-#{GEM_VERSION}.gem" 73 | end 74 | end 75 | 76 | namespace :web do 77 | desc 'Build the site files' 78 | task :build do 79 | system('cd site && jekyll build') 80 | end 81 | 82 | desc 'Publish the Web site' 83 | task publish: :build do 84 | system("rsync -qrlpt --filter='exclude .DS_Store' --del site/_site/ #{WEB_SERVER}:#{WEB_DIR}") 85 | end 86 | 87 | desc 'Serve the site locally' 88 | task :server do 89 | system('jekyll server') 90 | end 91 | end 92 | 93 | desc 'Clean up rdoc, packages, and HTML generated from Org-mode files' 94 | task clean: [doc_ns[:clobber_rdoc], gem_ns[:clobber_package]] do 95 | Dir['www/org/*.org'].each do |f| 96 | html = f.sub(/org/, 'public_html').sub(/\.org$/, '.html') 97 | File.delete(f.sub(/org/, 'public_html').sub(/\.org$/, '.html')) if File.exist?(html) 98 | end 99 | end 100 | 101 | task default: [gem_ns[:package]] 102 | -------------------------------------------------------------------------------- /site/todo.md: -------------------------------------------------------------------------------- 1 | --- 2 | layout: page 3 | title: To Do 4 | --- 5 | 6 | # Bugs 7 | 8 | > The Be staff...went to see the movie "Men in Black." ...The movie makes 9 | > a point that is somehow appropriate -- It is impossible to completely rid 10 | > the universe of bugs, but at least you can drive something fast, arm 11 | > yourself with powerful tools, and look good doing it.\\ 12 | > \\ 13 | > -- markg@be.com 14 | 15 | - Triggers cause GUI refresh for curses, but not for Sinatra app. 16 | 17 | - Transpose values >= 100 or <= 100 throw off formatting in patch window. 18 | 19 | - When iTerm is full-screen (command-return) and then becomes not full 20 | screen (command-return), the curses windows don't get redrawn properly. As 21 | a workaround you can manually resize the iTerm window, which will fix the 22 | curses windows. 23 | 24 | - There's no way to cancel out of a PromptWindow (file load/save). 25 | 26 | - Trigger and filter block text isn't read properly when triggers or filters 27 | are created in a loop, the blocks are not indented properly, etc. 28 | 29 | - Need better CSS for Web site so left margin of content moves when site 30 | made bigger and LHS grows into it. 31 | 32 | # New Features 33 | 34 | > Innovation is not about saying yes to everything. It's about saying NO to all 35 | > but the most crucial features.\\ 36 | > \\ 37 | > -- Steve Jobs 38 | 39 | - Display bank number in patch window. 40 | 41 | - IRB code should pre-define a few variables like `pm` for 42 | `PM::PatchMaster.instance`. 43 | 44 | - Document song notes and reload features. 45 | 46 | - Finish the "Creating Triggers" and "Song List" sections of 47 | file:tutorial.org. 48 | 49 | - Working on Web interface using Sinatra and Swing interface for JRuby. I'll 50 | probably concentrate on the Web interface. 51 | 52 | - Need a logo. 53 | 54 | - Add convenience methods to PM::PatchMaster (so they are available to 55 | trigger locks) for things like clamping byte values to (0..127) and 56 | limiting min/max values. 57 | 58 | - Windows observe contents to minimize redraws. Perhaps only need to observe 59 | PatchMaster itself? 60 | 61 | - Display instruments? 62 | 63 | - Alternate display that only shows song and patch names and little else? 64 | This might be useful during performance. Already have IRB mode. 65 | 66 | - Do I need to handle running bytes in Connection#midi_in, or does UniMIDI 67 | take care of that? 68 | 69 | - In PromptWindow, remember history and support up/down arrows, ^n, ^p. 70 | 71 | - Documentation for screen commands. 72 | 73 | - Trap signals like ^C. Don't do work, just set flag to be handled next time 74 | through loop. 75 | 76 | - Remember playing notes. When move from patch to patch, make sure to send 77 | corresponding note-off messages to the original outputs on the original 78 | channels. Add 2-dimensional arrays to output instrument: channel and note 79 | number. If entry is non-nil then note is playing. 80 | 81 | - Programmable MIDI messages: predefined keys that send blocks of MIDI data 82 | 83 | - See list of features at http://jimmenard.com/projects/keymaster/, but note 84 | that many of those can be implemented via triggers and filters 85 | 86 | - Fill-in-the-blank messages, useful for things like sysex for displaying 87 | song and patch name. This could get sent out whenever patch changes, and 88 | could be used to display song/patch in a synth's display, for example. 89 | -------------------------------------------------------------------------------- /lib/patchmaster/instrument.rb: -------------------------------------------------------------------------------- 1 | require 'midi-eye' 2 | 3 | # Ports are UniMIDI inputs or outputs. 4 | module PM 5 | 6 | class Instrument 7 | 8 | attr_reader :sym, :name, :port_num, :port 9 | 10 | def initialize(sym, name, port_num, port) 11 | @sym, @name, @port_num, @port = sym, name, port_num, port 12 | @name ||= @port.name if @port 13 | end 14 | 15 | end 16 | 17 | # When a connection is started, it adds itself to this InputInstrument's 18 | # +@connections+. When it ends, it removes itself. 19 | class InputInstrument < Instrument 20 | 21 | attr_accessor :connections, :triggers 22 | attr_reader :listener 23 | 24 | # If +port+ is nil (the normal case), creates either a real or a mock port 25 | def initialize(sym, name, port_num, use_midi=true) 26 | super(sym, name, port_num, input_port(port_num, use_midi)) 27 | @connections = [] 28 | @triggers = [] 29 | @listener = nil 30 | end 31 | 32 | def add_connection(conn) 33 | @connections << conn 34 | end 35 | 36 | def remove_connection(conn) 37 | @connections.delete(conn) 38 | end 39 | 40 | # Poll for more MIDI input and process it. 41 | def start 42 | PatchMaster.instance.debug("instrument #{name} start") 43 | @port.clear_buffer 44 | @listener = MIDIEye::Listener.new(@port).listen_for { |event| midi_in(event[:message].to_bytes) } 45 | @listener.run(:background => true) 46 | end 47 | 48 | def stop 49 | PatchMaster.instance.debug("instrument #{name} stop") 50 | @port.clear_buffer 51 | if @listener 52 | @listener.close 53 | @listener = nil 54 | end 55 | end 56 | 57 | # Passes MIDI bytes on to triggers and to each output connection. 58 | def midi_in(bytes) 59 | @triggers.each { |trigger| trigger.signal(bytes) } 60 | @connections.each { |conn| conn.midi_in(bytes) } 61 | end 62 | 63 | private 64 | 65 | def input_port(port_num, use_midi=true) 66 | if use_midi 67 | UniMIDI::Input.all[port_num].open 68 | else 69 | MockInputPort.new(port_num) 70 | end 71 | end 72 | 73 | end 74 | 75 | class OutputInstrument < Instrument 76 | 77 | def initialize(sym, name, port_num, use_midi=true) 78 | super(sym, name, port_num, output_port(port_num, use_midi)) 79 | end 80 | 81 | def midi_out(bytes) 82 | @port.puts bytes 83 | end 84 | 85 | private 86 | 87 | def output_port(port_num, use_midi) 88 | if use_midi 89 | UniMIDI::Output.all[port_num].open 90 | else 91 | MockOutputPort.new(port_num) 92 | end 93 | end 94 | end 95 | 96 | class MockInputPort 97 | 98 | attr_reader :name 99 | attr_accessor :buffer 100 | 101 | # For MIDIEye::Listener 102 | def self.is_compatible?(input) 103 | true 104 | end 105 | 106 | # Constructor param is ignored; it's required by MIDIEye. 107 | def initialize(arg) 108 | @name = "MockInputPort #{arg}" 109 | @buffer = [] 110 | end 111 | 112 | def gets 113 | [{:data => [], :timestamp => 0}] 114 | end 115 | 116 | def poll 117 | yield gets 118 | end 119 | 120 | def clear_buffer 121 | end 122 | end 123 | 124 | class MockOutputPort 125 | attr_reader :name 126 | attr_accessor :buffer 127 | 128 | def initialize(port_num) 129 | @name = "MockOutputPort #{port_num}" 130 | @buffer = [] 131 | end 132 | 133 | def puts(data) 134 | end 135 | end 136 | end 137 | -------------------------------------------------------------------------------- /lib/patchmaster/web/public/js/jquery.hotkeys.js: -------------------------------------------------------------------------------- 1 | /* 2 | * jQuery Hotkeys Plugin 3 | * Copyright 2010, John Resig 4 | * Dual licensed under the MIT or GPL Version 2 licenses. 5 | * 6 | * Based upon the plugin by Tzury Bar Yochay: 7 | * http://github.com/tzuryby/hotkeys 8 | * 9 | * Original idea by: 10 | * Binny V A, http://www.openjs.com/scripts/events/keyboard_shortcuts/ 11 | */ 12 | 13 | (function(jQuery){ 14 | 15 | jQuery.hotkeys = { 16 | version: "0.8", 17 | 18 | specialKeys: { 19 | 8: "backspace", 9: "tab", 13: "return", 16: "shift", 17: "ctrl", 18: "alt", 19: "pause", 20 | 20: "capslock", 27: "esc", 32: "space", 33: "pageup", 34: "pagedown", 35: "end", 36: "home", 21 | 37: "left", 38: "up", 39: "right", 40: "down", 45: "insert", 46: "del", 22 | 96: "0", 97: "1", 98: "2", 99: "3", 100: "4", 101: "5", 102: "6", 103: "7", 23 | 104: "8", 105: "9", 106: "*", 107: "+", 109: "-", 110: ".", 111 : "/", 24 | 112: "f1", 113: "f2", 114: "f3", 115: "f4", 116: "f5", 117: "f6", 118: "f7", 119: "f8", 25 | 120: "f9", 121: "f10", 122: "f11", 123: "f12", 144: "numlock", 145: "scroll", 191: "/", 224: "meta" 26 | }, 27 | 28 | shiftNums: { 29 | "`": "~", "1": "!", "2": "@", "3": "#", "4": "$", "5": "%", "6": "^", "7": "&", 30 | "8": "*", "9": "(", "0": ")", "-": "_", "=": "+", ";": ": ", "'": "\"", ",": "<", 31 | ".": ">", "/": "?", "\\": "|" 32 | } 33 | }; 34 | 35 | function keyHandler( handleObj ) { 36 | // Only care when a possible input has been specified 37 | if ( typeof handleObj.data !== "string" ) { 38 | return; 39 | } 40 | 41 | var origHandler = handleObj.handler, 42 | keys = handleObj.data.toLowerCase().split(" "); 43 | 44 | handleObj.handler = function( event ) { 45 | // Don't fire in text-accepting inputs that we didn't directly bind to 46 | if ( this !== event.target && (/textarea|select/i.test( event.target.nodeName ) || 47 | event.target.type === "text") ) { 48 | return; 49 | } 50 | 51 | // Keypress represents characters, not special keys 52 | var special = event.type !== "keypress" && jQuery.hotkeys.specialKeys[ event.which ], 53 | character = String.fromCharCode( event.which ).toLowerCase(), 54 | key, modif = "", possible = {}; 55 | 56 | // check combinations (alt|ctrl|shift+anything) 57 | if ( event.altKey && special !== "alt" ) { 58 | modif += "alt+"; 59 | } 60 | 61 | if ( event.ctrlKey && special !== "ctrl" ) { 62 | modif += "ctrl+"; 63 | } 64 | 65 | // TODO: Need to make sure this works consistently across platforms 66 | if ( event.metaKey && !event.ctrlKey && special !== "meta" ) { 67 | modif += "meta+"; 68 | } 69 | 70 | if ( event.shiftKey && special !== "shift" ) { 71 | modif += "shift+"; 72 | } 73 | 74 | if ( special ) { 75 | possible[ modif + special ] = true; 76 | 77 | } else { 78 | possible[ modif + character ] = true; 79 | possible[ modif + jQuery.hotkeys.shiftNums[ character ] ] = true; 80 | 81 | // "$" can be triggered as "Shift+4" or "Shift+$" or just "$" 82 | if ( modif === "shift+" ) { 83 | possible[ jQuery.hotkeys.shiftNums[ character ] ] = true; 84 | } 85 | } 86 | 87 | for ( var i = 0, l = keys.length; i < l; i++ ) { 88 | if ( possible[ keys[i] ] ) { 89 | return origHandler.apply( this, arguments ); 90 | } 91 | } 92 | }; 93 | } 94 | 95 | jQuery.each([ "keydown", "keyup", "keypress" ], function() { 96 | jQuery.event.special[ this ] = { add: keyHandler }; 97 | }); 98 | 99 | })( jQuery ); -------------------------------------------------------------------------------- /lib/patchmaster/web/sinatra_app.rb: -------------------------------------------------------------------------------- 1 | require 'sinatra' 2 | require 'sinatra/json' 3 | require 'singleton' 4 | 5 | # ================================================================ 6 | # Helper methods 7 | # ================================================================ 8 | 9 | def pm 10 | @pm ||= PM::SinatraApp.instance.pm 11 | end 12 | 13 | def return_status(opts = {}) 14 | pm = pm() 15 | status = { 16 | lists: pm.song_lists.map(&:name), 17 | list: pm.song_list.name, 18 | songs: pm.song_list.songs.map(&:name), 19 | triggers: pm.inputs.collect do |instrument| 20 | instrument.triggers.collect { |trigger| ":#{instrument.sym} #{trigger}" } 21 | end.flatten 22 | } 23 | if pm.song 24 | status[:song] = { 25 | name: pm.song.name, 26 | patches: pm.song.patches.map(&:name) 27 | } 28 | if pm.patch 29 | status[:patch] = { 30 | name: pm.patch.name, 31 | connections: pm.patch.connections.collect do |conn| 32 | { 33 | input: conn.input.name, 34 | input_chan: conn.input_chan ? conn.input_chan + 1 : 'all', 35 | output: conn.output.name, 36 | output_chan: conn.output_chan + 1, 37 | pc: conn.pc_prog.to_s, 38 | zone: if conn.zone 39 | [conn.note_num_to_name(conn.zone.begin), 40 | conn.note_num_to_name(conn.zone.end)] 41 | else 42 | '' 43 | end, 44 | xpose: conn.xpose.to_s, 45 | filter: conn.filter.to_s 46 | } 47 | end 48 | } 49 | end 50 | end 51 | json status.merge(opts) 52 | end 53 | 54 | # ================================================================ 55 | # URL handlers 56 | # ================================================================ 57 | 58 | not_found do 59 | path = request.env['REQUEST_PATH'] 60 | unless path == '/favicon.ico' 61 | warn "error: not_found called, request = #{request.inspect}" # DEBUG 62 | return_status(message: "No such URL: #{path}") 63 | end 64 | end 65 | 66 | get '/' do 67 | redirect '/index.html' 68 | end 69 | 70 | get '/status' do 71 | return_status 72 | end 73 | 74 | get '/next_patch' do 75 | pm.next_patch 76 | return_status 77 | end 78 | 79 | get '/prev_patch' do 80 | pm.prev_patch 81 | return_status 82 | end 83 | 84 | get '/next_song' do 85 | pm.next_song 86 | return_status 87 | end 88 | 89 | get '/prev_song' do 90 | pm.prev_song 91 | return_status 92 | end 93 | 94 | get '/panic' do 95 | # TODO: when panic called twice in a row, call panic(true) 96 | pm.panic 97 | return_status 98 | end 99 | 100 | # ================================================================ 101 | # GUI class: run method 102 | # ================================================================ 103 | 104 | module PM 105 | class SinatraApp < Sinatra::Base 106 | set :run, true 107 | set :root, File.dirname(__FILE__) 108 | 109 | include Singleton 110 | 111 | attr_accessor :port 112 | attr_reader :pm 113 | 114 | def initialize 115 | @pm = PM::PatchMaster.instance 116 | end 117 | 118 | def run 119 | self.class.set(:port, @port) if @port 120 | @pm.start 121 | ensure 122 | @pm.stop 123 | @pm.close_debug_file 124 | end 125 | 126 | # Public method callable by triggers 127 | def refresh 128 | # FIXME 129 | end 130 | end 131 | end 132 | -------------------------------------------------------------------------------- /site/_includes/footer.html: -------------------------------------------------------------------------------- 1 | 62 | -------------------------------------------------------------------------------- /test/patch_test.rb: -------------------------------------------------------------------------------- 1 | require 'test_helper' 2 | 3 | class PatchTest < Test::Unit::TestCase 4 | def setup 5 | @pm = PM::PatchMaster.instance 6 | 7 | @in_instrument = PM::InputInstrument.new(:tin, 'test_in', 0, false) 8 | @pm.inputs << @in_instrument 9 | 10 | @out_instrument = PM::OutputInstrument.new(:tout, 'test_out', 0, false) 11 | @pm.outputs << @out_instrument 12 | 13 | @options = { pc_prog: 3, zone: (40..60), xpose: 12 } 14 | @patch = PM::Patch.new('Untitled') 15 | @conn = PM::Connection.new(@in_instrument, nil, @out_instrument, 2, nil, @options) 16 | @patch << @conn 17 | 18 | @pm.start 19 | end 20 | 21 | def teardown 22 | @pm.stop 23 | @patch.stop 24 | end 25 | 26 | def test_start_starts_connections 27 | @patch.start 28 | assert_equal @conn, @in_instrument.connections.first 29 | @patch.stop 30 | end 31 | 32 | def test_start_sends_start_bytes 33 | @patch.start_bytes = [1, 2, 3] 34 | @patch.start 35 | @patch.stop 36 | assert_equal [1, 2, 3], @out_instrument.port.buffer[0, 3] 37 | end 38 | 39 | def test_stop_sends_stop_bytes 40 | @patch.start_bytes = nil 41 | @patch.stop_bytes = [1, 2, 3] 42 | @patch.start 43 | @patch.stop 44 | assert_equal [1, 2, 3], @out_instrument.port.buffer[-3..-1] 45 | end 46 | 47 | def test_inputs 48 | assert_equal [@in_instrument], @patch.inputs 49 | 50 | # Add another connection that uses the same input instrument 51 | @patch << PM::Connection.new(@in_instrument, nil, nil, nil) 52 | assert_equal [@in_instrument], @patch.inputs 53 | 54 | # Add another connection that uses a different one 55 | second_in_instrument = PM::InputInstrument.new(:tin2, '', 0, false) 56 | @patch << PM::Connection.new(second_in_instrument, nil, nil, nil) 57 | inputs = @patch.inputs 58 | assert_equal 2, inputs.size 59 | assert inputs.include?(@in_instrument) 60 | assert inputs.include?(second_in_instrument) 61 | end 62 | 63 | def test_all_prog_changes_sent 64 | conn2 = PM::Connection.new(@in_instrument, nil, @out_instrument, 3, nil, { pc_prog: 42 }) 65 | @patch << conn2 66 | 67 | @patch.start 68 | assert_equal [PM::PROGRAM_CHANGE + 1, 3, PM::PROGRAM_CHANGE + 2, 42], @out_instrument.port.buffer 69 | end 70 | 71 | # Tests two connections with non-overlapping zones that go to different 72 | # channels on the same instrument. 73 | def test_zones 74 | @conn.pc_prog = nil 75 | @conn.zone = (0..PM::Gs4) 76 | 77 | conn2 = PM::Connection.new(@in_instrument, nil, @out_instrument, 3, nil) 78 | conn2.zone = (PM::A4..127) 79 | @patch << conn2 80 | 81 | assert_equal (0..68), @conn.zone 82 | assert_equal (69..127), conn2.zone 83 | 84 | @patch.start 85 | 86 | # Send note in @conn1 zone 87 | @patch.connections.each { |c| c.midi_in([PM::NOTE_ON + 9, PM::C1, 127]) } 88 | expected = [PM::NOTE_ON + 1, PM::C2, 127] # transposed, channel 1 89 | assert_equal expected, @out_instrument.port.buffer 90 | 91 | # Send note in conn2 zone 92 | @patch.connections.each { |c| c.midi_in([PM::NOTE_ON + 9, PM::C5, 127]) } 93 | expected += [PM::NOTE_ON + 2, PM::C5, 127] # not transposed, channel 2 94 | assert_equal expected, @out_instrument.port.buffer 95 | 96 | # Note at top of @conn1 zone 97 | @patch.connections.each { |c| c.midi_in([PM::NOTE_ON + 9, PM::Gs4, 127]) } 98 | expected += [PM::NOTE_ON + 1, PM::Gs5, 127] # transposed, channel 1 99 | assert_equal expected, @out_instrument.port.buffer 100 | 101 | # Note at bottom of conn2 zone 102 | @patch.connections.each { |c| c.midi_in([PM::NOTE_ON + 9, PM::A4, 127]) } 103 | expected += [PM::NOTE_ON + 2, PM::A4, 127] # not transposed, channel 2 104 | assert_equal expected, @out_instrument.port.buffer 105 | end 106 | end 107 | -------------------------------------------------------------------------------- /site/index.md: -------------------------------------------------------------------------------- 1 | --- 2 | layout: page 3 | --- 4 | 5 | # PatchMaster 6 | 7 | > Welcome. Welcome. Welcome. 8 | > 9 | > -- The entire Ig Nobel awards ceremony welcoming speech 10 | 11 | PatchMaster is a MIDI processing and patching system. It allows a musician 12 | to reconfigure a MIDI setup instantaneously and modify the MIDI data in real 13 | time. 14 | 15 | With PatchMaster a performer can split controlling keyboards, layer MIDI 16 | channels, transpose them, send program changes and System Exclusive 17 | messages, limit controller and velocity values, and much more. At the stomp 18 | of a foot switch (or any other MIDI event), an entire MIDI system can be 19 | totally reconfigured. 20 | 21 | PatchMaster lets you describe _songs_, which are lists of _patches_ that 22 | connect _instruments_. Those _connections_ can send program changes, set 23 | keyboard splits, transpose, send volume or other controller changes, and let 24 | you apply any Ruby code you want to the MIDI stream in real time. 25 | 26 | _Song lists_ let you organize songs into set lists for live performance or 27 | in the studio. 28 | 29 | Any incoming MIDI message can _trigger_ an action such as moving to the next 30 | or previous patch or song. For example, you can tell PatchMaster to move 31 | forward or backward based on controller values coming from foot switches or 32 | an instrument's buttons. 33 | 34 | Any array of MIDI bytes can be stored as a named _message_ which can be sent 35 | via a trigger, a key press, or from any filter. 36 | 37 | A software panic button turns off any stuck notes. 38 | 39 | PatchMaster is cross-platform: it should run on Mac OS X, Linux, JRuby, and 40 | Windows. It requires Ruby 1.9 or above, and has been tested with Ruby 2.0. 41 | 42 | PatchMaster is by [Jim Menard](mailto:jim@jimmenard.com). It is a rewrite of 43 | [KeyMaster](http://jimmenard.com/projects/keymaster/). The Github repo is 44 | [here](https://github.com/jimm/patchmaster). 45 | 46 | # Requirements 47 | 48 | - The [midi-eye](https://github.com/arirusso/midi-eye) gem, which will be 49 | installed automatically if you install PatchMaster as a gem. midi-eye in 50 | turn requires (and will install automatically): 51 | - [midi-message](https://github.com/arirusso/midi-message) 52 | - [nibbler](https://github.com/arirusso/nibbler) 53 | - [unimidi](https://github.com/arirusso/unimidi) 54 | - The [sinatra](http://www.sinatrarb.com/) gem, if you want to use 55 | PatchMaster's browser GUI 56 | - Ruby 1.9 (because UniMIDI requires it) or higher (including Ruby 2.0) 57 | - Curses (comes with Ruby, but I'm not sure about JRuby) 58 | 59 | # Installation 60 | 61 | To install as a gem, type 62 | 63 | {% highlight bash %} 64 | gem install patchmaster 65 | {% endhighlight %} 66 | 67 | # Running PatchMaster 68 | 69 | {% highlight bash %} 70 | patchmaster [-v] [-n] [-i] [-w] [-p port] [-d] [patchmaster_file] 71 | {% endhighlight %} 72 | 73 | Starts PatchMaster and optionally loads `patchmaster_file`. 74 | 75 | `-v` outputs the version number and exits. 76 | 77 | The `-n` flag tells PatchMaster to not use MIDI. All MIDI errors such as not 78 | being able to connect to the MIDI instruments specified in pm_file are 79 | ignored, and no MIDI data is sent/received. That is useful if you want to 80 | run PatchMaster without actually talking to any MIDI instruments. 81 | 82 | To run PatchMaster from within an IRB session use `-i`. Reads 83 | `./.patchmasterrc` if it exists, `$HOME/.patchmasterrc` if not. See the 84 | documentation for details on the commands that are available. 85 | 86 | To run PatchMaster using a Web browser GUI use `-w` and point your browser at 87 | http://localhost:4567. To change the port, use `-p`. 88 | 89 | The `-d` flag turns on debug mode. The app becomes slightly more verbose and 90 | logs everything to /tmp/pm_debug.txt. 91 | 92 | # More Information 93 | 94 | - Descriptions of all the [components](/components.html): songs, patches, 95 | connections, filters, and more 96 | - All about [patches and connections](/patches.html) --- what happens when they run 97 | - The [PatchMaster file format](/file-format.html) 98 | - [IRB mode](/irb.html) 99 | - [Tips and tricks](/tips-and-tricks.html) 100 | - [Screen Shots](/screenshots.html) 101 | - [Changes](/changes.html) between PatchMaster versions 102 | - [To Do](/todo.html) list, including bugs and new features 103 | -------------------------------------------------------------------------------- /lib/patchmaster/connection.rb: -------------------------------------------------------------------------------- 1 | require 'patchmaster/consts' 2 | 3 | module PM 4 | 5 | # A Connection connects an InputInstrument to an OutputInstrument. Whenever 6 | # MIDI data arrives at the InputInstrument it is optionally modified or 7 | # filtered, then the remaining modified data is sent to the 8 | # OutputInstrument. 9 | class Connection 10 | 11 | attr_accessor :input, :input_chan, :output, :output_chan, 12 | :bank, :pc_prog, :zone, :xpose, :filter 13 | 14 | # If input_chan is nil than all messages from input will be sent to 15 | # output. 16 | # 17 | # All channels (input_chan, output_chan, etc.) are 1-based here but are 18 | # turned into 0-based channels for later use. 19 | def initialize(input, input_chan, output, output_chan, filter=nil, opts={}) 20 | @input, @input_chan, @output, @output_chan, @filter = input, input_chan, output, output_chan, filter 21 | @bank, @pc_prog, @zone, @xpose = opts[:bank], opts[:pc_prog], opts[:zone], opts[:xpose] 22 | 23 | @input_chan -= 1 if @input_chan 24 | @output_chan -= 1 if @output_chan 25 | end 26 | 27 | def start(start_bytes=nil) 28 | bytes = [] 29 | bytes += start_bytes if start_bytes 30 | # Bank select uses MSB if we're only sending one byte 31 | bytes += [CONTROLLER + @output_chan, CC_BANK_SELECT+32, @bank] if @bank 32 | bytes += [PROGRAM_CHANGE + @output_chan, @pc_prog] if @pc_prog 33 | midi_out(bytes) unless bytes.empty? 34 | @input.add_connection(self) 35 | end 36 | 37 | def stop(stop_bytes=nil) 38 | midi_out(stop_bytes) if stop_bytes 39 | @input.remove_connection(self) 40 | end 41 | 42 | def accept_from_input?(bytes) 43 | return true if @input_chan == nil 44 | return true unless bytes.channel? 45 | bytes.channel == @input_chan 46 | end 47 | 48 | # Returns true if the +@zone+ is nil (allowing all notes throught) or if 49 | # +@zone+ is a Range and +note+ is inside +@zone+. 50 | def inside_zone?(note) 51 | @zone == nil || @zone.include?(note) 52 | end 53 | 54 | # The workhorse. Ignore bytes that aren't from our input, or are outside 55 | # the zone. Change to output channel. Filter. 56 | # 57 | # Note that running bytes are not handled, but unimidi doesn't seem to use 58 | # them anyway. 59 | # 60 | # Finally, we go through gyrations to avoid duping bytes unless they are 61 | # actually modified in some way. 62 | def midi_in(bytes) 63 | return unless accept_from_input?(bytes) 64 | 65 | bytes_duped = false 66 | 67 | high_nibble = bytes.high_nibble 68 | case high_nibble 69 | when NOTE_ON, NOTE_OFF, POLY_PRESSURE 70 | return unless inside_zone?(bytes[1]) 71 | 72 | if bytes[0] != high_nibble + @output_chan || (@xpose && @xpose != 0) 73 | bytes = bytes.dup 74 | bytes_duped = true 75 | end 76 | 77 | bytes[0] = high_nibble + @output_chan 78 | bytes[1] = ((bytes[1] + @xpose) & 0xff) if @xpose 79 | when CONTROLLER, PROGRAM_CHANGE, CHANNEL_PRESSURE, PITCH_BEND 80 | if bytes[0] != high_nibble + @output_chan 81 | bytes = bytes.dup 82 | bytes_duped = true 83 | bytes[0] = high_nibble + @output_chan 84 | end 85 | end 86 | 87 | # We can't tell if a filter will modify the bytes, so we have to assume 88 | # they will be. If we didn't, we'd have to rely on the filter duping the 89 | # bytes and returning the dupe. 90 | if @filter 91 | if !bytes_duped 92 | bytes = bytes.dup 93 | bytes_duped = true 94 | end 95 | bytes = @filter.call(self, bytes) 96 | end 97 | 98 | if bytes && bytes.size > 0 99 | midi_out(bytes) 100 | end 101 | end 102 | 103 | def midi_out(bytes) 104 | @output.midi_out(bytes) 105 | end 106 | 107 | def pc? 108 | @pc_prog != nil 109 | end 110 | 111 | def note_num_to_name(n) 112 | oct = (n / 12) - 1 113 | note = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'][n % 12] 114 | "#{note}#{oct}" 115 | end 116 | 117 | def to_s 118 | str = "#{@input.name} ch #{@input_chan ? @input_chan+1 : 'all'} -> #{@output.name} ch #{@output_chan+1}" 119 | str << "; pc #@pc_prog" if pc? 120 | str << "; xpose #@xpose" if @xpose 121 | str << "; zone #{note_num_to_name(@zone.begin)}..#{note_num_to_name(@zone.end)}" if @zone 122 | str 123 | end 124 | end 125 | 126 | end # PM 127 | -------------------------------------------------------------------------------- /test/connection_test.rb: -------------------------------------------------------------------------------- 1 | require 'test_helper' 2 | 3 | class ConnectionTest < Test::Unit::TestCase 4 | def setup 5 | @in_instrument = PM::InputInstrument.new(:tin, 'test_in', 0, false) 6 | @out_instrument = PM::OutputInstrument.new(:tout, 'test_out', 0, false) 7 | @options = { pc_prog: 3, zone: (40..60), xpose: 12 } 8 | @conn = PM::Connection.new(@in_instrument, nil, @out_instrument, 2, nil, @options) 9 | end 10 | 11 | def test_start_attaches_self_to_input 12 | assert @in_instrument.connections.empty? 13 | @conn.start 14 | assert_equal 1, @in_instrument.connections.size 15 | assert_equal @conn, @in_instrument.connections.first 16 | end 17 | 18 | def test_stop_detaches_self_from_input 19 | @conn.start 20 | @conn.stop 21 | assert @in_instrument.connections.empty? 22 | end 23 | 24 | def test_start_sends_start_bytes 25 | assert_equal [], @out_instrument.port.buffer 26 | @conn.start([1, 2, 3]) 27 | assert_equal [1, 2, 3], @out_instrument.port.buffer[0, 3] 28 | @conn.stop 29 | assert_equal [1, 2, 3], @out_instrument.port.buffer[0, 3] 30 | end 31 | 32 | def test_stop_sends_stop_bytes 33 | assert_equal [], @out_instrument.port.buffer 34 | @conn.start 35 | @conn.stop([4, 5, 6]) 36 | assert_equal [4, 5, 6], @out_instrument.port.buffer[-3..-1] 37 | end 38 | 39 | def test_inside_zone 40 | assert !@conn.inside_zone?(39) 41 | assert @conn.inside_zone?(40) 42 | assert @conn.inside_zone?(60) 43 | assert !@conn.inside_zone?(61) 44 | end 45 | 46 | def test_everything_inside_zone_when_zone_nil 47 | @conn.zone = nil 48 | assert @conn.inside_zone?(1) 49 | assert @conn.inside_zone?(127) 50 | end 51 | 52 | def test_accept_from_input_filters_input_chan 53 | @conn.input_chan = 3 54 | @conn.zone = nil 55 | (0x80..0xff).each do |status| 56 | expected = status >= 0xf0 || (status & 0x0f) == 3 57 | assert_equal expected, @conn.accept_from_input?([status, 0, 0]) 58 | end 59 | assert @conn.accept_from_input?([0x93, 0, 0]) 60 | assert @conn 61 | end 62 | 63 | def test_accept_from_input_takes_anything_if_nil_in_chan 64 | (0x80..0xff).each do |status| 65 | assert @conn.accept_from_input?([status, 0, 0]) 66 | end 67 | end 68 | 69 | def test_out_of_zone_no_bytes_sent 70 | @conn.midi_in([PM::NOTE_ON, 3, 127]) 71 | assert @out_instrument.port.buffer.empty?, 72 | 'output port should be empty because note is out of range' 73 | end 74 | 75 | def test_output_sent_to_output_channel 76 | @conn.xpose = 0 77 | @conn.midi_in([PM::NOTE_ON + 1, 40, 127]) 78 | assert_equal [PM::NOTE_ON + 1, 40, 127], @out_instrument.port.buffer 79 | 80 | @out_instrument.port.buffer = [] 81 | @conn.midi_in([PM::NOTE_ON, 40, 127]) 82 | assert_equal [PM::NOTE_ON + 1, 40, 127], @out_instrument.port.buffer 83 | 84 | @out_instrument.port.buffer = [] 85 | @conn.midi_in([PM::CONTROLLER + 15, 1, 2]) 86 | assert_equal [PM::CONTROLLER + 1, 1, 2], @out_instrument.port.buffer 87 | end 88 | 89 | def test_transpose 90 | assert_equal 12, @conn.xpose 91 | @conn.midi_in([PM::NOTE_ON + 1, 40, 127]) 92 | assert_equal [PM::NOTE_ON + 1, 52, 127], @out_instrument.port.buffer 93 | end 94 | 95 | def test_prog_sent 96 | assert_equal 3, @conn.pc_prog 97 | @conn.start 98 | assert_equal [PM::PROGRAM_CHANGE + @conn.output_chan, 3], @out_instrument.port.buffer 99 | end 100 | 101 | def test_bank_sent 102 | @conn.bank = 2 103 | @conn.start 104 | assert_equal [PM::CONTROLLER + @conn.output_chan, PM::CC_BANK_SELECT + 32, 2, 105 | PM::PROGRAM_CHANGE + @conn.output_chan, 3], 106 | @out_instrument.port.buffer 107 | end 108 | 109 | def test_filter 110 | filter_block = ->(conn, bytes) { bytes.map(&:succ) } 111 | filter = PM::Filter.new(PM::CodeChunk.new(filter_block)) 112 | conn = PM::Connection.new(@in_instrument, nil, @out_instrument, 2, filter, @options) 113 | conn.midi_in([1, 2, 3]) 114 | assert_equal [2, 3, 4], @out_instrument.port.buffer 115 | end 116 | 117 | def test_note_num_to_name 118 | assert_equal 'C4', @conn.note_num_to_name(PM::C4) 119 | end 120 | 121 | def test_to_s 122 | assert_equal "test_in ch all -> test_out ch 2; pc 3; xpose 12; zone #{@conn.note_num_to_name(40)}..#{@conn.note_num_to_name(60)}", 123 | @conn.to_s 124 | end 125 | end 126 | -------------------------------------------------------------------------------- /site/patches.md: -------------------------------------------------------------------------------- 1 | --- 2 | layout: page 3 | title: Patches 4 | --- 5 | 6 | > A wandering minstrel I -\\ 7 | > A thing of threads and patches,\\ 8 | > Of ballads, songs and snatches,\\ 9 | > And dreamy lullaby!\\ 10 | > \\ 11 | > -- Sir William Gilbert, _The Mikado_ 12 | 13 | When a patch is started it becomes the _current patch_. Each connection is 14 | started (see below) and passed the patch's start bytes to send to its output 15 | instrument. When a patch is stopped, each connection is stopped and passed 16 | the stop bytes to send to its output. 17 | 18 | # Connections 19 | 20 | Connections have an input instrument and (optional) input channel, output 21 | instrument and channel, and the following optional values: 22 | 23 | - Program bank number 24 | - Program change number 25 | - Keyboard zone (low/high keys stored as a Ruby Range object) 26 | - Transpose 27 | - Filter (see [Connection Filters](#connection-filters) below) 28 | 29 | If the input instrument's channel is not specified then all input from that 30 | instrument is run through the connection. If the channel is specified then 31 | any incoming MIDI bytes on other channels are ignored. 32 | 33 | ## Start 34 | 35 | When a connection is started: 36 | 37 | - The start bytes from the patch, if any, are sent to the output instrument 38 | as-is (in particular, status bytes' channels are not changed). 39 | 40 | - The program change is sent to the output instrument (on the channel 41 | defined for the output instrument, of course). 42 | 43 | - The connection adds itself to its input instrument's list of outgoing 44 | connections. 45 | 46 | ## Stop 47 | 48 | When a connection is stopped: 49 | 50 | - The stop bytes from the patch, if any, are sent to the output instrument 51 | as-is (in particular, status bytes' channels are not changed). 52 | 53 | - The connection removes itself from its input instrument's list of outgoing 54 | connections. 55 | 56 | # Processing Incoming MIDI Data 57 | 58 | While the current patch is running, MIDI data that comes in from an 59 | instrument causes two things happen: 60 | 61 | - The data is sent to the instrument's triggers. Each trigger looks at the 62 | data and decides if it should act by executing its block of code. 63 | 64 | - The data is then sent to each of the connections connected to the 65 | instrument. 66 | 67 | An input instrument can be used by more than one connection. Each connection 68 | can modify the data and send it to a different MIDI instrument. 69 | 70 | - The data is ignored if it is not on the input instrument's selected 71 | channel for that connection. If no input channel is specified in a 72 | connection, then all incoming data is accepted. 73 | 74 | - Note messages (note on, note off, and polyphonic pressure) are transposed. 75 | 76 | - Channel messages (note on, note off, polyphonic pressure, controller, 77 | program change, channel pressure, and pitch bend) have their channel 78 | changed to the output instrument's selected channel. 79 | 80 | - If the connection has a filter, its block of code is run and the result of 81 | that block becomes the bytes to be output. The filter may return an empty 82 | array or nil which will prevent anything from being sent to the output. 83 | 84 | - The resulting bytes, if any, are sent to the output instrument. 85 | 86 | ## Connection Filters 87 | 88 | When a filter is run it is passed two arguments: the connection and an array 89 | of MIDI bytes. Whatever the filter returns will be sent to the output 90 | instrument. 91 | 92 | The filter is passed the connection not only so it can read its state (for 93 | example, the transpose value) but also so that it can modify the connection 94 | itself. For example, a filter could change the transpose value or keyboard 95 | zone, or even change the connection's filter itself, allowing for "hot 96 | swapping" of filter code. 97 | 98 | Note that if a filter does "hot swap" itself for another filter, that 99 | other filter will not be saved as the patch's filter by the "save" 100 | command. 101 | 102 | The filter's block must evaluate to the bytes you want sent. That is, it 103 | must have as its last line an array of bytes or `nil`. For example, 104 | 105 | {% highlight ruby %} 106 | filter { |connection, bytes| 107 | if bytes.note_off? 108 | bytes[2] -= 1 unless bytes[2] == 0 # decrease velocity by 1 109 | end 110 | bytes # don't forget this --- must return array of bytes 111 | } 112 | {% endhighlight %} 113 | -------------------------------------------------------------------------------- /lib/patchmaster/web/public/js/patchmaster.js: -------------------------------------------------------------------------------- 1 | // Generated by CoffeeScript 1.3.3 2 | (function() { 3 | var $, COLOR_SCHEMES, CONN_HEADERS, bindings, color_scheme_index, connection_row, connection_rows, cycle_colors, f, key, kp, list, list_item, maybe_name, message, val; 4 | 5 | $ = jQuery; 6 | 7 | CONN_HEADERS = "\n Input\n Chan\n Output\n Chan\n Prog\n Zone\n Xpose\n Filter\n"; 8 | 9 | COLOR_SCHEMES = ['default', 'green', 'amber', 'blue']; 10 | 11 | color_scheme_index = 0; 12 | 13 | list_item = function(val, highlighted_value) { 14 | var classes; 15 | classes = val === highlighted_value ? "selected reverse-" + COLOR_SCHEMES[color_scheme_index] : ''; 16 | return "

" + val + "

"; 17 | }; 18 | 19 | list = function(id, vals, highlighted_value) { 20 | var lis, val; 21 | lis = (function() { 22 | var _i, _len, _results; 23 | _results = []; 24 | for (_i = 0, _len = vals.length; _i < _len; _i++) { 25 | val = vals[_i]; 26 | _results.push(list_item(val, highlighted_value)); 27 | } 28 | return _results; 29 | })(); 30 | return $('#' + id).html(lis.join("\n")); 31 | }; 32 | 33 | connection_row = function(conn) { 34 | var key, vals; 35 | vals = (function() { 36 | var _i, _len, _ref, _results; 37 | _ref = ['input', 'input_chan', 'output', 'output_chan', 'pc', 'zone', 'xpose', 'filter']; 38 | _results = []; 39 | for (_i = 0, _len = _ref.length; _i < _len; _i++) { 40 | key = _ref[_i]; 41 | _results.push(conn[key]); 42 | } 43 | return _results; 44 | })(); 45 | return "" + (vals.join('')) + ""; 46 | }; 47 | 48 | connection_rows = function(connections) { 49 | var conn, rows; 50 | rows = (function() { 51 | var _i, _len, _results; 52 | _results = []; 53 | for (_i = 0, _len = connections.length; _i < _len; _i++) { 54 | conn = connections[_i]; 55 | _results.push(connection_row(conn)); 56 | } 57 | return _results; 58 | })(); 59 | $('#patch').html(CONN_HEADERS + "\n" + rows.join("\n")); 60 | return set_colors(); 61 | }; 62 | 63 | maybe_name = function(data, key) { 64 | if (data[key]) { 65 | return data[key]['name']; 66 | } else { 67 | return ''; 68 | } 69 | }; 70 | 71 | message = function(str) { 72 | return $('#message').html(str); 73 | }; 74 | 75 | kp = function(action) { 76 | return $.getJSON(action, function(data) { 77 | list('song-lists', data['lists'], data['list']); 78 | list('songs', data['songs'], maybe_name(data, 'song')); 79 | list('triggers', data['triggers']); 80 | if (data['song'] != null) { 81 | list('song', data['song']['patches'], maybe_name(data, 'patch')); 82 | if (data['patch'] != null) { 83 | connection_rows(data['patch']['connections']); 84 | } 85 | } 86 | if (data['message'] != null) { 87 | return message(data['message']); 88 | } 89 | }); 90 | }; 91 | 92 | remove_colors = function() { 93 | if (color_scheme_index >= 0) { 94 | var base_class; 95 | base_class = COLOR_SCHEMES[color_scheme_index]; 96 | $('body').removeClass(base_class); 97 | $('.selected, th, td#appname').removeClass("reverse-" + base_class); 98 | $('tr, td, th').removeClass("" + base_class + "-border"); 99 | } 100 | }; 101 | 102 | set_colors = function() { 103 | var base_class; 104 | base_class = COLOR_SCHEMES[color_scheme_index]; 105 | $('body').addClass(base_class); 106 | $('.selected, th, td#appname').addClass("reverse-" + base_class); 107 | return $('tr, td, th').addClass("" + base_class + "-border"); 108 | }; 109 | 110 | cycle_colors = function() { 111 | remove_colors(); 112 | color_scheme_index = (color_scheme_index + 1) % COLOR_SCHEMES.length; 113 | return set_colors(); 114 | }; 115 | 116 | bindings = { 117 | 'j': 'next_patch', 118 | 'down': 'next_patch', 119 | 'k': 'prev_patch', 120 | 'up': 'prev_patch', 121 | 'n': 'next_song', 122 | 'left': 'next_song', 123 | 'p': 'prev_song', 124 | 'right': 'prev_song', 125 | 'esc': 'panic' 126 | }; 127 | 128 | f = function(key, val) { 129 | return $(document).bind('keydown', key, function() { 130 | return kp(val); 131 | }); 132 | }; 133 | 134 | for (key in bindings) { 135 | val = bindings[key]; 136 | f(key, val); 137 | } 138 | 139 | $(document).bind('keydown', 'c', function() { 140 | return cycle_colors(); 141 | }); 142 | 143 | kp('status'); 144 | 145 | }).call(this); 146 | -------------------------------------------------------------------------------- /site/irb.md: -------------------------------------------------------------------------------- 1 | --- 2 | layout: page 3 | title: IRB 4 | --- 5 | 6 | > She sells sea shells by the sea shore. 7 | 8 | *Warning*: this feature of PatchMaster is brand new. The commands or their 9 | syntax may change as I play with IRB mode. So, please give me your 10 | [feedback](mailto:jim@jimmenard.com). 11 | 12 | PatchMaster's IRB mode lets you interactively define connections, send patch 13 | changes, and transpose and otherwise filter your MIDI setup. It's intended 14 | more for experimentation and jamming, where you don't know ahead of time 15 | exactly how you want your setup configured. 16 | 17 | Because of this, there are no songs or patches and no jumping from one to 18 | the other. Another way to think about it is that you're in one live patch 19 | that is constantly being redefined as you add connections. 20 | 21 | ## Starting IRB Mode 22 | 23 | Use the `-i` flag to start PatchMaster within an IRB console. 24 | 25 | On startup IRB mode looks for the file .patchmasterrc in the current 26 | directory and loads that file. If it does not exist, IRB mode looks for the 27 | file `$HOME/.patchmasterrc`. 28 | 29 | # Commands 30 | 31 | Type `pm_help` to get a list of all the PatchMaster commands available. 32 | There are a few new commands, and a few that behave slightly differently 33 | then when they're in a PatchMaster file. 34 | 35 | ## Familiar Commands 36 | 37 | All of the commands that are avilable in PatchMaster files are available to 38 | you here, but a few work slightly differently, and a few more just don't 39 | make sense. 40 | 41 | ### Changed 42 | 43 | Though you can give a block to a `connection` command just like you do in a 44 | PatchMaster file, the commands that are normally in such blocks (`prog_chg`, 45 | `zone`, `transpose`, and `filter`) also work outside of the block and affect 46 | the most recently defined connection. So for example, these two are 47 | equivalent: 48 | 49 | {% highlight ruby %} 50 | # From a PatchMaster file 51 | connection :mb, :kz, 1 do 52 | transpose 12 53 | zone C4, B5 54 | end 55 | 56 | # IRB mode equivalent 57 | connection :mb, :kz, 1 58 | transpose 12 59 | zone C4, B5 60 | {% endhighlight %} 61 | 62 | ### Don't make any sense 63 | 64 | - `song` 65 | - `patch` 66 | - `song_list` 67 | - `start_bytes` 68 | - `stop_bytes` 69 | 70 | ## New Commands 71 | 72 | ### `clear` 73 | 74 | `clear` deletes all connections. 75 | 76 | ### `panic` and `panic!` 77 | 78 | `panic` sends an all-notes-off message. `panic!` does the same thing and 79 | then sends individual note-off messages for all notes on all channels. 80 | 81 | # Tips & Tricks 82 | 83 | ## Initial Setup 84 | 85 | Store your setup (input, output, alias_output, etc.) in `~/.patchmasterrc`. 86 | 87 | ## Loading Files 88 | 89 | To load a file from within IRB: 90 | 91 | {% highlight bash %} 92 | $ bin/patchmaster -i 93 | PatchMaster loaded 94 | Type "pm_help" for help 95 | PatchMaster:001:0> require "myfile" 96 | {% endhighlight %} 97 | 98 | If `myfile.rb` isn't on your Ruby load path you'll see an error like 99 | "LoadError: cannot load such file -- myfile". In that case, there are three 100 | different solutions: 101 | 102 | ### Command line 103 | 104 | Start PatchMaster using the `ruby` command and add the proper directory 105 | using the `-I` command line argument: 106 | 107 | {% highlight bash %} 108 | $ ruby -I path/to/dir-containing-myfile bin/patchmaster -i 109 | $ bin/patchmaster -i 110 | PatchMaster loaded 111 | Type "pm_help" for help 112 | PatchMaster:002:0> require "myfile" 113 | {% endhighlight %} 114 | 115 | ### Specify Full Path to File 116 | 117 | {% highlight bash %} 118 | $ bin/patchmaster -i 119 | PatchMaster loaded 120 | Type "pm_help" for help 121 | PatchMaster:002:0> require "path/to/dir-containing-myfile/myfile" 122 | {% endhighlight %} 123 | 124 | ### Modify Load Path 125 | 126 | {% highlight bash %} 127 | $ bin/patchmaster -i 128 | PatchMaster loaded 129 | Type "pm_help" for help 130 | PatchMaster:001:0> $LOAD_PATH << "path/to/dir-containing-myfile" 131 | PatchMaster:002:0> require "myfile" 132 | {% endhighlight %} 133 | 134 | ## Common Configurations 135 | 136 | Have a few favorite connection configurations? Shove them into a file, 137 | either one configuration in each file or all in one file in different 138 | methods. For example, say you've created the file `myfile.rb` that contains 139 | the following: 140 | 141 | {% highlight ruby %} 142 | input 0, :kbd, 'Cool Controller' 143 | input 1, :kbd2, 'Kool Kontroller' 144 | output 0, :module1, 'Moddy the Module' 145 | output 1, :module2, 'YAMM' 146 | 147 | def vanilla 148 | clear 149 | connection :kbd, :module1, 1 150 | connection :kbd, :module2, 2 151 | end 152 | 153 | def chocolate 154 | clear 155 | connection :kbd, :module1, 1 156 | connection :kbd2, :module1, 3 157 | end 158 | {% endhighlight %} 159 | 160 | Then you can `require "myfile"` (or `require "/path/to/myfile"` if it's not 161 | in your load path) and type `vanilla` or `chocolate` to switch between the 162 | two setups you've defined. 163 | -------------------------------------------------------------------------------- /lib/patchmaster/patchmaster.rb: -------------------------------------------------------------------------------- 1 | require 'singleton' 2 | require 'delegate' 3 | require 'patchmaster/sorted_song_list' 4 | require 'patchmaster/cursor' 5 | 6 | module PM 7 | 8 | # Global behavior: master list of songs, list of song lists, stuff like 9 | # that. 10 | # 11 | # Typical use: 12 | # 13 | # PatchMaster.instance.load("my_pm_dsl_file") 14 | # PatchMaster.instance.start 15 | # # ...when you're done 16 | # PatchMaster.instance.stop 17 | class PatchMaster < SimpleDelegator 18 | 19 | DEBUG_FILE = '/tmp/pm_debug.txt' 20 | 21 | include Singleton 22 | 23 | attr_reader :inputs, :outputs, :all_songs, :song_lists 24 | attr_reader :messages, :message_bindings, :code_bindings 25 | attr_accessor :use_midi 26 | alias_method :use_midi?, :use_midi 27 | attr_accessor :gui 28 | attr_reader :loaded_file 29 | 30 | # A Cursor to which we delegate incoming position methods (#song_list, 31 | # #song, #patch, #next_song, #prev_patch, etc.) 32 | attr_reader :cursor 33 | 34 | def initialize 35 | @running = false 36 | @cursor = Cursor.new(self) 37 | super(@cursor) 38 | @use_midi = true 39 | @gui = nil 40 | @message_bindings = {} 41 | @code_bindings = {} 42 | 43 | if $DEBUG 44 | @debug_file = File.open(DEBUG_FILE, 'a') 45 | end 46 | 47 | init_data 48 | end 49 | 50 | def no_gui! 51 | @no_gui = true 52 | end 53 | 54 | # Loads +file+. Does its best to restore the current song list, song, and 55 | # patch after loading. 56 | def load(file) 57 | restart = running? 58 | stop 59 | 60 | @cursor.mark 61 | init_data 62 | DSL.new.load(file) 63 | @loaded_file = file 64 | @cursor.restore 65 | 66 | if restart 67 | start(false) 68 | elsif @cursor.patch 69 | @cursor.patch.start 70 | end 71 | rescue => ex 72 | raise("error loading #{file}: #{ex}\n" + caller.join("\n")) 73 | end 74 | 75 | def save(file) 76 | DSL.new.save(file) 77 | @loaded_file = file 78 | rescue => ex 79 | raise("error saving #{file}: #{ex}" + caller.join("\n")) 80 | end 81 | 82 | def bind_message(name, key) 83 | @message_bindings[key] = name 84 | end 85 | 86 | def bind_code(code_key) 87 | @code_bindings[code_key.key] = code_key 88 | end 89 | 90 | # Initializes the cursor and all data. 91 | def init_data 92 | @cursor.clear 93 | @inputs = [] 94 | @outputs = [] 95 | @song_lists = [] 96 | @all_songs = SortedSongList.new('All Songs') 97 | @song_lists << @all_songs 98 | @messages = {} 99 | end 100 | 101 | # If +init_cursor+ is +true+ (the default), initializes current song list, 102 | # song, and patch. 103 | def start(init_cursor = true) 104 | @cursor.init if init_cursor 105 | @cursor.patch.start if @cursor.patch 106 | @running = true 107 | @inputs.map(&:start) 108 | end 109 | 110 | # Stop everything, including input instruments' MIDIEye listener threads. 111 | def stop 112 | @cursor.patch.stop if @cursor.patch 113 | @inputs.map(&:stop) 114 | @running = false 115 | end 116 | 117 | # Run PatchMaster without the GUI. Don't use this when using PM::Main. If 118 | # there is a GUI then forward this request to it. Otherwise, call #start, 119 | # wait for inputs' MIDIEye listener threads to finish, then call #stop. 120 | # Note that normally nothing stops those threads, so this is used as a way 121 | # to make sure the script doesn't quit until killed by something like 122 | # SIGINT. 123 | def run 124 | if @gui 125 | @gui.run 126 | else 127 | start(true) 128 | @inputs.each { |input| input.listener.join } 129 | stop 130 | end 131 | end 132 | 133 | def running? 134 | @running 135 | end 136 | 137 | # Send the message with the given +name+ to all outputs. Names are matched 138 | # case-insensitively. 139 | def send_message(name) 140 | _correct_case_name, msg = @messages[name.downcase] 141 | if !msg 142 | message("Message \"#{name}\" not found") 143 | return 144 | end 145 | 146 | debug("Sending message \"#{name}\"") 147 | @outputs.each { |out| out.midi_out(msg) } 148 | 149 | # If the user accidentally calls send_message in a filter at the end, 150 | # then the filter will return whatever this method returns. Just in 151 | # case, return nil instead of whatever the preceding code would return. 152 | nil 153 | end 154 | 155 | # Sends the +CM_ALL_NOTES_OFF+ controller message to all output 156 | # instruments on all 16 MIDI channels. If +individual_notes+ is +true+ 157 | # send individual +NOTE_OFF+ messages to all notes as well. 158 | def panic(individual_notes=false) 159 | debug("panic(#{individual_notes})") 160 | @outputs.each do |out| 161 | buf = [] 162 | MIDI_CHANNELS.times do |chan| 163 | buf += [CONTROLLER + chan, CM_ALL_NOTES_OFF, 0] 164 | if individual_notes 165 | buf += (0..127).collect { |note| [NOTE_OFF + chan, note, 0] }.flatten 166 | end 167 | end 168 | out.midi_out(buf) 169 | end 170 | end 171 | 172 | # Output +str+ to @debug_file or $stderr. 173 | def debug(str) 174 | return unless $DEBUG 175 | f = @debug_file || $stderr 176 | f.puts str 177 | f.flush 178 | end 179 | 180 | def close_debug_file 181 | @debug_file.close if @debug_file 182 | end 183 | end 184 | end 185 | -------------------------------------------------------------------------------- /site/tips-and-tricks.md: -------------------------------------------------------------------------------- 1 | --- 2 | layout: page 3 | title: Tips and Tricks 4 | --- 5 | 6 | > An invasion of armies can be resisted, but not an idea whose time has come. 7 | > 8 | > -- Victor Hugo 9 | 10 | This section contains some ideas that will hopefully spur you to even more 11 | interesting and creative uses of PatchMaster. 12 | 13 | # Don't Panic! 14 | 15 | Hitting ESCAPE sends all-notes-off messages to every output instrument on 16 | all 16 MIDI channels. Hitting ESCAPE a second time sends individual note off 17 | messages to every note on all 16 channels to every output instrument. 18 | 19 | # What? 20 | 21 | predicates.rb defines methods on Integer and Array that might be useful to 22 | you when writing filters or triggers. Most of the Array methods apply 23 | themselves to the first byte, so for example these two are equivalent: 24 | 25 | {% highlight ruby %} 26 | b.controller? # true if b is controller status byte, any chan 27 | my_array.controller? # true if first byte is controller status byte 28 | my_array[0].controller? # same as previous line 29 | {% endhighlight %} 30 | 31 | # From One, Many 32 | 33 | You can turn one note into multiple notes either by setting up two different 34 | connections that connect the same input to the same output, or by writing a 35 | filter that turns one message into multiple like this: 36 | 37 | {% highlight ruby %} 38 | filter { |conn, bytes| 39 | if bytes.note? 40 | bytes += bytes # duplicate note message 41 | bytes[-2] += 12 # raise second note up an octave 42 | end 43 | bytes 44 | } 45 | {% endhighlight %} 46 | 47 | This also shows the use of the predicate method `note?` which returns true 48 | for note on, note off, and poly pressure messages. 49 | 50 | # This One Goes to 11 51 | 52 | Use start bytes or messages to set initial volumes for instruments, for 53 | example resetting all instrument's volumes to 127. 54 | 55 | # Hands-Free 56 | 57 | Use PatchMaster to play notes! A patch's start bytes can be used to play one 58 | or more notes-on messages, and the stop bytes can be used to play the 59 | corresponding note-off messages. 60 | 61 | # And Now, a Massage from the Swedish Prime Minister 62 | 63 | You don't have to enter message byte arrays manually. You can build up the 64 | message using Ruby code, storing it in a variable, and then hand that 65 | variable to the `message` method. See `examples/example.rb`. 66 | 67 | Messages can be sent not only from the keyboard but also from a trigger or a 68 | filter by calling 69 | 70 | {% highlight ruby %} 71 | send_message "Message Name" 72 | {% endhighlight %} 73 | 74 | To get the message's bytes, for example within a filter, use 75 | 76 | {% highlight ruby %} 77 | messages["My Message Name".downcase] 78 | {% endhighlight %} 79 | 80 | # Method to Your Madness 81 | 82 | You can write your own methods in the PatchMaster file and call them from 83 | triggers and filters. Your method has access to the PM::PatchMaster methods 84 | and instance variables --- for example, @outputs is the array of all output 85 | instruments. 86 | 87 | {% highlight ruby %} 88 | def output_reset 89 | @outputs.each { |out| out.midi_out([SYSTEM_RESET]) } 90 | end 91 | 92 | trigger(:mb, [CONTROLLER, 126, 127]) { output_reset } 93 | {% endhighlight %} 94 | 95 | # Time Lord 96 | 97 | Use the time to modify the MIDI data. Here's an example filter that 98 | increases or decreases volume based on the time --- essentially an LFO 99 | that is modulating amplitude. 100 | 101 | {% highlight ruby %} 102 | def time_based_volume 103 | t = Time.now.to_f # to_f gives sub-second accuracy 104 | unit_offset = Math.sin(t) # -1 .. 1 105 | volume = (unit_offset * 64) + 64 106 | volume = 127 if volume == 128 107 | volume 108 | end 109 | 110 | song "s1" do 111 | patch "p1" do 112 | connection :my_in, :my_out, 2 do 113 | filter do |c, b| 114 | # Add more bytes to outgoing b array (and return b) 115 | # Here, + 1 means we're sending this to MIDI channel 2 116 | b + [CONTROLLER + 1, CC_VOLUME, time_based_volume] 117 | end 118 | end 119 | end 120 | end 121 | {% endhighlight %} 122 | 123 | # Tuning 124 | 125 | You might want to set up a song that helps you tune your instruments 126 | by sending the proper program changes and entering note on and note 127 | off commands that play the tuning note on different synths. (Yes, 128 | you actually had to tune most older synths.) For example, 129 | 130 | 1. Patch One 131 | 132 | - Start message: program changes and note-ons for reference synth A and 133 | another synth (B). 134 | - Stop message: note-off for synth B. 135 | 136 | 2. Patch Two 137 | 138 | - Start message: program change and note-on for synth C. 139 | - Stop message: note-off for synth C. 140 | 141 | 3. Patch Three 142 | 143 | - Start message: program change and note-on for synth D. 144 | - Stop message: note-offs for synth D and reference synth A. 145 | 146 | # Matching Names 147 | 148 | When you enter the name of a song list, song, or patch on the screen, you 149 | need not type the whole name. Just use the shortest unique prefix of the 150 | name. Actually, you can type any regular expression. Also, you needn't worry 151 | about matching upper and lower case; all name comparisons are 152 | case-insensitive (the regular expression is automatically made to match 153 | case-insensitively). 154 | -------------------------------------------------------------------------------- /lib/patchmaster/cursor.rb: -------------------------------------------------------------------------------- 1 | module PM 2 | 3 | # A PM::Cursor knows the current PM::SongList, PM::Song, and PM::Patch, how 4 | # to move between songs and patches, and how to find them given name 5 | # regexes. 6 | class Cursor 7 | 8 | attr_reader :song_list, :song, :patch 9 | 10 | def initialize(pm) 11 | @pm = pm 12 | clear 13 | end 14 | 15 | # Set @song_list, @song, and @patch to +nil+. 16 | def clear 17 | @song_list = @song = @patch = nil 18 | # Do not erase names saved by #mark. 19 | end 20 | 21 | # Set @song_list to All Songs, @song to first song, and 22 | # @patch to song's first patch. Song and patch may be +nil+. 23 | def init 24 | @song_list = @pm.song_lists.first 25 | @song = @song_list.songs.first 26 | if @song 27 | @patch = @song.patches.first 28 | else 29 | @patch = nil 30 | end 31 | end 32 | 33 | def next_song 34 | return unless @song_list 35 | return if @song_list.songs.last == @song 36 | 37 | @patch.stop if @patch 38 | @song = @song_list.songs[@song_list.songs.index(@song) + 1] 39 | @patch = @song.patches.first 40 | @patch.start 41 | end 42 | 43 | def prev_song 44 | return unless @song_list 45 | return if @song_list.songs.first == @song 46 | 47 | @patch.stop if @patch 48 | @song = @song_list.songs[@song_list.songs.index(@song) - 1] 49 | @patch = @song.patches.first 50 | @patch.start 51 | end 52 | 53 | def next_patch 54 | return unless @song 55 | if @song.patches.last == @patch 56 | next_song 57 | elsif @patch 58 | @patch.stop 59 | @patch = @song.patches[@song.patches.index(@patch) + 1] 60 | @patch.start 61 | end 62 | end 63 | 64 | def prev_patch 65 | return unless @song 66 | if @song.patches.first == @patch 67 | prev_song 68 | elsif @patch 69 | @patch.stop 70 | @patch = @song.patches[@song.patches.index(@patch) - 1] 71 | @patch.start 72 | end 73 | end 74 | 75 | def goto_song(name_regex) 76 | new_song_list = new_song = new_patch = nil 77 | new_song = @song_list.find(name_regex) if @song_list 78 | new_song = @@pm.all_songs.find(name_regex) unless new_song 79 | new_patch = new_song ? new_song.patches.first : nil 80 | 81 | if (new_song && new_song != @song) || # moved to new song 82 | (new_song == @song && @patch != new_patch) # same song but not at same first patch 83 | 84 | @patch.stop if @patch 85 | 86 | if @song_list.songs.include?(new_song) 87 | new_song_list = @song_list 88 | else 89 | # Not found in current song list. Switch to @pm.all_songs list. 90 | new_song_list = @@pm.all_songs 91 | end 92 | 93 | @song_list = new_song_list 94 | @song = new_song 95 | @patch = new_patch 96 | @patch.start 97 | end 98 | end 99 | 100 | def goto_song_list(name_regex) 101 | name_regex = Regexp.new(name_regex.to_s, true) # make case-insensitive 102 | new_song_list = @pm.song_lists.detect { |song_list| song_list.name =~ name_regex } 103 | return unless new_song_list 104 | 105 | @song_list = new_song_list 106 | 107 | new_song = @song_list.songs.first 108 | new_patch = new_song ? new_song.patches.first : nil 109 | 110 | if new_patch != @patch 111 | @patch.stop if @patch 112 | new_patch.start if new_patch 113 | end 114 | @song = new_song 115 | @patch = new_patch 116 | end 117 | 118 | # Remembers the names of the current song list, song, and patch. 119 | # Used by #restore. 120 | def mark 121 | @song_list_name = @song_list ? @song_list.name : nil 122 | @song_name = @song ? @song.name : nil 123 | @patch_name = @patch ? @patch.name : nil 124 | end 125 | 126 | # Using the names saved by #save, try to find them now. 127 | # 128 | # Since names can change we use Damerau-Levenshtein distance on lowercase 129 | # versions of all strings. 130 | def restore 131 | return unless @song_list_name # will be nil on initial load 132 | 133 | @song_list = find_nearest_match(@pm.song_lists, @song_list_name) || @pm.all_songs 134 | @song = find_nearest_match(@song_list.songs, @song_name) || @song_list.songs.first 135 | if @song 136 | @patch = find_nearest_match(@song.patches, @patch_name) || @song.patches.first 137 | else 138 | @patch = nil 139 | end 140 | end 141 | 142 | # List must contain objects that respond to #name. If +str+ is nil or 143 | # +list+ is +nil+ or empty then +nil+ is returned. 144 | def find_nearest_match(list, str) 145 | return nil unless str && list && !list.empty? 146 | 147 | str = str.downcase 148 | distances = list.collect { |item| dameraulevenshtein(str, item.name.downcase) } 149 | list[distances.index(distances.min)] 150 | end 151 | 152 | # https://gist.github.com/182759 (git://gist.github.com/182759.git) 153 | # Referenced from http://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance 154 | def dameraulevenshtein(seq1, seq2) 155 | oneago = nil 156 | thisrow = (1..seq2.size).to_a + [0] 157 | seq1.size.times do |x| 158 | twoago, oneago, thisrow = oneago, thisrow, [0] * seq2.size + [x + 1] 159 | seq2.size.times do |y| 160 | delcost = oneago[y] + 1 161 | addcost = thisrow[y - 1] + 1 162 | subcost = oneago[y - 1] + ((seq1[x] != seq2[y]) ? 1 : 0) 163 | thisrow[y] = [delcost, addcost, subcost].min 164 | if (x > 0 and y > 0 and seq1[x] == seq2[y-1] and seq1[x-1] == seq2[y] and seq1[x] != seq2[y]) 165 | thisrow[y] = [thisrow[y], twoago[y-2] + 1].min 166 | end 167 | end 168 | end 169 | return thisrow[seq2.size - 1] 170 | end 171 | 172 | end 173 | end 174 | -------------------------------------------------------------------------------- /lib/patchmaster/curses/main.rb: -------------------------------------------------------------------------------- 1 | require 'curses' 2 | require 'singleton' 3 | require 'patchmaster/curses/geometry' 4 | %w(list patch info trigger prompt help).each { |w| require "patchmaster/curses/#{w}_window" } 5 | 6 | module PM 7 | 8 | class Main 9 | 10 | include Singleton 11 | include Curses 12 | 13 | FUNCTION_KEY_SYMBOLS = {} 14 | 12.times do |i| 15 | FUNCTION_KEY_SYMBOLS["f#{i+1}".to_sym] = Key::F1 + i 16 | FUNCTION_KEY_SYMBOLS["F#{i+1}".to_sym] = Key::F1 + i 17 | end 18 | 19 | def initialize 20 | @pm = PatchMaster.instance 21 | end 22 | 23 | def run 24 | @pm.start 25 | begin 26 | config_curses 27 | create_windows 28 | 29 | loop do 30 | begin 31 | refresh_all 32 | ch = getch 33 | message("ch = #{ch}") if $DEBUG 34 | case ch 35 | when 'j', Key::DOWN, ' ' 36 | @pm.next_patch 37 | when 'k', Key::UP 38 | @pm.prev_patch 39 | when 'n', Key::RIGHT 40 | @pm.next_song 41 | when 'p', Key::LEFT 42 | @pm.prev_song 43 | when 'g' 44 | name = PromptWindow.new('Go To Song', 'Go to song:').gets 45 | @pm.goto_song(name) if name.length > 0 46 | when 't' 47 | name = PromptWindow.new('Go To Song List', 'Go to Song List:').gets 48 | @pm.goto_song_list(name) if name.length > 0 49 | when 'e' 50 | close_screen 51 | file = @pm.loaded_file || PromptWindow.new('Edit', 'Edit file:').gets 52 | edit(file) if file.length > 0 53 | when 'r' 54 | load(@pm.loaded_file) if @pm.loaded_file && @pm.loaded_file.length > 0 55 | when 'h', '?' 56 | help 57 | when 27 # "\e" doesn't work here 58 | # Twice in a row sends individual note-off commands 59 | message('Sending panic note off messages...') 60 | @pm.panic(@prev_cmd == 27) 61 | message('Panic sent') 62 | when 'l' 63 | file = PromptWindow.new('Load', 'Load file:').gets 64 | if file.length > 0 65 | begin 66 | load(file) 67 | message("Loaded #{file}") 68 | rescue => ex 69 | message(ex.to_s) 70 | end 71 | end 72 | when 's' 73 | file = PromptWindow.new('Save', 'Save into file:').gets 74 | if file.length > 0 75 | begin 76 | save(file) 77 | message("Saved #{file}") 78 | rescue => ex 79 | message(ex.to_s) 80 | end 81 | end 82 | when 'q' 83 | break 84 | when Key::RESIZE 85 | resize_windows 86 | end 87 | @prev_cmd = ch 88 | rescue => ex 89 | message(ex.to_s) 90 | @pm.debug caller.join("\n") 91 | end 92 | 93 | msg_name = @pm.message_bindings[ch] 94 | @pm.send_message(msg_name) if msg_name 95 | code_key = @pm.code_bindings[ch] 96 | code_key.run if code_key 97 | end 98 | ensure 99 | clear 100 | refresh 101 | close_screen 102 | @pm.stop 103 | @pm.close_debug_file 104 | end 105 | end 106 | 107 | def config_curses 108 | init_screen 109 | cbreak # unbuffered input 110 | noecho # do not show typed keys 111 | stdscr.keypad(true) # enable arrow keys 112 | curs_set(0) # cursor: 0 = invisible, 1 = normal 113 | end 114 | 115 | def create_windows 116 | g = PM::Geometry.new 117 | 118 | @song_lists_win = ListWindow.new(*g.song_lists_rect, nil) 119 | @song_list_win = ListWindow.new(*g.song_list_rect, 'Song List') 120 | @song_win = ListWindow.new(*g.song_rect, 'Song') 121 | @patch_win = PatchWindow.new(*g.patch_rect, 'Patch') 122 | @message_win = Window.new(*g.message_rect) 123 | @trigger_win = TriggerWindow.new(*g.trigger_rect) 124 | @info_win = InfoWindow.new(*g.info_rect) 125 | 126 | @message_win.scrollok(false) 127 | end 128 | 129 | def resize_windows 130 | g = PM::Geometry.new 131 | 132 | @song_lists_win.move_and_resize(g.song_lists_rect) 133 | @song_list_win.move_and_resize(g.song_list_rect) 134 | @song_win.move_and_resize(g.song_rect) 135 | @patch_win.move_and_resize(g.patch_rect) 136 | @trigger_win.move_and_resize(g.trigger_rect) 137 | @info_win.move_and_resize(g.info_rect) 138 | 139 | r = g.message_rect 140 | @message_win.move(r[2], r[3]) 141 | @message_win.resize(r[0], r[1]) 142 | end 143 | 144 | def load(file) 145 | @pm.load(file) 146 | end 147 | 148 | def save(file) 149 | @pm.save(file) 150 | end 151 | 152 | # Opens the most recently loaded/saved file name in an editor. After 153 | # editing, the file is re-loaded. 154 | def edit(file) 155 | editor_command = find_editor 156 | unless editor_command 157 | message("Can not find $VISUAL, $EDITOR, vim, or vi on your path") 158 | return 159 | end 160 | 161 | cmd = "#{editor_command} #{file}" 162 | @pm.debug(cmd) 163 | system(cmd) 164 | load(file) 165 | end 166 | 167 | # Return the first legit command from $VISUAL, $EDITOR, vim, vi, and 168 | # notepad.exe. 169 | def find_editor 170 | @editor ||= [ENV['VISUAL'], ENV['EDITOR'], 'vim', 'vi', 'notepad.exe'].compact.detect do |cmd| 171 | system('which', cmd) || File.exist?(cmd) 172 | end 173 | end 174 | 175 | def help 176 | g = PM::Geometry.new 177 | win = HelpWindow.new(*g.help_rect) 178 | win.draw 179 | win.refresh 180 | getch # wait for key and eat it 181 | end 182 | 183 | def message(str) 184 | if @message_win 185 | @message_win.clear 186 | @message_win.addstr(str) 187 | @message_win.refresh 188 | else 189 | $stderr.puts str 190 | end 191 | @pm.debug "#{Time.now} #{str}" 192 | end 193 | 194 | # Public method callable by triggers 195 | def refresh 196 | refresh_all 197 | end 198 | 199 | def refresh_all 200 | set_window_data 201 | wins = [@song_lists_win, @song_list_win, @song_win, @patch_win, @info_win, @trigger_win] 202 | wins.map(&:draw) 203 | ([stdscr] + wins).map(&:noutrefresh) 204 | Curses.doupdate 205 | end 206 | 207 | def set_window_data 208 | @song_lists_win.set_contents('Song Lists', @pm.song_lists, :song_list) 209 | 210 | song_list = @pm.song_list 211 | @song_list_win.set_contents(song_list.name, song_list.songs, :song) 212 | 213 | song = @pm.song 214 | if song 215 | @song_win.set_contents(song.name, song.patches, :patch) 216 | @info_win.text = song.notes 217 | patch = @pm.patch 218 | @patch_win.patch = patch 219 | else 220 | @song_win.set_contents(nil, nil, :patch) 221 | @info_win.text = nil 222 | @patch_win.patch = nil 223 | end 224 | end 225 | 226 | end 227 | end 228 | -------------------------------------------------------------------------------- /test/dsl_test.rb: -------------------------------------------------------------------------------- 1 | require 'stringio' 2 | require 'test_helper' 3 | 4 | class DSLTest < Test::Unit::TestCase 5 | EXAMPLE_DSL = File.join(File.dirname(__FILE__), 'example_dsl.rb') 6 | 7 | def setup 8 | @pm = PM::PatchMaster.instance 9 | @pm.init_data 10 | @dsl = PM::DSL.new 11 | @dsl.load(EXAMPLE_DSL) 12 | end 13 | 14 | def teardown 15 | @pm.init_data 16 | end 17 | 18 | def test_load_input 19 | mb = @pm.inputs.detect { |instr| instr.sym == :mb } 20 | assert_not_nil mb 21 | assert_kind_of PM::InputInstrument, mb 22 | end 23 | 24 | def test_load_output 25 | kz = @pm.outputs.detect { |instr| instr.sym == :kz } 26 | assert_kind_of PM::OutputInstrument, kz 27 | end 28 | 29 | def test_output_name 30 | sj = @pm.outputs.detect { |instr| instr.sym == :sj } 31 | assert_kind_of PM::OutputInstrument, sj 32 | assert_equal 'MockOutputPort 4', sj.name 33 | end 34 | 35 | def test_load_code_keys 36 | assert_equal 2, @pm.code_bindings.length 37 | assert_equal "do\n $global_code_key_value = 42\nend", 38 | @pm.code_bindings.values[0].code_chunk.text 39 | assert_equal '{ $global_code_key_value = 99 }', 40 | @pm.code_bindings.values[1].code_chunk.text 41 | end 42 | 43 | def test_load_triggers 44 | mb = @pm.inputs.detect { |instr| instr.sym == :mb } 45 | triggers = mb.triggers 46 | assert_equal 5, triggers.length 47 | trigger = triggers[0] 48 | assert_equal [PM::CONTROLLER, PM::CC_GEN_PURPOSE_5, 0], trigger.bytes 49 | assert_equal '{ prev_song }', mb.triggers[3].code_chunk.text 50 | end 51 | 52 | def test_load_songs 53 | assert_equal 2, @pm.all_songs.songs.length 54 | song = @pm.all_songs.find('First Song') 55 | assert_kind_of PM::Song, song 56 | assert_kind_of PM::Song, @pm.all_songs.find('Second Song') 57 | 58 | assert_equal 'First Song', song.name 59 | assert_equal 2, song.patches.length 60 | end 61 | 62 | def test_load_patches 63 | song = @pm.all_songs.find('First Song') 64 | patch = song.patches[0] 65 | assert_equal [PM::TUNE_REQUEST], patch.start_bytes 66 | assert_equal [PM::STOP], patch.stop_bytes 67 | assert_equal 3, patch.connections.length 68 | end 69 | 70 | def test_load_connection 71 | mb = @pm.inputs.detect { |instr| instr.sym == :mb } 72 | kz = @pm.outputs.detect { |instr| instr.sym == :kz } 73 | song = @pm.all_songs.find('First Song') 74 | patch = song.patches[0] 75 | conn = patch.connections[0] 76 | 77 | assert_equal mb, conn.input 78 | assert_nil conn.input_chan 79 | assert_equal kz, conn.output 80 | assert_equal 1, conn.output_chan 81 | 82 | assert_equal 64, conn.pc_prog 83 | assert_equal (PM::C4..PM::B5), conn.zone 84 | assert_equal conn.xpose, 12 85 | end 86 | 87 | def test_load_another_connection 88 | song = @pm.all_songs.find('First Song') 89 | patch = song.patches[0] 90 | conn = patch.connections[1] 91 | 92 | assert_equal 2, conn.bank 93 | assert_equal 100, conn.pc_prog 94 | end 95 | 96 | def test_skip_input_chan 97 | # Make sure that we can skip the second input_chan argument and things 98 | # are still assigned properly. 99 | mb = @pm.inputs.detect { |instr| instr.sym == :mb } 100 | sj = @pm.outputs.detect { |instr| instr.sym == :sj } 101 | conn = @pm.all_songs.find('Second Song').patches[0].connections[0] 102 | 103 | assert_equal mb, conn.input 104 | assert_nil conn.input_chan 105 | assert_equal sj, conn.output 106 | assert_equal 3, conn.output_chan 107 | end 108 | 109 | def test_save 110 | f = '/tmp/dsl_test_save.rb' 111 | begin 112 | @dsl.save(f) 113 | # TODO: write more here 114 | rescue StandardError => e 115 | raise e.to_s 116 | ensure 117 | File.delete(f) 118 | end 119 | end 120 | 121 | def test_what_saves_is_loadable 122 | f = '/tmp/dsl_test_what_saves_is_loadable.rb' 123 | begin 124 | @dsl.save(f) 125 | @pm.init_data 126 | @dsl.load(f) 127 | rescue StandardError => e 128 | raise e.to_s 129 | ensure 130 | File.delete(f) 131 | end 132 | end 133 | 134 | def test_save_file_contents 135 | f = '/tmp/dsl_test_save_file_contents.rb' 136 | @dsl.save('/tmp/dsl_test_save_file_contents.rb') 137 | str = IO.read(f) 138 | assert_match 'output 1, :ws_out, "WaveStation"', str 139 | assert_match "message \"Tune Request\", [#{PM::TUNE_REQUEST}]", str 140 | assert_match 'message_key :f1, "Tune Request"', str 141 | assert_match 'trigger(:mb, [176, 50, 0]) { next_patch }', str 142 | assert_match 'trigger(:mb, [176, 52, 0]) { next_song }', str 143 | assert_match 'filter { |c, b| b } # no-op', str 144 | assert_match 'filter { |c, b| b[0] += 1; b }', str 145 | rescue StandardError => e 146 | raise e.to_s 147 | ensure 148 | File.delete(f) 149 | end 150 | 151 | def test_aliases 152 | conn = @pm.all_songs.find('Second Song').patches[0].connections[0] 153 | assert_equal 22, conn.pc_prog 154 | assert_not_nil conn.zone 155 | end 156 | 157 | def test_zone_takes_empty_end 158 | conn = @pm.all_songs.find('Second Song').patches[0].connections[0] 159 | assert_equal (PM::D4..127), conn.zone 160 | end 161 | 162 | def test_zone_takes_range 163 | conn = @pm.all_songs.find('Second Song').patches[0].connections[1] 164 | assert_equal (PM::C4..PM::B5), conn.zone 165 | end 166 | 167 | def test_unique_instrument_symbol 168 | file = '/tmp/dsl_test.rb' 169 | str = IO.read(EXAMPLE_DSL) 170 | str.gsub!(/output 4, :sj/, 'output 4, :ws_out') 171 | File.open(file, 'w') { |f| f.puts str } 172 | begin 173 | @pm.init_data 174 | @dsl = PM::DSL.new 175 | @dsl.load(file) 176 | raise 'expected unique symbol error to be raised' 177 | rescue StandardError => e 178 | assert_match(/can not have the same symbol $:ws_out$/, e.to_s) 179 | ensure 180 | File.delete(file) 181 | end 182 | end 183 | 184 | def test_read_filter_text 185 | str = <<~EOS 186 | { |connection, bytes| 187 | if bytes.note_off? 188 | bytes[2] -= 1 unless bytes[2] == 0 # decrease velocity by 1 189 | end 190 | bytes 191 | } 192 | EOS 193 | assert_equal str.strip, 194 | @pm.all_songs 195 | .find('First Song') 196 | .patches[0] 197 | .connections[1] 198 | .filter 199 | .code_chunk 200 | .text 201 | 202 | assert_equal '{ |c, b| b } # no-op', 203 | @pm.all_songs 204 | .find('Second Song') 205 | .patches[0] 206 | .connections[1] 207 | .filter 208 | .code_chunk 209 | .text 210 | end 211 | 212 | def test_messages 213 | assert_equal ['Tune Request', [PM::TUNE_REQUEST]], 214 | @pm.messages['Tune Request'.downcase] 215 | end 216 | end 217 | -------------------------------------------------------------------------------- /test/patchmaster_test.rb: -------------------------------------------------------------------------------- 1 | require 'test_helper' 2 | 3 | class PatchMasterTest < Test::Unit::TestCase 4 | EXAMPLE_DSL = File.join(File.dirname(__FILE__), 'example_dsl.rb') 5 | 6 | def setup 7 | @pm = PM::PatchMaster.instance 8 | @pm.load(EXAMPLE_DSL) 9 | @pm.start 10 | 11 | # We can assume the DSL loader worked properly, since that's tested in 12 | # DSLTest. 13 | end 14 | 15 | def teardown 16 | @pm.stop 17 | @pm.init_data 18 | end 19 | 20 | def test_start 21 | assert_equal @pm.all_songs, @pm.song_list 22 | assert_equal @pm.all_songs.songs[0], @pm.song 23 | assert_equal @pm.all_songs.songs[0].patches[0], @pm.patch 24 | assert_only_curr_patch_running 25 | end 26 | 27 | def test_running 28 | assert @pm.running?, 'PatchMaster instance should be running' 29 | assert_only_curr_patch_running 30 | end 31 | 32 | def test_stop 33 | @pm.stop 34 | assert !@pm.patch.running? 35 | assert !@pm.running? 36 | 37 | @pm.all_songs.songs.each do |song| 38 | song.patches.each do |patch| 39 | assert !patch.running?, "patch #{patch.name} should not be running" 40 | end 41 | end 42 | end 43 | 44 | def test_next_song 45 | @pm.next_song 46 | assert_equal @pm.all_songs, @pm.song_list 47 | assert_equal @pm.all_songs.songs[1], @pm.song 48 | assert_equal @pm.all_songs.songs[1].patches[0], @pm.patch 49 | assert_only_curr_patch_running 50 | end 51 | 52 | def test_next_song_end_of_song_list_does_nothing 53 | @pm.next_song 54 | @pm.next_song 55 | assert_equal @pm.all_songs, @pm.song_list 56 | assert_equal @pm.all_songs.songs[1], @pm.song 57 | assert_equal @pm.all_songs.songs[1].patches[0], @pm.patch 58 | assert @pm.all_songs.songs[1].patches[0].running? 59 | assert_only_curr_patch_running 60 | end 61 | 62 | def test_prev_song 63 | @pm.next_song # We've proven that next_song works 64 | @pm.prev_song 65 | assert_equal @pm.all_songs, @pm.song_list 66 | assert_equal @pm.all_songs.songs[0], @pm.song 67 | assert_equal @pm.all_songs.songs[0].patches[0], @pm.patch 68 | assert_only_curr_patch_running 69 | end 70 | 71 | def test_prev_song_start_of_song_list_does_nothing 72 | @pm.prev_song 73 | assert_equal @pm.all_songs, @pm.song_list 74 | assert_equal @pm.all_songs.songs[0], @pm.song 75 | assert_equal @pm.all_songs.songs[0].patches[0], @pm.patch 76 | assert_only_curr_patch_running 77 | end 78 | 79 | def test_next_patch 80 | @pm.next_patch 81 | assert_equal @pm.all_songs, @pm.song_list 82 | assert_equal @pm.all_songs.songs[0], @pm.song 83 | assert_equal @pm.all_songs.songs[0].patches[1], @pm.patch 84 | assert_only_curr_patch_running 85 | end 86 | 87 | def test_next_patch_end_of_song 88 | @pm.next_patch 89 | @pm.next_patch # should call next song 90 | assert_equal @pm.all_songs, @pm.song_list 91 | assert_equal @pm.all_songs.songs[1], @pm.song 92 | assert_equal @pm.all_songs.songs[1].patches[0], @pm.patch 93 | assert_only_curr_patch_running 94 | end 95 | 96 | def test_prev_patch 97 | @pm.next_patch # We've proven that next_patch works 98 | @pm.prev_patch 99 | assert_equal @pm.all_songs, @pm.song_list 100 | assert_equal @pm.all_songs.songs[0], @pm.song 101 | assert_equal @pm.all_songs.songs[0].patches[0], @pm.patch 102 | assert_only_curr_patch_running 103 | end 104 | 105 | def test_prev_patch_start_of_song 106 | @pm.prev_patch 107 | assert_equal @pm.all_songs, @pm.song_list 108 | assert_equal @pm.all_songs.songs[0], @pm.song 109 | assert_equal @pm.all_songs.songs[0].patches[0], @pm.patch 110 | assert_only_curr_patch_running 111 | end 112 | 113 | def test_goto_song 114 | @pm.goto_song('First') 115 | song = @pm.all_songs.find('First') 116 | assert_equal song, @pm.song 117 | assert_equal song.patches.first, @pm.patch 118 | assert_only_curr_patch_running 119 | end 120 | 121 | def test_goto_song_list 122 | @pm.goto_song_list('Tonight') 123 | assert_equal "Tonight's Song List", @pm.song_list.name 124 | assert_equal @pm.song_list.songs.first, @pm.song 125 | assert_equal @pm.song_list.songs.first.patches.first, @pm.patch 126 | assert_only_curr_patch_running 127 | end 128 | 129 | def test_find_nearest_match 130 | song = @pm.send(:find_nearest_match, @pm.all_songs.songs, 'Frist Song') 131 | assert_not_nil song 132 | assert_equal 'First Song', song.name 133 | 134 | song = @pm.send(:find_nearest_match, @pm.all_songs.songs, 'SECOND SONG') 135 | assert_not_nil song 136 | assert_equal 'Second Song', song.name 137 | 138 | song = @pm.send(:find_nearest_match, @pm.all_songs.songs, 'Second Sing') 139 | assert_not_nil song 140 | assert_equal 'Second Song', song.name 141 | assert_only_curr_patch_running 142 | end 143 | 144 | def test_load_restores_position 145 | @pm.next_song 146 | @pm.load(EXAMPLE_DSL) 147 | 148 | assert @pm.running?, 'PatchMaster instance should be running' 149 | assert_equal 'All Songs', @pm.song_list.name 150 | assert_equal 'Second Song', @pm.song.name 151 | assert_equal 'Second Song, First Patch', @pm.patch.name 152 | end 153 | 154 | def test_send_message 155 | # We've started a patch that sends tune request as start_bytes 156 | assert_equal [PM::TUNE_REQUEST], @pm.outputs[0].port.buffer 157 | 158 | @pm.send_message 'Tune Request' 159 | 160 | # Make sure the message was sent 161 | assert_equal [PM::TUNE_REQUEST, PM::TUNE_REQUEST], @pm.outputs[0].port.buffer 162 | end 163 | 164 | def assert_only_curr_patch_running 165 | @pm.all_songs.songs.each do |song| 166 | song.patches.each do |patch| 167 | if patch == @pm.patch 168 | assert patch.running?, "patch #{patch.name} should be running" 169 | else 170 | assert !patch.running?, "patch #{patch.name} should not be running" 171 | end 172 | end 173 | end 174 | end 175 | 176 | def test_panic 177 | @pm.panic 178 | @pm.outputs.each do |out| 179 | expected = (0...PM::MIDI_CHANNELS).collect do |chan| 180 | [PM::CONTROLLER + chan, PM::CM_ALL_NOTES_OFF, 0] 181 | end.flatten 182 | assert_equal 16 * 3, expected.length 183 | # Match expected to end of buffer, since start bytes, program changes, 184 | # etc. might have been sent already. 185 | assert_equal expected, out.port.buffer[-expected.length..-1] 186 | end 187 | end 188 | 189 | def test_panic_all_notes 190 | @pm.panic(true) 191 | @pm.outputs.each do |out| 192 | expected = (0...PM::MIDI_CHANNELS).collect do |chan| 193 | [PM::CONTROLLER + chan, PM::CM_ALL_NOTES_OFF, 0] + 194 | (0..127).collect { |note| [PM::NOTE_OFF + chan, note, 0] }.flatten 195 | end.flatten 196 | assert_equal 16 * (3 + 128 * 3), expected.length 197 | # Match expected to end of buffer, since start bytes, program changes, 198 | # etc. might have been sent already. 199 | assert_equal expected, out.port.buffer[-expected.length..-1] 200 | end 201 | end 202 | end 203 | -------------------------------------------------------------------------------- /site/components.md: -------------------------------------------------------------------------------- 1 | --- 2 | layout: page 3 | title: Components 4 | --- 5 | 6 | > "The time has come," the Walrus said,\\ 7 | > "To talk of many things:\\ 8 | > Of shoes - and ships - and sealing wax -\\ 9 | > Of cabbages - and kings -\\ 10 | > And why the sea is boiling hot -\\ 11 | > And whether pigs have wings."\\ 12 | > \\ 13 | > -- Lewis Carroll, _Through the Looking-Glass_ 14 | 15 | This section describes the things that make up a PatchMaster document: 16 | instruments, songs, patches, connections, triggers, messages, and filters. 17 | The [file format](/file-format.html) page tells you how to put them all 18 | together into a PatchMaster file. 19 | 20 | # Instruments 21 | 22 | An instrument represents either a MIDI input to a synth, drum machine, or 23 | other device or a MIDI output from a controller. Each instrument needs a 24 | symbol (a usually short name starting with ":"), specifies which UNIMidi 25 | port number it uses, and has a name. 26 | 27 | Input instrument symbols must be unique, as must output instruments. The 28 | same symbol can be used for an input and an output, however. You'd usually 29 | do that if you have an instrument such as a keyboard that can act as both a 30 | controller (an output instrument) and a sound module (an input instrument). 31 | 32 | If you don't give an instrument a name, PatchMaster will display the name 33 | that UNIMidi uses. This isn't always what you want, because if you're using 34 | a MIDI interface such as the Unitor amt8, UNIMidi will use the names of the 35 | ports themselves, not the instruments plugged in to them (for example, 36 | "Unitor Port 0", "Unitor Port 1", ...). 37 | 38 | ## Example 39 | 40 | Let's say you have a keyboard controller that doesn't generate any sound on 41 | port 0 of your MIDI interface, a typical keyboard synth (both controller and 42 | sound generator) on port 1, and a rack-mount sound generator on port 2. 43 | Here's what that might look like in your PatchMaster file: 44 | 45 | {% highlight ruby %} 46 | input 0, :con, 'My Controller' 47 | input 1, :kbd, 'The Keyboard' 48 | output 1, :kbd, 'The Keyboard' 49 | output 2, :rack # Will use UNIMidi name 50 | {% endhighlight %} 51 | 52 | # Songs 53 | 54 | A song is a named list of patches that allow you to control your MIDI setup. 55 | A song can have any number of patches. You can step forward and backward 56 | through the patches in a song using the GUI movement keys or 57 | [triggers](/triggers.html). 58 | 59 | When a song becomes the current song, its first patch is made the current 60 | patch. 61 | 62 | # Patches 63 | 64 | A patch is a named collection of connections that can modify the MIDI data. 65 | The simplest connection connects one MIDI input device directly to another 66 | on a single channel. 67 | 68 | ## Start and Stop Bytes 69 | 70 | A patch also has optional _start bytes_ and _stop bytes_. These are arrays 71 | of MIDI bytes that can contain any MIDI data such as patch changes, volume 72 | controller settings, note on or off messages (for those looong drones), and 73 | System Exclusive messages. 74 | 75 | # Connections 76 | 77 | A connection connects an input instrument (all incoming channels or just 78 | one) to a single output channel of an output instrument. All messages coming 79 | from the input instruments are changed to be on the output instrument 80 | channel. 81 | 82 | When talking about the "notes" that a connection modifies, this means all 83 | MIDI messages that have note values: note on, note off, and polyphonic 84 | pressure. 85 | 86 | ## Program Changes 87 | 88 | A connection can optionally send a bank number and program change to its 89 | output instrument's channel. If a bank number is specified, first the bank 90 | change is sent then the program change. 91 | 92 | ## Zones 93 | 94 | A connection can optionally specify a zone: a range of keys outside of which 95 | all MIDI data will be ignored. Since a patch can contain multiple 96 | connections, this lets you split and layer your controllers, sending some 97 | notes to some synths but not others. 98 | 99 | ## Transposes 100 | 101 | A connection can transpose all notes by a fixed value. If a transposition 102 | would cause a note number to be out of range (lower than 0 or higher than 103 | 127), then the value is wrapped around --- a note transposed up to 128 104 | becomes 0, for example. 105 | 106 | ## Filters 107 | 108 | Filters let you do anything you want to the data, including filter out 109 | notes, transpose, modify controller values --- anything. That's because a 110 | filter has a block of Ruby code that gets executed for every message that 111 | goes through the connection. 112 | 113 | Filters are applied as the last step in a connection's modification of the 114 | MIDI data. This means that the status byte's channel is already changed to 115 | the output instrument's channel for this connection (assuming the message is 116 | a channel message). 117 | 118 | The filter's block must return the array of bytes you want sent to the 119 | output. Don't use the "return" keyword; simply add the bytes as the last 120 | thing in the block. 121 | 122 | # Song Lists 123 | 124 | A song list is a list of songs. A song can appear in more than one song 125 | list. One special song list called "All Songs" contains the list of all 126 | songs. 127 | 128 | # Named Messages 129 | 130 | A named message is an array of MIDI bytes with a name. Named messages can be 131 | sent using message keys, via triggers, or even from filters. 132 | 133 | Named messages are sent to all output instruments. The MIDI bytes are sent 134 | from PatchMaster with channels unchanged. If a named message contains 135 | channel messages then the receiver will of course ignore all except those on 136 | the channels it's configured to receive. 137 | 138 | Note: the word "message" as used in the previous sections on this page refer 139 | to the MIDI bytes coming from your instruments or being sent to the output 140 | instruments. The phrase "named message" refers to one of these things we're 141 | talking about here. 142 | 143 | ## Message Keys 144 | 145 | You can assign named messages to keys when using the PatchMaster GUI. 146 | Whenever the assigned key is pressed, the corresponding message is sent. See 147 | the [file format](/file-format.html) page for how to assign a named message 148 | to a key. 149 | 150 | # Code Keys 151 | 152 | You can assign a blocks of code to be executed when keys are pressed when 153 | using the PatchMaster GUI. Whenver the assigned key is pressed, the 154 | corresponding block of code is run. See the [file format](/file-format.html) 155 | page for how to assign a code block to a key. 156 | 157 | # Triggers 158 | 159 | A trigger looks for a particular incoming MIDI message from a paticular 160 | input instrument and runs a block of code when it is seen. The blocks can 161 | contain any Ruby code. Typically triggers are used for navigation or sending 162 | named messages. 163 | 164 | All triggers are executed by the `PM::PatchMaster` instance. Practially 165 | speaking this means you can call any of the methods of that object or its 166 | `PM::Cursor` object, including but not limited to 167 | 168 | - `next_song`, `prev_song`, `next_patch`, `prev_patch` 169 | - `goto_song` 170 | - `send_message` 171 | - `panic` 172 | -------------------------------------------------------------------------------- /site/tutorial.md: -------------------------------------------------------------------------------- 1 | --- 2 | layout: page 3 | title: Tutorial 4 | --- 5 | 6 | > Build a man a fire, and he'll be warm for a day. 7 | > Set a man on fire, and he'll be warm for the rest of his life. 8 | > 9 | > -- Terry Pratchett 10 | 11 | This tutorial walks you through creating a PatchMaster file from scratch. It 12 | assumes you've installed PatchMater as a gem, which will also install 13 | related utilities such as `unimidi`. 14 | 15 | PatchMaster files are Ruby files. Since Ruby files typically use the 16 | extension ".rb", go ahead and create a new file in your favorite editor 17 | named "pm_tutorial.rb". 18 | 19 | The PatchMaster file we'll be creating in this tutorial is verbose. There 20 | are short forms of most of the commands and some of the things we include 21 | are optional. 22 | 23 | # Defining Your Instruments 24 | 25 | ## Find your instruments 26 | 27 | In a terminal window, type 28 | 29 | {% highlight bash %} 30 | unimidi list 31 | {% endhighlight %} 32 | 33 | This command lists all the input and output instruments that are attached to 34 | your Mac, whether physical or virtual. You'll need to remember the input and 35 | output instrument numbers listed by `unimidi`. 36 | 37 | ## Add them to your PatchMaster file 38 | 39 | Open a file in your text editor. For each MIDI input output you want to use, 40 | add a line like this: 41 | 42 | {% highlight ruby %} 43 | input 0, :keys, 'Long Name' 44 | {% endhighlight %} 45 | 46 | The number is the number you got from the `unimidi list` command. ":keys" is 47 | any short name; it's what you will use to refer to that MIDI input. The name 48 | must begin with the ":" character and can not contain any spaces. 49 | 50 | The name for each instrument must be different. 51 | 52 | Likewise, for each MIDI output add a line like this: 53 | 54 | {% highlight ruby %} 55 | output 0, :keys, 'Long Name' 56 | {% endhighlight %} 57 | 58 | Output names must be unique, but can be the same as input names. For a MIDI 59 | instrument that uses both its input and its output you will probably want to 60 | use the same name. 61 | 62 | # Your First Song 63 | 64 | After the instrument inputs and outputs, add an empty song: 65 | 66 | {% highlight ruby %} 67 | song "My First Song" do 68 | end 69 | {% endhighlight %} 70 | 71 | ## A Patch 72 | 73 | Let's add a patch that connects the input from `:keys` to the output 74 | `:another` on channel 1. 75 | 76 | {% highlight ruby %} 77 | song "My First Song" do 78 | patch "First Patch" do 79 | connection :keys, nil, :another, 1 80 | end 81 | end 82 | {% endhighlight %} 83 | 84 | The `nil` tells PatchMaster to pass through any channel message that comes 85 | from `:keys`. The 1 tells it to translate all messages from `:keys` to 86 | channel 1 before sending it to `:another`. 87 | 88 | Now let's connect `:keys` to the same synth on a different channel but 89 | modify the MIDI a bit as it goes through. 90 | 91 | {% highlight ruby %} 92 | song "My First Song" do 93 | patch "First Patch" do 94 | connection :keys, nil, :another, 1 95 | connection :keys, nil, :another, 2 do 96 | prog_chg 42 97 | transpose 12 98 | zone C4, B6 99 | end 100 | end 101 | end 102 | {% endhighlight %} 103 | 104 | Here we've connected `:keys` to channel 2 of `:another`, sent it a program 105 | change command, transposed all notes (and polyphonic pressure messages) up 106 | an octave, and limited the notes passed through to those in the two octaves 107 | from C4 to B6. 108 | 109 | ### A Filter 110 | 111 | Filters allow you to take complete control over the MIDI that gets sent 112 | through a connection. Let's use a filter to modify the volume of all notes 113 | in real time using a software LFO (Low Frequency Oscillator). 114 | 115 | *NOTE* This LFO only sets the velocity of each note. It doesn't change the 116 | overall volume over time (_e.g._, tremolo). To do that you'd need to create 117 | a method that gets called regularly, probably in a separate thread, and that 118 | sends volume control change messages. 119 | 120 | First, we need to write a method that outputs a value between 0 and 127 and 121 | that changes over time. Let's put this method definition before our song. 122 | 123 | {% highlight ruby %} 124 | # Outputs a value from 0 to 127 based on the time. 125 | def lfo 126 | t = Time.now.to_f # to_f gives sub-second accuracy 127 | unit_offset = Math.sin(t) # -1 .. 1 128 | val = (unit_offset * 64) + 64 129 | val = 127 if volume == 128 130 | val 131 | end 132 | 133 | song "My First Song" do 134 | # ... 135 | end 136 | {% endhighlight %} 137 | 138 | Next let's add a new connection from `:keys` to `:third` that uses a filter 139 | to replace the volume of any note message with the current LFO value. 140 | 141 | {% highlight ruby %} 142 | def lfo 143 | # see above 144 | end 145 | 146 | song "My First Song" do 147 | patch "First Patch" do 148 | # ... First two connections skipped here, see above. 149 | # As a shortcut, you don't have to specify "nil" for input. 150 | connection :keys, :third, 1 do 151 | filter do |connection, bytes| 152 | if bytes.note? && bytes[2] != 0 # not a note off 153 | bytes[2] = lfo() # LFO determines volume 154 | end 155 | bytes # Don't forget to return bytes here 156 | end 157 | end 158 | end 159 | end 160 | {% endhighlight %} 161 | 162 | # Creating Some Messages 163 | 164 | Messages contain arbitrary bytes that can get sent at any time. They are 165 | sent to all outputs. Let's define two messages. The first is a tune request 166 | and the second sends individual note off messages to every note on every 167 | channel. 168 | 169 | {% highlight ruby %} 170 | message "Tune Request", [TUNE_REQUEST] 171 | 172 | full_volumes = (0...MIDI_CHANNELS).collect do |chan| 173 | [CONTROLLER + chan, CC_VOLUME, 127] 174 | end.flatten 175 | message "Full Volume", full_volumes 176 | {% endhighlight %} 177 | 178 | We can bind messages to computer keys. Here we'll bind the tune request 179 | message to F1 and the full volume message to F2. The names here must match 180 | the names you gave the messages above. 181 | 182 | {% highlight ruby %} 183 | message_key :f1, "Tune Request" 184 | message_key :f2, "Full Volume" 185 | {% endhighlight %} 186 | 187 | # Creating Triggers 188 | 189 | Triggers make things happen. Let's make a trigger that moves to the next 190 | patch and one that sends a tune request message. 191 | 192 | [TODO: finish this section] 193 | 194 | Bonus exercise: Write triggers that move to the next song, the previous 195 | patch and the previous song. 196 | 197 | # A Song List 198 | 199 | [TODO: write this section] 200 | 201 | # The Whole File 202 | 203 | The whole file should look something like this. Blank lines don't matter. 204 | 205 | {% highlight ruby %} 206 | input 0, :keys, 'Long Name' 207 | 208 | output 0, :keys, 'Long Name' 209 | output 1, :another, 'Another Long Name' 210 | output 2, :third, 'Rack Mount Synth' 211 | 212 | message "Tune Request", [TUNE_REQUEST] 213 | 214 | full_volumes = (0...MIDI_CHANNELS).collect do |chan| 215 | [CONTROLLER + chan, CC_VOLUME, 127] 216 | end.flatten 217 | message "Full Volume", full_volumes 218 | 219 | message_key :f1, "Tune Request" 220 | message_key :f2, "Full Volume" 221 | 222 | # Outputs a value from 0 to 127 based on the time. 223 | def lfo 224 | t = Time.now.to_f # to_f gives sub-second accuracy 225 | unit_offset = Math.sin(t) # -1 .. 1 226 | val = (unit_offset * 64) + 64 227 | if val < 0 228 | 0 229 | elsif val > 127 230 | 127 231 | else 232 | val 233 | end 234 | end 235 | 236 | song "My First Song" do 237 | patch "First Patch" do 238 | connection :keys, nil, :another, 1 239 | connection :keys, nil, :another, 2 do 240 | prog_chg 42 241 | transpose 12 242 | zone C4, B6 243 | end 244 | connection :keys, :third, 1 do 245 | filter do |connection, bytes| 246 | if bytes.note? && bytes[2] != 0 # not a note off 247 | bytes[2] = lfo() # LFO determines volume 248 | end 249 | bytes 250 | end 251 | end 252 | end 253 | end 254 | {% endhighlight %} 255 | -------------------------------------------------------------------------------- /site/css/main.css: -------------------------------------------------------------------------------- 1 | /* Base */ 2 | /* ----------------------------------------------------------*/ 3 | 4 | * { 5 | margin: 0; 6 | padding: 0; 7 | } 8 | 9 | html, body { height: 100%; } 10 | 11 | body { 12 | font-family: Helvetica, Arial, sans-serif; 13 | font-size: 16px; 14 | line-height: 1.5; 15 | font-weight: 300; 16 | background-color: #fdfdfd; 17 | } 18 | 19 | h1, h2, h3, h4, h5, h6 { font-size: 100%; font-weight: 400; } 20 | 21 | a { color: #2a7ae2; text-decoration: none; } 22 | a:hover { color: #000; text-decoration: underline; } 23 | a:visited { color: #205caa; } 24 | 25 | /* Utility */ 26 | 27 | .wrap:before, 28 | .wrap:after { content:""; display:table; } 29 | .wrap:after { clear: both; } 30 | .wrap { 31 | max-width: 800px; 32 | padding: 0 30px; 33 | margin: 0 auto; 34 | zoom: 1; 35 | } 36 | 37 | 38 | /* Layout Styles */ 39 | /* ----------------------------------------------------------*/ 40 | 41 | /* Site header */ 42 | 43 | .site-header { 44 | border-top: 5px solid #333; 45 | border-bottom: 1px solid #e8e8e8; 46 | min-height: 56px; 47 | background-color: white; 48 | } 49 | 50 | .site-title, 51 | .site-title:hover, 52 | .site-title:visited { 53 | display: block; 54 | color: #333; 55 | font-size: 26px; 56 | letter-spacing: -1px; 57 | float: left; 58 | line-height: 56px; 59 | position: relative; 60 | z-index: 1; 61 | } 62 | 63 | .site-nav { 64 | float: right; 65 | line-height: 56px; 66 | } 67 | 68 | .site-nav .menu-icon { display: none; } 69 | 70 | .site-nav .page-link { 71 | margin-left: 20px; 72 | color: #727272; 73 | letter-spacing: -.5px; 74 | } 75 | 76 | /* Site footer */ 77 | 78 | .site-footer { 79 | border-top: 1px solid #e8e8e8; 80 | padding: 30px 0; 81 | } 82 | 83 | .footer-heading { 84 | font-size: 18px; 85 | font-weight: 300; 86 | letter-spacing: -.5px; 87 | margin-bottom: 15px; 88 | } 89 | 90 | .site-footer .column { float: left; margin-bottom: 15px; } 91 | 92 | .footer-col-1 { 93 | width: 270px; /*fallback*/ 94 | width: -webkit-calc(35% - 10px); 95 | width: -moz-calc(35% - 10px); 96 | width: -o-calc(35% - 10px); 97 | width: calc(35% - 10px); 98 | margin-right: 10px 99 | } 100 | .footer-col-2 { 101 | width: 175px; /*fallback*/ 102 | width: -webkit-calc(23.125% - 10px); 103 | width: -moz-calc(23.125% - 10px); 104 | width: -o-calc(23.125% - 10px); 105 | width: calc(23.125% - 10px); 106 | margin-right: 10px 107 | } 108 | .footer-col-3 { 109 | width: 335px; /*fallback*/ 110 | width: -webkit-calc(41.875%); 111 | width: -moz-calc(41.875%); 112 | width: -o-calc(41.875%); 113 | width: calc(41.875%); 114 | } 115 | 116 | .site-footer ul { list-style: none; } 117 | 118 | .site-footer li, 119 | .site-footer p { 120 | font-size: 15px; 121 | letter-spacing: -.3px; 122 | color: #828282; 123 | } 124 | 125 | .github-icon-svg, 126 | .twitter-icon-svg { 127 | display: inline-block; 128 | width: 16px; 129 | height: 16px; 130 | position: relative; 131 | top: 3px; 132 | } 133 | 134 | 135 | /* Page Content styles */ 136 | /* ----------------------------------------------------------*/ 137 | 138 | .page-content { 139 | padding: 30px 0; 140 | background-color: #fff; 141 | } 142 | 143 | 144 | /* Home styles */ 145 | /* ----------------------------------------------------------*/ 146 | 147 | .home h1 { margin-bottom: 25px; } 148 | 149 | .posts { list-style-type: none; } 150 | 151 | .posts li { margin-bottom: 30px; } 152 | 153 | .posts .post-link { 154 | font-size: 24px; 155 | letter-spacing: -1px; 156 | line-height: 1; 157 | } 158 | 159 | .posts .post-date { 160 | display: block; 161 | font-size: 15px; 162 | color: #818181; 163 | } 164 | 165 | 166 | /* Post styles */ 167 | /* ----------------------------------------------------------*/ 168 | 169 | .post-header { margin: 10px 0 30px; } 170 | 171 | .post-header h1 { 172 | font-size: 42px; 173 | letter-spacing: -1.75px; 174 | line-height: 1; 175 | font-weight: 300; 176 | } 177 | 178 | .post-header .meta { 179 | font-size: 15px; 180 | color: #818181; 181 | margin-top: 5px; 182 | } 183 | 184 | .post-content { margin: 0 0 30px; } 185 | 186 | .post-content > * { margin: 20px 0; } 187 | 188 | 189 | .post-header h1, 190 | .post-content h2, 191 | .post-content h3, 192 | .post-content h4, 193 | .post-content h5, 194 | .post-content h6 { 195 | line-height: 1; 196 | font-weight: 300; 197 | margin: 40px 0 20px; 198 | } 199 | 200 | .post-content h1 { 201 | font-size: 42px; 202 | letter-spacing: -1.75px; 203 | line-height: 1; 204 | font-weight: 300; 205 | margin-top: 1em; 206 | } 207 | 208 | .post-content h2 { 209 | font-size: 32px; 210 | letter-spacing: -1.25px; 211 | } 212 | 213 | .post-content h3 { 214 | font-size: 26px; 215 | letter-spacing: -1px; 216 | } 217 | 218 | .post-content h4 { 219 | font-size: 20px; 220 | letter-spacing: -1px; 221 | } 222 | 223 | .post-content blockquote { 224 | border-left: 4px solid #e8e8e8; 225 | padding-left: 20px; 226 | font-size: 18px; 227 | opacity: .6; 228 | letter-spacing: -1px; 229 | font-style: italic; 230 | margin: 30px 0; 231 | } 232 | 233 | .post-content ul, 234 | .post-content ol { padding-left: 20px; } 235 | 236 | .post pre, 237 | .post code { 238 | border: 1px solid #d5d5e9; 239 | background-color: #eef; 240 | padding: 8px 12px; 241 | -webkit-border-radius: 3px; 242 | -moz-border-radius: 3px; 243 | border-radius: 3px; 244 | font-size: 15px; 245 | overflow:scroll; 246 | } 247 | 248 | .post code { padding: 1px 5px; } 249 | 250 | .post ul, 251 | .post ol { margin-left: 1.35em; } 252 | 253 | .post pre code { 254 | border: 0; 255 | padding-right: 0; 256 | padding-left: 0; 257 | } 258 | 259 | /* terminal */ 260 | .post pre.terminal { 261 | border: 1px solid #000; 262 | background-color: #333; 263 | color: #FFF; 264 | -webkit-border-radius: 3px; 265 | -moz-border-radius: 3px; 266 | border-radius: 3px; 267 | } 268 | 269 | .post pre.terminal code { background-color: #333; } 270 | 271 | /* Syntax highlighting styles */ 272 | /* ----------------------------------------------------------*/ 273 | 274 | .highlight { background: #ffffff; } 275 | .highlight .c { color: #999988; font-style: italic } /* Comment */ 276 | .highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */ 277 | .highlight .k { font-weight: bold } /* Keyword */ 278 | .highlight .o { font-weight: bold } /* Operator */ 279 | .highlight .cm { color: #999988; font-style: italic } /* Comment.Multiline */ 280 | .highlight .cp { color: #999999; font-weight: bold } /* Comment.Preproc */ 281 | .highlight .c1 { color: #999988; font-style: italic } /* Comment.Single */ 282 | .highlight .cs { color: #999999; font-weight: bold; font-style: italic } /* Comment.Special */ 283 | .highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */ 284 | .highlight .gd .x { color: #000000; background-color: #ffaaaa } /* Generic.Deleted.Specific */ 285 | .highlight .ge { font-style: italic } /* Generic.Emph */ 286 | .highlight .gr { color: #aa0000 } /* Generic.Error */ 287 | .highlight .gh { color: #999999 } /* Generic.Heading */ 288 | .highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */ 289 | .highlight .gi .x { color: #000000; background-color: #aaffaa } /* Generic.Inserted.Specific */ 290 | .highlight .go { color: #888888 } /* Generic.Output */ 291 | .highlight .gp { color: #555555 } /* Generic.Prompt */ 292 | .highlight .gs { font-weight: bold } /* Generic.Strong */ 293 | .highlight .gu { color: #aaaaaa } /* Generic.Subheading */ 294 | .highlight .gt { color: #aa0000 } /* Generic.Traceback */ 295 | .highlight .kc { font-weight: bold } /* Keyword.Constant */ 296 | .highlight .kd { font-weight: bold } /* Keyword.Declaration */ 297 | .highlight .kp { font-weight: bold } /* Keyword.Pseudo */ 298 | .highlight .kr { font-weight: bold } /* Keyword.Reserved */ 299 | .highlight .kt { color: #445588; font-weight: bold } /* Keyword.Type */ 300 | .highlight .m { color: #009999 } /* Literal.Number */ 301 | .highlight .s { color: #d14 } /* Literal.String */ 302 | .highlight .na { color: #008080 } /* Name.Attribute */ 303 | .highlight .nb { color: #0086B3 } /* Name.Builtin */ 304 | .highlight .nc { color: #445588; font-weight: bold } /* Name.Class */ 305 | .highlight .no { color: #008080 } /* Name.Constant */ 306 | .highlight .ni { color: #800080 } /* Name.Entity */ 307 | .highlight .ne { color: #990000; font-weight: bold } /* Name.Exception */ 308 | .highlight .nf { color: #990000; font-weight: bold } /* Name.Function */ 309 | .highlight .nn { color: #555555 } /* Name.Namespace */ 310 | .highlight .nt { color: #000080 } /* Name.Tag */ 311 | .highlight .nv { color: #008080 } /* Name.Variable */ 312 | .highlight .ow { font-weight: bold } /* Operator.Word */ 313 | .highlight .w { color: #bbbbbb } /* Text.Whitespace */ 314 | .highlight .mf { color: #009999 } /* Literal.Number.Float */ 315 | .highlight .mh { color: #009999 } /* Literal.Number.Hex */ 316 | .highlight .mi { color: #009999 } /* Literal.Number.Integer */ 317 | .highlight .mo { color: #009999 } /* Literal.Number.Oct */ 318 | .highlight .sb { color: #d14 } /* Literal.String.Backtick */ 319 | .highlight .sc { color: #d14 } /* Literal.String.Char */ 320 | .highlight .sd { color: #d14 } /* Literal.String.Doc */ 321 | .highlight .s2 { color: #d14 } /* Literal.String.Double */ 322 | .highlight .se { color: #d14 } /* Literal.String.Escape */ 323 | .highlight .sh { color: #d14 } /* Literal.String.Heredoc */ 324 | .highlight .si { color: #d14 } /* Literal.String.Interpol */ 325 | .highlight .sx { color: #d14 } /* Literal.String.Other */ 326 | .highlight .sr { color: #009926 } /* Literal.String.Regex */ 327 | .highlight .s1 { color: #d14 } /* Literal.String.Single */ 328 | .highlight .ss { color: #990073 } /* Literal.String.Symbol */ 329 | .highlight .bp { color: #999999 } /* Name.Builtin.Pseudo */ 330 | .highlight .vc { color: #008080 } /* Name.Variable.Class */ 331 | .highlight .vg { color: #008080 } /* Name.Variable.Global */ 332 | .highlight .vi { color: #008080 } /* Name.Variable.Instance */ 333 | .highlight .il { color: #009999 } /* Literal.Number.Integer.Long */ 334 | 335 | 336 | /* media queries */ 337 | /* ----------------------------------------------------------*/ 338 | 339 | 340 | @media screen and (max-width: 750px) { 341 | 342 | .footer-col-1 { width: 50%; } 343 | 344 | .footer-col-2 { 345 | width: 45%; /*fallback*/ 346 | width: -webkit-calc(50% - 10px); 347 | width: -moz-calc(50% - 10px); 348 | width: -o-calc(50% - 10px); 349 | width: calc(50% - 10px); 350 | margin-right: 0; 351 | } 352 | 353 | .site-footer .column.footer-col-3 { 354 | width: auto; 355 | float: none; 356 | clear: both; 357 | } 358 | 359 | } 360 | 361 | @media screen and (max-width: 600px) { 362 | 363 | .wrap { padding: 0 12px; } 364 | 365 | .site-nav { 366 | position: fixed; 367 | z-index: 10; 368 | top: 14px; right: 8px; 369 | background-color: white; 370 | -webkit-border-radius: 5px; 371 | -moz-border-radius: 5px; 372 | border-radius: 5px; 373 | border: 1px solid #e8e8e8; 374 | } 375 | 376 | .site-nav .menu-icon { 377 | display: block; 378 | font-size: 24px; 379 | color: #505050; 380 | float: right; 381 | width: 36px; 382 | text-align: center; 383 | line-height: 36px; 384 | } 385 | 386 | .site-nav .menu-icon svg { width: 18px; height: 16px; } 387 | 388 | .site-nav .trigger { 389 | clear: both; 390 | margin-bottom: 5px; 391 | display: none; 392 | } 393 | 394 | .site-nav:hover .trigger { display: block; } 395 | 396 | .site-nav .page-link { 397 | display: block; 398 | text-align: right; 399 | line-height: 1.25; 400 | padding: 5px 10px; 401 | margin: 0; 402 | } 403 | 404 | .post-header h1 { font-size: 36px; } 405 | .post-content h2 { font-size: 28px; } 406 | .post-content h3 { font-size: 22px; } 407 | .post-content h4 { font-size: 18px; } 408 | .post-content blockquote { padding-left: 10px; } 409 | .post-content ul, 410 | .post-content ol { padding-left: 10px; } 411 | 412 | .site-footer .column { 413 | float: none; 414 | clear: both; 415 | width: auto; 416 | margin: 0 0 15px; } 417 | 418 | } 419 | -------------------------------------------------------------------------------- /lib/patchmaster/dsl.rb: -------------------------------------------------------------------------------- 1 | require 'unimidi' 2 | require_relative './code_chunk' 3 | 4 | module PM 5 | 6 | # Implements a DSL for describing a PatchMaster setup. 7 | class DSL 8 | 9 | include PM 10 | 11 | def initialize 12 | @pm = PatchMaster.instance 13 | init 14 | end 15 | 16 | # Initialize state used for reading. 17 | def init 18 | @inputs = {} 19 | @outputs = {} 20 | @triggers = [] 21 | @filters = [] 22 | @code_keys = [] 23 | @songs = {} # key = name, value = song 24 | end 25 | 26 | def load(file) 27 | contents = IO.read(file) 28 | init 29 | instance_eval(contents) 30 | read_code_keys(contents) 31 | read_triggers(contents) 32 | read_filters(contents) 33 | end 34 | 35 | def input(port_num, sym, name=nil) 36 | raise "input: two inputs can not have the same symbol (:#{sym})" if @inputs[sym] 37 | 38 | input = InputInstrument.new(sym, name, port_num, @pm.use_midi?) 39 | @inputs[sym] = input 40 | @pm.inputs << input 41 | rescue => ex 42 | raise "input: error creating input instrument \"#{name || sym}\" on input port #{port_num}: #{ex}" 43 | end 44 | alias_method :inp, :input 45 | 46 | def output(port_num, sym, name=nil) 47 | raise "output: two outputs can not have the same symbol (:#{sym})" if @outputs[sym] 48 | 49 | output = OutputInstrument.new(sym, name, port_num, @pm.use_midi?) 50 | @outputs[sym] = output 51 | @pm.outputs << output 52 | rescue => ex 53 | raise "output: error creating output instrument \"#{name || sym}\" on output port #{port_num}: #{ex}" 54 | end 55 | alias_method :out, :output 56 | alias_method :outp, :output 57 | 58 | def message(name, bytes) 59 | @pm.messages[name.downcase] = [name, bytes] 60 | end 61 | 62 | def message_key(key_or_sym, name) 63 | if name.is_a?(Symbol) 64 | name, key_or_sym = key_or_sym, name 65 | $stderr.puts "WARNING: the arguments to message_key are now key first, then name." 66 | $stderr.puts "I will use #{name} as the name and #{key_or_sym} as the key for now." 67 | $stderr.puts "Please swap them for future compatability." 68 | end 69 | if key_or_sym.is_a?(String) && name.is_a?(String) 70 | if name.length == 1 && key_or_sym.length > 1 71 | name, key_or_sym = key_or_sym, name 72 | $stderr.puts "WARNING: the arguments to message_key are now key first, then name." 73 | $stderr.puts "I will use #{name} as the name and #{key_or_sym} as the key for now." 74 | $stderr.puts "Please swap them for future compatability." 75 | elsif name.length == 1 && key_or_sym.length == 1 76 | raise "message_key: since both name and key are one-character strings, I can't tell which is which. Please make the name longer." 77 | end 78 | end 79 | @pm.bind_message(name, to_binding_key(key_or_sym)) 80 | end 81 | 82 | def code_key(key_or_sym, &block) 83 | ck = CodeKey.new(to_binding_key(key_or_sym), CodeChunk.new(block)) 84 | @pm.bind_code(ck) 85 | @code_keys << ck 86 | end 87 | 88 | def trigger(instrument_sym, bytes, &block) 89 | instrument = @inputs[instrument_sym] 90 | raise "trigger: error finding instrument #{instrument_sym}" unless instrument 91 | t = Trigger.new(bytes, CodeChunk.new(block)) 92 | instrument.triggers << t 93 | @triggers << t 94 | end 95 | 96 | def song(name) 97 | @song = Song.new(name) # ctor saves into @pm.all_songs 98 | @songs[name] = @song 99 | yield @song if block_given? 100 | end 101 | 102 | def notes(txt) 103 | @song.notes = txt 104 | end 105 | 106 | def patch(name) 107 | @patch = Patch.new(name) 108 | @song << @patch 109 | yield @patch if block_given? 110 | end 111 | 112 | def start_bytes(bytes) 113 | @patch.start_bytes = bytes 114 | end 115 | 116 | def stop_bytes(bytes) 117 | @patch.stop_bytes = bytes 118 | end 119 | 120 | # in_chan can be skipped, so "connection :foo, :bar, 1" is the same as 121 | # "connection :foo, nil, :bar, 1". 122 | def connection(in_sym, in_chan, out_sym, out_chan=nil) 123 | input = @inputs[in_sym] 124 | if in_chan.kind_of? Symbol 125 | out_chan = out_sym 126 | out_sym = in_chan 127 | in_chan = nil 128 | end 129 | raise "can't find input instrument #{in_sym}" unless input 130 | output = @outputs[out_sym] 131 | raise "can't find outputput instrument #{out_sym}" unless output 132 | 133 | @conn = Connection.new(input, in_chan, output, out_chan) 134 | @patch << @conn 135 | yield @conn if block_given? 136 | end 137 | alias_method :conn, :connection 138 | alias_method :c, :connection 139 | 140 | # If only +bank_or_prog+ is specified, then it's a program change. If 141 | # both, then it's bank number. 142 | def prog_chg(bank_or_prog, prog=nil) 143 | if prog 144 | @conn.bank = bank_or_prog 145 | @conn.pc_prog = prog 146 | else 147 | @conn.pc_prog = bank_or_prog 148 | end 149 | end 150 | alias_method :pc, :prog_chg 151 | 152 | # If +start_or_range+ is a Range, use that. Else either or both params may 153 | # be nil. 154 | def zone(start_or_range=nil, stop=nil) 155 | @conn.zone = if start_or_range.kind_of? Range 156 | start_or_range 157 | elsif start_or_range == nil && stop == nil 158 | nil 159 | else 160 | ((start_or_range || 0) .. (stop || 127)) 161 | end 162 | end 163 | alias_method :z, :zone 164 | 165 | def transpose(xpose) 166 | @conn.xpose = xpose 167 | end 168 | alias_method :xpose, :transpose 169 | alias_method :x, :transpose 170 | 171 | def filter(&block) 172 | @conn.filter = Filter.new(CodeChunk.new(block)) 173 | @filters << @conn.filter 174 | end 175 | alias_method :f, :filter 176 | 177 | def song_list(name, song_names) 178 | sl = SongList.new(name) 179 | @pm.song_lists << sl 180 | song_names.each do |sn| 181 | song = @songs[sn] 182 | raise "song \"#{sn}\" not found (song list \"#{name}\")" unless song 183 | sl << song 184 | end 185 | end 186 | 187 | def alias_input(new_sym, old_sym) 188 | @inputs[new_sym] = @inputs[old_sym] 189 | end 190 | 191 | def alias_output(new_sym, old_sym) 192 | @outputs[new_sym] = @outputs[old_sym] 193 | end 194 | 195 | # **************************************************************** 196 | 197 | def save(file) 198 | File.open(file, 'w') { |f| 199 | save_instruments(f) 200 | save_messages(f) 201 | save_message_keys(f) 202 | save_code_keys(f) 203 | save_triggers(f) 204 | save_songs(f) 205 | save_song_lists(f) 206 | } 207 | end 208 | 209 | def save_instruments(f) 210 | @pm.inputs.each do |instr| 211 | f.puts "input #{instr.port_num}, :#{instr.sym}, #{instr.name.inspect}" 212 | end 213 | @pm.outputs.each do |instr| 214 | f.puts "output #{instr.port_num}, :#{instr.sym}, #{instr.name.inspect}" 215 | end 216 | f.puts 217 | end 218 | 219 | def save_messages(f) 220 | @pm.messages.each do |_, (correct_case_name, msg)| 221 | f.puts "message #{correct_case_name.inspect}, #{msg.inspect}" 222 | end 223 | end 224 | 225 | def save_message_keys(f) 226 | @pm.message_bindings.each do |key, message_name| 227 | f.puts "message_key #{to_save_key(key).inspect}, #{message_name.inspect}" 228 | end 229 | end 230 | 231 | def save_code_keys(f) 232 | @pm.code_bindings.values.each do |code_key| 233 | str = if code_key.code_chunk.text[0] == '{' 234 | "code_key(#{to_save_key(code_key.key).inspect}) #{code_key.code_chunk.text}" 235 | else 236 | "code_key #{to_save_key(code_key.key).inspect} #{code_key.code_chunk.text}" 237 | end 238 | f.puts str 239 | end 240 | end 241 | 242 | def save_triggers(f) 243 | @pm.inputs.each do |instrument| 244 | instrument.triggers.each do |trigger| 245 | str = "trigger(:#{instrument.sym}, #{trigger.bytes.inspect}) #{trigger.code_chunk.text}" 246 | f.puts str 247 | end 248 | end 249 | f.puts 250 | end 251 | 252 | def save_songs(f) 253 | @pm.all_songs.songs.each do |song| 254 | f.puts "song #{song.name.inspect} do" 255 | song.patches.each { |patch| save_patch(f, patch) } 256 | f.puts "end" 257 | f.puts 258 | end 259 | end 260 | 261 | def save_patch(f, patch) 262 | f.puts " patch #{patch.name.inspect} do" 263 | f.puts " start_bytes #{patch.start_bytes.inspect}" if patch.start_bytes 264 | patch.connections.each { |conn| save_connection(f, conn) } 265 | f.puts " end" 266 | end 267 | 268 | def save_connection(f, conn) 269 | in_chan = conn.input_chan ? conn.input_chan + 1 : 'nil' 270 | out_chan = conn.output_chan + 1 271 | f.puts " conn :#{conn.input.sym}, #{in_chan}, :#{conn.output.sym}, #{out_chan} do" 272 | f.puts " prog_chg #{conn.pc_prog}" if conn.pc? 273 | f.puts " zone #{conn.note_num_to_name(conn.zone.begin)}, #{conn.note_num_to_name(conn.zone.end)}" if conn.zone 274 | f.puts " xpose #{conn.xpose}" if conn.xpose 275 | f.puts " filter #{conn.filter.code_chunk.text}" if conn.filter 276 | f.puts " end" 277 | end 278 | 279 | def save_song_lists(f) 280 | @pm.song_lists.each do |sl| 281 | next if sl == @pm.all_songs 282 | f.puts "song_list #{sl.name.inspect}, [" 283 | @pm.all_songs.songs.each do |song| 284 | f.puts " #{song.name.inspect}," 285 | end 286 | f.puts "]" 287 | end 288 | end 289 | 290 | # **************************************************************** 291 | 292 | private 293 | 294 | # Translate symbol like :f1 to the proper function key value. 295 | def to_binding_key(key_or_sym) 296 | if key_or_sym.is_a?(Symbol) && PM::Main::FUNCTION_KEY_SYMBOLS[key_or_sym] 297 | key_or_sym = PM::Main::FUNCTION_KEY_SYMBOLS[key_or_sym] 298 | end 299 | end 300 | 301 | # Translate function key values into symbol strings and other keys into 302 | # double-quoted strings. 303 | def to_save_key(key) 304 | if PM::Main::FUNCTION_KEY_SYMBOLS.value?(key) 305 | PM::Main::FUNCTION_KEY_SYMBOLS.key(key) 306 | else 307 | key 308 | end 309 | end 310 | 311 | def read_triggers(contents) 312 | read_block_text('trigger', @triggers, contents) 313 | end 314 | 315 | def read_filters(contents) 316 | read_block_text('filter', @filters, contents) 317 | end 318 | 319 | def read_code_keys(contents) 320 | read_block_text('code_key', @code_keys, contents) 321 | end 322 | 323 | # Extremely simple block text reader. Relies on indentation to detect end 324 | # of code block. 325 | def read_block_text(name, containers, contents) 326 | i = -1 327 | in_block = false 328 | block_indentation = nil 329 | block_end_token = nil 330 | chunk = nil 331 | contents.each_line do |line| 332 | if line =~ /^(\s*)#{name}\s*.*?(({|do|->\s*{|lambda\s*{)(.*))/ 333 | block_indentation, text = $1, $2 334 | i += 1 335 | chunk = containers[i].code_chunk 336 | chunk.text = text + "\n" 337 | in_block = true 338 | block_end_token = case text 339 | when /^{/ 340 | "}" 341 | when /^do\b/ 342 | "end" 343 | when /^(->|lambda)\s*({|do)/ 344 | $2 == "{" ? "}" : "end" 345 | else 346 | "}|end" # regex 347 | end 348 | elsif in_block 349 | line =~ /^(\s*)(.*)/ 350 | indentation, text = $1, $2 351 | if indentation.length <= block_indentation.length 352 | if text =~ /^#{block_end_token}/ 353 | chunk.text << line 354 | end 355 | in_block = false 356 | else 357 | chunk.text << line 358 | end 359 | end 360 | end 361 | containers.each do |thing| 362 | text = thing.code_chunk.text 363 | text.strip! if text 364 | end 365 | end 366 | 367 | end 368 | end 369 | -------------------------------------------------------------------------------- /lib/patchmaster/consts.rb: -------------------------------------------------------------------------------- 1 | # MIDI and PatchMaster constants. 2 | module PM 3 | 4 | # Define MIDI note names C0 - B10 5 | (0..10).each { |oct| 6 | {:C => 0, :D => 2, :E => 4, :F => 5, :G => 7, :A => 9, :B => 11}.each { |note,val| 7 | base = (oct+1) * 12 + val 8 | eval < Source code in files. How quaint. 7 | > 8 | > -- Attributed to Kent Beck 9 | 10 | PatchMaster files describe your MIDI setup and define named messages, 11 | triggers, songs with their patches, and song lists. They are written in Ruby 12 | using a few special keywords (Ruby method names). 13 | 14 | When your PatchMaster file is loaded, it has available all the constants and 15 | classes defined in the PM module. That means you can refer to things like 16 | the constants defined in `patchmaster/consts.rb` without having to prefix 17 | them with "PM::". 18 | 19 | For a sample PatchMaster file, see 20 | [examples/example.rb](https://github.com/jimm/patchmaster/blob/master/examples/example.rb). 21 | 22 | For a more detailed discussion of the things that can be in a PatchMaster 23 | file (how they work and what they're for), see 24 | [Components](/components.html) and [Running Patches](/patches.html). 25 | 26 | # Loading and Saving PatchMaster Files 27 | 28 | When you start PatchMaster you can specify a file to load on the command 29 | line. While it's running, you can (re)load a file with the 'l' key. 30 | 31 | You can save what's been loaded with the 's' key. To be honest, the 32 | PatchMaster save feature isn't all that useful since you can't change 33 | anything from within PatchMaster anyway --- yet. 34 | 35 | # Editing PatchMaster Files 36 | 37 | > Most editors are failed writers - but so are most writers.\\ 38 | > \\ 39 | > -- T. S. Eliot 40 | 41 | You can create and edit PatchMaster files using any text editor you like. 42 | 43 | ## Editing From Within Patchmaster 44 | 45 | While running PatchMaster, the 'e' key lets you edit the file you loaded or 46 | most recently saved. If you have not yet loaded a file or you save the file 47 | to a different location, PatchMaster will ask you for a file name. 48 | 49 | The edit command suspends PatchMaster and starts the editor defined by the 50 | environment variables `VISUAL` or `EDITOR`. If neither of those are defined 51 | it tries 'vim', 'vi', and finally 'notepad.exe'. 52 | 53 | After editing a file, PatchMaster attempts to reload that file and continue 54 | with the same song list, song, and patch that was current when you edited 55 | the file. 56 | 57 | When you edit a file from within PatchMaster, it has no way of knowing if 58 | you saved that file to a different location. If you do so and want to load 59 | that file you'll have to use the 'l' command to do so. 60 | 61 | ## Trigger and Filter Blocks 62 | 63 | Triggers and filters have blocks of code that they run. Saving them out to a 64 | PatchMaster file requires those blocks be saved. However, there is no 65 | practical way to obtain the text of a code block across all versions of Ruby 66 | at runtime. To get around this, when loading the file PatchMaster re-reads 67 | the file, looking for the trigger and filter definitions and saving their 68 | blocks as text. When the trigger or filter is saved, the block text that was 69 | read is written back out. 70 | 71 | This simplistic solution can lead to three potential problems. 72 | 73 | 1. The algorithm used to find the code block text is dumb. It assumes that 74 | the end of the block is indented to the same level as the begnning, and 75 | that all intervening lines are indented more than the beginning and end 76 | lines. (One-line blocks on the same as the `trigger` or `filter` keyword 77 | are fine.) 78 | 79 | 2. If your PatchMaster file creates triggers or filters in a loop (more 80 | precisely, if there isn't a one-to-one in-order correspondence between 81 | trigger and filter instances and their apperance in the file) then the 82 | block's text can't be read properly and it won't be saved or displayed 83 | properly. The trigger or filter will run just fine --- it's just that the 84 | text representing the block on save will be wrong. 85 | 86 | 3. If your filter or trigger does anything tricky like changing its own code 87 | (replacing its block with another) there is no way that PatchMaster can 88 | know the text of the new code. When the trigger or filter is saved, the 89 | old block text will be written out. 90 | 91 | As a workaround, you'll have to avoid using PatchMaster's save feature. Make 92 | all your edits to triggers and filters from outside of PatchMaster, using 93 | your editor. 94 | 95 | To be honest, the PatchMaster save feature isn't all that useful since you 96 | can't change anything from within PatchMaster anyway --- yet. Once editing 97 | capabilities are added to PatchMaster this might become more bothersome. 98 | 99 | # Anatomy of a PatchMaster File 100 | 101 | ## MIDI Instruments 102 | 103 | input/output port, symbol, optional_name 104 | 105 | Describes MIDI inputs and outputs. 106 | 107 | Symbols must be unique within instrument type (input or output). For 108 | example, you can have an input instrument with the symbol :ws and an output 109 | instrument with the same symbol :ws, but you can't have two inputs or two 110 | outputs with the same symbol. 111 | 112 | Example: 113 | 114 | {% highlight ruby %} 115 | input 0, :mb, 'midiboard' 116 | input 1, :ws, 'WaveStation' 117 | output 1, :ws, 'WaveStation' 118 | output 2, :kz, 'K2000R' 119 | output 4, :sj # Name will come from UNIMidi 120 | {% endhighlight %} 121 | 122 | ### Aliases 123 | 124 | Sometimes you have two different instruments using the same MIDI port and 125 | you'd like to refer to them by two different names. In that case, you can 126 | use `alias_input` or `alias_output`. 127 | 128 | Both commands have the same format: `alias_input :new_sym, :old_sym`. For 129 | example, if you have a MIDI output going into a keyboard and the "thru" MIDI 130 | port from that keyboard goes out to a drum machine, you could define them 131 | like this: 132 | 133 | {% highlight ruby %} 134 | output 1, :kbd, 'My Keyboard and Drum Machine' 135 | alias_output :drums, :kbd 136 | {% endhighlight %} 137 | 138 | ## Named Messages 139 | 140 | {% highlight ruby %} 141 | message name, bytes 142 | {% endhighlight %} 143 | 144 | Stores a named MIDI message. These messages can be sent at any time using 145 | message keys or triggers, and can be sent from filters. 146 | 147 | Example: 148 | 149 | {% highlight ruby %} 150 | message "Tune Request", [TUNE_REQUEST] 151 | {% endhighlight %} 152 | 153 | The `TUNE_REQUEST` constant is defined in `patchmaster/consts.rb`. 154 | 155 | See also [Named Messages in Filters](#named-messages-in-filters) below. 156 | 157 | ## Message Keys 158 | 159 | {% highlight ruby %} 160 | message_key key, name 161 | {% endhighlight %} 162 | 163 | Maps the named message to a key. Message keys are ignored if PatchMaster was 164 | started without the curses GUI. 165 | 166 | `key` may be any one-character string (for example '8' or "p") or a function 167 | key symbol of the form `:f1`, `:f2`, etc. 168 | 169 | ### Note 170 | 171 | Older versions of PatchMaster (before 1.2.0) reversed the order of the two 172 | arguments to `message_key`. The reversed order is still accepted but a 173 | deprecation warning is output. 174 | 175 | ## Code Keys 176 | 177 | {% highlight ruby %} 178 | code_key(key) { block of code } 179 | # or, the same thing 180 | code_key key do 181 | block of code 182 | end 183 | {% endhighlight %} 184 | 185 | Maps the block of code to a key. Code keys are ignored if PatchMaster was 186 | started without the curses GUI. When the key is pressed, the block of code 187 | is executed. 188 | 189 | `key` may be any one-character string (for example '8' or "p") or a function 190 | key symbol of the form `:f1`, `:f2`, etc. 191 | 192 | Note that if you use the `{ ... }` syntax for the block, then `key` must be 193 | surrounded by parentheses. 194 | 195 | ## Triggers 196 | 197 | {% highlight ruby %} 198 | trigger input_instrument_symbol, bytes, block 199 | {% endhighlight %} 200 | 201 | Input MIDI messages can trigger blocks of code to run. When `bytes` are sent 202 | from the given input instrument then `block` is executed. All of the methods 203 | of PM::PatchMaster are made available to the trigger, so for example the 204 | block can call methods such as `#next_patch`, `#prev_song`, or 205 | `#send_message`. 206 | 207 | Example: 208 | 209 | {% highlight ruby %} 210 | trigger(:mb, [CONTROLLER, CC_GEN_PURPOSE_5, 127]) { next_patch } 211 | trigger(:mb, [CONTROLLER, CC_GEN_PURPOSE_6, 127]) { prev_patch } 212 | trigger(:mb, [CONTROLLER, 126, 127]) { send_message "Tune Request" } 213 | {% endhighlight %} 214 | 215 | ## Songs 216 | 217 | {% highlight ruby %} 218 | song name block 219 | {% endhighlight %} 220 | 221 | A song is a list of patches. 222 | 223 | Example: 224 | 225 | {% highlight ruby %} 226 | song "My First Song" do 227 | # ... 228 | end 229 | {% endhighlight %} 230 | 231 | ### Patches 232 | 233 | {% highlight ruby %} 234 | patch name block 235 | {% endhighlight %} 236 | 237 | A patch contains connections and optional start and stop byte arrays. 238 | 239 | - start_bytes 240 | - stop_bytes 241 | - connection 242 | 243 | Example: 244 | 245 | {% highlight ruby %} 246 | song "My First Song" do 247 | patch "First Song, First Patch" do 248 | start_bytes [TUNE_REQUEST] 249 | connection :mb, :kz, 2 do # all chans from :mb, out to ch 2 on :kz 250 | # ... 251 | end 252 | connection :ws, 6, :sj, 4 do # only ch 6 from :ws_kbd, out to ch 4 on :sj 253 | # ... 254 | end 255 | conn :ws, 6, :d4, 10 256 | end 257 | end 258 | {% endhighlight %} 259 | 260 | #### Connections 261 | 262 | {% highlight ruby %} 263 | connection in_sym, in_chan, out_sym, out_chan, block 264 | connection in_sym, nil, out_sym, out_chan, block 265 | connection in_sym, out_sym, out_chan, block 266 | {% endhighlight %} 267 | 268 | Connects an input instrument to an output instrument. If `in_chan` is `nil` 269 | or is skipped then any message coming from that instrument will be 270 | processed, else only messages coming from the specified channel will be 271 | processed. 272 | 273 | A connection can optionally take a block that specifies a program change or 274 | bank plus program change (sent to the output instrument on `out_chan`), a 275 | zone, a transposition, and a filter (see below). 276 | 277 | - prog_chg 278 | - zone 279 | - transpose 280 | - filter 281 | 282 | All those values are optional; you don't have to specify them. 283 | 284 | Example: 285 | 286 | {% highlight ruby %} 287 | song "My First Song" do 288 | patch "First Song, First Patch" do 289 | connection :ws, 6, :sj, 4 do # only chan 6 from :ws, out to ch 4 on :sj 290 | prog_chg 100 # no bank, prog chg 100 291 | zone C4, B5 292 | transpose -12 293 | filter { |connection, bytes| 294 | # ... 295 | } 296 | end 297 | end 298 | end 299 | {% endhighlight %} 300 | 301 | ##### Program Changes 302 | 303 | {% highlight ruby %} 304 | prog_chg prog_number 305 | prog_chg bank_number, prog_number 306 | {% endhighlight %} 307 | 308 | Sends `prog_number` to the output instrument's channel. If `bank_number` is 309 | specified, sends bank change then program change. 310 | 311 | Only one program change per connection is allowed. If there is more than one 312 | in a connection the last one is used. 313 | 314 | Examples: 315 | 316 | {% highlight ruby %} 317 | prog_chg 42 # program change only 318 | prog_chg 2, 100 # bank change th 319 | {% endhighlight %} 320 | 321 | ##### Zones 322 | 323 | {% highlight ruby %} 324 | zone low, high 325 | zone (low..high) # or (low...high) to exclude high 326 | {% endhighlight %} 327 | 328 | By default a connection accepts and processes notes (and poly pressure 329 | messages) for all MIDI note numbers 0-127. You can use the zone command to 330 | limit which notes are passed through. Notes outside the defined range are 331 | ignored. 332 | 333 | The `zone` command can take either two notes or a range. Notes can be 334 | numbers, or you can use the constants defined in consts.rb such as `C2`, 335 | `Ab3`, or `Df7` ("s" for sharp, "f" or "b" for "flat"). 336 | 337 | If you specify a single number, it's the bottom of the zone and the zone 338 | extends all the way up to note 127. If you specify no numbers, that's the 339 | same as not specifying a zone at all; all notes will get through. 340 | 341 | Only one zone per connection is allowed. If there is more than one in a 342 | connection the last one is used. 343 | 344 | Example: 345 | 346 | {% highlight ruby %} 347 | zone C2 # filters out all notes below C2 348 | zone C2, B4 # only allows notes from C2 to B4 349 | zone (C2..B4) # same as previous 350 | zone (C2...C5) # same as previous ("..." excludes top) 351 | {% endhighlight %} 352 | 353 | ##### Transpose 354 | 355 | {% highlight ruby %} 356 | transpose num 357 | {% endhighlight %} 358 | 359 | Specifies a note transposition that will be applied to all incoming note on, 360 | note off, and polyphonic pressure messages. 361 | 362 | Note that transposition occurs after a connection's zone has filtered out 363 | incoming data, not before. 364 | 365 | ##### Filters 366 | 367 | {% highlight ruby %} 368 | filter block_with_two_args 369 | {% endhighlight %} 370 | 371 | Filters are applied as the last step in a connection's modification of the 372 | MIDI data. This means that the status byte's channel is already changed to 373 | the output instrument's channel for this connection (assuming the message is 374 | a channel message). 375 | 376 | The filter's block must return the array of bytes you want sent to the 377 | output. Don't use the "return" keyword; simply make sure the byte array is 378 | the last thing in the block. 379 | 380 | Only one filter per connection is allowed. If there is more than one in a 381 | connection the last one is used. 382 | 383 | Example: 384 | 385 | {% highlight ruby %} 386 | song "My First Song" do 387 | patch "First Song, First Patch" do 388 | connection :ws, 6, :sj, 4 do # only chan 6 from :ws, out to ch 4 on :sj 389 | prog_chg 100 390 | zone C4, B5 391 | filter { |connection, bytes| 392 | if bytes.note_off? 393 | bytes[2] -= 1 unless bytes[2] == 0 # decrease velocity by 1 394 | end 395 | bytes 396 | } 397 | end 398 | end 399 | end 400 | {% endhighlight %} 401 | 402 | ###### Named Messages in Filters 403 | 404 | Named messages sent from filters are sent before the filtered bytes are 405 | sent. Make sure the filter returns the filtered bytes after sending your 406 | message. If you send the mesasge last in your filter then no other bytes 407 | will be sent. 408 | 409 | {% highlight ruby %} 410 | # WRONG 411 | filter do |conn, bytes| 412 | bytes 413 | send_message "Interesting Bytes" 414 | end 415 | 416 | # RIGHT 417 | filter do |conn, bytes| 418 | send_message "Interesting Bytes" 419 | bytes # pass through original bytes unchanged 420 | end 421 | {% endhighlight %} 422 | 423 | Note that named messages sent from filters are sent every time any MIDI 424 | bytes are run through the filter --- practically speaking, every time a note 425 | or controller is sent through the filter. 426 | 427 | Instead of using `send_message` to send the message directly, you can copy 428 | the bytes into the byte array. This way, you can send the message after the 429 | bytes are sent, not before. Here's how: 430 | 431 | {% highlight ruby %} 432 | filter do |conn, bytes| 433 | msg_bytes = messages["My Message Name".downcase] 434 | bytes + msg_bytes # return original bytes plus message bytes 435 | end 436 | {% endhighlight %} 437 | 438 | ## Song Lists 439 | 440 | {% highlight ruby %} 441 | song_list name, [song_name, song_name...] 442 | {% endhighlight %} 443 | 444 | Optional. 445 | 446 | Example: 447 | 448 | {% highlight ruby %} 449 | song_list "Tonight's Song List", [ 450 | "First Song", 451 | "Second Song" 452 | ] 453 | {% endhighlight %} 454 | 455 | # Aliases 456 | 457 | Many of the keywords in PatchMaster files have short versions. 458 | 459 | | Full Name | Aliases | Notes | 460 | |------------+-----------+---------------------------------| 461 | | input | inp | "in" is a reserved word in Ruby | 462 | | output | outp, out | | 463 | | connection | conn, c | | 464 | | prog_chg | pc | | 465 | | zone | z | | 466 | | transpose | xpose, x | | 467 | | filter | f | | 468 | --------------------------------------------------------------------------------