mdaines-soxophone 0.2

data/COPYING

@@ -0,0 +1,25 @@
+"Soxophone" is (c) 2009 Michael Daines, but the concept
+and notation scanner is based on "Bloopsaphone", which is
+copyright (c) 2009 why the lucky stiff and is also released
+under the MIT license.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software,
+and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+  
+The above copyright notice and this permission notice shall be 
+included in all copies or substantial portions of the Software.
+   
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
+OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README

@@ -0,0 +1,167 @@
+!!!SOXOPHONE!!!
+   =========
+   
+   This is a small synthesis and
+   sequencing library that runs on
+   top of SoX. You write little
+   Ruby programs and it arranges
+   a bunch of command-line
+   stuff to make your songs.
+   
+   The notation and general idea
+   were borrowed from _why's
+   Bloopsaphone.
+
+
+A quick demo
+------------
+
+1. You need to install SoX:
+   
+     http://sox.sourceforge.net/
+     
+   You can probably use the version
+   provided by your package manager
+   (I use MacPorts).
+   
+2. Run the example:
+   
+     ruby soxo.rb
+
+   You'll get an MP3 you can play
+   in your music player.
+
+     open soxo.mp3
+
+
+The basics of Soxophone
+-----------------------
+   
+   (Follow along with the "boop.rb"
+   example.)
+   
+   
+1. Before anything, you need a
+   Soxophone block, like this:
+   
+     Soxophone.play do |x|
+       
+     end
+   
+   This means that Soxophone will
+   ask SoX to play your song with
+   the "play" command. You can
+   also write your song to a file,
+   like this:
+   
+     Soxophone.write("tune.mp3") do |x|
+       
+     end
+   
+   
+2. Then, you define sounds.
+   
+   To define a sound, ask the object
+   the block yields for a sound:
+   
+     Soxophone.play do |x|
+       boop = x.sound :sine
+     end
+
+   All the SoX synth sounds, like
+   sine waves, square waves, and so
+   on are supported.
+   
+   You can set attributes on your
+   sounds to change them. For example,
+   to add a simple envelope:
+   
+     boop = x.sound :sine
+     boop.release = 0.75
+   
+   This means the "boop" sound will
+   start fading out three quarters
+   of the way from the end.
+   
+   You can add a few other effects,
+   like a phaser effect and a
+   tremolo effect. See "effects.rb"
+   for an example.
+   
+   Soxophone also allows you to use
+   sampled sound files. To do this,
+   you ask for a sample:
+   
+     tri = x.sample "triangle.mp3"
+     
+   Samples can have effects too, and
+   you can play chords with them
+   (see below).
+   
+   Samples are pitch-shifted relative
+   to middle A. If you're including
+   a drum sample, you want to just
+   write a middle A (or A4, or
+   just "a") so the pitch won't
+   be shifted.
+   
+   
+3. Next, you define tunes.
+   
+   Just ask to use one of your sounds
+   in a tune:
+   
+     x.tune boop, "a b c"
+   
+   Here, we're asking Soxophone to
+   play three quarter notes with the
+   "boop" sound.
+   
+   You can write as many tunes as you
+   want and Soxophone will mix
+   them all together.
+   
+   Notes look like this:
+   
+     a (quarter note at middle A)
+     a5 (quarter note one octave higher than middle A)
+     2:c (half note at middle C)
+     1e3 (whole note at E but one octave lower)
+     c# (quarter note at C sharp)
+     eb (quarter note at E flat)
+     eb3 (quarter note at E flat but one octave lower)
+   
+   So, a note is written like this:
+   
+   - The duration (as the lower half
+     of a fraction of a bar)
+   - An optional ":"
+   - The note name
+   - An optional sharp or flat
+   - The octave
+   
+   You can write a plus or minus to
+   move notes up or down:
+   
+     - a + a + a (A3, A4, and A5)
+   
+   You can also write chords. Just
+   surround notes with parentheses:
+   
+     a c e (a c e)
+   
+4. Then, run your composition through
+   Ruby:
+   
+     ruby boop.rb
+   
+   If you asked Soxophone to play your
+   composition, it'll play through your
+   speakers. If you asked to write
+   a file, the file will appear.
+   
+   Make sure you try the examples!
+   
+
+------
+

data/Rakefile

@@ -0,0 +1,3 @@
+task :default do
+  `ragel -R lib/soxophone/notation.rl -o lib/soxophone/notation.rb`
+end

