beats 1.3.0 → 2.0.0

data/lib/beats/kit_builder.rb

@@ -0,0 +1,74 @@
+module Beats
+  class KitBuilder
+    # Raised when trying to load a sound file which can't be found at the path specified
+    class SoundFileNotFoundError < RuntimeError; end
+
+    # Raised when trying to load a sound file which either isn't actually a sound file, or
+    # is in an unsupported format.
+    class InvalidSoundFormatError < RuntimeError; end
+
+    BITS_PER_SAMPLE = 16
+    SAMPLE_FORMAT = "pcm_#{BITS_PER_SAMPLE}".to_sym
+    SAMPLE_RATE = 44100
+
+    def initialize(base_path)
+      @base_path = base_path
+      @labels_to_filenames = {}
+    end
+
+    def add_item(label, filename)
+      @labels_to_filenames[label] = absolute_file_name(filename)
+    end
+
+    def has_label?(label)
+      @labels_to_filenames.keys.include?(label)
+    end
+
+    def build_kit
+      # Load each sample buffer
+      filenames_to_buffers = {}
+      @labels_to_filenames.values.uniq.each do |filename|
+        filenames_to_buffers[filename] = load_sample_buffer(filename)
+      end
+
+      # Convert each buffer to the same sample format
+      num_channels = filenames_to_buffers.values.map(&:channels).max || 1
+      canonical_format = WaveFile::Format.new(num_channels, SAMPLE_FORMAT, SAMPLE_RATE)
+      filenames_to_buffers.values.each {|buffer| buffer.convert!(canonical_format) }
+
+      labels_to_buffers = {}
+      @labels_to_filenames.each do |label, filename|
+        labels_to_buffers[label] = filenames_to_buffers[filename].samples
+      end
+      labels_to_buffers[Kit::PLACEHOLDER_TRACK_NAME] = []
+
+      Kit.new(labels_to_buffers, num_channels, BITS_PER_SAMPLE)
+    end
+
+    private
+
+    # Converts relative path into absolute path. Note that this will also handle
+    # expanding ~ on platforms that support that.
+    def absolute_file_name(filename)
+      File.expand_path(filename, @base_path)
+    end
+
+    def load_sample_buffer(filename)
+      sample_buffer = nil
+
+      begin
+        reader = WaveFile::Reader.new(filename)
+        reader.each_buffer(reader.total_sample_frames) do |buffer|
+          sample_buffer = buffer
+        end
+      rescue Errno::ENOENT
+        raise SoundFileNotFoundError, "Sound file #{filename} not found."
+      rescue StandardError
+        raise InvalidSoundFormatError, "Sound file #{filename} is either not a sound file, " +
+                                       "or is in an unsupported format. BEATS can handle 8, 16, 24, or 32-bit PCM *.wav files."
+      end
+
+      sample_buffer
+    end
+  end
+end

data/lib/beats/pattern.rb

@@ -5,8 +5,6 @@ module Beats
   # This object is like sheet music; the AudioEngine is responsible creating actual
   # audio data for a Pattern (with the help of a Kit).
   class Pattern
-    FLOW_TRACK_NAME = "flow"
-
     def initialize(name)
       @name = name
       @tracks = {}
@@ -21,7 +19,7 @@ module Beats
       # 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 = step_count()
+      longest_track_length = step_count
       @tracks.values.each do |track|
         if track.rhythm.length < longest_track_length
           track.rhythm += "." * (longest_track_length - track.rhythm.length)
@@ -49,25 +47,7 @@ module Beats
       @tracks.length == other_pattern.tracks.length
     end
 
-    # Returns a YAML representation of the Pattern. Produces nicer looking output than the default
-    # version of to_yaml().
-    def to_yaml
-      longest_track_name_length =
-        @tracks.keys.inject(0) do |max_length, name|
-          (name.to_s.length > max_length) ? name.to_s.length : max_length
-        end
-      ljust_amount = longest_track_name_length + 7
-
-      yaml = "#{@name.to_s.capitalize}:\n"
-      @tracks.keys.sort.each do |track_name|
-        yaml += "  - #{track_name}:".ljust(ljust_amount)
-        yaml += "#{@tracks[track_name].rhythm}\n"
-      end
-
-      yaml
-    end
-
-    attr_accessor :tracks, :name
+    attr_reader :tracks, :name
 
   private
 

