beats 1.2.4 → 1.2.5

data/test/songoptimizer_test.rb

@@ -2,7 +2,7 @@ require 'includes'
 
 class MockSongOptimizer < SongOptimizer
   def clone_song_ignoring_patterns_and_flow(original_song)
-    return super
+    super
   end
 end
 
@@ -35,7 +35,7 @@ Chorus:
   - hh_closed:        X.XXX.XXX.XX..X.
   - sounds/tom4.wav:  ...........X....
   - sounds/tom2.wav:  ..............X."
-  
+
   EXAMPLE_SONG_YAML_EMPTY_SUB_PATTERN = "
 Song:
   Tempo: 135
@@ -50,16 +50,16 @@ Verse:
   - snare:  ..........X."
 
   def self.load_fixture(fixture_name)
-    return SongParser.new().parse(FIXTURE_BASE_PATH, File.read("test/fixtures/#{fixture_name}"))
+    SongParser.new().parse(FIXTURE_BASE_PATH, File.read("test/fixtures/#{fixture_name}"))
   end
 
   def test_optimize
     parser = SongParser.new()
     original_song, kit = parser.parse(File.dirname(__FILE__) + "/..", EXAMPLE_SONG_YAML)
-    
+
     optimizer = SongOptimizer.new()
     optimized_song = optimizer.optimize(original_song, 4)
-    
+
     assert_equal(optimized_song.tempo, 135)
     #assert_equal(optimized_song.total_tracks, 5)
 
@@ -67,47 +67,47 @@ Verse:
     #assert_equal(original_song.sample_length, optimized_song.sample_length)
     #assert_equal(original_song.sample_length_with_overflow, optimized_song.sample_length_with_overflow)
     #assert_equal(original_song.sample_data(false), optimized_song.sample_data(false))
-    
+
     # Patterns :verse_0 and :verse_4 should be removed since they are identical to :chorus_0
     assert_equal([:chorus_0, :chorus_12, :chorus_4, :chorus_8, :verse_12, :verse_8],
                  optimized_song.patterns.keys.sort {|x, y| x.to_s <=> y.to_s })
-        
+
     pattern = optimized_song.patterns[:verse_8]
     assert_equal(pattern.tracks.keys.sort, ["bass", "hh_closed"])
     assert_equal(pattern.tracks["bass"].rhythm, "X...")
     assert_equal(pattern.tracks["hh_closed"].rhythm, "X.X.")
-    
+
     pattern = optimized_song.patterns[:verse_12]
     assert_equal(pattern.tracks.keys.sort, ["agogo", "bass", "hh_closed", "snare"])
     assert_equal(pattern.tracks["bass"].rhythm, "X...")
     assert_equal(pattern.tracks["snare"].rhythm, "..X.")
     assert_equal(pattern.tracks["hh_closed"].rhythm, "X.X.")
     assert_equal(pattern.tracks["agogo"].rhythm, "..XX")
-    
+
     pattern = optimized_song.patterns[:chorus_0]
     assert_equal(pattern.tracks.keys.sort, ["bass", "hh_closed"])
     assert_equal(pattern.tracks["bass"].rhythm, "X...")
     assert_equal(pattern.tracks["hh_closed"].rhythm, "X.XX")
-    
+
     pattern = optimized_song.patterns[:chorus_4]
     assert_equal(pattern.tracks.keys.sort, ["bass", "hh_closed", "snare"])
     assert_equal(pattern.tracks["bass"].rhythm, "X...")
     assert_equal(pattern.tracks["snare"].rhythm, "X...")
     assert_equal(pattern.tracks["hh_closed"].rhythm, "X.XX")
-    
+
     pattern = optimized_song.patterns[:chorus_8]
     assert_equal(pattern.tracks.keys.sort, ["bass", "hh_closed", "sounds/tom4.wav"])
     assert_equal(pattern.tracks["bass"].rhythm, "XX..")
     assert_equal(pattern.tracks["hh_closed"].rhythm, "X.XX")
     assert_equal(pattern.tracks["sounds/tom4.wav"].rhythm, "...X")
-    
+
     pattern = optimized_song.patterns[:chorus_12]
     assert_equal(pattern.tracks.keys.sort, ["bass", "hh_closed", "snare", "sounds/tom2.wav"])
     assert_equal(pattern.tracks["bass"].rhythm, "X...")
     assert_equal(pattern.tracks["snare"].rhythm, "X...")
     assert_equal(pattern.tracks["hh_closed"].rhythm, "..X.")
     assert_equal(pattern.tracks["sounds/tom2.wav"].rhythm, "..X.")
