beats 1.3.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc3e2d1d7e7730ec749de9aacb9446ef847cfcbd
-  data.tar.gz: 42bff66e1caa2ff6ff503e57aac501ac36c0d445
+  metadata.gz: 386d1a9b9e83c848b2f9ae9c802f1ce9c717c99a
+  data.tar.gz: 287a1390bed816c4bcf65bb5749af04297d8bfd9
 SHA512:
-  metadata.gz: c5782528094a11cd93d7a49fa944787fd8150066ebc8f72a75253c4fd1326ae106c58fdb337591f815f4bf4cc85b58fdae497660e96c86789d365b833a72b15f
-  data.tar.gz: 666d0a00cf0da6f21e7c1476ded37fd97b41db884add895aff0e627a8e0e9bebbd6c8ee6f5f76d4a2f5916e9d9e83c203846082bc9ce0fad78a681000e0c87be
+  metadata.gz: dd8197163c74429d9e1ba1c5ded23af90f423ac48702e085732c5476e788064f497854d585da512f0babd1fb2ad85119fa21caea591e821105e4133cfa8ab443
+  data.tar.gz: 24f11590f134ee21e801d463c6be28334f009ab2da5294b27aa23af2db7ab27550817a61a6db1c3b699ae821e351f1c892da2f2644252ed2bd8faebe4f908236

data/LICENSE

@@ -1,6 +1,6 @@
 == BEATS
 
-# Copyright (c) 2010-14 Joel Strait
+# Copyright (c) 2010-17 Joel Strait
 #
 # Permission is hereby granted, free of charge, to any person
 # obtaining a copy of this software and associated documentation

data/README.markdown

@@ -13,13 +13,13 @@ Beats is a command-line drum machine written in pure Ruby. Feed it a song notate
         - snare:    roland_tr_909_2.wav
         - hihat:    house_2_5.wav
         - cowbell:  big_beat_5.wav
-        - deep:     house_2_2.wav  
-    
+        - deep:     house_2_2.wav
+
     Verse:
       - bass:     X..X...X..X.....
       - snare:    ....X.......X...
       - hihat:    ..X...X...X...X.
-    
+
     Chorus:
       - bass:     X..X...X..X.....
       - snare:    ....X.......X...