data/examples/boop.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require "soxophone"
+
+Soxophone.play do |x|
+  
+  boop = x.sound :sine
+  boop.release = 0.75
+  
+  x.tune boop, "a b c"
+  
+end

data/examples/chords.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require "soxophone"
+
+Soxophone.play do |x|
+  s = x.sound :sine
+  x.tune s, "(1:a c e) (1:c e g) - (1:e g b)"
+end

data/examples/effects.rb

@@ -0,0 +1,25 @@
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require "soxophone"
+
+Soxophone.play do |x|
+  s = x.sound(:square)
+  s.release = 0.5
+  
+  x.tune s, "a b c"
+end
+
+Soxophone.play do |x|
+  s = x.sound(:square)
+  s.release = 0.5
+  s.tremolo = 10
+  
+  x.tune s, "a b c"
+end
+
+Soxophone.play do |x|
+  s = x.sound(:square)
+  s.release = 0.5
+  s.phaser = true
+  
+  x.tune s, "a b c"
+end

data/examples/envelope.rb

@@ -0,0 +1,26 @@
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require "soxophone"
+
+Soxophone.play do |x|
+  s = x.sound :sine
+  s.attack = 0.5
+  s.release = 0.5
+  
+  x.tune s, "1a 1a 1a 8"
+end
+
+Soxophone.play do |x|
+  s = x.sound :sine
+  s.attack = 0
+  s.release = 0.25
+  
+  x.tune s, "1a 1a 1a 8"
+end
+
+Soxophone.play do |x|
+  s = x.sound :sine
+  s.attack = 1
+  s.release = 0
+  
+  x.tune s, "1a 1a 1a 8"
+end

data/examples/notation.rb

@@ -0,0 +1,23 @@
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require "soxophone"
+
+def inspect_notation(n)
+  puts "#{n} =>"
+  Soxophone::Notation.instructions(n).each do |ins|
+    puts ins.inspect
+  end
+  puts
+end
+
+inspect_notation('a b c')
+inspect_notation('a 8b 1:c')
+inspect_notation('a bb c#')
+inspect_notation('a + b - c')
+inspect_notation('a5 b2 c3')
+
+inspect_notation('(a b)')
+inspect_notation('(a b) c')
+inspect_notation('(a b) (c d)')
+inspect_notation('g3 (a b) c (d e) f')
+
+inspect_notation('a b !!!')

data/examples/samples.rb

@@ -0,0 +1,23 @@
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require "soxophone"
+
+Soxophone.play do |x|
+  c = x.sample("crash.mp3")
+  c.gain = -9
+  
+  x.tune c, "1a 4a"
+end
+
+Soxophone.play do |x|
+  t = x.sample("triangle.mp3")
+  t.gain = 5
+  
+  x.tune t, "1a 16a 16a 16a 16a"
+end
+
+Soxophone.play do |x|
+  t = x.sample("triangle.mp3")
+  t.gain = 5
+  
+  x.tune t, "a b c d e f g + a - 4 (a c e)"
+end

data/lib/soxophone.rb

@@ -0,0 +1,22 @@
+module Soxophone
+  
+  def self.play
+    s = Base.new
+    yield s
+    system "play #{"-m" if s.tunes.size > 1} #{s.paths.map { |p| "-t sox #{p} " }.join(" ")}"
+  end
+  
+  def self.write(path)
+    s = Base.new
+    yield s
+    system "sox #{"-m" if s.tunes.size > 1} #{s.paths.map { |p| "-t sox #{p} " }.join(" ")} #{path}"
+  end
+  
+end
+
+require "soxophone/notation"
+require "soxophone/effects"
+require "soxophone/sound"
+require "soxophone/sample"
+require "soxophone/tune"
+require "soxophone/base"

data/lib/soxophone/base.rb

@@ -0,0 +1,39 @@
+require "tempfile"
+
+module Soxophone
+  
+  class Base
+  
+    def initialize
+      @tunes = []
+    end
+    
+    attr_accessor :tunes
+    
+    def sound(kind)
+      Sound.new(kind)
+    end
+    
+    def sample(path)
+      Sample.new(path)
+    end
+  
+    def tune(sound, notation)
+      tune = Tune.new(sound)
+      tune.instructions = Notation.instructions(notation)
+      @tunes << tune
+    end
+  
+    def paths
+      @tunes.map do |tune|
+        tmp = Tempfile.new("soxo")
+        system tune.cmd(tmp.path)
+        tmp.close
+        
+        tmp.path
+      end
+    end
+  
+  end
+  
+end

