wavefile 0.4.0 → 0.5.0

data/test/info_test.rb

@@ -12,7 +12,7 @@ class InfoTest < Test::Unit::TestCase
     format_chunk = { :audio_format => 1, :channels => 2, :sample_rate => 44100,
                      :byte_rate => 176400, :block_align => 4, :bits_per_sample => 16 }
     info = Info.new(FILE_NAME, format_chunk, 44100)
-    
+
     assert_equal(FILE_NAME, info.file_name)
     assert_equal(1, info.audio_format)
     assert_equal(2, info.channels)
@@ -20,41 +20,13 @@ class InfoTest < Test::Unit::TestCase
     assert_equal(176400, info.byte_rate)
     assert_equal(4, info.block_align)
     assert_equal(16, info.bits_per_sample)
-    assert_equal(44100, info.sample_count)
-    assert_equal({:hours => 0, :minutes => 0, :seconds => 1, :milliseconds => 0}, info.duration)
-  end
-
-  def test_duration
-    format_chunk = { :audio_format => 1, :channels => 2, :byte_rate => 176400, :block_align => 4, :bits_per_sample => 16 }
-
-    # Test common sample rates (22050 and 44100), and some crazy arbitrary sample rate (12346)
-    [22050, 44100, 12346].each do |sample_rate|
-      format_chunk[:sample_rate] = sample_rate
-
-      info = Info.new(FILE_NAME, format_chunk, 0)
-      assert_equal({:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 0}, info.duration)
-
-      info = Info.new(FILE_NAME, format_chunk, sample_rate / 2)
-      assert_equal({:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 500}, info.duration)
-
-      info = Info.new(FILE_NAME, format_chunk, sample_rate)
-      assert_equal({:hours => 0, :minutes => 0, :seconds => 1, :milliseconds => 0}, info.duration)
-
-      info = Info.new(FILE_NAME, format_chunk, sample_rate * SECONDS_IN_MINUTE)
-      assert_equal({:hours => 0, :minutes => 1, :seconds => 0, :milliseconds => 0}, info.duration)
-
-      info = Info.new(FILE_NAME, format_chunk, sample_rate * SECONDS_IN_HOUR)
-      assert_equal({:hours => 1, :minutes => 0, :seconds => 0, :milliseconds => 0}, info.duration)
-
-      info = Info.new(FILE_NAME, format_chunk, (sample_rate * SECONDS_IN_MINUTE) + sample_rate + (sample_rate / 2))
-      assert_equal({:hours => 0, :minutes => 1, :seconds => 1, :milliseconds => 500}, info.duration)
-    end
-
-    # Test for when the number of hours is more than a day.
-    format_chunk[:sample_rate] = 44100
-    samples_per_hour = 44100 * 60 * 60
-    info = Info.new(FILE_NAME, format_chunk, samples_per_hour * 25)
-    assert_equal({:hours => 25, :minutes => 0, :seconds => 0, :milliseconds => 0}, info.duration)
+    assert_equal(44100, info.sample_frame_count)
+
+    assert_equal(0, info.duration.hours)
+    assert_equal(0, info.duration.minutes)
+    assert_equal(1, info.duration.seconds)
+    assert_equal(0, info.duration.milliseconds)
+    assert_equal(44100, info.duration.sample_frame_count)
+    assert_equal(44100, info.duration.sample_rate)
   end
 end
-

data/test/reader_test.rb

@@ -9,7 +9,7 @@ class ReaderTest < Test::Unit::TestCase
 
   FIXTURE_ROOT_PATH = "test/fixtures"
 
-  
+
   def test_nonexistent_file
     assert_raise(Errno::ENOENT) { Reader.new(fixture("i_do_not_exist.wav")) }
 
@@ -17,63 +17,77 @@ class ReaderTest < Test::Unit::TestCase
   end
 
   def test_invalid_formats