data/lib/beats/song.rb

@@ -1,7 +1,4 @@
 module Beats
-  class InvalidTempoError < RuntimeError; end
-
-
   # Domain object which models the 'sheet music' for a full song. Models the Patterns
   # that should be played, in which order (i.e. the flow), and at which tempo.
   #
@@ -10,6 +7,8 @@ module Beats
   # A Kit provides the sample data for each of these sounds. With a Song and a Kit
   # the AudioEngine can produce the audio data that is saved to disk.
   class Song
+    class InvalidTempoError < RuntimeError; end
+
     DEFAULT_TEMPO = 120
 
     def initialize
@@ -21,7 +20,6 @@ module Beats
     # Adds a new pattern to the song, with the specified name.
     def pattern(name)
       @patterns[name] = Pattern.new(name)
-      @patterns[name]
     end
 
 
@@ -52,7 +50,7 @@ module Beats
     end
 
     def tempo=(new_tempo)
-      unless (new_tempo.class == Fixnum || new_tempo.class == Float) && new_tempo > 0
+      unless (new_tempo.is_a?(Integer) || new_tempo.class == Float) && new_tempo > 0
         raise InvalidTempoError, "Invalid tempo: '#{new_tempo}'. Tempo must be a number greater than 0."
       end
 
@@ -61,7 +59,7 @@ module Beats
 
     # Returns a new Song that is identical but with no patterns or flow.
     def copy_ignoring_patterns_and_flow
-      copy = Song.new()
+      copy = Song.new
       copy.tempo = @tempo
 
       copy
@@ -75,7 +73,7 @@ module Beats
       track_names = track_names()
 
       track_names.each do |track_name|
-        new_song = copy_ignoring_patterns_and_flow()
+        new_song = copy_ignoring_patterns_and_flow
 
         @patterns.each do |name, original_pattern|
           new_pattern = new_song.pattern(name)
@@ -102,23 +100,6 @@ module Beats
       @patterns.reject! {|k, pattern| !@flow.member?(pattern.name) }
     end
 
-    # Serializes the current Song to a YAML string. This string can then be used to construct a new Song
-    # using the SongParser class. This lets you save a Song to disk, to be re-loaded later. Produces nicer
-    # looking output than the default version of to_yaml().
-    def to_yaml(kit)
-      # This implementation intentionally builds up a YAML string manually instead of using YAML::dump().
-      # Ruby 1.8 makes it difficult to ensure a consistent ordering of hash keys, which makes the output ugly
-      # and also hard to test.
-
-      yaml_output = "Song:\n"
-      yaml_output += "  Tempo: #{@tempo}\n"
-      yaml_output += flow_to_yaml()
-      yaml_output += kit.to_yaml(2)
-      yaml_output += patterns_to_yaml()
-
-      yaml_output
-    end
-
     attr_reader :patterns, :tempo
     attr_accessor :flow
 
@@ -127,36 +108,5 @@ module Beats
     def longest_length_in_array(arr)
       arr.inject(0) {|max_length, name| [name.to_s.length, max_length].max }
     end
-
-    def flow_to_yaml
-      yaml_output = "  Flow:\n"
-      ljust_amount = longest_length_in_array(@flow) + 1  # The +1 is for the trailing ":"
-      previous = nil
-      count = 0
-      @flow.each do |pattern_name|
-        if pattern_name == previous || previous.nil?
-          count += 1
-        else
-          yaml_output += "    - #{(previous.to_s.capitalize + ':').ljust(ljust_amount)}  x#{count}\n"
-          count = 1
-        end
-        previous = pattern_name
-      end
-      yaml_output += "    - #{(previous.to_s.capitalize + ':').ljust(ljust_amount)}  x#{count}\n"
-
-      yaml_output
-    end
-
-    def patterns_to_yaml
-      yaml_output = ""
-
-      # Sort to ensure a consistent order, to make testing easier
-      pattern_names = @patterns.keys.map {|key| key.to_s}  # Ruby 1.8 can't sort symbols...
-      pattern_names.sort.each do |pattern_name|
-        yaml_output += "\n" + @patterns[pattern_name.to_sym].to_yaml()
-      end
-
-      yaml_output
-    end
   end
 end

