beats 1.1.0 → 1.2.0

data/lib/songparser.rb

@@ -10,7 +10,7 @@ class SongParser
       - Verse: x2
       - Chorus: x2"
   
-  def initialize()
+  def initialize
   end
   
   def parse(base_path, definition = nil)
@@ -40,7 +40,7 @@ class SongParser
     add_patterns_to_song(song, raw_song_components[:patterns])
     
     # 4.) Set structure
-    if(raw_song_components[:structure] == nil)
+    if raw_song_components[:structure] == nil
       raise SongParseError, "Song must have a Structure section in the header."
     else
       set_song_structure(song, raw_song_components[:structure])
@@ -51,16 +51,15 @@ class SongParser
   
 private
 
-  # This is basically a factory. Don't see a benefit to extracting to a full class.
-  # Also, is "canonicalize" a word?
+  # Is "canonicalize" a word?
   def canonicalize_definition(definition)
-    if(definition.class == String)
+    if definition.class == String
       begin
         raw_song_definition = YAML.load(definition)
       rescue ArgumentError => detail
         raise SongParseError, "Syntax error in YAML file"
       end
-    elsif(definition.class == Hash)
+    elsif definition.class == Hash
       raw_song_definition = definition
     else
       raise SongParseError, "Invalid song input"
@@ -73,7 +72,7 @@ private
     raw_song_components = {}
     raw_song_components[:full_definition] = downcase_hash_keys(raw_song_definition)
     
-    if(raw_song_components[:full_definition]["song"] != nil)
+    if 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
@@ -90,46 +89,59 @@ private
     kit = Kit.new(base_path)
     
     # Add sounds defined in the Kit section of the song header
