jstrait-wavefile 0.2.1 → 0.3.0

data/README.markdown

@@ -36,6 +36,31 @@ You can get basic metadata:
     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:
 

data/lib/wavefile.rb

@@ -48,10 +48,10 @@ The "data" subchunk contains the size of the data and the actual sound:
 class WaveFile
   CHUNK_ID = "RIFF"
   FORMAT = "WAVE"
-  SUB_CHUNK1_ID = "fmt "
+  FORMAT_CHUNK_ID = "fmt "
   SUB_CHUNK1_SIZE = 16
-  AUDIO_FORMAT = 1
-  SUB_CHUNK2_ID = "data"
+  PCM = 1
+  DATA_CHUNK_ID = "data"
   HEADER_SIZE = 36
 
   def initialize(num_channels, sample_rate, bits_per_sample, sample_data = [])
@@ -71,21 +71,31 @@ class WaveFile
   end
   
   def self.open(path)
-    header = read_header(path)
+    file = File.open(path, "rb")
     
-    if valid_header?(header)
-      sample_data = read_sample_data(path,
-                                     header[:sub_chunk1_size],
-                                     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
-      raise StandardError, "#{path} is either not a valid wave file, or is in an unsupported format"
+    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
@@ -100,15 +110,15 @@ class WaveFile
     file_contents = CHUNK_ID
     file_contents += [HEADER_SIZE + sample_data_size].pack("V")
     file_contents += FORMAT
-    file_contents += SUB_CHUNK1_ID
+    file_contents += FORMAT_CHUNK_ID
     file_contents += [SUB_CHUNK1_SIZE].pack("V")
-    file_contents += [AUDIO_FORMAT].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 += SUB_CHUNK2_ID
+    file_contents += DATA_CHUNK_ID
     file_contents += [sample_data_size].pack("V")
 
     # Write the sample data
@@ -140,7 +150,7 @@ class WaveFile
     return @sample_data
   end
   
-  def normalized_sample_data()
+  def normalized_sample_data()    
     if @bits_per_sample == 8
       min_value = 128.0
       max_value = 127.0
@@ -232,87 +242,213 @@ class WaveFile
   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
 
-  attr_reader :num_channels, :sample_rate, :bits_per_sample, :byte_rate, :block_align
+  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(path)
+  def self.read_header(file)
     header = {}
-    file = File.open(path, "rb")
+    
+    # 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
 
-    begin
-        # 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] = file.sysread(4)
-        header[:sub_chunk1_size] = file.sysread(4).unpack("V")[0]
-        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] = file.sysread(4)
-        header[:sub_chunk2_size] = file.sysread(4).unpack("V")[0]
-    rescue EOFError
-      file.close()
+  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 header
+    return chunk_id, chunk_size
   end
-  
-  def self.valid_header?(header)
-    valid_bits_per_sample = header[:bits_per_sample] == 8   ||
-                            header[:bits_per_sample] == 16
+
+  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
     
-    valid_num_channels = (1..65535) === header[:num_channels]
+    unless header[:sub_chunk2_id] == DATA_CHUNK_ID
+      errors << "Unsupported chunk id: '#{header[:sub_chunk2_id]}'"
+    end
     
-    return valid_bits_per_sample                    &&
-           valid_num_channels                       &&
-           header[:chunk_id] == CHUNK_ID            &&
-           header[:format] == FORMAT                &&
-           header[:sub_chunk1_id] == SUB_CHUNK1_ID  &&
-           header[:audio_format] == AUDIO_FORMAT    &&
-           header[:sub_chunk2_id] == SUB_CHUNK2_ID
+    return errors
   end
   
-  def self.read_sample_data(path, sub_chunk1_size, num_channels, bits_per_sample, sample_data_size)
-    offset = 20 + sub_chunk1_size + 8
-    file = File.open(path, "rb")
-
-    begin
-        data = file.sysread(offset)
-        
-        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
-    rescue EOFError
-      file.close()
+  # 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

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

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jstrait-wavefile
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors: 
 - Joel Strait
@@ -25,8 +25,10 @@ files:
 - LICENSE
 - README.markdown
 - lib/wavefile.rb
+- test/wavefile_test.rb
 has_rdoc: false
 homepage: http://www.joelstrait.com/
+licenses: 
 post_install_message: 
 rdoc_options: []
 
@@ -47,7 +49,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
 summary: A class for reading and writing Wave files (*.wav)