-    # Reader.new() and Reader.info() should raise the same errors for invalid files,
-    # so run the tests for both methods.
-    [:new, :info].each do |method_name|
+    invalid_fixtures = [
       # File contains 0 bytes
-      assert_raise(InvalidFormatError) { Reader.send(method_name, fixture("invalid/empty.wav")) }
+      "invalid/empty.wav",
 
       # File consists of "RIFF" and nothing else
-      assert_raise(InvalidFormatError) { Reader.send(method_name, fixture("invalid/incomplete_riff_header.wav")) }
+      "invalid/incomplete_riff_header.wav",
 
       # First 4 bytes in the file are not "RIFF"
-      assert_raise(InvalidFormatError) { Reader.send(method_name, fixture("invalid/bad_riff_header.wav")) }
+      "invalid/bad_riff_header.wav",
 
       # The format code in the RIFF header is not "WAVE"
-      assert_raise(InvalidFormatError) { Reader.new(fixture("invalid/bad_wavefile_format.wav")) }
+      "invalid/bad_wavefile_format.wav",
 
       # The file consists of just a valid RIFF header
-      assert_raise(InvalidFormatError) { Reader.new(fixture("invalid/no_format_chunk.wav")) }
+      "invalid/no_format_chunk.wav",
 
       # The format chunk has 0 bytes in it (despite the chunk size being 16)
-      assert_raise(InvalidFormatError) { Reader.new(fixture("invalid/empty_format_chunk.wav")) }
+      "invalid/empty_format_chunk.wav",
 
       # The format chunk has some data, but not all of the minimum required.
-      assert_raise(InvalidFormatError) { Reader.new(fixture("invalid/insufficient_format_chunk.wav")) }
+      "invalid/insufficient_format_chunk.wav",
 
       # The RIFF header and format chunk are OK, but there is no data chunk
-      assert_raise(InvalidFormatError) { Reader.new(fixture("invalid/no_data_chunk.wav")) }
+      "invalid/no_data_chunk.wav",
+    ]
+
+    # Reader.new and Reader.info should raise the same errors for invalid files,
+    # so run the tests for both methods.
+    [:new, :info].each do |method_name|
+      invalid_fixtures.each do |fixture_name|
+        assert_raise(InvalidFormatError) { Reader.send(method_name, fixture(fixture_name)) }
+      end
     end
   end
 
   def test_unsupported_formats
-    # Audio format is 2, which is not supported
-    assert_raise(UnsupportedFormatError) { Reader.new(fixture("unsupported/unsupported_audio_format.wav")) }
+    unsupported_fixtures = [
+      # Audio format is 2, which is not supported
+      "unsupported/unsupported_audio_format.wav",
 
-    # Bits per sample is 24, which is not supported
-    assert_raise(UnsupportedFormatError) { Reader.new(fixture("unsupported/unsupported_bits_per_sample.wav")) }
+      # Bits per sample is 24, which is not supported
+      "unsupported/unsupported_bits_per_sample.wav",
 
-    # Channel count is 0
-    assert_raise(UnsupportedFormatError) { Reader.new(fixture("unsupported/bad_channel_count.wav")) }
+      # Channel count is 0
+      "unsupported/bad_channel_count.wav",
 
-    # Sample rate is 0
-    assert_raise(UnsupportedFormatError) { Reader.new(fixture("unsupported/bad_sample_rate.wav")) }
+      # Sample rate is 0
+      "unsupported/bad_sample_rate.wav",
+    ]
+
+    unsupported_fixtures.each do |fixture_name|
+      assert_raise(UnsupportedFormatError) { Reader.new(fixture(fixture_name)) }
+    end
   end
 
   def test_initialize
-    format = Format.new(:stereo, 16, 22050)
+    format = Format.new(:stereo, :pcm_16, 22050)
 
-    exhaustively_test do |channels, bits_per_sample|
-      file_name = fixture("valid/valid_#{channels}_#{bits_per_sample}_44100.wav")
+    exhaustively_test do |channels, sample_format|
+      file_name = fixture("valid/valid_#{channels}_#{sample_format}_44100.wav")
 
       # Read native format
       reader = Reader.new(file_name)
       assert_equal(CHANNEL_ALIAS[channels], reader.format.channels)