-    
+
     assert_equal(optimized_song.flow, [:chorus_0, :chorus_0, :verse_8, :verse_12,
                                        :chorus_0, :chorus_0, :verse_8, :verse_12,
                                        :chorus_0, :chorus_4, :chorus_8, :chorus_12,
@@ -121,54 +121,54 @@ Verse:
                                        :chorus_0, :chorus_4, :chorus_8, :chorus_12,
                                        :chorus_0, :chorus_4, :chorus_8, :chorus_12])
   end
-  
+
   def test_optimize_song_nondivisible_max_pattern_length()
     parser = SongParser.new()
     original_song, kit = parser.parse(File.dirname(__FILE__) + "/..", EXAMPLE_SONG_YAML_EMPTY_SUB_PATTERN)
-    
+
     optimizer = SongOptimizer.new()
     optimized_song = optimizer.optimize(original_song, 7)
-    
+
     pattern = optimized_song.patterns[:verse_0]
     assert_equal(["bass"], pattern.tracks.keys.sort)
     assert_equal("X......", pattern.tracks["bass"].rhythm)
-    
+
     pattern = optimized_song.patterns[:verse_7]
     assert_equal(["bass", "snare"], pattern.tracks.keys.sort)
     assert_equal(".X...", pattern.tracks["bass"].rhythm)
     assert_equal("...X.", pattern.tracks["snare"].rhythm)
-    
+
     assert_equal([:verse_0, :verse_7], optimized_song.flow)
   end
-  
+
   def test_pattern_collision
     original_song, kit = SongOptimizerTest.load_fixture("valid/optimize_pattern_collision.txt")
     optimizer = SongOptimizer.new()
     optimized_song = optimizer.optimize(original_song, 4)
-  
+
     assert_equal([:verse2_0, :verse_0, :verse_20], optimized_song.patterns.keys.sort {|x, y| x.to_s <=> y.to_s })
   end
 
   def test_optimize_song_containing_empty_pattern()
     parser = SongParser.new()
     original_song, kit = parser.parse(File.dirname(__FILE__) + "/..", EXAMPLE_SONG_YAML_EMPTY_SUB_PATTERN)
-    
+
     optimizer = SongOptimizer.new()
     optimized_song = optimizer.optimize(original_song, 4)
-    
+
     pattern = optimized_song.patterns[:verse_0]
     assert_equal(["bass"], pattern.tracks.keys.sort)
     assert_equal("X...", pattern.tracks["bass"].rhythm)
-    
+
     pattern = optimized_song.patterns[:verse_4]
     assert_equal(["placeholder"], pattern.tracks.keys.sort)
     assert_equal("....", pattern.tracks["placeholder"].rhythm)
-    
+
     pattern = optimized_song.patterns[:verse_8]
     assert_equal(["bass", "snare"], pattern.tracks.keys.sort)
     assert_equal("X...", pattern.tracks["bass"].rhythm)
     assert_equal("..X.", pattern.tracks["snare"].rhythm)
-    
+
     assert_equal([:verse_0, :verse_4, :verse_8], optimized_song.flow)
   end
 end

data/test/songparser_test.rb

@@ -12,7 +12,7 @@ class SongParserTest < Test::Unit::TestCase
                       :example_with_empty_track,
                       :multiple_tracks_same_sound,
                       :with_structure]
-  
+
   INVALID_FIXTURES = [:bad_repeat_count,
                       :bad_flow,
                       :bad_tempo,
@@ -25,7 +25,7 @@ class SongParserTest < Test::Unit::TestCase
                       :sound_in_track_wrong_format]
 
   def self.load_fixture(fixture_name)
-    return SongParser.new().parse(FIXTURE_BASE_PATH, File.read("test/fixtures/#{fixture_name}"))
+    SongParser.new().parse(FIXTURE_BASE_PATH, File.read("test/fixtures/#{fixture_name}"))
   end
 
   def self.generate_test_data
@@ -37,20 +37,20 @@ class SongParserTest < Test::Unit::TestCase
       test_songs[fixture_name] = song
       test_kits[fixture_name] = kit
     end
-    
+
     return test_songs, test_kits
   end
 
   # TODO: Add somes tests to validate the Kits
   def test_valid_parse
     test_songs, test_kits = SongParserTest.generate_test_data()
-    
+
     assert_equal(120, test_songs[:no_tempo].tempo)
     assert_equal([:verse], test_songs[:no_tempo].flow)
-    
+
     assert_equal(100, test_songs[:repeats_not_specified].tempo)
     assert_equal([:verse], test_songs[:repeats_not_specified].flow)
