wavefile 0.3.0

data/LICENSE

@@ -0,0 +1,24 @@
+== WaveFile
+
+# Copyright (c) 2009 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,79 @@
+A Ruby gem for reading and writing wave files (*.wav).
+
+# Installation
+
+First, install the WaveFile gem...
+
+    gem install wavefile
+
+...and include it in your Ruby program:
+
+    require 'wavefile'
+
+# Usage
+
+To open a wave file and get the raw sample data:
+
+    w = WaveFile.open("myfile.wav")
+    samples = w.sample_data
+
+Sample data is stored in an array. For mono files, each sample is a single number. For stereo files, each sample is represented by an array containing a value for the left and right channel.
+
+    # Mono example
+    [0, 128, 255, 128]
+    
+    # Stereo example
+    [[0, 255], [128, 128], [255, 0], [128, 128]]
+
+You can also get the sample data in a normalized form, with each sample between -1.0 and 1.0:
+
+    normalized_samples = w.normalized_sample_data
+
+You can get basic metadata:
+
+    w.num_channels      # 1 for mono, 2 for stereo
+    w.mono?             # Alias for num_channels == 1
+    w.stereo?           # Alias for num_channels == 2
+    w.sample_rate       # 11025, 22050, 44100, etc.
+    w.bits_per_sample   # 8 or 16
+    w.duration          # Example: {:hours => 0, :minutes => 3, :seconds => 12, :milliseconds => 345 }
+
+You can view all of the metadata at once using the `inspect()` method. It returns a multi-line string:
+
+    w.inspect()
+	
+	# Example result:
+	#   Channels:        2
+	#   Sample rate:     44100
+	#   Bits per sample: 16
+	#   Block align:     4
+	#   Byte rate:       176400
+	#   Sample count:    498070
+	#   Duration:        0h:0m:11s:294ms
+
+You can use setter methods to convert a file to a different format. For example, you can convert a mono file to stereo, or down-sample a 16-bit file to 8-bit.
+
+	w.num_channels = 2
+	w.num_channels = :stereo   // Equivalent to line above
+	w.sample_rate = 22050
+	w.bits_per_sample = 16	
+
+Changes are not saved to disk until you call the `save()` method.
+
+	w.save("myfile.wav")
+
+To create and save a new wave file:
+
+    w = WaveFile.new(1, 44100, 16)  # num_channels,
+                                    # sample_rate,
+                                    # bits_per_sample
+    w.sample_data = <array of samples goes here>
+    w.save("myfile.wav")
+
+When calling the `sample_data=()` method, the passed in array can contain either raw samples or normalized samples. If the first item in the array is a Float, the entire array is assumed to be normalized. Normalized samples are automatically converted into raw samples when saving.
+
+You can reverse a file with the `reverse()` method:
+
+	w = WaveFile.open("myfile.wav")
+	w.reverse()
+	w.save("myfile_reversed.wav")

data/lib/wavefile.rb

@@ -0,0 +1,456 @@
+#!/usr/bin/env ruby
+
+=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

data/test/wavefile_test.rb