-      assert_equal(bits_per_sample, reader.format.bits_per_sample)
+      assert_equal(extract_bits_per_sample(sample_format), reader.format.bits_per_sample)
       assert_equal(44100, reader.format.sample_rate)
       assert_equal(false, reader.closed?)
       assert_equal(file_name, reader.file_name)
-      reader.close()
+      assert_equal(0, reader.current_sample_frame)
+      assert_equal(2240, reader.total_sample_frames)
+      reader.close
 
       # Read a non-native format
       reader = Reader.new(file_name, format)
@@ -82,109 +96,119 @@ class ReaderTest < Test::Unit::TestCase
       assert_equal(22050, reader.format.sample_rate)
       assert_equal(false, reader.closed?)
       assert_equal(file_name, reader.file_name)
-      reader.close()
+      assert_equal(0, reader.current_sample_frame)
+      assert_equal(2240, reader.total_sample_frames)
+      reader.close
 
       # Block is given.
       reader = Reader.new(file_name) {|reader| reader.read(1024) }
       assert_equal(CHANNEL_ALIAS[channels], reader.format.channels)
-      assert_equal(bits_per_sample, reader.format.bits_per_sample)
+      assert_equal(extract_bits_per_sample(sample_format), reader.format.bits_per_sample)
       assert_equal(44100, reader.format.sample_rate)
       assert(reader.closed?)
       assert_equal(file_name, reader.file_name)
+      assert_equal(1024, reader.current_sample_frame)
+      assert_equal(2240, reader.total_sample_frames)
     end
   end
 
   def test_read_native_format
-    exhaustively_test do |channels, bits_per_sample|
-      buffers = read_file("valid/valid_#{channels}_#{bits_per_sample}_44100.wav", 1024)
+    exhaustively_test do |channels, sample_format|
+      buffers = read_file("valid/valid_#{channels}_#{sample_format}_44100.wav", 1024)
 
       assert_equal(3, buffers.length)
       assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
-      assert_equal(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 128, buffers[0].samples)
-      assert_equal(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 128, buffers[1].samples)
-      assert_equal(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 24,  buffers[2].samples)
+      assert_equal(SQUARE_WAVE_CYCLE[channels][sample_format] * 128, buffers[0].samples)
+      assert_equal(SQUARE_WAVE_CYCLE[channels][sample_format] * 128, buffers[1].samples)
+      assert_equal(SQUARE_WAVE_CYCLE[channels][sample_format] * 24,  buffers[2].samples)
     end
   end
 
   def test_read_with_format_conversion
-    buffers = read_file("valid/valid_mono_16_44100.wav", 1024, Format.new(:stereo, 8, 22100))
+    buffers = read_file("valid/valid_mono_pcm_16_44100.wav", 1024, Format.new(:stereo, :pcm_8, 22100))
 
     assert_equal(3, buffers.length)
     assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
-    assert_equal(SQUARE_WAVE_CYCLE[:stereo][8] * 128, buffers[0].samples)
-    assert_equal(SQUARE_WAVE_CYCLE[:stereo][8] * 128, buffers[1].samples)
-    assert_equal(SQUARE_WAVE_CYCLE[:stereo][8] * 24,  buffers[2].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_8] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_8] * 128, buffers[1].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_8] * 24,  buffers[2].samples)
   end
 
   def test_read_with_padding_byte
-    buffers = read_file("valid/valid_mono_8_44100_with_padding_byte.wav", 1024)
+    buffers = read_file("valid/valid_mono_pcm_8_44100_with_padding_byte.wav", 1024)
 
     assert_equal(3, buffers.length)
     assert_equal([1024, 1024, 191], buffers.map {|buffer| buffer.samples.length })