-    
+
     # These two songs should be the same, except that one uses a kit in the song header
     # and the other doesn't.
     [:example_no_kit, :example_with_kit].each do |song_key|
@@ -68,13 +68,13 @@ class SongParserTest < Test::Unit::TestCase
       assert_equal(5, song.patterns[:chorus].tracks.length)
       assert_equal(1, song.patterns[:bridge].tracks.length)
     end
-    
+
     song = test_songs[:example_with_empty_track]
     assert_equal(1, song.patterns.length)
     assert_equal(2, song.patterns[:verse].tracks.length)
     assert_equal("........", song.patterns[:verse].tracks["test/sounds/bass_mono_8.wav"].rhythm)
     assert_equal("X...X...", song.patterns[:verse].tracks["test/sounds/snare_mono_8.wav"].rhythm)
-    
+
     song = test_songs[:multiple_tracks_same_sound]
     assert_equal(2, song.patterns.length)
     assert_equal(7, song.patterns[:verse].tracks.length)
@@ -87,21 +87,21 @@ class SongParserTest < Test::Unit::TestCase
     assert_equal("..............X.", song.patterns[:verse].tracks["snare"].rhythm)
     assert_equal("X.XXX.XXX.X.X.X.", song.patterns[:verse].tracks["hh_closed"].rhythm)
     assert_equal("..............XX", song.patterns[:verse].tracks["agogo"].rhythm)
-  
+
     song = test_songs[:with_structure]
     assert_equal([:verse, :verse], song.flow)
     assert_equal(1, song.patterns.length)
     assert_equal(1, song.patterns[:verse].tracks.length)
     assert_equal("X...X...", song.patterns[:verse].tracks["test/sounds/bass_mono_8.wav"].rhythm)
   end
-  
+
   def test_invalid_parse
     INVALID_FIXTURES.each do |fixture|
       assert_raise(SongParseError) do
         song = SongParserTest.load_fixture("invalid/#{fixture}.txt")
       end
     end
-    
+
     assert_raise(InvalidRhythmError) do
       song = SongParserTest.load_fixture("invalid/bad_rhythm.txt")
     end

data/test/track_test.rb

@@ -3,45 +3,45 @@ require 'includes'
 class TrackTest < Test::Unit::TestCase
   def generate_test_data
     test_tracks = {}
-    
+
     test_tracks[:blank] = Track.new("bass", "")
     test_tracks[:solo] = Track.new("bass", "X")
     test_tracks[:with_overflow] = Track.new("bass", "...X")
     test_tracks[:with_barlines] = Track.new("bass", "|X.X.|X.X.|")
     test_tracks[:placeholder] = Track.new("bass", "....")
     test_tracks[:complicated] = Track.new("bass", "..X...X...X...X.X...X...X...X...")
-    
-    return test_tracks
+
+    test_tracks
   end
-  
+
   def test_initialize
     test_tracks = generate_test_data()
-    
+
     assert_equal([0], test_tracks[:blank].beats)
     assert_equal("bass", test_tracks[:blank].name)
     assert_equal("", test_tracks[:blank].rhythm)
-    
+
     assert_equal([0, 1], test_tracks[:solo].beats)
     assert_equal("bass", test_tracks[:solo].name)
     assert_equal("X", test_tracks[:solo].rhythm)
-    
+
     assert_equal([3, 1], test_tracks[:with_overflow].beats)
     assert_equal("...X", test_tracks[:with_overflow].rhythm)
-    
+
     assert_equal([0, 2, 2, 2, 2], test_tracks[:with_barlines].beats)
     # Bar lines should be removed from rhythm:
     assert_equal("X.X.X.X.", test_tracks[:with_barlines].rhythm)
-    
+
     assert_equal([4], test_tracks[:placeholder].beats)
     assert_equal("....", test_tracks[:placeholder].rhythm)
-    
+
     assert_equal([2, 4, 4, 4, 2, 4, 4, 4, 4], test_tracks[:complicated].beats)
     assert_equal("..X...X...X...X.X...X...X...X...", test_tracks[:complicated].rhythm)
   end
-  
+
   def test_step_count
     test_tracks = generate_test_data()
-    
+
     assert_equal(0,  test_tracks[:blank].step_count())
     assert_equal(1,  test_tracks[:solo].step_count())
     assert_equal(4,  test_tracks[:with_overflow].step_count())

metadata

@@ -1,52 +1,51 @@
 --- !ruby/object:Gem::Specification
 name: beats
 version: !ruby/object:Gem::Version