data/lib/soxophone/effects.rb

@@ -0,0 +1,41 @@
+module Soxophone
+  
+  module Effects
+    
+    attr_reader :tremolo
+    attr_reader :phaser
+    attr_reader :gain
+    
+    def tremolo=(tremolo)
+      unless tremolo.is_a?(Numeric)
+        raise "Tremolo must be a number"
+      end
+      @tremolo = tremolo
+    end
+    
+    def phaser=(phaser)
+      unless [true, false].include?(phaser)
+        raise "Phaser must be true or false"
+      end
+      @phaser = phaser
+    end
+    
+    def gain=(gain)
+      unless gain.is_a?(Numeric)
+        raise "Gain must be a number"
+      end
+      @gain = gain
+    end
+    
+    def effectopts
+      fx = []
+      fx << "tremolo #{tremolo}" if tremolo
+      fx << "phaser 0.6 0.66 3 0.6 2 -t" if phaser
+      fx << "gain #{gain}" if gain
+      
+      fx.compact.join(" ")
+    end
+    
+  end
+  
+end

data/lib/soxophone/notation.rb

@@ -0,0 +1,504 @@
+# line 1 "lib/soxophone/notation.rl"
+#  :$: BLOOPSAPHONE :$:
+#  Copyright (c) 2009 why the lucky stiff
+#  Based on sfxr (c) 2007 Tomas Pettersson
+#    (Also released under the MIT license)
+#  
+#  Permission is hereby granted, free of charge, to any person
+#  obtaining a copy of this software and associated documentation
+#  files (the "Software"), to deal in the Software without restriction,
+#  including without limitation the rights to use, copy, modify, merge,
+#  publish, distribute, sublicense, and/or sell copies of the Software,
+#  and to permit persons to whom the Software is furnished to do so,
+#  subject to the following conditions:
+#    
+#  The above copyright notice and this permission notice shall be 
+#  included in all copies or substantial portions of the Software.
+#     
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+#  ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+#  TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+#  PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+#  SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+#  OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
+#  OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+#  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+#  SOFTWARE.
+
+module Soxophone
+
+  class Rest
+    attr_accessor :duration
+  end
+
+  class Note
+    attr_accessor :tone, :duration, :octave
+  end
+  
+  class Chord
+    def initialize
+      @notes = []
+    end
+    def duration
+      notes.map { |n| n.duration }.min
+    end
+    attr_accessor :notes
+  end
+
+  module Notation
+
+    NUMBERS = {
+      'A' => 0,
+      'B' => 2,
+      'C' => 3,
+      'D' => 5,
+      'E' => 7,
+      'F' => 8,
+      'G' => 10
+    }
+
+    
+# line 62 "lib/soxophone/notation.rb"
+class << self
+	attr_accessor :_bloopnotes_actions
+	private :_bloopnotes_actions, :_bloopnotes_actions=
+end
+self._bloopnotes_actions = [
+	0, 1, 0, 1, 1, 1, 2, 1, 
+	3, 1, 5, 1, 6, 1, 7, 1, 
+	8, 1, 9, 1, 10, 2, 0, 11, 
+	2, 0, 13, 2, 0, 14, 2, 1, 
+	13, 2, 2, 14, 2, 3, 12, 2, 
+	4, 12, 2, 5, 12
+]
+
+class << self
+	attr_accessor :_bloopnotes_key_offsets
+	private :_bloopnotes_key_offsets, :_bloopnotes_key_offsets=
+end
+self._bloopnotes_key_offsets = [
+	0, 0, 13, 15, 18, 19, 19, 21, 
+	24, 25, 25, 32, 37, 41, 45, 47
+]
+
+class << self
+	attr_accessor :_bloopnotes_trans_keys
+	private :_bloopnotes_trans_keys, :_bloopnotes_trans_keys=
+end
+self._bloopnotes_trans_keys = [
+	32, 40, 41, 43, 45, 9, 13, 49, 
+	57, 65, 71, 97, 103, 49, 57, 58, 
+	48, 57, 58, 49, 57, 58, 48, 57, 
+	58, 58, 48, 57, 65, 71, 97, 103, 
+	58, 65, 71, 97, 103, 65, 71, 97, 
+	103, 35, 98, 49, 56, 49, 56, 0
+]
+
+class << self
+	attr_accessor :_bloopnotes_single_lengths
+	private :_bloopnotes_single_lengths, :_bloopnotes_single_lengths=
+end
+self._bloopnotes_single_lengths = [
+	0, 5, 0, 1, 1, 0, 0, 1, 
+	1, 0, 1, 1, 0, 2, 0, 0
+]
+
+class << self
+	attr_accessor :_bloopnotes_range_lengths
+	private :_bloopnotes_range_lengths, :_bloopnotes_range_lengths=
+end
+self._bloopnotes_range_lengths = [
+	0, 4, 1, 1, 0, 0, 1, 1, 
+	0, 0, 3, 2, 2, 1, 1, 0
+]
+
+class << self
+	attr_accessor :_bloopnotes_index_offsets
+	private :_bloopnotes_index_offsets, :_bloopnotes_index_offsets=
+end
+self._bloopnotes_index_offsets = [
+	0, 0, 10, 12, 15, 17, 18, 20, 
+	23, 25, 26, 31, 35, 38, 42, 44
+]
+
+class << self
+	attr_accessor :_bloopnotes_trans_targs
+	private :_bloopnotes_trans_targs, :_bloopnotes_trans_targs=
+end
+self._bloopnotes_trans_targs = [
+	1, 1, 1, 2, 6, 1, 10, 13, 
+	13, 0, 3, 1, 5, 4, 1, 5, 
+	1, 1, 7, 1, 9, 8, 1, 9, 
+	1, 1, 12, 11, 13, 13, 1, 12, 
+	13, 13, 1, 13, 13, 1, 14, 14, 
+	15, 1, 15, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 0
+]
+
+class << self
+	attr_accessor :_bloopnotes_trans_actions
+	private :_bloopnotes_trans_actions, :_bloopnotes_trans_actions=
+end
+self._bloopnotes_trans_actions = [
+	19, 15, 17, 0, 0, 19, 0, 0, 
+	0, 0, 3, 30, 0, 0, 24, 0, 
+	24, 24, 5, 33, 0, 0, 27, 0, 
+	27, 27, 0, 0, 1, 1, 21, 0, 
+	1, 1, 21, 1, 1, 21, 9, 9, 
+	9, 42, 7, 36, 39, 30, 24, 24, 
+	24, 33, 27, 27, 27, 21, 21, 21, 
+	42, 36, 39, 0
+]
+
+class << self
+	attr_accessor :_bloopnotes_to_state_actions
+	private :_bloopnotes_to_state_actions, :_bloopnotes_to_state_actions=
+end
+self._bloopnotes_to_state_actions = [
+	0, 11, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0
+]
+
+class << self
+	attr_accessor :_bloopnotes_from_state_actions
+	private :_bloopnotes_from_state_actions, :_bloopnotes_from_state_actions=
+end
+self._bloopnotes_from_state_actions = [
+	0, 13, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0
+]
+
+class << self
+	attr_accessor :_bloopnotes_eof_trans
+	private :_bloopnotes_eof_trans, :_bloopnotes_eof_trans=
+end
+self._bloopnotes_eof_trans = [
+	0, 0, 46, 49, 49, 49, 50, 53, 
+	53, 53, 56, 56, 56, 57, 58, 59
+]
+
+class << self
+	attr_accessor :bloopnotes_start
+end
+self.bloopnotes_start = 1;
+class << self
+	attr_accessor :bloopnotes_error
+end
+self.bloopnotes_error = 0;
+
+class << self
+	attr_accessor :bloopnotes_en_main
+end
+self.bloopnotes_en_main = 1;
+
+# line 130 "lib/soxophone/notation.rl"
+
+
+    def self.instructions(data)
+      oct = 4
+      len = 4
+      tone = nil
+      mod = nil
+      instructions = []
+    
+      data += " "
+      eof = -1
+    
+      
+# line 210 "lib/soxophone/notation.rb"
+begin
+	p ||= 0
+	pe ||= data.length
+	cs = bloopnotes_start
+	ts = nil
+	te = nil
+	act = 0
+end
+
+# line 220 "lib/soxophone/notation.rb"
+begin
+	_klen, _trans, _keys, _acts, _nacts = nil
+	_goto_level = 0
+	_resume = 10
+	_eof_trans = 15
+	_again = 20
+	_test_eof = 30
+	_out = 40
+	while true
+	_trigger_goto = false
+	if _goto_level <= 0
+	if p == pe
+		_goto_level = _test_eof
+		next
+	end
+	if cs == 0
+		_goto_level = _out
+		next
+	end
+	end
+	if _goto_level <= _resume
+	_acts = _bloopnotes_from_state_actions[cs]
+	_nacts = _bloopnotes_actions[_acts]
+	_acts += 1
+	while _nacts > 0
+		_nacts -= 1
+		_acts += 1
+		case _bloopnotes_actions[_acts - 1]
+			when 7 then
+# line 1 "lib/soxophone/notation.rl"
+		begin
+ts = p
+		end
+# line 1 "lib/soxophone/notation.rl"
+# line 255 "lib/soxophone/notation.rb"
+		end # from state action switch
+	end
+	if _trigger_goto
+		next
+	end
+	_keys = _bloopnotes_key_offsets[cs]
+	_trans = _bloopnotes_index_offsets[cs]
+	_klen = _bloopnotes_single_lengths[cs]
+	_break_match = false
+	
+	begin
+	  if _klen > 0
+	     _lower = _keys
+	     _upper = _keys + _klen - 1
+
+	     loop do
+	        break if _upper < _lower
+	        _mid = _lower + ( (_upper - _lower) >> 1 )
+
+	        if data[p] < _bloopnotes_trans_keys[_mid]
+	           _upper = _mid - 1
+	        elsif data[p] > _bloopnotes_trans_keys[_mid]
+	           _lower = _mid + 1
+	        else
+	           _trans += (_mid - _keys)
+	           _break_match = true
+	           break
+	        end
+	     end # loop
+	     break if _break_match
+	     _keys += _klen
+	     _trans += _klen
+	  end
+	  _klen = _bloopnotes_range_lengths[cs]
+	  if _klen > 0
+	     _lower = _keys
+	     _upper = _keys + (_klen << 1) - 2
+	     loop do
+	        break if _upper < _lower
+	        _mid = _lower + (((_upper-_lower) >> 1) & ~1)
+	        if data[p] < _bloopnotes_trans_keys[_mid]
+	          _upper = _mid - 2
+	        elsif data[p] > _bloopnotes_trans_keys[_mid+1]
+	          _lower = _mid + 2
+	        else
+	          _trans += ((_mid - _keys) >> 1)
+	          _break_match = true
+	          break
+	        end
+	     end # loop
+	     break if _break_match
+	     _trans += _klen
+	  end
+	end while false
+	end
+	if _goto_level <= _eof_trans
+	cs = _bloopnotes_trans_targs[_trans]
+	if _bloopnotes_trans_actions[_trans] != 0
+		_acts = _bloopnotes_trans_actions[_trans]
+		_nacts = _bloopnotes_actions[_acts]
+		_acts += 1
+		while _nacts > 0
+			_nacts -= 1
+			_acts += 1
+			case _bloopnotes_actions[_acts - 1]
+when 0 then
+# line 62 "lib/soxophone/notation.rl"
+		begin
+ len = data[ts..p].to_i 		end
+# line 62 "lib/soxophone/notation.rl"
+when 1 then
+# line 63 "lib/soxophone/notation.rl"
+		begin
+ len = 1; 		end
+# line 63 "lib/soxophone/notation.rl"
+when 2 then
+# line 64 "lib/soxophone/notation.rl"
+		begin
+ len = 1; 		end
+# line 64 "lib/soxophone/notation.rl"
+when 3 then
+# line 65 "lib/soxophone/notation.rl"
+		begin
+ mod = data[p-1..p-1] 		end
+# line 65 "lib/soxophone/notation.rl"
+when 4 then
+# line 66 "lib/soxophone/notation.rl"
+		begin
+ oct = data[p-1..p-1].to_i 		end
+# line 66 "lib/soxophone/notation.rl"
+when 5 then
+# line 67 "lib/soxophone/notation.rl"
+		begin
+ tone = data[p-1..p-1] 		end
+# line 67 "lib/soxophone/notation.rl"
+when 8 then
+# line 72 "lib/soxophone/notation.rl"
+		begin
+te = p+1
+ begin 
+          chord = Chord.new
+         end
+		end
+# line 72 "lib/soxophone/notation.rl"
+when 9 then
+# line 75 "lib/soxophone/notation.rl"
+		begin
+te = p+1
+ begin 
+          if chord
+            instructions << chord
+            chord = nil
+          end
+         end
+		end
+# line 75 "lib/soxophone/notation.rl"
+when 10 then
+# line 125 "lib/soxophone/notation.rl"
+		begin
+te = p+1
+		end
+# line 125 "lib/soxophone/notation.rl"
+when 11 then
+# line 81 "lib/soxophone/notation.rl"
+		begin
+te = p
+p = p - 1; begin 
+          unless chord
+            rest = Rest.new
+            rest.duration = len
+            
+            instructions << rest
+          end
+          
+          mod = nil;
+          tone = nil;
+          len = 4;
+         end
+		end
+# line 81 "lib/soxophone/notation.rl"
+when 12 then
+# line 93 "lib/soxophone/notation.rl"
+		begin
+te = p
+p = p - 1; begin 
+          note = Note.new
+          
+          num = NUMBERS[tone.upcase]
+          if mod == 'b'
+            num -= 1
+          elsif mod == '#'
+            num += 1
+          end
+      
+          note.tone = num
+          note.duration = len
+          note.octave = oct
+          
+          if chord
+            chord.notes << note
+          else
+            instructions << note
+          end
+        
+          mod = nil
+          tone = nil
+          len = 4
+         end
+		end
+# line 93 "lib/soxophone/notation.rl"
+when 13 then
+# line 117 "lib/soxophone/notation.rl"
+		begin
+te = p
+p = p - 1; begin 
+          oct += 1
+          len = 4
+         end
+		end
+# line 117 "lib/soxophone/notation.rl"
+when 14 then
+# line 121 "lib/soxophone/notation.rl"
+		begin
+te = p
+p = p - 1; begin 
+          oct -= 1
+          len = 4
+         end
+		end
+# line 121 "lib/soxophone/notation.rl"
+# line 446 "lib/soxophone/notation.rb"
+			end # action switch
+		end
+	end
+	if _trigger_goto
+		next
+	end
+	end
+	if _goto_level <= _again
+	_acts = _bloopnotes_to_state_actions[cs]
+	_nacts = _bloopnotes_actions[_acts]
+	_acts += 1
+	while _nacts > 0
+		_nacts -= 1
+		_acts += 1
+		case _bloopnotes_actions[_acts - 1]
+when 6 then
+# line 1 "lib/soxophone/notation.rl"
+		begin
+ts = nil;		end
+# line 1 "lib/soxophone/notation.rl"
+# line 467 "lib/soxophone/notation.rb"
+		end # to state action switch
+	end
+	if _trigger_goto
+		next
+	end
+	if cs == 0
+		_goto_level = _out
+		next
+	end
+	p += 1
+	if p != pe
+		_goto_level = _resume
+		next
+	end
+	end
+	if _goto_level <= _test_eof
+	if p == eof
+	if _bloopnotes_eof_trans[cs] > 0
+		_trans = _bloopnotes_eof_trans[cs] - 1;
+		_goto_level = _eof_trans
+		next;
+	end
+end
+	end
+	if _goto_level <= _out
+		break
+	end
+	end
+	end
+# line 145 "lib/soxophone/notation.rl"
+
+    
+      instructions
+    end
+
+  end
+  
+end