-    if(raw_kit != nil)
-      raw_kit.each {|kit_item|
+    unless raw_kit == nil
+      raw_kit.each do |kit_item|
         kit.add(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{|key|
+    raw_patterns.keys.each do |key|
       track_list = raw_patterns[key]
-      track_list.each{|track_definition|
-        track_name = track_definition.keys.first
-        track_path = track_name
+      
+      unless track_list == nil
+        track_list.each do |track_definition|
+          track_name = track_definition.keys.first
+          track_path = track_name
         
-        kit.add(track_name, track_path)
-      }
-    }
+          kit.add(track_name, track_path)
+        end
+      end
+    end
     
     return kit
   end
   
   def add_patterns_to_song(song, raw_patterns)
-    raw_patterns.keys.each{|key|
+    raw_patterns.keys.each do |key|
       new_pattern = song.pattern key.to_sym
 
       track_list = raw_patterns[key]
-      track_list.each{|track_definition|
+      if track_list == nil
+        # TODO: Use correct capitalization of pattern name in error message
+        # TODO: Possibly allow if pattern not referenced in the Structure, or has 0 repeats?
+        raise SongParseError, "Pattern '#{key}' has no tracks. It needs at least one."
+      end
+      
+      track_list.each do |track_definition|
         track_name = track_definition.keys.first
-       new_pattern.track track_name, song.kit.get_sample_data(track_name), track_definition[track_name]
-      }
-    }
+        
+        # Handle case where no track pattern is specified (i.e. "- foo.wav:" instead of "- foo.wav: X.X.X.X.")
+        track_definition[track_name] ||= ""
+        
+        new_pattern.track track_name, song.kit.get_sample_data(track_name), track_definition[track_name]
+      end
+    end
   end
   
   def set_song_structure(song, raw_structure)
     structure = []
 
     raw_structure.each{|pattern_item|
-      if(pattern_item.class == String)
+      if pattern_item.class == String
         pattern_item = {pattern_item => "x1"}
       end
       
@@ -141,12 +153,12 @@ private
       multiples_str.slice!(0)
       multiples = multiples_str.to_i
       
-      if(multiples_str.match(/[^0-9]/) != nil)
+      unless 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."
       else
-        if(multiples < 0)
+        if multiples < 0
           raise SongParseError, "'#{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))
+        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 structure with "x0" repeats.
           # This can be convenient for defining the structure before all patterns have been added to the song file.
@@ -161,9 +173,9 @@ private
     
   # Converts all hash keys to be lowercase
   def downcase_hash_keys(hash)
-    return hash.inject({}) {|new_hash, pair|
+    return hash.inject({}) do |new_hash, pair|
         new_hash[pair.first.downcase] = pair.last
         new_hash
-    }
+    end
   end
 end

data/lib/songsplitter.rb

@@ -0,0 +1,38 @@
+# Used to split a Song object into multiple Song objects, where each resulting
+# object only has 1 track. For example, if a Song has 5 tracks, this will return
+# a hash of 5 songs, each with one of the original song's tracks.
+class SongSplitter
+  def initialize()
+  end
+  
+  def split(original_song)
+    track_names = original_song.track_names()
+    
+    split_songs = {}
+    track_names.each do |track_name|
+      new_song = original_song.copy_ignoring_patterns_and_structure()
+      
+      if track_name == "placeholder"
+        track_sample_data = []
+      else
+        track_sample_data = new_song.kit.get_sample_data(track_name)
+      end
+      
+      original_song.patterns.each do |name, original_pattern|
+        new_pattern = new_song.pattern name
+        
+        if original_pattern.tracks.has_key?(track_name)
+          new_pattern.track track_name, track_sample_data, original_pattern.tracks[track_name].rhythm
+        else
+          new_pattern.track track_name, track_sample_data, "." * original_pattern.tick_count()
+        end
+      end
+      
+      new_song.structure = original_song.structure
+      
+      split_songs[track_name] = new_song
+    end
+    
+    return split_songs
+  end
+end

data/lib/track.rb

@@ -1,35 +1,41 @@
+class InvalidRhythmError < RuntimeError; end
+
 class Track
   REST = "."
   BEAT = "X"
   
-  def initialize(name, wave_data, pattern)
+  def initialize(name, wave_data, rhythm)
+    # TODO: Add validation for input parameters
+    
     @wave_data = wave_data
     @name = name
     @sample_data = nil
     @overflow = nil
-    self.pattern = pattern
+    self.rhythm = rhythm
   end
   
-  def pattern=(pattern)
-    @pattern = pattern
+  def rhythm=(rhythm)
+    @rhythm = rhythm
     beats = []
     
     beat_length = 0
-    #pattern.each_char{|ch|
-    pattern.each_byte{|ch|
+    #rhythm.each_char{|ch|
+    rhythm.each_byte do |ch|
       ch = ch.chr
       if ch == BEAT
         beats << beat_length
         beat_length = 1
-      else
+      elsif ch == REST
         beat_length += 1
+      else
+        raise InvalidRhythmError, "Track #{@name} has an invalid rhythm: '#{rhythm}'. Can only contain 'X' or '.'"
       end
-    }
+    end
     
-    if(beat_length > 0)
+    if beat_length > 0
       beats << beat_length
     end
-    if(beats == [])
+    if beats == []
       beats = [0]
     end
     @beats = beats
@@ -39,6 +45,10 @@ class Track
     @overflow = nil
   end
   
+  def intro_sample_length(tick_sample_length)
+    return @beats[0] * tick_sample_length.floor
+  end
+  
   def sample_length(tick_sample_length)
     total_ticks = @beats.inject(0) {|sum, n| sum + n}
     return (total_ticks * tick_sample_length).floor
@@ -47,7 +57,7 @@ class Track
   def sample_length_with_overflow(tick_sample_length)
     temp_sample_length = sample_length(tick_sample_length)
     
-    if(@beats != [0])
+    unless @beats == [0]
       beat_sample_length = @beats.last * tick_sample_length
       if(@wave_data.length > beat_sample_length)
         temp_sample_length += @wave_data.length - beat_sample_length.floor
@@ -57,33 +67,37 @@ class Track
     return temp_sample_length.floor
   end
   
-  def sample_data(tick_sample_length, incoming_overflow = nil)
+  def tick_count
+    return @rhythm.length
+  end
+  
+  def sample_data(tick_sample_length)
     actual_sample_length = sample_length(tick_sample_length)
     full_sample_length = sample_length_with_overflow(tick_sample_length)
 
-    if(@sample_data == nil)
+    if @sample_data == nil
       fill_value = (@wave_data.first.class == Array) ? [0, 0] : 0
       output_data = [].fill(fill_value, 0, full_sample_length)
     
-      if(full_sample_length > 0)
+      if full_sample_length > 0
         remainder = 0.0
         offset = @beats[0] * tick_sample_length
         remainder += (@beats[0] * tick_sample_length) - (@beats[0] * tick_sample_length).floor
 
-        @beats[1...(@beats.length)].each {|beat_length|
+        @beats[1...(@beats.length)].each do |beat_length|
           beat_sample_length = beat_length * tick_sample_length
 
           remainder += beat_sample_length - beat_sample_length.floor
-          if(remainder >= 1.0)
+          if remainder >= 1.0
             beat_sample_length += 1
             remainder -= 1.0
           end
 
           output_data[offset...(offset + wave_data.length)] = wave_data
           offset += beat_sample_length.floor
-        }
+        end
       
-        if(full_sample_length > actual_sample_length)
+        if full_sample_length > actual_sample_length
           @sample_data = output_data[0...offset]
           @overflow = output_data[actual_sample_length...full_sample_length]
         else
@@ -98,21 +112,9 @@ class Track
 
     primary_sample_data = @sample_data.dup
     
-    if(incoming_overflow != nil && incoming_overflow != [])
-      # TO DO: Add check for when incoming overflow is longer than
-      # track full length to prevent track from lengthening.
-      intro_length = @beats.first * tick_sample_length.floor
-      
-      if(incoming_overflow.length <= intro_length)
-        primary_sample_data[0...incoming_overflow.length] = incoming_overflow
-      else
-        primary_sample_data[0...intro_length] = incoming_overflow[0...intro_length]
-      end
-    end
-    
     return {:primary => primary_sample_data, :overflow => @overflow}
   end
   
   attr_accessor :name, :wave_data
-  attr_reader :pattern
+  attr_reader :rhythm
 end

data/lib/wavefile.rb

@@ -0,0 +1,475 @@
+# DO NOT EDIT THIS FILE
+# DO NOT EDIT THIS FILE
+# DO NOT EDIT THIS FILE
+#
+# OK, so what's the deal here? This file contains the WaveFile class defined
+# in v0.3.0 of the WaveFile gem (http://github.com/jstrait/wavefile). So why
+# are we manually importing the class instead of just using the Gem? The
+# reason is that (on my machine at least) it takes about 0.2 seconds
+# to load RubyGems in 1.8.7. This is a non-trivial amount of time, and for
+# shorter songs it can be a relatively large percentage of the total runtime.
+# (In Ruby 1.9, it has no effect on performance, since RubyGems is already
+# baked in anyway).
+#
+# So, considering that the WaveFile gem only contains one class (this file),
+# I'm just moving it here. This means BEATS doesn't have to use the
+# WaveFile gem, it therefore doesn't need to use RubyGems either. It's a hack,
+# but a pragmatic hack.
+# 
+# The caveat is that to make this as Gem-like as possible, this file should
+# be treated as an external library, and not edited.
+
+=begin
+WAV File Specification
+FROM http://ccrma.stanford.edu/courses/422/projects/WaveFormat/
+The canonical WAVE format starts with the RIFF header:
+0         4   ChunkID          Contains the letters "RIFF" in ASCII form
+                               (0x52494646 big-endian form).
+4         4   ChunkSize        36 + SubChunk2Size, or more precisely:
+                               4 + (8 + SubChunk1Size) + (8 + SubChunk2Size)
+                               This is the size of the rest of the chunk
+                               following this number.  This is the size of the
+                               entire file in bytes minus 8 bytes for the
+                               two fields not included in this count:
+                               ChunkID and ChunkSize.
+8         4   Format           Contains the letters "WAVE"
+                               (0x57415645 big-endian form).
+
+The "WAVE" format consists of two subchunks: "fmt " and "data":
+The "fmt " subchunk describes the sound data's format:
+12        4   Subchunk1ID      Contains the letters "fmt "
+                               (0x666d7420 big-endian form).
+16        4   Subchunk1Size    16 for PCM.  This is the size of the
+                               rest of the Subchunk which follows this number.
+20        2   AudioFormat      PCM = 1 (i.e. Linear quantization)
+                               Values other than 1 indicate some
+                               form of compression.
+22        2   NumChannels      Mono = 1, Stereo = 2, etc.
+24        4   SampleRate       8000, 44100, etc.
+28        4   ByteRate         == SampleRate * NumChannels * BitsPerSample/8
+32        2   BlockAlign       == NumChannels * BitsPerSample/8
+                               The number of bytes for one sample including
+                               all channels. I wonder what happens when
+                               this number isn't an integer?
+34        2   BitsPerSample    8 bits = 8, 16 bits = 16, etc.
+
+The "data" subchunk contains the size of the data and the actual sound:
+36        4   Subchunk2ID      Contains the letters "data"
+                               (0x64617461 big-endian form).
+40        4   Subchunk2Size    == NumSamples * NumChannels * BitsPerSample/8
+                               This is the number of bytes in the data.
+                               You can also think of this as the size
+                               of the read of the subchunk following this
+                               number.
+44        *   Data             The actual sound data.
+=end
+
+class WaveFile
+  CHUNK_ID = "RIFF"
+  FORMAT = "WAVE"
+  FORMAT_CHUNK_ID = "fmt "
+  SUB_CHUNK1_SIZE = 16
+  PCM = 1
+  DATA_CHUNK_ID = "data"
+  HEADER_SIZE = 36
+
+  def initialize(num_channels, sample_rate, bits_per_sample, sample_data = [])
+    if num_channels == :mono
+      @num_channels = 1
+    elsif num_channels == :stereo
+      @num_channels = 2
+    else
+      @num_channels = num_channels
+    end
+    @sample_rate = sample_rate
+    @bits_per_sample = bits_per_sample
+    @sample_data = sample_data
+    
+    @byte_rate = sample_rate * @num_channels * (bits_per_sample / 8)
+    @block_align = @num_channels * (bits_per_sample / 8)
+  end
+  
+  def self.open(path)
+    file = File.open(path, "rb")
+    
+    begin
+      header = read_header(file)
+      errors = validate_header(header)
+
+      if errors == []
+        sample_data = read_sample_data(file,
+                                       header[:num_channels],
+                                       header[:bits_per_sample],
+                                       header[:sub_chunk2_size])
+
+        wave_file = self.new(header[:num_channels],
+                             header[:sample_rate],
+                             header[:bits_per_sample],
+                             sample_data)
+      else
+        error_msg = "#{path} can't be opened, due to the following errors:\n"
+        errors.each {|error| error_msg += "  * #{error}\n" }
+        raise StandardError, error_msg
+      end
+    rescue EOFError
+      raise StandardError, "An error occured while reading #{path}."
+    ensure
+      file.close()
+    end
+    
+    return wave_file
+  end
+
+  def save(path)
+    # All numeric values should be saved in little-endian format
+
+    sample_data_size = @sample_data.length * @num_channels * (@bits_per_sample / 8)
+
+    # Write the header
+    file_contents = CHUNK_ID
+    file_contents += [HEADER_SIZE + sample_data_size].pack("V")
+    file_contents += FORMAT
+    file_contents += FORMAT_CHUNK_ID
+    file_contents += [SUB_CHUNK1_SIZE].pack("V")
+    file_contents += [PCM].pack("v")
+    file_contents += [@num_channels].pack("v")
+    file_contents += [@sample_rate].pack("V")
+    file_contents += [@byte_rate].pack("V")
+    file_contents += [@block_align].pack("v")
+    file_contents += [@bits_per_sample].pack("v")
+    file_contents += DATA_CHUNK_ID
+    file_contents += [sample_data_size].pack("V")
+
+    # Write the sample data
+    if !mono?
+      output_sample_data = []
+      @sample_data.each{|sample|
+        sample.each{|sub_sample|
+          output_sample_data << sub_sample
+        }
+      }
+    else
+      output_sample_data = @sample_data
+    end
+    
+    if @bits_per_sample == 8
+      file_contents += output_sample_data.pack("C*")
+    elsif @bits_per_sample == 16
+      file_contents += output_sample_data.pack("s*")
+    else
+      raise StandardError, "Bits per sample is #{@bits_per_samples}, only 8 or 16 are supported"
+    end
+
+    file = File.open(path, "w")
+    file.syswrite(file_contents)
+    file.close
+  end
+  
+  def sample_data()
+    return @sample_data
+  end
+  
+  def normalized_sample_data()    
+    if @bits_per_sample == 8
+      min_value = 128.0
+      max_value = 127.0
+      midpoint = 128
+    elsif @bits_per_sample == 16
+      min_value = 32768.0
+      max_value = 32767.0
+      midpoint = 0
+    else
+      raise StandardError, "Bits per sample is #{@bits_per_samples}, only 8 or 16 are supported"
+    end
+    
+    if mono?
+      normalized_sample_data = @sample_data.map {|sample|
+        sample -= midpoint
+        if sample < 0
+          sample.to_f / min_value
+        else
+          sample.to_f / max_value
+        end
+      }
+    else
+      normalized_sample_data = @sample_data.map {|sample|
+        sample.map {|sub_sample|
+          sub_sample -= midpoint
+          if sub_sample < 0
+            sub_sample.to_f / min_value
+          else
+            sub_sample.to_f / max_value
+          end
+        }
+      }
+    end
+    
+    return normalized_sample_data
+  end
+  
+  def sample_data=(sample_data)
+    if sample_data.length > 0 && ((mono? && sample_data[0].class == Float) ||
+                                  (!mono? && sample_data[0][0].class == Float))
+      if @bits_per_sample == 8
+        # Samples in 8-bit wave files are stored as a unsigned byte
+        # Effective values are 0 to 255, midpoint at 128
+        min_value = 128.0
+        max_value = 127.0
+        midpoint = 128
+      elsif @bits_per_sample == 16
+        # Samples in 16-bit wave files are stored as a signed little-endian short
+        # Effective values are -32768 to 32767, midpoint at 0
+        min_value = 32768.0
+        max_value = 32767.0
+        midpoint = 0
+      else
+        raise StandardError, "Bits per sample is #{@bits_per_samples}, only 8 or 16 are supported"
+      end
+      
+      if mono?
+        @sample_data = sample_data.map {|sample|
+          if(sample < 0.0)
+            (sample * min_value).round + midpoint
+          else
+            (sample * max_value).round + midpoint
+          end
+        }
+      else
+        @sample_data = sample_data.map {|sample|
+          sample.map {|sub_sample|
+            if(sub_sample < 0.0)
+              (sub_sample * min_value).round + midpoint
+            else
+              (sub_sample * max_value).round + midpoint
+            end
+          }
+        }
+      end
+    else
+      @sample_data = sample_data
+    end
+  end
+
+  def mono?()
+    return num_channels == 1
+  end
+  
+  def stereo?()
+    return num_channels == 2
+  end
+  
+  def reverse()
+    sample_data.reverse!()
+  end
+  
+  def duration()
+    total_samples = sample_data.length
+    samples_per_millisecond = @sample_rate / 1000.0
+    samples_per_second = @sample_rate
+    samples_per_minute = samples_per_second * 60
+    samples_per_hour = samples_per_minute * 60
+    hours, minutes, seconds, milliseconds = 0, 0, 0, 0
+    
+    if(total_samples >= samples_per_hour)
+      hours = total_samples / samples_per_hour
+      total_samples -= samples_per_hour * hours
+    end
+    
+    if(total_samples >= samples_per_minute)
+      minutes = total_samples / samples_per_minute
+      total_samples -= samples_per_minute * minutes
+    end
+    
+    if(total_samples >= samples_per_second)
+      seconds = total_samples / samples_per_second
+      total_samples -= samples_per_second * seconds
+    end
+    
+    milliseconds = (total_samples / samples_per_millisecond).floor
+    
+    return  { :hours => hours, :minutes => minutes, :seconds => seconds, :milliseconds => milliseconds }
+  end
+
+  def bits_per_sample=(new_bits_per_sample)
+    if new_bits_per_sample != 8 && new_bits_per_sample != 16
+      raise StandardError, "Bits per sample of #{@bits_per_samples} is invalid, only 8 or 16 are supported"
+    end
+    
+    if @bits_per_sample == 16 && new_bits_per_sample == 8
+      conversion_func = lambda {|sample|
+        if(sample < 0)
+          (sample / 256) + 128
+        else
+          # Faster to just divide by integer 258?
+          (sample / 258.007874015748031).round + 128
+        end
+      }
+
+      if mono?
+        @sample_data.map! &conversion_func
+      else
+        sample_data.map! {|sample| sample.map! &conversion_func }
+      end
+    elsif @bits_per_sample == 8 && new_bits_per_sample == 16
+      conversion_func = lambda {|sample|
+        sample -= 128
+        if(sample < 0)
+          sample * 256
+        else
+          # Faster to just multiply by integer 258?
+          (sample * 258.007874015748031).round
+        end
+      }
+      
+      if mono?
+        @sample_data.map! &conversion_func
+      else
+        sample_data.map! {|sample| sample.map! &conversion_func }
+      end
+    end
+    
+    @bits_per_sample = new_bits_per_sample
+  end
+  
+  def num_channels=(new_num_channels)
+    if new_num_channels == :mono
+      new_num_channels = 1
+    elsif new_num_channels == :stereo
+      new_num_channels = 2
+    end
+    
+    # The cases of mono -> stereo and vice-versa are handled in specially,
+    # because those conversion methods are faster than the general methods,
+    # and the large majority of wave files are expected to be either mono or stereo.    
+    if @num_channels == 1 && new_num_channels == 2
+      sample_data.map! {|sample| [sample, sample]}
+    elsif @num_channels == 2 && new_num_channels == 1
+        sample_data.map! {|sample| (sample[0] + sample[1]) / 2}
+    elsif @num_channels == 1 && new_num_channels >= 2
+      sample_data.map! {|sample| [].fill(sample, 0, new_num_channels)}
+    elsif @num_channels >= 2 && new_num_channels == 1
+      sample_data.map! {|sample| sample.inject(0) {|sub_sample, sum| sum + sub_sample } / @num_channels }
+    elsif @num_channels > 2 && new_num_channels == 2
+      sample_data.map! {|sample| [sample[0], sample[1]]}
+    end
+    
+    @num_channels = new_num_channels
+  end
+
+  def inspect()
+    duration = self.duration()
+    
+    result =  "Channels:        #{@num_channels}\n" +
+              "Sample rate:     #{@sample_rate}\n" +
+              "Bits per sample: #{@bits_per_sample}\n" +
+              "Block align:     #{@block_align}\n" +
+              "Byte rate:       #{@byte_rate}\n" +
+              "Sample count:    #{@sample_data.length}\n" +
+              "Duration:        #{duration[:hours]}h:#{duration[:minutes]}m:#{duration[:seconds]}s:#{duration[:milliseconds]}ms\n"
+  end
+
+  attr_reader :num_channels, :bits_per_sample, :byte_rate, :block_align
+  attr_accessor :sample_rate
+  
+private
+
+  def self.read_header(file)
+    header = {}
+    
+    # Read RIFF header
+    riff_header = file.sysread(12).unpack("a4Va4")
+    header[:chunk_id] = riff_header[0]
+    header[:chunk_size] = riff_header[1]
+    header[:format] = riff_header[2]
+    
+    # Read format subchunk
+    header[:sub_chunk1_id], header[:sub_chunk1_size] = self.read_to_chunk(file, FORMAT_CHUNK_ID)
+    format_subchunk_str = file.sysread(header[:sub_chunk1_size])
+    format_subchunk = format_subchunk_str.unpack("vvVVvv")  # Any extra parameters are ignored
+    header[:audio_format] = format_subchunk[0]
+    header[:num_channels] = format_subchunk[1]
+    header[:sample_rate] = format_subchunk[2]
+    header[:byte_rate] = format_subchunk[3]
+    header[:block_align] = format_subchunk[4]
+    header[:bits_per_sample] = format_subchunk[5]
+    
+    # Read data subchunk
+    header[:sub_chunk2_id], header[:sub_chunk2_size] = self.read_to_chunk(file, DATA_CHUNK_ID)
+    
+    return header
+  end
+
+  def self.read_to_chunk(file, expected_chunk_id)
+    chunk_id = file.sysread(4)
+    chunk_size = file.sysread(4).unpack("V")[0]
+
+    while chunk_id != expected_chunk_id
+      # Skip chunk
+      file.sysread(chunk_size)
+      
+      chunk_id = file.sysread(4)
+      chunk_size = file.sysread(4).unpack("V")[0]
+    end
+    
+    return chunk_id, chunk_size
+  end
+
+  def self.validate_header(header)
+    errors = []
+    
+    unless header[:bits_per_sample] == 8  ||  header[:bits_per_sample] == 16
+      errors << "Invalid bits per sample of #{header[:bits_per_sample]}. Only 8 and 16 are supported."
+    end
+    
+    unless (1..65535) === header[:num_channels]
+      errors << "Invalid number of channels. Must be between 1 and 65535."
+    end
+    
+    unless header[:chunk_id] == CHUNK_ID
+      errors << "Unsupported chunk ID: '#{header[:chunk_id]}'"
+    end
+    
+    unless header[:format] == FORMAT
+      errors << "Unsupported format: '#{header[:format]}'"
+    end
+    
+    unless header[:sub_chunk1_id] == FORMAT_CHUNK_ID
+      errors << "Unsupported chunk id: '#{header[:sub_chunk1_id]}'"
+    end
+    
+    unless header[:audio_format] == PCM
+      errors << "Unsupported audio format code: '#{header[:audio_format]}'"
+    end
+    
+    unless header[:sub_chunk2_id] == DATA_CHUNK_ID
+      errors << "Unsupported chunk id: '#{header[:sub_chunk2_id]}'"
+    end
+    
+    return errors
+  end
+  
+  # Assumes that file is "queued up" to the first sample
+  def self.read_sample_data(file, num_channels, bits_per_sample, sample_data_size)
+    if(bits_per_sample == 8)
+      data = file.sysread(sample_data_size).unpack("C*")
+    elsif(bits_per_sample == 16)
+      data = file.sysread(sample_data_size).unpack("s*")
+    else
+      data = []
+    end
+    
+    if(num_channels > 1)
+      multichannel_data = []
+      
+      i = 0
+      while i < data.length
+        multichannel_data << data[i...(num_channels + i)]
+        i += num_channels
+      end
+      
+      data = multichannel_data
+    end
+    
+    return data
+  end
+end