@@ -29,48 +29,13 @@ Beats is a command-line drum machine written in pure Ruby. Feed it a song notate
 
 And [here's what it sounds like](http://beatsdrummachine.com/media/beat.mp3) after getting the Beats treatment. What a glorious groove!
 
-
-Current Status
---------------
-
-The latest stable version of Beats is 1.3.0, released on March 4, 2013.
-
-This release is for all you swingers out there. A new `Swing` declaration in the song header will cause the song to be played with either a swung 8th note or swung 16th note rhythm. For example, take this song:
-
-    Song:
-      Tempo: 120
-      Flow:
-        - Verse: x4
-
-    Verse:
-    - bass.wav:   X...X...X...X...
-    - snare.wav:  ....X.......X...
-    - hihat.wav:  X.X.X.X.X.X.X.X.
-
-It will [sound like this](http://beatsdrummachine.com/media/straight.wav).
-
-You can add an 8th note swing like this (notice the 3rd line, everything else is the same):
-
-    Song:
-      Tempo: 120
-      Swing: 8   # Or, 16
-      Flow:
-        - Verse: x4
-
-    Verse:
-    - bass.wav:   X...X...X...X...
-    - snare.wav:  ....X.......X...
-    - hihat.wav:  X.X.X.X.X.X.X.X.
-
-And it will now [sound like this](http://beatsdrummachine.com/media/swing.wav).
-
-This release also includes a small bug fix. When you run the `beats` command with no arguments, it now displays the help screen, rather than an error message.
+For more, check out [beatsdrummachine.com](http://beatsdrummachine.com)
 
 
 Installation
 ------------
 
-To install the latest stable version (1.3.0) from [rubygems.org](http://rubygems.org/gems/beats), run the following from the command line:
+To install the latest stable version (2.0.0) from [rubygems.org](http://rubygems.org/gems/beats), run the following from the command line:
 
     gem install beats
 
@@ -86,7 +51,22 @@ Usage
 
 Beats runs from the command-line. Run `beats -h` to see the available options. For more detailed instructions, visit [https://github.com/jstrait/beats/wiki/Usage](https://github.com/jstrait/beats/wiki/Usage) on the [Beats Wiki](https://github.com/jstrait/beats/wiki).
 
-The Beats wiki also has a [Getting Started](https://github.com/jstrait/beats/wiki/Getting-Started) tutorial which shows how to create an example beat from scratch.
+Check out [this tutorial at beatsdrummachine.com](http://beatsdrummachine.com/tutorial/) to see an example of how to create a beat from sratch.
+
+
+What's New
+----------
+
+The latest stable version of Beats is 2.0.0, released on September 4, 2017. It is primarily a modernization release, and contains some relatively small backwards incompatible changes.
+
+* Track rhythms can now have spaces in them. For example, `X... .... X... ....` is now a valid rhythm. Spaces are ignored, and don't affect the rhythm. For example, `X...    X...` is treated as the same rhythm as `X...X...`
+* Wave files using `WAVEFORMATEXTENSIBLE` format can now be used, due to upgrading the WaveFile gem dependency to v0.8.1 behind the scenes.
+* Installing the gem is now simpler, since it no longer requires installing the legacy `syck` YAML parser via an extension.
+* A `Fixnum is deprecated` message is no longer shown when using Ruby 2.4
+* **Backwards incompatible changes**:
+  * Song files containing a `Structure` section are no longer supported. A `Flow` section should be used instead. Support for the `Structure` section has been deprecated since v1.2.1 (released in 2011).
+  * Track rhythms can no longer start with a `|` character. For example, `|X...X...` is no longer a valid rhythm. However, bar lines are still allowed to appear elsewhere in the rhythm. For example, `X...X...|X...X...|` _is_ a valid rhythm. The reason for this change is that a rhythm starting with `|` is parsed as a YAML scalar block now that Beats is using the Psych YAML library behind the scenes. The fact that the old Syck YAML library didn't treat rhythms starting with a `|` as a YAML scalar block appears to have been a bug in Syck?
+* The minimum supported Ruby version is now 1.9.3, instead of 1.8.7
 
 
 Local Development
@@ -114,5 +94,5 @@ Contact me (Joel Strait) by sending a GitHub message or opening a GitHub issue.
 
 License
 -------
-Beats is released under the MIT license.
+Beats Drum Machine is released under the MIT license.
 

data/bin/beats

@@ -3,9 +3,9 @@
 start_time = Time.now
 
 $:.unshift File.dirname(__FILE__) + "/../lib"
+gem "wavefile", "=0.8.1"
 require "optparse"
 require "yaml"
-require "syck"
 require "wavefile"
 require "beats"
 require "wavefile/cachingwriter"
@@ -13,9 +13,8 @@ require "wavefile/cachingwriter"
 include Beats
 
 USAGE_INSTRUCTIONS = ""
-YAML::ENGINE.yamler = 'syck' if defined?(YAML::ENGINE)
 
-def parse_options()
+def parse_options
   options = {:split => false}
 
   optparse = OptionParser.new do |opts|
@@ -45,9 +44,9 @@ def parse_options()
   end
 
   USAGE_INSTRUCTIONS << optparse.to_s
-  optparse.parse!()
+  optparse.parse!
 
-  return options
+  options
 end
 
 def print_error(error, input_file_name)
@@ -57,7 +56,7 @@ def print_error(error, input_file_name)
     puts USAGE_INSTRUCTIONS
   when Errno::ENOENT
     puts "Song file '#{input_file_name}' not found.\n"
-  when SongParseError
+  when SongParser::ParseError
     puts "Song file '#{input_file_name}' has an error:\n"
     puts "  #{error}\n"
   when StandardError
@@ -70,7 +69,7 @@ def print_error(error, input_file_name)
 end
 
 begin
-  options = parse_options()
+  options = parse_options
 
   if ARGV.empty?
     puts USAGE_INSTRUCTIONS

data/lib/beats.rb

@@ -2,6 +2,7 @@ require 'beats/audioengine'
 require 'beats/audioutils'
 require 'beats/beatsrunner'
 require 'beats/kit'
+require 'beats/kit_builder'
 require 'beats/pattern'
 require 'beats/song'
 require 'beats/songparser'
@@ -10,5 +11,5 @@ require 'beats/track'
 require 'beats/transforms/song_swinger'
 
 module Beats
-  VERSION = "1.3.0"
+  VERSION = "2.0.0"
 end

data/lib/beats/audioengine.rb

@@ -27,7 +27,7 @@ module Beats
       num_tracks_in_song = @song.total_tracks
 
       # Open output wave file and prepare it for writing sample data.
-      format = WaveFile::Format.new(@kit.num_channels, @kit.bits_per_sample, SAMPLE_RATE)
+      format = WaveFile::Format.new(@kit.num_channels, "pcm_#{@kit.bits_per_sample}".to_sym, SAMPLE_RATE)
       writer = WaveFile::CachingWriter.new(output_file_name, format)
 
       # Generate each pattern's sample data, or pull it from cache, and append it to the wave file.
@@ -50,7 +50,7 @@ module Beats
       final_overflow_composite = AudioUtils.scale(final_overflow_composite, format.channels, num_tracks_in_song)
       writer.write(WaveFile::Buffer.new(final_overflow_composite, format))
 
-      writer.close()
+      writer.close
 
       writer.total_duration
     end
@@ -61,27 +61,27 @@ module Beats
 
     # Generates the sample data for a single track, using the specified sound's sample data.
     def generate_track_sample_data(track, sound)
-      beats = track.beats
-      if beats == [0]
+      trigger_step_lengths = track.trigger_step_lengths
+      if trigger_step_lengths == [0]
         return {:primary => [], :overflow => []}    # Is this really what should happen? Why throw away overflow?
       end
 
       fill_value = (@kit.num_channels == 1) ? 0 : [0, 0]
       primary_sample_data = [].fill(fill_value, 0, AudioUtils.step_start_sample(track.step_count, @step_sample_length))
 
-      step_index = beats[0]
-      beat_sample_length = 0
-      beats[1...(beats.length)].each do |beat_step_length|
+      step_index = trigger_step_lengths[0]
+      trigger_sample_length = 0
+      trigger_step_lengths[1...(trigger_step_lengths.length)].each do |trigger_step_length|
         start_sample = AudioUtils.step_start_sample(step_index, @step_sample_length)
         end_sample = [(start_sample + sound.length), primary_sample_data.length].min
-        beat_sample_length = end_sample - start_sample
+        trigger_sample_length = end_sample - start_sample
 
-        primary_sample_data[start_sample...end_sample] = sound[0...beat_sample_length]
+        primary_sample_data[start_sample...end_sample] = sound[0...trigger_sample_length]
 
-        step_index += beat_step_length
+        step_index += trigger_step_length
       end
 
-      overflow_sample_data = (sound == [] || beats.length == 1) ? [] : sound[beat_sample_length...(sound.length)]
+      overflow_sample_data = (sound == [] || trigger_step_lengths.length == 1) ? [] : sound[trigger_sample_length...(sound.length)]
 
       {:primary => primary_sample_data, :overflow => overflow_sample_data}
     end
@@ -143,8 +143,8 @@ module Beats
         if pattern_track_names.member?(incoming_track_name)
           track = pattern.tracks[incoming_track_name]
 
-          if track.beats.length > 1
-            intro_length = (pattern.tracks[incoming_track_name].beats[0] * step_sample_length).floor
+          if track.trigger_step_lengths.length > 1
+            intro_length = (pattern.tracks[incoming_track_name].trigger_step_lengths[0] * step_sample_length).floor
             end_sample = [end_sample, intro_length].min
           end
         end

data/lib/beats/beatsrunner.rb

@@ -18,15 +18,15 @@ module Beats
 
     def run
       base_path = @options[:base_path] || File.dirname(@input_file_name)
-      song, kit = SongParser.new().parse(base_path, File.read(@input_file_name))
+      song, kit = SongParser.new.parse(base_path, File.read(@input_file_name))
 
       song = normalize_for_pattern_option(song)
       songs_to_generate = normalize_for_split_option(song)
 
-      song_optimizer = SongOptimizer.new()
-      durations = songs_to_generate.collect do |output_file_name, song|
-        song = song_optimizer.optimize(song, OPTIMIZED_PATTERN_LENGTH)
-        AudioEngine.new(song, kit).write_to_file(output_file_name)
+      song_optimizer = SongOptimizer.new
+      durations = songs_to_generate.collect do |output_file_name, song_to_generate|
+        optimized_song = song_optimizer.optimize(song_to_generate, OPTIMIZED_PATTERN_LENGTH)
+        AudioEngine.new(optimized_song, kit).write_to_file(output_file_name)
       end
 
       {:duration => durations.last}
@@ -45,7 +45,7 @@ module Beats
         end
 
         song.flow = [pattern_name]
-        song.remove_unused_patterns()
+        song.remove_unused_patterns
       end
 
       song
@@ -56,9 +56,8 @@ module Beats
       songs_to_generate = {}
 
       if @options[:split]
-        split_songs = song.split()
+        split_songs = song.split
         split_songs.each do |track_name, split_song|
-          # TODO: Move building the output file name into its own method?
           extension = File.extname(@output_file_name)
           file_name = File.dirname(@output_file_name) + "/" +
                       File.basename(@output_file_name, extension) + "-" + File.basename(track_name, extension) +

data/lib/beats/kit.rb

@@ -1,47 +1,17 @@
 module Beats
-  # 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
-
-
-  # This class provides a repository for the sounds used in a song. Most usefully, it
-  # also handles converting the sounds to a common format. For example, if a song requires
-  # a sound that is mono/8-bit, another that is stereo/8-bit, and another that is
-  # stereo/16-bit, they have to be converted to a common format before they can be used
-  # together. Kit handles this conversion; all sounds retrieved using
-  # get_sample_data() will be in a common format.
-  #
-  # Sounds can only be added at initialization. During initialization, the sample data
-  # for each sound is loaded into memory, and converted to the common format if necessary.
-  # This format is:
-  #
-  #   Bits per sample: 16
-  #   Sample rate:     44100
-  #   Channels:        Stereo, unless all of the kit sounds are mono.
-  #
-  # For example if the kit has these sounds:
-  #
-  #   my_sound_1.wav:  mono, 16-bit
-  #   my_sound_2.wav:  stereo, 8-bit
-  #   my_sound_3.wav:  mono, 8-bit
-  #
-  # they will all be converted to stereo/16-bit during initialization.
   class Kit
-    def initialize(base_path, kit_items)
-      @base_path = base_path
-      @label_mappings = {}
-      @sound_bank = {}
-      @num_channels = 1
-      @bits_per_sample = 16  # Only use 16-bit files as output. Supporting 8-bit output
-                             # means extra complication for no real gain (I'm skeptical
-                             # anyone would explicitly want 8-bit output instead of 16-bit).
+    class LabelNotFoundError < RuntimeError; end
 
-      load_sounds(base_path, kit_items)
+    PLACEHOLDER_TRACK_NAME = 'empty_track_placeholder_name_234hkj32hjk4hjkhds23'
+
+    def initialize(items, num_channels, bits_per_sample)
+      @items = items
+      @num_channels = num_channels
+      @bits_per_sample = bits_per_sample
     end
 
+    attr_reader :num_channels, :bits_per_sample
+
     # Returns the sample data for a sound contained in the Kit. If the all sounds in the
     # kit are mono, then this will be a flat Array of Fixnums between -32768 and 32767.
     # Otherwise, this will be an Array of Fixnums pairs between -32768 and 32767.
@@ -63,125 +33,11 @@ module Beats
     #
     # Returns the sample data Array for the sound bound to label.
     def get_sample_data(label)
-      if label == "placeholder"
-        return []
-      end
-
-      sample_data = @sound_bank[label]
-
-      if sample_data.nil?
-        # TODO: Should we really throw an exception here rather than just returning nil?
-        raise StandardError, "Kit doesn't contain sound '#{label}'."
-      else
-        return sample_data
-      end
-    end
-
-    def scale!(scale_factor)
-      @sound_bank.each do |label, sample_array|
-        @sound_bank[label] = AudioUtils.scale(sample_array, @num_channels, scale_factor)
-      end
-    end
-
-    # Returns a YAML representation of the Kit. Produces nicer looking output than the default version
-    # of to_yaml().
-    #
-    # indent_space_count - The number of spaces to indent each line in the output (default: 0).
-    #
-    # Returns a String representation of the Kit in YAML format.
-    def to_yaml(indent_space_count = 0)
-      yaml = ""
-      longest_label_mapping_length =
-        @label_mappings.keys.inject(0) do |max_length, name|
-          (name.to_s.length > max_length) ? name.to_s.length : max_length
-        end
-
-      if @label_mappings.length > 0
-        yaml += " " * indent_space_count + "Kit:\n"
-        ljust_amount = longest_label_mapping_length + 1  # The +1 is for the trailing ":"
-        @label_mappings.sort.each do |label, path|
-          yaml += " " * indent_space_count + "  - #{(label + ":").ljust(ljust_amount)}  #{path}\n"
-        end
-      end
-
-      yaml
-    end
-
-    attr_reader :base_path, :label_mappings, :bits_per_sample, :num_channels
-
-  private
-
-    def load_sounds(base_path, kit_items)
-      # Set label mappings
-      kit_items.each do |label, sound_file_names|
-        if sound_file_names.class == Array
-          raise StandardError, "Composite sounds aren't allowed (yet...)"
-        end
-
-        unless label == sound_file_names
-          @label_mappings[label] = sound_file_names
-        end
+      unless @items.has_key?(label)
+        raise LabelNotFoundError, "Kit doesn't contain sound '#{label}'."
       end
 
-      kit_items = make_file_names_absolute(kit_items)
-      sound_buffers = load_raw_sounds(kit_items)
-
-      canonical_format = WaveFile::Format.new(@num_channels, @bits_per_sample, 44100)
-
-      # Convert each sound to a common format
-      sound_buffers.each {|file_name, buffer| sound_buffers[file_name] = buffer.convert(canonical_format) }
-
-      # If necessary, mix component sounds into a composite
-      kit_items.each do |label, sound_file_names|
-        @sound_bank[label] = mixdown(sound_file_names, sound_buffers)
-      end
-    end
-
-    # Converts relative paths into absolute paths. Note that this will also handle
-    # expanding ~ on platforms that support that.
-    def make_file_names_absolute(kit_items)
-      kit_items.each do |label, sound_file_names|
-        unless sound_file_names.class == Array
-          sound_file_names = [sound_file_names]
-        end
-
-        sound_file_names.map! {|sound_file_name| File.expand_path(sound_file_name, base_path) }
-        kit_items[label] = sound_file_names
-      end
-
-      kit_items
-    end
-
-    # Load all sound files, bailing if any are invalid
-    def load_raw_sounds(kit_items)
-      raw_sounds = {}
-      kit_items.values.flatten.each do |sound_file_name|
-        begin
-          info = WaveFile::Reader.info(sound_file_name)
-          WaveFile::Reader.new(sound_file_name).each_buffer(info.sample_frame_count) do |buffer|
-            raw_sounds[sound_file_name] = buffer
-            @num_channels = [@num_channels, buffer.channels].max
-          end
-        rescue Errno::ENOENT
-          raise SoundFileNotFoundError, "Sound file #{sound_file_name} not found."
-        rescue StandardError
-          raise InvalidSoundFormatError, "Sound file #{sound_file_name} 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
-      end
-
-      raw_sounds
-    end
-
-    def mixdown(sound_file_names, raw_sounds)
-      sample_arrays = []
-      sound_file_names.each do |sound_file_name|
-        sample_arrays << raw_sounds[sound_file_name].samples
-      end
-
-      composited_sample_data = AudioUtils.composite(sample_arrays, @num_channels)
-
-      AudioUtils.scale(composited_sample_data, @num_channels, sound_file_names.length)
+      @items[label]
     end
   end
 end