data/lib/soxophone/notation.rl

@@ -0,0 +1,152 @@
+#  :$: BLOOPSAPHONE :$:
+#  Copyright (c) 2009 why the lucky stiff
+#  Based on sfxr (c) 2007 Tomas Pettersson
+#    (Also released under the MIT license)
+#  
+#  Permission is hereby granted, free of charge, to any person
+#  obtaining a copy of this software and associated documentation
+#  files (the "Software"), to deal in the Software without restriction,
+#  including without limitation the rights to use, copy, modify, merge,
+#  publish, distribute, sublicense, and/or sell copies of the Software,
+#  and to permit persons to whom the Software is furnished to do so,
+#  subject to the following conditions:
+#    
+#  The above copyright notice and this permission notice shall be 
+#  included in all copies or substantial portions of the Software.
+#     
+#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+#  ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+#  TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+#  PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+#  SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+#  OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
+#  OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+#  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+#  SOFTWARE.
+
+module Soxophone
+
+  class Rest
+    attr_accessor :duration
+  end
+
+  class Note
+    attr_accessor :tone, :duration, :octave
+  end
+  
+  class Chord
+    def initialize
+      @notes = []
+    end
+    def duration
+      notes.map { |n| n.duration }.min
+    end
+    attr_accessor :notes
+  end
+
+  module Notation
+
+    NUMBERS = {
+      'A' => 0,
+      'B' => 2,
+      'C' => 3,
+      'D' => 5,
+      'E' => 7,
+      'F' => 8,
+      'G' => 10
+    }
+
+    %%{
+      machine bloopnotes;
+
+      len = [1-9] [0-9]? ":"? %{ len = data[ts..p].to_i };
+      up = "+" %{ len = 1; } len?;
+      down = "-" %{ len = 1; } len?;
+      mod = [b#] %{ mod = data[p-1..p-1] };
+      oct = [1-8] %{ oct = data[p-1..p-1].to_i };
+      note = len? [a-gA-G] %{ tone = data[p-1..p-1] } mod? oct?;
+      startchord = "(";
+      endchord = ")";
+
+      main := |*
+        startchord => {
+          chord = Chord.new
+        };
+        endchord => {
+          if chord
+            instructions << chord
+            chord = nil
+          end
+        };
+        len => {
+          unless chord
+            rest = Rest.new
+            rest.duration = len
+            
+            instructions << rest
+          end
+          
+          mod = nil;
+          tone = nil;
+          len = 4;
+        };
+        note => {
+          note = Note.new
+          
+          num = NUMBERS[tone.upcase]
+          if mod == 'b'
+            num -= 1
+          elsif mod == '#'
+            num += 1
+          end
+      
+          note.tone = num
+          note.duration = len
+          note.octave = oct
+          
+          if chord
+            chord.notes << note
+          else
+            instructions << note
+          end
+        
+          mod = nil
+          tone = nil
+          len = 4
+        };
+        up   => {
+          oct += 1
+          len = 4
+        };
+        down => {
+          oct -= 1
+          len = 4
+        };
+        space;
+      *|;
+
+      write data nofinal;
+    
+    }%%
+
+    def self.instructions(data)
+      oct = 4
+      len = 4
+      tone = nil
+      mod = nil
+      instructions = []
+    
+      data += " "
+      eof = -1
+    
+      %%{
+        write init;
+        write exec;
+      }%%
+    
+      instructions
+    end
+
+  end
+  
+end

data/lib/soxophone/sample.rb

@@ -0,0 +1,47 @@
+module Soxophone
+  
+  class Sample
+    
+    include Effects
+  
+    def initialize(path)
+      self.path = path
+    end
+  
+    attr_reader :path
+    
+    def path=(path)
+      unless File.file?(path)
+        raise "Sample path must be a file"
+      end
+      @path = path
+    end
+    
+    def notecmd(freq, duration)
+      if duration > length
+        "sox #{path} -r 48k -c1 -p pad 0 #{duration - length} pitch #{freq*100}"
+      else
+        "sox #{path} -r 48k -c1 -p trim 0 #{duration} pitch #{freq*100}"
+      end
+    end
+  
+    def chordcmd(freqs, duration)
+      cmds = freqs.map { |f| notecmd(f, duration) }
+      "sox -m #{cmds.map { |c| "\"|#{c}\"" }.join(" ")} -p"
+    end
+    
+    private
+    
+      def length
+        if instance_variable_defined?(:@length)
+          return @length
+        end
+        
+        rate = `soxi -r #{path}`.strip.to_i
+        samples = `soxi -s #{path}`.strip.to_i
+        @length = samples.quo(rate)
+      end
+    
+  end
+  
+end