data/lib/beats/songoptimizer.rb

@@ -20,7 +20,7 @@ module Beats
     # generated faster.
     def optimize(original_song, max_pattern_length)
       # 1.) Create a new song, cloned from the original
-      optimized_song = original_song.copy_ignoring_patterns_and_flow()
+      optimized_song = original_song.copy_ignoring_patterns_and_flow
 
       # 2.) Subdivide patterns
       optimized_song = subdivide_song_patterns(original_song, optimized_song, max_pattern_length)
@@ -82,7 +82,7 @@ module Beats
           # Otherwise, this pattern will have no steps, and no sound will be generated,
           # causing the pattern to be "compacted away".
           if new_pattern.tracks.empty?
-            new_pattern.track("placeholder", blank_track_pattern)
+            new_pattern.track(Kit::PLACEHOLDER_TRACK_NAME, blank_track_pattern)
           end
 
           step_index += max_pattern_length
@@ -122,7 +122,7 @@ module Beats
       song.flow = new_flow
 
       # This isn't strictly necessary, but makes resulting songs easier to read for debugging purposes.
-      song.remove_unused_patterns()
+      song.remove_unused_patterns
 
       song
     end

data/lib/beats/songparser.rb

@@ -1,7 +1,4 @@
 module Beats
-  class SongParseError < RuntimeError; end
-
-
   # This class is used to parse a raw YAML song definition into domain objects (i.e.
   # Song, Pattern, Track, and Kit). These domain objects can then be used by AudioEngine
   # to generate the actual audio data that is saved to disk.
@@ -9,11 +6,7 @@ module Beats
   # The sole public method is parse(). It takes a raw YAML string and returns a Song and
   # Kit object (or raises an error if the YAML string couldn't be parsed correctly).
   class SongParser
-    DONT_USE_STRUCTURE_WARNING =
-        "\n" +
-        "WARNING! This song contains a 'Structure' section in the header.\n" +
-        "As of BEATS 1.2.1, the 'Structure' section should be renamed 'Flow'.\n" +
-        "You should change your song file, in a future version using 'Structure' will cause an error.\n"
+    class ParseError < RuntimeError; end
 
     NO_SONG_HEADER_ERROR_MSG =
   "Song must have a header. Here's an example:
@@ -43,17 +36,17 @@ module Beats
         unless raw_song_components[:tempo].nil?
           song.tempo = raw_song_components[:tempo]
         end
-      rescue InvalidTempoError => detail
-        raise SongParseError, "#{detail}"
+      rescue Song::InvalidTempoError => detail
+        raise ParseError, "#{detail}"
       end
 
       # 2.) Build the kit
       begin
         kit = build_kit(base_path, raw_song_components[:kit], raw_song_components[:patterns])
-      rescue SoundFileNotFoundError => detail
-        raise SongParseError, "#{detail}"
-      rescue InvalidSoundFormatError => detail
-        raise SongParseError, "#{detail}"
+      rescue KitBuilder::SoundFileNotFoundError => detail
+        raise ParseError, "#{detail}"
+      rescue KitBuilder::InvalidSoundFormatError => detail
+        raise ParseError, "#{detail}"
       end
 
       # 3.) Load patterns
@@ -61,7 +54,7 @@ module Beats
 
       # 4.) Set flow
       if raw_song_components[:flow].nil?
-        raise SongParseError, "Song must have a Flow section in the header."
+        raise ParseError, "Song must have a Flow section in the header."
       else
         set_song_flow(song, raw_song_components[:flow])
       end
@@ -70,8 +63,8 @@ module Beats
       if raw_song_components[:swing]
         begin
           song = Transforms::SongSwinger.transform(song, raw_song_components[:swing])