-    assert_equal(SQUARE_WAVE_CYCLE[:mono][8] * 128, buffers[0].samples)
-    assert_equal(SQUARE_WAVE_CYCLE[:mono][8] * 128, buffers[1].samples)
-    assert_equal((SQUARE_WAVE_CYCLE[:mono][8] * 23) + [88, 88, 88, 88, 167, 167, 167], 
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 128, buffers[1].samples)
+    assert_equal((SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 23) + [88, 88, 88, 88, 167, 167, 167],
                  buffers[2].samples)
   end
 
   def test_each_buffer_no_block_given
-    reader = Reader.new(fixture("valid/valid_mono_16_44100.wav"))
+    reader = Reader.new(fixture("valid/valid_mono_pcm_16_44100.wav"))
     assert_raise(LocalJumpError) { reader.each_buffer(1024) }
   end
 
   def test_each_buffer_native_format
-    exhaustively_test do |channels, bits_per_sample|  
-      reader = Reader.new(fixture("valid/valid_#{channels}_#{bits_per_sample}_44100.wav"))
+    exhaustively_test do |channels, sample_format|
+      reader = Reader.new(fixture("valid/valid_#{channels}_#{sample_format}_44100.wav"))
 
       buffers = []
       reader.each_buffer(1024) {|buffer| buffers << buffer }
-    
+
       assert(reader.closed?)
       assert_equal(3, buffers.length)
       assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
-      assert_equal(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 128, buffers[0].samples)
-      assert_equal(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 128, buffers[1].samples)
-      assert_equal(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 24,  buffers[2].samples)
+      assert_equal(SQUARE_WAVE_CYCLE[channels][sample_format] * 128, buffers[0].samples)
+      assert_equal(SQUARE_WAVE_CYCLE[channels][sample_format] * 128, buffers[1].samples)
+      assert_equal(SQUARE_WAVE_CYCLE[channels][sample_format] * 24,  buffers[2].samples)
+      assert_equal(2240, reader.current_sample_frame)
+      assert_equal(2240, reader.total_sample_frames)
     end
   end
 
   def test_each_buffer_with_format_conversion
-    reader = Reader.new(fixture("valid/valid_mono_16_44100.wav"), Format.new(:stereo, 8, 22050))
+    reader = Reader.new(fixture("valid/valid_mono_pcm_16_44100.wav"), Format.new(:stereo, :pcm_8, 22050))
     assert_equal(2, reader.format.channels)
     assert_equal(8, reader.format.bits_per_sample)
     assert_equal(22050, reader.format.sample_rate)
 
     buffers = []
     reader.each_buffer(1024) {|buffer| buffers << buffer }
-    
+
     assert_equal(3, buffers.length)
     assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
-    assert_equal(SQUARE_WAVE_CYCLE[:stereo][8] * 128, buffers[0].samples)
-    assert_equal(SQUARE_WAVE_CYCLE[:stereo][8] * 128, buffers[1].samples)
-    assert_equal(SQUARE_WAVE_CYCLE[:stereo][8] * 24,  buffers[2].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_8] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_8] * 128, buffers[1].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_8] * 24,  buffers[2].samples)
+    assert_equal(2240, reader.current_sample_frame)
+    assert_equal(2240, reader.total_sample_frames)
   end
 
   def test_each_buffer_with_padding_byte
     buffers = []
-    reader = Reader.new(fixture("valid/valid_mono_8_44100_with_padding_byte.wav"))
+    reader = Reader.new(fixture("valid/valid_mono_pcm_8_44100_with_padding_byte.wav"))
     reader.each_buffer(1024) {|buffer| buffers << buffer }
 
     assert_equal(3, buffers.length)
     assert_equal([1024, 1024, 191], buffers.map {|buffer| buffer.samples.length })
-    assert_equal(SQUARE_WAVE_CYCLE[:mono][8] * 128, buffers[0].samples)
-    assert_equal(SQUARE_WAVE_CYCLE[:mono][8] * 128, buffers[1].samples)
-    assert_equal((SQUARE_WAVE_CYCLE[:mono][8] * 23) + [88, 88, 88, 88, 167, 167, 167], 
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 128, buffers[1].samples)
+    assert_equal((SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 23) + [88, 88, 88, 88, 167, 167, 167],
                  buffers[2].samples)