data/lib/soxophone/sound.rb

@@ -0,0 +1,65 @@
+module Soxophone
+
+  class Sound
+    
+    include Effects
+    
+    KINDS = %w(
+      sine square triangle sawtooth trapezium
+      exp noise whitenoise pinknoise brownnoise
+    )
+    
+    def initialize(kind)
+      self.kind = kind
+      self.attack = 0
+      self.release = 0
+    end
+    
+    attr_reader :kind
+    attr_reader :attack
+    attr_reader :release
+    
+    def kind=(kind)
+      unless KINDS.include?(kind.to_s)
+        raise "Kind must be one of #{KINDS.join(", ")}"
+      end
+      @kind = kind
+    end
+    
+    def attack=(attack)
+      unless attack.is_a?(Numeric)
+        raise "Attack must be a number"
+      end
+      @attack = attack
+    end
+    
+    def release=(release)
+      unless release.is_a?(Numeric)
+        raise "Release must be a number"
+      end
+      @release = release
+    end
+    
+    def notecmd(freq, duration)
+      env = envelope(duration)
+      "sox -n -p synth #{duration} #{kind} %#{freq} #{env}"
+    end
+    
+    def chordcmd(freqs, duration)
+      env = envelope(duration)
+      "sox -n -c1 -p synth #{duration} #{freqs.map { |f| "#{kind} %#{f}" }.join(" ")} #{env}"
+    end
+    
+    private
+    
+      def envelope(duration)
+        env = []
+        env << "fade #{attack * duration}" if attack > 0
+        env << "fade 0 #{duration} #{release * duration}" if release > 0
+        
+        env.compact.join(" ")
+      end
+    
+  end
+  
+end

