beats 1.0.0

data/LICENSE

@@ -0,0 +1,24 @@
+== BEATS
+
+# Copyright (c) 2010 Joel Strait
+#
+# 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 OR COPYRIGHT
+# HOLDERS 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.markdown

@@ -0,0 +1,27 @@
+BEATS
+-----
+
+BEATS is a drum machine written in pure Ruby. Feed it a song notated in YAML, and it will produce a precision-milled Wave file of impeccable timing and feel. Here's an example song:
+
+    Song:
+      Tempo: 120
+      Structure:
+        - Verse:   x2
+        - Chorus:  x4
+        - Verse:   x2
+        - Chorus:  x4
+
+    Verse:
+      - bass.wav:       X...X...X...X...
+      - snare.wav:      ..............X.
+      - hh_closed.wav:  X.XXX.XXX.X.X.X.
+      - agogo_high.wav: ..............XX
+
+    Chorus:
+      - bass.wav:       X...X...X...X...
+      - snare.wav:      ....X.......X...
+      - hh_closed.wav:  X.XXX.XXX.XX..X.
+      - tom4.wav:       ...........X....
+      - tom2.wav:       ..............X.
+
+For installation and usage instructions, visit the BEATS website at [http://beatsdrummachine.com](http://beatsdrummachine.com).

data/bin/beats

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + "/../lib/song"
+require File.dirname(__FILE__) + "/../lib/kit"
+require File.dirname(__FILE__) + "/../lib/pattern"
+require File.dirname(__FILE__) + "/../lib/track"
+require "rubygems"
+require "optparse"
+require "yaml"
+require "wavefile"
+
+BEATS_VERSION = "1.0.0"
+SAMPLE_RATE = 44100
+
+def parse_options
+  options = {:split => false, :pattern => ""}
+
+  optparse = OptionParser.new do |opts|
+    opts.on('-s', '--split', "Save each track to an individual wave file") do
+      options[:split] = true
+    end
+
+    opts.on('-p', '--pattern PATTERN_NAME', "Output a single pattern instead of the whole song" ) do |p|
+      options[:pattern] = p
+    end
+    
+    opts.on('-v', '--version', "Display version number and exit") do
+      puts "BEATS v#{BEATS_VERSION}"
+      exit
+    end
+    
+    opts.on( '-h', '--help', "Display this screen and exit" ) do
+      puts opts
+      exit
+    end
+  end
+  optparse.parse!
+  
+  return options
+end
+
+def save_wave_file(file_name, num_channels, bits_per_sample, sample_data)
+  output = WaveFile.new(num_channels, SAMPLE_RATE, bits_per_sample)
+  output.sample_data = sample_data
+  output.save(file_name)
+  return output.duration
+end
+
+start = Time.now
+
+options = parse_options
+input_file = ARGV[0]
+output_file = ARGV[1]
+
+if(input_file == nil)
+  ARGV[0] = '-h'
+  parse_options()
+end
+
+if(output_file == nil)
+  output_file = File.basename(input_file, File.extname(input_file)) + ".wav"
+end
+
+begin
+  parse_start_time = Time.now
+  song_from_file = Song.new(File.dirname(input_file), YAML.load_file(input_file))
+  
+  generate_samples_start = Time.now
+  sample_data = song_from_file.sample_data(options[:pattern], options[:split])
+  #puts "Time to generate sample data: #{Time.now - generate_samples_start}"
+
+  wave_write_start = Time.now
+  if(options[:split])
+    duration = nil
+    sample_data.keys.each {|track_name|
+      extension = File.extname(output_file)
+      file_name = File.basename(output_file, extension) + "-" + File.basename(track_name.to_s, extension) + extension
+      
+      duration = save_wave_file(file_name,
+                                song_from_file.num_channels,
+                                song_from_file.bits_per_sample,
+                                sample_data[track_name])
+    }
+  else
+    duration = save_wave_file(output_file, song_from_file.num_channels, song_from_file.bits_per_sample, sample_data)
+  end
+  
+  puts "#{duration[:minutes]}:#{duration[:seconds].to_s.rjust(2, '0')} of audio produced in #{Time.now - start} seconds."
+rescue Errno::ENOENT => detail
+  puts ""
+  puts "Song file '#{input_file}' not found."
+  puts ""
+rescue ArgumentError => detail
+  puts ""
+  puts "Song file '#{input_file}' has an error:"
+  puts "  Syntax error in YAML file:"
+  puts "  #{detail}"
+  puts ""
+rescue SongParseError => detail
+  puts ""
+  puts "Song file '#{input_file}' has an error:"
+  puts "  #{detail}"
+  puts ""
+rescue StandardError => detail
+  puts ""
+  puts "An error occured while generating sound for '#{input_file}':"
+  puts "  #{detail}"
+  puts ""
+end

data/lib/kit.rb

@@ -0,0 +1,40 @@
+class Kit
+  def initialize()
+    @sounds = {}
+    @num_channels = 0
+    @bits_per_sample = 0
+  end
+  
+  def add(name, path)
+    if(!@sounds.has_key? name)
+      w = WaveFile.open(path)
+      @sounds[name] = w
+    
+      if w.num_channels > @num_channels
+        @num_channels = w.num_channels
+      end
+      if w.bits_per_sample > @bits_per_sample
+        @bits_per_sample = w.bits_per_sample
+      end
+    end
+  end
+  
+  def get_sample_data(name)
+    w = @sounds[name]
+    
+    if w == nil
+      raise StandardError, "Kit doesn't contain sound '#{name}'."
+    else
+      w.num_channels = @num_channels
+      w.bits_per_sample = @bits_per_sample
+
+      return w.sample_data
+    end
+  end
+  
+  def size
+    return @sounds.length
+  end
+  
+  attr_reader :bits_per_sample, :num_channels
+end

data/lib/pattern.rb

@@ -0,0 +1,122 @@
+class Pattern
+  def initialize(name)
+    @name = name
+    @tracks = {}
+  end
+  
+  def track(name, wave_data, pattern)
+    new_track = Track.new(name, wave_data, pattern)        
+    @tracks[new_track.name] = new_track
+    
+    # If the new track is longer than any of the previously added tracks,
+    # pad the other tracks with trailing . to make them all the same length.
+    # Necessary to prevent incorrect overflow calculations for tracks.
+    longest_track_length = 0
+    @tracks.values.each {|track|
+      if(track.pattern.length > longest_track_length)
+        longest_track_length = track.pattern.length
+      end
+    }
+    @tracks.values.each {|track|
+      if(track.pattern.length < longest_track_length)
+        track.pattern += "." * (longest_track_length - track.pattern.length)
+      end
+    }
+    
+    return new_track
+  end
+  
+  def sample_length(tick_sample_length)
+    @tracks.keys.collect {|track_name| @tracks[track_name].sample_length(tick_sample_length) }.max || 0
+  end
+  
+  def sample_length_with_overflow(tick_sample_length)
+    @tracks.keys.collect {|track_name| @tracks[track_name].sample_length_with_overflow(tick_sample_length) }.max || 0
+  end
+  
+  def sample_data(tick_sample_length, num_channels, num_tracks_in_song, incoming_overflow, split = false)
+    if(split)
+      return split_sample_data(tick_sample_length, num_channels, incoming_overflow)
+    else
+      return combined_sample_data(tick_sample_length, num_channels, num_tracks_in_song, incoming_overflow)
+    end
+  end
+  
+  attr_accessor :tracks, :name
+
+private
+
+  def combined_sample_data(tick_sample_length, num_channels, num_tracks_in_song, incoming_overflow)
+    fill_value = (num_channels == 1) ? 0 : [].fill(0, 0, num_channels)
+    track_names = @tracks.keys
+    primary_sample_data = []
+    overflow_sample_data = {}
+    actual_sample_length = sample_length(tick_sample_length)
+
+    if(track_names.length > 0)
+      primary_sample_data = [].fill(fill_value, 0, actual_sample_length)
+
+      track_names.each {|track_name|
+        temp = @tracks[track_name].sample_data(tick_sample_length, incoming_overflow[track_name])
+
+        track_samples = temp[:primary]
+        if(num_channels == 1)
+          (0...track_samples.length).each {|i| primary_sample_data[i] += track_samples[i] }
+        else
+          (0...track_samples.length).each {|i|
+            primary_sample_data[i] = [primary_sample_data[i][0] + track_samples[i][0],
+                                      primary_sample_data[i][1] + track_samples[i][1]]
+          }
+        end
+
+        overflow_sample_data[track_name] = temp[:overflow]
+      }
+    end
+    
+    # Add samples for tracks with overflow from previous pattern, but not
+    # contained in current pattern.
+    incoming_overflow.keys.each {|track_name|
+      if(!track_names.member?(track_name) && incoming_overflow[track_name].length > 0)
+        if(num_channels == 1)
+          (0...incoming_overflow[track_name].length).each {|i| primary_sample_data[i] += incoming_overflow[track_name][i]}
+        else
+          (0...incoming_overflow[track_name].length).each {|i| primary_sample_data[i][0] += incoming_overflow[track_name][i][0]
+                                                               primary_sample_data[i][1] += incoming_overflow[track_name][i][1]}
+        end
+      end
+    }
+    
+    # Mix down the tracks into one
+    if(num_channels == 1)
+      primary_sample_data = primary_sample_data.map {|sample| (sample / num_tracks_in_song).round }
+    else
+      primary_sample_data = primary_sample_data.map {|sample| [(sample[0] / num_tracks_in_song).round, (sample[1] / num_tracks_in_song).round] }
+    end
+    
+    return {:primary => primary_sample_data, :overflow => overflow_sample_data}
+  end
+
+  def split_sample_data(tick_sample_length, num_channels, incoming_overflow)
+    fill_value = (num_channels == 1) ? 0 : [].fill(0, 0, num_channels)
+    primary_sample_data = {}
+    overflow_sample_data = {}
+    
+    @tracks.keys.each {|track_name|
+      temp = @tracks[track_name].sample_data(tick_sample_length, incoming_overflow[track_name])
+      primary_sample_data[track_name] = temp[:primary]
+      overflow_sample_data[track_name] = temp[:overflow]
+    }
+    
+    incoming_overflow.keys.each {|track_name|
+      if(@tracks[track_name] == nil)
+        # TO DO: Add check for when incoming overflow is longer than
+        # track full length to prevent track from lengthening.
+        primary_sample_data[track_name] = [].fill(fill_value, 0, sample_length(tick_sample_length))
+        primary_sample_data[track_name][0...incoming_overflow[track_name].length] = incoming_overflow[track_name]
+        overflow_sample_data[track_name] = []
+      end
+    }
+    
+    return {:primary => primary_sample_data, :overflow => overflow_sample_data}
+  end
+end

data/lib/song.rb

@@ -0,0 +1,294 @@
+class SongParseError < RuntimeError; end
+
+class Song
+  SAMPLE_RATE = 44100
+  SECONDS_PER_MINUTE = 60.0
+  PATH_SEPARATOR = File.const_get("SEPARATOR")
+
+  def initialize(input_path, definition = nil)
+    self.tempo = 120
+    @input_path = input_path
+    @kit = Kit.new()
+    @patterns = {}
+    @structure = []
+
+    if(definition != nil)
+      parse(definition)
+    end
+  end
+
+  def pattern(name)
+    @patterns[name] = Pattern.new(name)
+    return @patterns[name]
+  end
+
+  def sample_length()
+    @structure.inject(0) {|sum, pattern_name|
+      sum + @patterns[pattern_name].sample_length(@tick_sample_length)
+    }
+  end
+
+  def sample_length_with_overflow()
+    if(@structure.length == 0)
+      return 0
+    end
+    
+    full_sample_length = self.sample_length
+    last_pattern_sample_length = @patterns[@structure.last].sample_length(@tick_sample_length)
+    last_pattern_overflow_length = @patterns[@structure.last].sample_length_with_overflow(@tick_sample_length)
+    overflow = last_pattern_overflow_length - last_pattern_sample_length
+
+    return sample_length + overflow
+  end
+  
+  def total_tracks()
+    @patterns.keys.collect {|pattern_name| @patterns[pattern_name].tracks.length }.max || 0
+  end
+
+  def sample_data(pattern_name, split)
+    num_tracks_in_song = self.total_tracks()
+    fill_value = (@kit.num_channels == 1) ? 0 : [].fill(0, 0, @kit.num_channels)
+
+    if(pattern_name == "")      
+      if(split)
+        return sample_data_split_all_patterns(fill_value, num_tracks_in_song)
+      else
+        return sample_data_combined_all_patterns(fill_value, num_tracks_in_song)
+      end
+    else
+      pattern = @patterns[pattern_name.downcase.to_sym]
+      
+      if(pattern == nil)
+        raise StandardError, "Pattern '#{pattern_name}' not found in song."
+      else
+        primary_sample_length = pattern.sample_length(@tick_sample_length)
+      
+        if(split)
+          return sample_data_split_single_pattern(fill_value, num_tracks_in_song, pattern, primary_sample_length)
+        else
+          return sample_data_combined_single_pattern(fill_value, num_tracks_in_song, pattern, primary_sample_length)
+        end
+      end
+    end
+  end
+
+  def num_channels()
+    return @kit.num_channels
+  end
+  
+  def bits_per_sample()
+    return @kit.bits_per_sample
+  end
+
+  def tempo()
+    return @tempo
+  end
+
+  def tempo=(new_tempo)
+    if(new_tempo.class != Fixnum || new_tempo <= 0)
+      raise SongParseError, "Invalid tempo: '#{new_tempo}'. Tempo must be a number greater than 0."
+    end
+    
+    @tempo = new_tempo
+    @tick_sample_length = (SAMPLE_RATE * SECONDS_PER_MINUTE) / new_tempo / 4.0
+  end
+
+  attr_reader :input_path, :tick_sample_length
+  attr_accessor :structure
+
+private
+
+  def merge_overflow(overflow, num_tracks_in_song)
+    merged_sample_data = []
+
+    if(overflow != {})
+      longest_overflow = overflow[overflow.keys.first]
+      overflow.keys.each {|track_name|
+        if(overflow[track_name].length > longest_overflow.length)
+          longest_overflow = overflow[track_name]
+        end
+      }
+
+      final_overflow_pattern = Pattern.new(:overflow)
+      final_overflow_pattern.track "", [], "."
+      final_overflow_sample_data = final_overflow_pattern.sample_data(longest_overflow.length, @kit.num_channels, num_tracks_in_song, overflow, false)
+      merged_sample_data = final_overflow_sample_data[:primary]
+    end
+
+    return merged_sample_data
+  end
+
+  # Converts all hash keys to be lowercase
+  def downcase_hash_keys(hash)
+    return hash.inject({}) {|new_hash, pair|
+        new_hash[pair.first.downcase] = pair.last
+        new_hash
+    }
+  end
+
+  def parse(definition)
+    if(definition.class == String)
+      song_definition = YAML.load(definition)
+    elsif(definition.class == Hash)
+      song_definition = definition
+    else
+      raise StandardError, "Invalid song input"
+    end
+
+    @kit = build_kit(song_definition)
+
+    song_definition = downcase_hash_keys(song_definition)
+    
+    # Process each pattern
+    song_definition.keys.each{|key|
+      if(key != "song")
+        new_pattern = self.pattern key.to_sym
+
+        track_list = song_definition[key]
+        track_list.each{|track_definition|
+          track_name = track_definition.keys.first
+          new_pattern.track track_name, @kit.get_sample_data(track_name), track_definition[track_name]
+        }
+      end
+    }
+    
+    # Process song header
+    parse_song_header(downcase_hash_keys(song_definition["song"]))
+  end
+  
+  def parse_song_header(header_data)
+    self.tempo = header_data["tempo"]
+
+    pattern_list = header_data["structure"]
+    structure = []
+    pattern_list.each{|pattern_item|
+      if(pattern_item.class == String)
+        pattern_item = {pattern_item => "x1"}
+      end
+      
+      pattern_name = pattern_item.keys.first
+      pattern_name_sym = pattern_name.downcase.to_sym
+      
+      if(!@patterns.has_key?(pattern_name_sym))
+        raise SongParseError, "Song structure includes non-existant pattern: #{pattern_name}."
+      end
+      
+      multiples_str = pattern_item[pattern_name]
+      multiples_str.slice!(0)
+      multiples = multiples_str.to_i
+      
+      if(multiples_str.match(/[^0-9]/) != nil)
+        raise SongParseError, "'#{multiples_str}' is an invalid number of repeats for pattern '#{pattern_name}'. Number of repeats should be a whole number."
+      elsif(multiples < 0)
+        raise SongParseError, "'#{multiples_str}' is an invalid number of repeats for pattern '#{pattern_name}'. Must be 0 or greater."
+      end
+      
+      multiples.times { structure << pattern_name_sym }
+    }
+
+    @structure = structure
+  end
+  
+  def build_kit(song_definition)
+    kit = Kit.new()
+    
+    song_definition.keys.each{|key|
+      if(key.downcase != "song")
+        track_list = song_definition[key]
+        track_list.each{|track_definition|
+          track_name = track_definition.keys.first
+          track_path = track_name
+          if(!track_path.start_with?(PATH_SEPARATOR))
+            track_path = @input_path + PATH_SEPARATOR + track_path
+          end
+          
+          if(!File.exists? track_path)
+            raise SongParseError, "File '#{track_name}' not found for pattern '#{key}'"
+          end
+          
+          kit.add(track_name, track_path)
+        }
+      end
+    }
+    
+    return kit
+  end
+  
+  def sample_data_split_all_patterns(fill_value, num_tracks_in_song)
+    output_data = {}
+    
+    offset = 0
+    overflow = {}
+    @structure.each {|pattern_name|
+      pattern_sample_length = @patterns[pattern_name].sample_length(@tick_sample_length)
+      pattern_sample_data = @patterns[pattern_name].sample_data(@tick_sample_length, @kit.num_channels, num_tracks_in_song, overflow, true)
+      
+      pattern_sample_data[:primary].keys.each {|track_name|
+        if(output_data[track_name] == nil)
+          output_data[track_name] = [].fill(fill_value, 0, self.sample_length_with_overflow())
+        end
+
+        output_data[track_name][offset...(offset + pattern_sample_length)] = pattern_sample_data[:primary][track_name]
+      }
+      
+      overflow.keys.each {|track_name|
+        if(pattern_sample_data[:primary][track_name] == nil)
+          output_data[track_name][offset...overflow[track_name].length] = overflow[track_name]
+        end
+      }
+      
+      overflow = pattern_sample_data[:overflow]
+      offset += pattern_sample_length
+    }
+
+    overflow.keys.each {|track_name|
+      output_data[track_name][offset...overflow[track_name].length] = overflow[track_name]
+    }
+
+    return output_data
+  end
+  
+  def sample_data_split_single_pattern(fill_value, num_tracks_in_song, pattern, primary_sample_length)
+    output_data = {}
+    
+    pattern_sample_length = pattern.sample_length(@tick_sample_length)
+    pattern_sample_data = pattern.sample_data(@tick_sample_length, @kit.num_channels, num_tracks_in_song, {}, true)
+    
+    pattern_sample_data[:primary].keys.each {|track_name|
+      overflow_sample_length = pattern_sample_data[:overflow][track_name].length
+      full_sample_length = pattern_sample_length + overflow_sample_length
+      output_data[track_name] = [].fill(fill_value, 0, full_sample_length)
+      output_data[track_name][0...pattern_sample_length] = pattern_sample_data[:primary][track_name]
+      output_data[track_name][pattern_sample_length...full_sample_length] = pattern_sample_data[:overflow][track_name]
+    }
+    
+    return output_data
+  end
+  
+  def sample_data_combined_all_patterns(fill_value, num_tracks_in_song)
+    output_data = [].fill(fill_value, 0, self.sample_length_with_overflow)
+
+    offset = 0
+    overflow = {}
+    @structure.each {|pattern_name|
+      pattern_sample_length = @patterns[pattern_name].sample_length(@tick_sample_length)
+      pattern_sample_data = @patterns[pattern_name].sample_data(@tick_sample_length, @kit.num_channels, num_tracks_in_song, overflow)
+      output_data[offset...offset + pattern_sample_length] = pattern_sample_data[:primary]
+      overflow = pattern_sample_data[:overflow]
+      offset += pattern_sample_length
+    }
+    
+    # Handle overflow from final pattern
+    output_data[offset...output_data.length] = merge_overflow(overflow, num_tracks_in_song)
+    return output_data
+  end
+  
+  def sample_data_combined_single_pattern(fill_value, num_tracks_in_song, pattern, primary_sample_length)
+    output_data = [].fill(fill_value, 0, pattern.sample_length_with_overflow(@tick_sample_length))
+    sample_data = pattern.sample_data(tick_sample_length, @kit.num_channels, num_tracks_in_song, {}, false)
+    output_data[0...primary_sample_length] = sample_data[:primary]
+    output_data[primary_sample_length...output_data.length] = merge_overflow(sample_data[:overflow], num_tracks_in_song)
+
+    return output_data
+  end
+end