@@ -0,0 +1,339 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'wavefile'
+
+class WaveFileTest < Test::Unit::TestCase
+  def test_initialize
+
+  end
+  
+  def test_read_empty_file
+    assert_raise(StandardError) { w = WaveFile.open("examples/invalid/empty.wav") }
+  end
+  
+  def test_read_nonexistent_file
+    assert_raise(Errno::ENOENT) { w = WaveFile.open("examples/invalid/nonexistent.wav") }
+  end
+
+  def test_read_valid_file
+    # Mono file
+    w = WaveFile.open("examples/valid/sine-mono-8bit.wav")
+    assert_equal(w.num_channels, 1)
+    assert_equal(w.mono?, true)
+    assert_equal(w.stereo?, false)
+    assert_equal(w.sample_rate, 44100)
+    assert_equal(w.bits_per_sample, 8)
+    assert_equal(w.byte_rate, 44100)
+    assert_equal(w.block_align, 1)
+    assert_equal(w.sample_data.length, 44100)
+    # Test that sample array is in format [sample, sample ... sample]
+    valid = true
+    w.sample_data.each{|sample| valid &&= (sample.class == Fixnum)}
+    assert_equal(valid, true)
+    
+    # Stereo file
+    w = WaveFile.open("examples/valid/sine-stereo-8bit.wav")
+    assert_equal(w.num_channels, 2)
+    assert_equal(w.mono?, false)
+    assert_equal(w.stereo?, true)
+    assert_equal(w.sample_rate, 44100)
+    assert_equal(w.bits_per_sample, 8)
+    assert_equal(w.byte_rate, 88200)
+    assert_equal(w.block_align, 2)
+    assert_equal(w.sample_data.length, 44100)
+    # Test that sample array is in format [[left, right], [left, right] ... [left,right]]
+    valid = true
+    w.sample_data.each{|sample| valid &&= (sample.class == Array) && (sample.length == 2)}
+    assert_equal(valid, true)
+  end
+  
+  def test_new_file
+    # Mono
+    w = WaveFile.new(1, 44100, 8)
+    assert_equal(w.num_channels, 1)
+    assert_equal(w.sample_rate, 44100)
+    assert_equal(w.bits_per_sample, 8)
+    assert_equal(w.byte_rate, 44100)
+    assert_equal(w.block_align, 1)
+    
+    # Mono
+    w = WaveFile.new(:mono, 44100, 8)
+    assert_equal(w.num_channels, 1)
+    assert_equal(w.sample_rate, 44100)
+    assert_equal(w.bits_per_sample, 8)
+    assert_equal(w.byte_rate, 44100)
+    assert_equal(w.block_align, 1)
+    
+    # Stereo
+    w = WaveFile.new(2, 44100, 16)
+    assert_equal(w.num_channels, 2)
+    assert_equal(w.sample_rate, 44100)
+    assert_equal(w.bits_per_sample, 16)
+    assert_equal(w.byte_rate, 176400)
+    assert_equal(w.block_align, 4)
+    
+    # Stereo
+    w = WaveFile.new(:stereo, 44100, 16)
+    assert_equal(w.num_channels, 2)
+    assert_equal(w.sample_rate, 44100)
+    assert_equal(w.bits_per_sample, 16)
+    assert_equal(w.byte_rate, 176400)
+    assert_equal(w.block_align, 4)
+    
+    # Quad
+    w = WaveFile.new(4, 44100, 16)
+    assert_equal(w.num_channels, 4)
+    assert_equal(w.sample_rate, 44100)
+    assert_equal(w.bits_per_sample, 16)
+    assert_equal(w.byte_rate, 352800)
+    assert_equal(w.block_align, 8)
+  end
+  
+  def test_normalized_sample_data
+    # Mono 8-bit
+    w = WaveFile.new(:mono, 44100, 8)
+    w.sample_data = [0, 32, 64, 96, 128, 160, 192, 223, 255]
+    assert_equal(w.normalized_sample_data, [-1.0, -0.75, -0.5, -0.25, 0.0,
+                                            (32.0 / 127.0), (64.0 / 127.0), (95.0 / 127.0), 1.0])
+    
+    # Mono 16-bit
+    w = WaveFile.new(:mono, 44100, 16)
+    w.sample_data = [-32768, -24576, -16384, -8192, 0, 8192, 16383, 24575, 32767]
+    assert_equal(w.normalized_sample_data, [-1.0, -0.75, -0.5, -0.25, 0.0,
+                                            (8192.0 / 32767.0), (16383.0 / 32767.0), (24575.0 / 32767.0), 1.0])
+    
+    # Stereo 8-bit
+    w = WaveFile.new(:stereo, 44100, 8)
+    w.sample_data = [[0, 255], [32, 223], [64, 192], [96, 160], [128, 128], [160, 96], [192, 64], [223, 32], [255, 0]]
+    assert_equal(w.normalized_sample_data, [[-1.0, 1.0],
+                                            [-0.75, (95.0 / 127.0)],
+                                            [-0.5, (64.0 / 127.0)],
+                                            [-0.25, (32.0 / 127.0)],
+                                            [0.0, 0.0],
+                                            [(32.0 / 127.0), -0.25],
+                                            [(64.0 / 127.0), -0.5],
+                                            [(95.0 / 127.0), -0.75],
+                                            [1.0, -1.0]])
+                                           
+    # Stereo 16-bit
+    w = WaveFile.new(:stereo, 44100, 16)
+    w.sample_data = [[-32768, 32767], [-24576, 24575], [-16384, 16384], [-8192, 8192], [0, 0], [8192, -8192], [16384, -16384], [24575, -24576], [32767, -32768]]
+    assert_equal(w.normalized_sample_data, [[-1.0, 1.0],
+                                            [-0.75, (24575.0 / 32767.0)],
+                                            [-0.5, (16384.0 / 32767.0)],
+                                            [-0.25, (8192.0 / 32767.0)],
+                                            [0.0, 0.0],
+                                            [(8192.0 / 32767.0), -0.25],
+                                            [(16384.0 / 32767.0), -0.5],
+                                            [(24575.0 / 32767.0), -0.75],
+                                            [1.0, -1.0]])
+  end
+  
+  def test_sample_data=
+    # Mono 8-bit
+    w = WaveFile.new(:mono, 44100, 8)
+    w.sample_data = [-1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.75, 1.0]
+    assert_equal(w.sample_data, [0, 32, 64, 96, 128, 160, 192, 223, 255])
+    
+    # Mono 16-bit
+    w = WaveFile.new(:mono, 44100, 16)
+    w.sample_data = [-1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.75, 1.0]
+    assert_equal(w.sample_data, [-32768, -24576, -16384, -8192, 0, 8192, 16384, 24575, 32767])
+    
+    # Stereo 8-bit
+    w = WaveFile.new(:stereo, 44100, 8)
+    w.sample_data = [[-1.0, 1.0], [-0.75, 0.75], [-0.5, 0.5], [-0.25, 0.25], [0.0, 0.0],
+                     [0.25, -0.25], [0.5, -0.5], [0.75, -0.75], [1.0, -1.0]]
+    assert_equal(w.sample_data, [[0, 255], [32, 223], [64, 192], [96, 160], [128, 128],
+                                 [160, 96], [192, 64], [223, 32], [255, 0]])
+    
+    # Stereo 16-bit
+    w = WaveFile.new(:stereo, 44100, 16)
+    w.sample_data = [[-1.0, 1.0], [-0.75, 0.75], [-0.5, 0.5], [-0.25, 0.25], [0.0, 0.0],
+                     [0.25, -0.25], [0.5, -0.5], [0.75, -0.75], [1.0, -1.0]]
+    assert_equal(w.sample_data, [[-32768, 32767], [-24576, 24575], [-16384, 16384], [-8192, 8192], [0, 0],
+                                 [8192, -8192], [16384, -16384], [24575, -24576], [32767, -32768]])
+  end
+  
+  def test_mono?
+    w = WaveFile.new(1, 44100, 16)
+    assert_equal(w.mono?, true)
+    
+    w = WaveFile.open("examples/valid/sine-mono-8bit.wav")
+    assert_equal(w.mono?, true)
+    
+    w = WaveFile.new(2, 44100, 16)
+    assert_equal(w.mono?, false)
+    
+    w = WaveFile.new(4, 44100, 16)
+    assert_equal(w.mono?, false)
+  end
+  
+  def test_stereo?
+    w = WaveFile.new(1, 44100, 16)
+    assert_equal(w.stereo?, false)
+    
+    w = WaveFile.open("examples/valid/sine-mono-8bit.wav")
+    assert_equal(w.stereo?, false)
+    
+    w = WaveFile.new(2, 44100, 16)
+    assert_equal(w.stereo?, true)
+    
+    w = WaveFile.new(4, 44100, 16)
+    assert_equal(w.stereo?, false)
+  end
+  
+  def test_reverse
+    # Mono
+    w = WaveFile.new(:mono, 44100, 16)
+    w.sample_data = [1, 2, 3, 4, 5]
+    w.reverse
+    assert_equal(w.sample_data, [5, 4, 3, 2, 1])
+  
+    # Stereo
+    w = WaveFile.new(:stereo, 44100, 16)
+    w.sample_data = [[1, 9], [2, 8], [3, 7], [4, 6], [5, 5]]
+    w.reverse
+    assert_equal(w.sample_data, [[5, 5], [4, 6], [3, 7], [2, 8], [1, 9]])
+  end
+  
+  def test_duration()
+    sample_rate = 44100
+    
+    [30001, 22050, 44100].each {|bits_per_sample|
+      [8, 16].each {|bits_per_sample|
+        [:mono, :stereo].each {|num_channels|
+          w = WaveFile.new(num_channels, sample_rate, bits_per_sample)
+          
+          w.sample_data = []
+          assert_equal(w.duration, {:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 0})
+          w.sample_data = get_duration_test_samples(num_channels, (sample_rate.to_f / 1000.0).floor)
+          assert_equal(w.duration, {:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 0})
+          w.sample_data = get_duration_test_samples(num_channels, (sample_rate.to_f / 1000.0).ceil)
+          assert_equal(w.duration, {:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 1})
+          w.sample_data = get_duration_test_samples(num_channels, sample_rate / 2)
+          assert_equal(w.duration, {:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 500})
+          w.sample_data = get_duration_test_samples(num_channels, sample_rate - 1)
+          assert_equal(w.duration, {:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 999})
+          w.sample_data = get_duration_test_samples(num_channels, sample_rate)
+          assert_equal(w.duration, {:hours => 0, :minutes => 0, :seconds => 1, :milliseconds => 0})
+          w.sample_data = get_duration_test_samples(num_channels, sample_rate * 2)
+          assert_equal(w.duration, {:hours => 0, :minutes => 0, :seconds => 2, :milliseconds => 0})
+          w.sample_data = get_duration_test_samples(num_channels, (sample_rate / 2) * 3)
+          assert_equal(w.duration, {:hours => 0, :minutes => 0, :seconds => 1, :milliseconds => 500})
+          
+          # These tests currently take too long to run...
+          #w.sample_data = [].fill(0.0, 0, sample_rate * 60)
+          #assert_equal(w.duration, {:hours => 0, :minutes => 1, :seconds => 0, :milliseconds => 0})
+          #w.sample_data = [].fill(0.0, 0, sample_rate * 60 * 60)
+          #assert_equal(w.duration, {:hours => 1, :minutes => 0, :seconds => 0, :milliseconds => 0})
+        }
+      }
+    }
+  end
+  
+  def get_duration_test_samples(num_channels, num_samples)
+    if num_channels == :mono || num_channels == 1
+      return [].fill(0.0, 0, num_samples)
+    elsif num_channels == :stereo || num_channels == 2
+      return [].fill([0.0, 0.0], 0, num_samples)
+    else
+      return "error"
+    end
+  end
+  
+  def test_bits_per_sample=()
+    # Set bits_per_sample to invalid value (non-8 or non-16)
+    w = WaveFile.open("examples/valid/sine-mono-8bit.wav")
+    assert_raise(StandardError) { w.bits_per_sample = 20 }
+    w = WaveFile.new(:mono, 44100, 16)
+    assert_raise(StandardError) { w.bits_per_sample = 4 }
+    
+    w_before = WaveFile.open("examples/valid/sine-mono-8bit.wav")
+    w_after = WaveFile.open("examples/valid/sine-mono-8bit.wav")
+    w_after.bits_per_sample = 8
+    assert_equal(w_before.sample_data, w_after.sample_data)
+    
+    w_before = WaveFile.open("examples/valid/sine-stereo-8bit.wav")
+    w_after = WaveFile.open("examples/valid/sine-stereo-8bit.wav")
+    w_after.bits_per_sample = 8
+    assert_equal(w_before.sample_data, w_after.sample_data)
+    
+    # Open mono 16 bit file, change to 16 bit, still the same
+    # Open stereo 16 bit file, change to 16 bit, still the same
+    
+    # Open mono 8 bit file, convert to 16 bit
+    w = WaveFile.new(:mono, 44100, 8)
+    w.sample_data = [0, 32, 64, 96, 128, 160, 192, 223, 255]
+    w.bits_per_sample = 16
+    assert_equal(w.sample_data, [-32768, -24576, -16384, -8192, 0, 8256, 16513, 24511, 32767])
+    
+    # Open stereo 8 bit file, convert to 16 bit
+    w = WaveFile.new(:stereo, 44100, 8)
+    w.sample_data = [[0, 255], [32, 223], [64, 192], [96, 160], [128, 128],
+                    [160, 96], [192, 64], [223, 32], [255, 0]]
+    w.bits_per_sample = 16
+    assert_equal(w.sample_data, [[-32768, 32767], [-24576, 24511], [-16384, 16513], [-8192, 8256], [0, 0],
+                                 [8256, -8192], [16513, -16384], [24511, -24576], [32767, -32768]])
+    
+    # Open mono 16 bit file, convert to 8 bit
+    w = WaveFile.new(:mono, 44100, 16)
+    w.sample_data = [-32768, -24576, -16384, -8192, 0, 8256, 16513, 24511, 32767]
+    w.bits_per_sample = 8
+    assert_equal(w.sample_data, [0, 32, 64, 96, 128, 160, 192, 223, 255])
+    
+    # Open stereo 16 bit file, convert to 8 bit, conversion successful
+    w = WaveFile.new(:stereo, 44100, 16)
+    w.sample_data = [[-32768, 32767], [-24576, 24511], [-16384, 16513], [-8192, 8256], [0, 0],
+                     [8256, -8192], [16513, -16384], [24511, -24576], [32767, -32768]]
+    w.bits_per_sample = 8
+    assert_equal(w.sample_data, [[0, 255], [32, 223], [64, 192], [96, 160], [128, 128],
+                                 [160, 96], [192, 64], [223, 32], [255, 0]])
+    
+    # Open 8 bit mono, convert to 16 bit, back to 8 bit.
+    w_before = WaveFile.open("examples/valid/sine-mono-8bit.wav")
+    w_after = WaveFile.open("examples/valid/sine-mono-8bit.wav")
+    w_after.bits_per_sample = 16
+    assert_not_equal(w_before.sample_data, w_after.sample_data)
+    w_after.bits_per_sample = 8
+    assert_equal(w_before.sample_data, w_after.sample_data)
+    
+    # Open 8 bit stereo, convert to 16 bit, back to 8 bit.
+    w_before = WaveFile.open("examples/valid/sine-stereo-8bit.wav")
+    w_after = WaveFile.open("examples/valid/sine-stereo-8bit.wav")
+    w_after.bits_per_sample = 16
+    assert_not_equal(w_before.sample_data, w_after.sample_data)
+    w_after.bits_per_sample = 8
+    assert_equal(w_before.sample_data, w_after.sample_data)
+    
+    # Open 16 bit mono, convert to 8 bit, back to 16 bit.
+    # Open 16 bit stereo, convert to 8 bit, back to 16 bit.
+  end
+  
+  def test_num_channels=()
+    w = WaveFile.new(:mono, 44100, 16)
+    w.sample_data = [-32768, -24576, -16384, -8192, 0, 8256, 16513, 24511, 32767]
+    w.num_channels = 2
+    assert_equal(w.sample_data, [[-32768, -32768], [-24576, -24576], [-16384, -16384], [-8192, -8192], [0, 0],
+                                 [8256, 8256], [16513, 16513], [24511, 24511], [32767, 32767]])
+                                 
+    w = WaveFile.new(:mono, 44100, 16)
+    w.sample_data = [-32768, -24576, -16384, -8192, 0, 8256, 16513, 24511, 32767]
+    w.num_channels = 3
+    assert_equal(w.sample_data, [[-32768, -32768, -32768], [-24576, -24576, -24576], [-16384, -16384, -16384], [-8192, -8192, -8192], [0, 0, 0],
+                                [8256, 8256, 8256], [16513, 16513, 16513], [24511, 24511, 24511], [32767, 32767, 32767]])
+                                
+    w = WaveFile.new(:stereo, 44100, 16)
+    w.sample_data = [[-32768, -32768], [-24576, -24576], [-16384, -16384], [-8192, -8192], [0, 0],
+                     [8256, 8256], [16513, 16513], [24511, 24511], [32767, 32767]]
+    w.num_channels = 1
+    assert_equal(w.sample_data, [-32768, -24576, -16384, -8192, 0, 8256, 16513, 24511, 32767])
+    
+    w = WaveFile.new(3, 44100, 16)
+    w.sample_data = [[-32768, -32768, -32768], [-24576, -24576, -24576], [-16384, -16384, -16384], [-8192, -8192, -8192], [0, 0, 0],
+                     [8256, 8256, 8256], [16513, 16513, 16513], [24511, 24511, 24511], [32767, 32767, 32767]]
+    w.num_channels = 1
+    assert_equal(w.sample_data, [-32768, -24576, -16384, -8192, 0, 8256, 16513, 24511, 32767])
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: wavefile
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Joel Strait
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-12 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: joel.strait at gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- README.markdown
+- lib/wavefile.rb
+- test/wavefile_test.rb
+has_rdoc: true
+homepage: http://www.joelstrait.com/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A class for reading and writing Wave sound files (*.wav)
+test_files: []
+