-        rescue Transforms::InvalidSwingRateError => detail
-          raise SongParseError, "#{detail}"
+        rescue Transforms::SongSwinger::InvalidSwingRateError => detail
+          raise ParseError, "#{detail}"
         end
       end
 
@@ -85,8 +78,10 @@ module Beats
     def hashify_raw_yaml(raw_yaml_string)
       begin
         raw_song_definition = YAML.load(raw_yaml_string)
+      rescue Psych::SyntaxError => detail
+        raise ParseError, "Syntax error in YAML file: #{detail}"
       rescue ArgumentError => detail
-        raise SongParseError, "Syntax error in YAML file"
+        raise ParseError, "Syntax error in YAML file: #{detail}"
       end
 
       raw_song_components = {}
@@ -95,23 +90,13 @@ module Beats
       unless raw_song_components[:full_definition]["song"].nil?
         raw_song_components[:header] = downcase_hash_keys(raw_song_components[:full_definition]["song"])
       else
-        raise SongParseError, NO_SONG_HEADER_ERROR_MSG
+        raise ParseError, NO_SONG_HEADER_ERROR_MSG
       end
       raw_song_components[:tempo]     = raw_song_components[:header]["tempo"]
       raw_song_components[:folder]    = raw_song_components[:header]["folder"]
       raw_song_components[:kit]       = raw_song_components[:header]["kit"]
 
-      raw_flow = raw_song_components[:header]["flow"]
-      raw_structure = raw_song_components[:header]["structure"]
-      unless raw_flow.nil?
-        raw_song_components[:flow]    = raw_flow
-      else
-        unless raw_structure.nil?
-          puts DONT_USE_STRUCTURE_WARNING
-        end
-
-        raw_song_components[:flow]    = raw_structure
-      end
+      raw_song_components[:flow] = raw_song_components[:header]["flow"]
 
       raw_song_components[:swing]   = raw_song_components[:header]["swing"]
       raw_song_components[:patterns]  = raw_song_components[:full_definition].reject {|k, v| k == "song"}
@@ -119,23 +104,19 @@ module Beats
       return raw_song_components
     end
 
-
     def build_kit(base_path, raw_kit, raw_patterns)
-      kit_items = {}
+      kit_builder = KitBuilder.new(base_path)
 
       # Add sounds defined in the Kit section of the song header
       # Converts [{a=>1}, {b=>2}, {c=>3}] from raw YAML to {a=>1, b=>2, c=>3}
       # TODO: Raise error is same name is defined more than once in the Kit
       unless raw_kit.nil?
         raw_kit.each do |kit_item|
-          kit_items[kit_item.keys.first] = kit_item.values.first
+          kit_builder.add_item(kit_item.keys.first, kit_item.values.first)
         end
       end
 
       # Add sounds not defined in Kit section, but used in individual tracks
-      # TODO Investigate detecting duplicate keys already defined in the Kit section, as this could possibly
-      # result in a performance improvement when the sound has to be converted to a different bit rate/num channels,
-      # as well as use less memory.
       raw_patterns.keys.each do |key|
         track_list = raw_patterns[key]
 
@@ -144,30 +125,28 @@ module Beats
             track_name = track_definition.keys.first
             track_path = track_name
 
-            if track_name != Pattern::FLOW_TRACK_NAME && kit_items[track_name].nil?
-              kit_items[track_name] = track_path
+            if !kit_builder.has_label?(track_name)
+              kit_builder.add_item(track_name, track_path)
             end
           end
         end
       end
 
-      Kit.new(base_path, kit_items)
+      kit_builder.build_kit
     end
 
-
     def add_patterns_to_song(song, raw_patterns)
       raw_patterns.keys.each do |key|
         new_pattern = song.pattern key.to_sym
 
         track_list = raw_patterns[key]
-        # TODO Also raise error if only there is only 1 track and it's a flow track
+
         if track_list.nil?
           # TODO: Use correct capitalization of pattern name in error message
           # TODO: Possibly allow if pattern not referenced in the Flow, or has 0 repeats?