data/lib/soxophone/tune.rb

@@ -0,0 +1,44 @@
+module Soxophone
+  
+  class Tune
+    def initialize(sound)
+      @instructions = []
+      @sound = sound
+    end
+  
+    attr_accessor :instructions, :sound
+    
+    def cmd(out_path)
+      "sox #{cmds.map { |c| "\"|#{c.gsub('"', '\"')}\"" }.join(" ")} -t sox #{out_path} #{sound.effectopts}"
+    end
+    
+    private
+  
+      def cmds
+        @instructions.map do |ins|
+          duration = 1.0 / ins.duration
+        
+          case ins
+          when Chord
+            freqs = ins.notes.map { |n| n.tone + ((n.octave - 4) * 12) }
+            
+            if freqs.size == 1
+              sound.notecmd(freqs.first, duration)
+            else
+              sound.chordcmd(freqs, duration)
+            end
+          
+          when Note
+            freq = ins.tone + ((ins.octave - 4) * 12)
+            sound.notecmd(freq, duration)
+          
+          when Rest
+            "sox -n -p trim 0 #{duration}"
+          
+          end
+        end
+        
+    end
+  end
+  
+end

data/soxo.rb

@@ -0,0 +1,40 @@
+$LOAD_PATH << File.dirname(__FILE__) + "/lib"
+require "soxophone"
+
+Soxophone.write("soxo.mp3") do |x|
+  
+  toot = x.sound :sine
+  toot.attack = 0
+  toot.release = 0.25
+  toot.tremolo = 100
+  
+  squp = x.sound :square
+  squp.gain = -9
+  squp.attack = 0
+  squp.release = 0.5
+  
+  pish = x.sound :noise
+  pish.attack = 0
+  pish.release = 0.9
+  
+  x.tune toot, %q*
+    8c 8e 8g + 2c 8 4a - (2d f) 4
+    8c 8e 8g + 2b 8 4a - (2c e) 4
+    8c 8e 8g + 2a 8-4g   (2b d) 4
+    1c
+  *
+  
+  x.tune squp, %q*
+    1c2 1g2
+    1e2 1a3
+    1g2 1d3
+    1c2
+  *
+  
+  x.tune pish, %q*
+    1a  4a 4 4a 4
+    1a  4a 4 4a 4
+    1a  4a 4 4a 4
+  *
+  
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: mdaines-soxophone
+version: !ruby/object:Gem::Version 
+  version: "0.2"
+platform: ruby
+authors: 
+- Michael Daines
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-19 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: a little synth and sequencer
+email: michael@mdaines.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- COPYING
+files: 
+- COPYING
+- README
+- examples/boop.rb
+- examples/chords.rb
+- examples/effects.rb
+- examples/envelope.rb
+- examples/notation.rb
+- examples/samples.rb
+- examples/crash.mp3
+- examples/triangle.mp3
+- lib/soxophone.rb
+- lib/soxophone/base.rb
+- lib/soxophone/effects.rb
+- lib/soxophone/notation.rb
+- lib/soxophone/notation.rl
+- lib/soxophone/sample.rb
+- lib/soxophone/sound.rb
+- lib/soxophone/tune.rb
+- Rakefile
+- soxo.rb
+has_rdoc: false
+homepage: http://github.com/mdaines/soxophone
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: a little synth and sequencer
+test_files: []
+