+    assert_equal(2239, reader.current_sample_frame)
+    assert_equal(2239, reader.total_sample_frames)
   end
 
   def test_closed?
-    reader = Reader.new(fixture("valid/valid_mono_16_44100.wav"))
+    reader = Reader.new(fixture("valid/valid_mono_pcm_16_44100.wav"))
     assert_equal(false, reader.closed?)
-    reader.close()
+    reader.close
     assert(reader.closed?)
 
-    # For Reader.each_buffer()
-    reader = Reader.new(fixture("valid/valid_mono_16_44100.wav"))
+    # For Reader.each_buffer
+    reader = Reader.new(fixture("valid/valid_mono_pcm_16_44100.wav"))
     assert_equal(false, reader.closed?)
     reader.each_buffer(1024) do |buffer|
       # No-op
@@ -193,12 +217,73 @@ class ReaderTest < Test::Unit::TestCase
   end
 
   def test_read_after_close
-    reader = Reader.new(fixture("valid/valid_mono_16_44100.wav"))
+    reader = Reader.new(fixture("valid/valid_mono_pcm_16_44100.wav"))
     buffer = reader.read(1024)
-    reader.close()
+    reader.close
     assert_raise(IOError) { reader.read(1024) }
   end
 
+  def test_sample_counts_manual_reads
+    exhaustively_test do |channels, sample_format|
+      reader = Reader.new(fixture("valid/valid_#{channels}_#{sample_format}_44100.wav"))
+      
+      assert_equal(0, reader.current_sample_frame)
+      assert_equal(2240, reader.total_sample_frames)
+      test_duration({:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 50, :sample_count => 2240},
+                    reader.total_duration)
+
+
+      reader.read(1024)
+      assert_equal(1024, reader.current_sample_frame)
+      assert_equal(2240, reader.total_sample_frames)
+      test_duration({:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 50, :sample_count => 2240},
+                    reader.total_duration)
+
+
+      reader.read(1024)
+      assert_equal(2048, reader.current_sample_frame)
+      assert_equal(2240, reader.total_sample_frames)
+      test_duration({:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 50, :sample_count => 2240},
+                    reader.total_duration)
+
+
+      reader.read(192)
+      assert_equal(2240, reader.current_sample_frame)
+      assert_equal(2240, reader.total_sample_frames)
+      test_duration({:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 50, :sample_count => 2240},
+                    reader.total_duration)
+ 
+
+      reader.close
+      assert_equal(2240, reader.current_sample_frame)
+      assert_equal(2240, reader.total_sample_frames)
+      test_duration({:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 50, :sample_count => 2240},
+                    reader.total_duration)
+    end
+  end
+
+  def test_sample_counts_each_buffer
+    exhaustively_test do |channels, sample_format|
+      expected_results = [ 1024, 2048, 2240 ]
+
+      file_name = fixture("valid/valid_#{channels}_#{sample_format}_44100.wav")
+      reader = Reader.new(file_name)
+
+      assert_equal(0, reader.current_sample_frame)
+      assert_equal(2240, reader.total_sample_frames)
+
+      reader.each_buffer(1024) do |buffer|
+        expected_result = expected_results.slice!(0)
+
+        assert_equal(expected_result, reader.current_sample_frame)
+        assert_equal(2240, reader.total_sample_frames)
+      end
+      
+      assert_equal(2240, reader.current_sample_frame)
+      assert_equal(2240, reader.total_sample_frames)
+    end
+  end
+
 private
 
   def read_file(file_name, buffer_size, format=nil)
@@ -210,7 +295,7 @@ private
         buffers << reader.read(buffer_size)
       end
     rescue EOFError
-      reader.close()
+      reader.close
     end
 
     return buffers
@@ -219,4 +304,16 @@ private
   def fixture(fixture_name)
     return "#{FIXTURE_ROOT_PATH}/#{fixture_name}"
   end