-          raise SongParseError, "Pattern '#{key}' has no tracks. It needs at least one."
+          raise ParseError, "Pattern '#{key}' has no tracks. It needs at least one."
         end
 
-        # TODO: What if there is more than one flow? Raise error, or have last one win?
         track_list.each do |track_definition|
           track_name = track_definition.keys.first
 
@@ -197,16 +176,16 @@ module Beats
         multiples = multiples_str.to_i
 
         unless multiples_str.match(/[^0-9]/).nil?
-          raise SongParseError,
+          raise ParseError,
                 "'#{multiples_str}' is an invalid number of repeats for pattern '#{pattern_name}'. Number of repeats should be a whole number."
         else
           if multiples < 0
-            raise SongParseError, "'#{multiples_str}' is an invalid number of repeats for pattern '#{pattern_name}'. Must be 0 or greater."
+            raise ParseError, "'#{multiples_str}' is an invalid number of repeats for pattern '#{pattern_name}'. Must be 0 or greater."
           elsif multiples > 0 && !song.patterns.has_key?(pattern_name_sym)
             # This test is purposefully designed to only throw an error if the number of repeats is greater
             # than 0. This allows you to specify an undefined pattern in the flow with "x0" repeats.
             # This can be convenient for defining the flow before all patterns have been added to the song file.
-            raise SongParseError, "Song flow includes non-existent pattern: #{pattern_name}."
+            raise ParseError, "Song flow includes non-existent pattern: #{pattern_name}."
           end
         end
 

data/lib/beats/track.rb

@@ -1,57 +1,46 @@
 module Beats
-  class InvalidRhythmError < RuntimeError; end
-
-
   # Domain object which models a kit sound playing a rhythm. For example,
   # a bass drum playing every quarter note for two measures.
   #
   # This object is like sheet music; the AudioEngine is responsible creating actual
   # audio data for a Track (with the help of a Kit).
   class Track
+    class InvalidRhythmError < RuntimeError; end
+
     REST = "."
     BEAT = "X"
     BARLINE = "|"
+    SPACE = " "
+    DISALLOWED_CHARACTERS = /[^X\.]/   # I.e., anything not an 'X' or a '.'
 
     def initialize(name, rhythm)
-      # TODO: Add validation for input parameters
       @name = name
       self.rhythm = rhythm
     end
 
-    # TODO: What to have this invoked when setting like this?
-    #   track.rhythm[x..y] = whatever
     def rhythm=(rhythm)
       @rhythm = rhythm.delete(BARLINE)
-      beats = []
-
-      beat_length = 0
-      #rhythm.each_char{|ch|
-      @rhythm.each_byte do |ch|
-        ch = ch.chr
-        if ch == BEAT
-          beats << beat_length
-          beat_length = 1
-        elsif ch == REST
-          beat_length += 1
-        else
-          raise InvalidRhythmError, "Track #{@name} has an invalid rhythm: '#{rhythm}'. Can only contain '#{BEAT}', '#{REST}' or '#{BARLINE}'"
-        end
-      end
-
-      if beat_length > 0
-        beats << beat_length
-      end
-      if beats == []
-        beats = [0]
-      end
-      @beats = beats
+      @rhythm = @rhythm.delete(SPACE)
+      @trigger_step_lengths = calculate_trigger_step_lengths
     end
 
     def step_count
       @rhythm.length
     end
 
-    attr_accessor :name
-    attr_reader :rhythm, :beats
+    attr_reader :name, :rhythm, :trigger_step_lengths
+
+    private
+
+    def calculate_trigger_step_lengths
+      if @rhythm.match(DISALLOWED_CHARACTERS)
+        raise InvalidRhythmError, "Track #{@name} has an invalid rhythm: '#{rhythm}'. Can only contain '#{BEAT}', '#{REST}', '#{BARLINE}', or ' '"
+      end
+
+      trigger_step_lengths = @rhythm.scan(/X?\.*/)[0..-2].map(&:length)
+      trigger_step_lengths.unshift(0) unless @rhythm.start_with?(REST)
+
+      trigger_step_lengths
+    end
   end
 end