-  version: 1.2.4
-  prerelease: 
+  version: 1.2.5
 platform: ruby
 authors:
 - Joel Strait
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-23 00:00:00.000000000 Z
+date: 2013-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: wavefile
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.6.0
 description: A command-line drum machine. Feed it a song notated in YAML, and it will
   produce a precision-milled Wave file of impeccable timing and feel.
 email: joel dot strait at Google's popular web mail service
 executables:
 - beats
-extensions: []
+extensions:
+- ext/mkrf_conf.rb
 extra_rdoc_files: []
 files:
 - LICENSE
 - README.markdown
 - Rakefile
-- lib/audioengine.rb
-- lib/audioutils.rb
+- lib/beats/audioengine.rb
+- lib/beats/audioutils.rb
+- lib/beats/beatsrunner.rb
+- lib/beats/kit.rb
+- lib/beats/pattern.rb
+- lib/beats/song.rb
+- lib/beats/songoptimizer.rb
+- lib/beats/songparser.rb
+- lib/beats/track.rb
 - lib/beats.rb
-- lib/kit.rb
-- lib/pattern.rb
-- lib/song.rb
-- lib/songoptimizer.rb
-- lib/songparser.rb
-- lib/track.rb
 - lib/wavefile/cachingwriter.rb
 - bin/beats
 - test/audioengine_test.rb
@@ -104,6 +103,7 @@ files:
 - test/fixtures/valid/example_stereo_8.txt
 - test/fixtures/valid/example_with_empty_track.txt
 - test/fixtures/valid/example_with_kit.txt
+- test/fixtures/valid/foo.txt
 - test/fixtures/valid/multiple_tracks_same_sound.txt
 - test/fixtures/valid/no_tempo.txt
 - test/fixtures/valid/optimize_pattern_collision.txt
@@ -126,6 +126,8 @@ files:
 - test/sounds/agogo_low_mono_8.wav
 - test/sounds/agogo_low_stereo_16.wav
 - test/sounds/agogo_low_stereo_8.wav
+- test/sounds/bass.wav
+- test/sounds/bass2.wav
 - test/sounds/bass2_mono_16.wav
 - test/sounds/bass2_mono_8.wav
 - test/sounds/bass2_stereo_16.wav
@@ -205,29 +207,29 @@ files:
 - test/sounds/tom4_stereo_8.wav
 - test/sounds/tone.wav
 - test/track_test.rb
+- ext/mkrf_conf.rb
 homepage: http://beatsdrummachine.com/
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.1.11
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A command-line drum machine. Feed it a song notated in YAML, and it will
   produce a precision-milled Wave file of impeccable timing and feel.
 test_files:
@@ -286,6 +288,7 @@ test_files:
 - test/fixtures/valid/example_stereo_8.txt
 - test/fixtures/valid/example_with_empty_track.txt
 - test/fixtures/valid/example_with_kit.txt
+- test/fixtures/valid/foo.txt
 - test/fixtures/valid/multiple_tracks_same_sound.txt
 - test/fixtures/valid/no_tempo.txt
 - test/fixtures/valid/optimize_pattern_collision.txt
@@ -308,6 +311,8 @@ test_files:
 - test/sounds/agogo_low_mono_8.wav
 - test/sounds/agogo_low_stereo_16.wav
 - test/sounds/agogo_low_stereo_8.wav
+- test/sounds/bass.wav
+- test/sounds/bass2.wav
 - test/sounds/bass2_mono_16.wav
 - test/sounds/bass2_mono_8.wav
 - test/sounds/bass2_stereo_16.wav

data/lib/audioengine.rb