+
+  def extract_bits_per_sample(sample_format)
+    sample_format.to_s.split("_").last.to_i
+  end
+
+  def test_duration(expected_hash, duration)
+    assert_equal(expected_hash[:hours], duration.hours)
+    assert_equal(expected_hash[:minutes], duration.minutes)
+    assert_equal(expected_hash[:seconds], duration.seconds)
+    assert_equal(expected_hash[:milliseconds], duration.milliseconds)
+    assert_equal(expected_hash[:sample_count], duration.sample_frame_count)
+  end
 end

data/test/wavefile_io_test_helper.rb

@@ -4,43 +4,53 @@ module WaveFileIOTestHelper
   SQUARE_WAVE_CYCLE = {}
   SQUARE_WAVE_CYCLE[:mono] = {}
 
-  SQUARE_WAVE_CYCLE[:mono][8] =    [88, 88, 88, 88, 167, 167, 167, 167]
-  SQUARE_WAVE_CYCLE[:mono][16] =   [-10000, -10000, -10000, -10000, 10000, 10000, 10000, 10000]
-  SQUARE_WAVE_CYCLE[:mono][32] =   [-1000000000, -1000000000, -1000000000, -1000000000,
-                                     1000000000, 1000000000, 1000000000, 1000000000]
+  SQUARE_WAVE_CYCLE[:mono][:pcm_8] =    [88, 88, 88, 88, 167, 167, 167, 167]
+  SQUARE_WAVE_CYCLE[:mono][:pcm_16] =   [-10000, -10000, -10000, -10000, 10000, 10000, 10000, 10000]
+  SQUARE_WAVE_CYCLE[:mono][:pcm_32] =   [-1000000000, -1000000000, -1000000000, -1000000000,
+                                          1000000000, 1000000000, 1000000000, 1000000000]
+  SQUARE_WAVE_CYCLE[:mono][:float_32] = [-0.5, -0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5]
+  SQUARE_WAVE_CYCLE[:mono][:float_64] = SQUARE_WAVE_CYCLE[:mono][:float_32]
 
   SQUARE_WAVE_CYCLE[:stereo] = {}
-  SQUARE_WAVE_CYCLE[:stereo][8] =  [[88, 88], [88, 88], [88, 88], [88, 88],
-                                    [167, 167], [167, 167], [167, 167], [167, 167]]
-  SQUARE_WAVE_CYCLE[:stereo][16] = [[-10000, -10000], [-10000, -10000], [-10000, -10000], [-10000, -10000],
-                                    [10000, 10000], [10000, 10000], [10000, 10000], [10000, 10000]]
-  SQUARE_WAVE_CYCLE[:stereo][32] = [[-1000000000, -1000000000], [-1000000000, -1000000000],
-                                    [-1000000000, -1000000000], [-1000000000, -1000000000],
-                                    [ 1000000000,  1000000000], [ 1000000000,  1000000000],
-                                    [ 1000000000,  1000000000], [ 1000000000,  1000000000]]
+  SQUARE_WAVE_CYCLE[:stereo][:pcm_8] =  [[88, 88], [88, 88], [88, 88], [88, 88],
+                                         [167, 167], [167, 167], [167, 167], [167, 167]]
+  SQUARE_WAVE_CYCLE[:stereo][:pcm_16] = [[-10000, -10000], [-10000, -10000], [-10000, -10000], [-10000, -10000],
+                                         [10000, 10000], [10000, 10000], [10000, 10000], [10000, 10000]]
+  SQUARE_WAVE_CYCLE[:stereo][:pcm_32] = [[-1000000000, -1000000000], [-1000000000, -1000000000],
+                                         [-1000000000, -1000000000], [-1000000000, -1000000000],
+                                         [ 1000000000,  1000000000], [ 1000000000,  1000000000],
+                                         [ 1000000000,  1000000000], [ 1000000000,  1000000000]]
+  SQUARE_WAVE_CYCLE[:stereo][:float_32] = [[-0.5, -0.5], [-0.5, -0.5], [-0.5, -0.5], [-0.5, -0.5],
+                                         [0.5, 0.5], [0.5, 0.5], [0.5, 0.5], [0.5, 0.5]]
+  SQUARE_WAVE_CYCLE[:stereo][:float_64] = SQUARE_WAVE_CYCLE[:stereo][:float_32]
 
   SQUARE_WAVE_CYCLE[:tri] = {}
-  SQUARE_WAVE_CYCLE[:tri][8] =    [[88, 88, 88], [88, 88, 88], [88, 88, 88], [88, 88, 88],
+  SQUARE_WAVE_CYCLE[:tri][:pcm_8] =    [[88, 88, 88], [88, 88, 88], [88, 88, 88], [88, 88, 88],
                                     [167, 167, 167], [167, 167, 167], [167, 167, 167], [167, 167, 167]]
-  SQUARE_WAVE_CYCLE[:tri][16] =   [[-10000, -10000, -10000], [-10000, -10000, -10000],
-                                   [-10000, -10000, -10000], [-10000, -10000, -10000],
-                                   [ 10000,  10000,  10000], [ 10000,  10000,  10000],
-                                   [ 10000,  10000,  10000], [ 10000,  10000,  10000]]
-  SQUARE_WAVE_CYCLE[:tri][32] =   [[-1000000000, -1000000000, -1000000000],
-                                   [-1000000000, -1000000000, -1000000000],
-                                   [-1000000000, -1000000000, -1000000000],
-                                   [-1000000000, -1000000000, -1000000000],
-                                   [ 1000000000,  1000000000,  1000000000],
-                                   [ 1000000000,  1000000000,  1000000000],
-                                   [ 1000000000,  1000000000,  1000000000],
-                                   [ 1000000000,  1000000000,  1000000000]]
-  
-  
-  # Executes the given block against different combinations of number of channels and bits per sample.
+  SQUARE_WAVE_CYCLE[:tri][:pcm_16] =   [[-10000, -10000, -10000], [-10000, -10000, -10000],
+                                        [-10000, -10000, -10000], [-10000, -10000, -10000],
+                                        [ 10000,  10000,  10000], [ 10000,  10000,  10000],
+                                        [ 10000,  10000,  10000], [ 10000,  10000,  10000]]
+  SQUARE_WAVE_CYCLE[:tri][:pcm_32] =   [[-1000000000, -1000000000, -1000000000],
+                                        [-1000000000, -1000000000, -1000000000],
+                                        [-1000000000, -1000000000, -1000000000],
+                                        [-1000000000, -1000000000, -1000000000],
+                                        [ 1000000000,  1000000000,  1000000000],
+                                        [ 1000000000,  1000000000,  1000000000],
+                                        [ 1000000000,  1000000000,  1000000000],
+                                        [ 1000000000,  1000000000,  1000000000]]
+  SQUARE_WAVE_CYCLE[:tri][:float_32] = [[-0.5, -0.5, -0.5], [-0.5, -0.5, -0.5], [-0.5, -0.5, -0.5], [-0.5, -0.5, -0.5],
+                                        [0.5, 0.5, 0.5], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5], [0.5, 0.5, 0.5]]
+  SQUARE_WAVE_CYCLE[:tri][:float_64] = SQUARE_WAVE_CYCLE[:tri][:float_32]
+
+
+  # Executes the given block against different combinations of number of channels and sample_format
   def exhaustively_test
     [:mono, :stereo, :tri].each do |channels|
-      Format::SUPPORTED_BITS_PER_SAMPLE.each do |bits_per_sample|
-        yield(channels, bits_per_sample)
+      [:pcm, :float].each do |sample_format|
+        Format::SUPPORTED_BITS_PER_SAMPLE[sample_format].each do |bits_per_sample|
+          yield(channels, "#{sample_format}_#{bits_per_sample}".to_sym)
+        end
       end
     end
   end