@@ -1,161 +0,0 @@
-# This class actually generates the output audio data that is saved to disk.
-#
-# To produce audio data, it needs two things: a Song and a Kit. The Song tells
-# it which sounds to trigger and when, while the Kit provides the sample data
-# for each of these sounds.
-#
-# Example usage, assuming song and kit are already defined:
-#
-#   engine = AudioEngine.new(song, kit)
-#   engine.write_to_file("my_song.wav")
-#
-class AudioEngine
-  SAMPLE_RATE = 44100
-  PACK_CODE = "s*"   # All output sample data is assumed to be 16-bit
-
-  def initialize(song, kit)
-    @song = song
-    @kit = kit
-    
-    @step_sample_length = AudioUtils.step_sample_length(SAMPLE_RATE, @song.tempo) 
-    @composited_pattern_cache = {}
-  end
-
-  def write_to_file(output_file_name)
-    packed_pattern_cache = {}
-    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)
-    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.
-    incoming_overflow = {}
-    @song.flow.each do |pattern_name|
-      key = [pattern_name, incoming_overflow.hash]
-      unless packed_pattern_cache.member?(key)
-        sample_data = generate_pattern_sample_data(@song.patterns[pattern_name], incoming_overflow)
-
-        packed_pattern_cache[key] = { :primary => WaveFile::Buffer.new(sample_data[:primary], format),
-                                      :overflow => WaveFile::Buffer.new(sample_data[:overflow], format) }
-      end
-
-      writer.write(packed_pattern_cache[key][:primary])
-      incoming_overflow = packed_pattern_cache[key][:overflow].samples
-    end
-
-    # Write any remaining overflow from the final pattern
-    final_overflow_composite = AudioUtils.composite(incoming_overflow.values, format.channels)
-    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()
-
-    return WaveFile::Reader.info(output_file_name).duration
-  end
-
-  attr_reader :step_sample_length
-
-private
-
-  # 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]
-      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|
-      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
-
-      primary_sample_data[start_sample...end_sample] = sound[0...beat_sample_length]
-
-      step_index += beat_step_length
-    end
-
-    overflow_sample_data = (sound == [] || beats.length == 1) ? [] : sound[beat_sample_length...(sound.length)]
-
-    return {:primary => primary_sample_data, :overflow => overflow_sample_data}
-  end
-
-  # Composites the sample data for each of the pattern's tracks, and returns the overflow sample data
-  # from tracks whose last sound trigger extends past the end of the pattern. This overflow can be
-  # used by the next pattern to avoid sounds cutting off when the pattern changes.
-  def generate_pattern_sample_data(pattern, incoming_overflow)
-    # Unless cached, composite each track's sample data.
-    if @composited_pattern_cache[pattern] == nil
-      primary_sample_data, overflow_sample_data = composite_pattern_tracks(pattern)
-      @composited_pattern_cache[pattern] = {:primary => primary_sample_data.dup, :overflow => overflow_sample_data.dup}
-    else
-      primary_sample_data = @composited_pattern_cache[pattern][:primary].dup
-      overflow_sample_data = @composited_pattern_cache[pattern][:overflow].dup
-    end
-    
-    # Composite overflow from the previous pattern onto this pattern, to prevent sounds from cutting off.
-    primary_sample_data, overflow_sample_data = handle_incoming_overflow(pattern,
-                                                                         incoming_overflow,
-                                                                         primary_sample_data,
-                                                                         overflow_sample_data)
-    primary_sample_data = AudioUtils.scale(primary_sample_data, @kit.num_channels, @song.total_tracks)
-    
-    return {:primary => primary_sample_data, :overflow => overflow_sample_data}
-  end
-
-  def composite_pattern_tracks(pattern)
-    overflow_sample_data = {}
-
-    raw_track_sample_arrays = []
-      pattern.tracks.each do |track_name, track|
-        temp = generate_track_sample_data(track, @kit.get_sample_data(track.name))
-        raw_track_sample_arrays << temp[:primary]
-        overflow_sample_data[track_name] = temp[:overflow]
-      end
-
-    primary_sample_data = AudioUtils.composite(raw_track_sample_arrays, @kit.num_channels)
-    return primary_sample_data, overflow_sample_data
-  end
-
-  # Applies sound overflow (i.e. long sounds such as cymbal crash which extend past the last step)
-  # from the previous pattern in the flow to the current pattern. This prevents sounds from being
-  # cut off when the pattern changes.
-  # 
-  # It would probably be shorter and conceptually simpler to deal with incoming overflow in
-  # generate_track_sample_data() instead of this method. (In fact, this method would go away).
-  # However, doing it this way allows for caching composited pattern sample data, and
-  # applying incoming overflow to the composite. This allows each pattern to only be composited once,
-  # regardless of the incoming overflow that each performance of it receives. If incoming overflow
-  # was handled at the Track level we couldn't do that.
-  def handle_incoming_overflow(pattern, incoming_overflow, primary_sample_data, overflow_sample_data)
-    pattern_track_names = pattern.tracks.keys
-    sample_arrays = [primary_sample_data]
-
-    incoming_overflow.each do |incoming_track_name, incoming_sample_data|
-      end_sample = incoming_sample_data.length
-      
-      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
-          end_sample = [end_sample, intro_length].min
-        end
-      end
-
-      if end_sample > primary_sample_data.length
-        end_sample = primary_sample_data.length
-        overflow_sample_data[incoming_track_name] = incoming_sample_data[(primary_sample_data.length)...(incoming_sample_data.length)]
-      end
-
-      sample_arrays << incoming_sample_data[0...end_sample]
-    end
-
-    return AudioUtils.composite(sample_arrays, @kit.num_channels), overflow_sample_data
-  end
-end