wavefile 0.4.0 → 0.5.0

data/test/buffer_test.rb

@@ -5,8 +5,8 @@ include WaveFile
 
 class BufferTest < Test::Unit::TestCase
   def test_convert
-    old_format = Format.new(1, 16, 44100)
-    new_format = Format.new(2, 16, 22050)
+    old_format = Format.new(:mono, :pcm_16, 44100)
+    new_format = Format.new(:stereo, :pcm_16, 22050)
 
     old_buffer = Buffer.new([-100, 0, 200], old_format)
     new_buffer = old_buffer.convert(new_format)
@@ -23,8 +23,8 @@ class BufferTest < Test::Unit::TestCase
   end
 
   def test_convert!
-    old_format = Format.new(1, 16, 44100)
-    new_format = Format.new(2, 16, 22050)
+    old_format = Format.new(:mono, :pcm_16, 44100)
+    new_format = Format.new(:stereo, :pcm_16, 22050)
 
     old_buffer = Buffer.new([-100, 0, 200], old_format)
     new_buffer = old_buffer.convert!(new_format)
@@ -38,38 +38,38 @@ class BufferTest < Test::Unit::TestCase
 
 
   def test_convert_buffer_channels
-    Format::SUPPORTED_BITS_PER_SAMPLE.each do |bits_per_sample|
+    Format::SUPPORTED_BITS_PER_SAMPLE[:pcm].each do |bits_per_sample|
       [44100, 22050].each do |sample_rate|
         # Assert that not changing the number of channels is a no-op
-        b = Buffer.new([-100, 0, 200], Format.new(1, bits_per_sample, sample_rate))
-        b.convert!(Format.new(1, bits_per_sample, sample_rate))
+        b = Buffer.new([-100, 0, 200], Format.new(:mono, bits_per_sample, sample_rate))
+        b.convert!(Format.new(:mono, bits_per_sample, sample_rate))
         assert_equal([-100, 0, 200], b.samples)
 
         # Mono => Stereo
-        b = Buffer.new([-100, 0, 200], Format.new(1, bits_per_sample, sample_rate))
-        b.convert!(Format.new(2, bits_per_sample, sample_rate))
+        b = Buffer.new([-100, 0, 200], Format.new(:mono, bits_per_sample, sample_rate))
+        b.convert!(Format.new(:stereo, bits_per_sample, sample_rate))
         assert_equal([[-100, -100], [0, 0], [200, 200]], b.samples)
 
         # Mono => 3-channel
-        b = Buffer.new([-100, 0, 200], Format.new(1, bits_per_sample, sample_rate))
+        b = Buffer.new([-100, 0, 200], Format.new(:mono, bits_per_sample, sample_rate))
         b.convert!(Format.new(3, bits_per_sample, sample_rate))
         assert_equal([[-100, -100, -100], [0, 0, 0], [200, 200, 200]], b.samples)
 
         # Stereo => Mono
-        b = Buffer.new([[-100, -100], [0, 0], [200, 50], [8, 1]], Format.new(2, bits_per_sample, sample_rate))
-        b.convert!(Format.new(1, bits_per_sample, sample_rate))
+        b = Buffer.new([[-100, -100], [0, 0], [200, 50], [8, 1]], Format.new(:stereo, bits_per_sample, sample_rate))
+        b.convert!(Format.new(:mono, bits_per_sample, sample_rate))
         assert_equal([-100, 0, 125, 4], b.samples)
 
         # 3-channel => Mono
         b = Buffer.new([[-100, -100, -100], [0, 0, 0], [200, 50, 650], [5, 1, 1], [5, 1, 2]],
                        Format.new(3, bits_per_sample, sample_rate))
-        b.convert!(Format.new(1, bits_per_sample, sample_rate))
+        b.convert!(Format.new(:mono, bits_per_sample, sample_rate))
         assert_equal([-100, 0, 300, 2, 2], b.samples)
 
         # 3-channel => Stereo
         b = Buffer.new([[-100, -100, -100], [1, 2, 3], [200, 50, 650]],
                        Format.new(3, bits_per_sample, sample_rate))
-        b.convert!(Format.new(2, bits_per_sample, sample_rate))
+        b.convert!(Format.new(:stereo, bits_per_sample, sample_rate))
         assert_equal([[-100, -100], [1, 2], [200, 50]], b.samples)
 
         # Unsupported conversion (4-channel => 3-channel)
@@ -80,42 +80,232 @@ class BufferTest < Test::Unit::TestCase
     end
   end
 
-  def test_convert_buffer_bits_per_sample
-    # Assert that not changing the number of channels is a no-op
-    b = Buffer.new([-32768, -24576, -16384, -8192, 0, 8192, 16384, 24575, 32767], Format.new(1, 16, 44100))
-    b.convert!(Format.new(1, 16, 44100))
-    assert_equal([-32768, -24576, -16384, -8192, 0, 8192, 16384, 24575, 32767], b.samples)
+  def test_convert_buffer_bits_per_sample_no_op
+    Format::SUPPORTED_BITS_PER_SAMPLE[:pcm].each do |bits_per_sample|
+      b = Buffer.new([0, 128, 255], Format.new(:mono, bits_per_sample, 44100))
+      b.convert!(Format.new(:mono, bits_per_sample, 44100))
+
+      # Target format is the same as the original format, so the sample data should not change
+      assert_equal([0, 128, 255], b.samples)
+    end
+  end
 
-    # 8 => 16, Mono
-    b = Buffer.new([0, 32, 64, 96, 128, 160, 192, 223, 255], Format.new(1, 8, 44100))
-    b.convert!(Format.new(1, 16, 44100))
+  def test_convert_buffer_bits_per_sample_8_to_16
+    # Mono
+    b = Buffer.new([0, 32, 64, 96, 128, 160, 192, 223, 255], Format.new(:mono, :pcm_8, 44100))
+    b.convert!(Format.new(:mono, :pcm_16, 44100))
     assert_equal([-32768, -24576, -16384, -8192, 0, 8192, 16384, 24320, 32512], b.samples)
 
-    # 8 => 32, Mono
-    b = Buffer.new([0, 32, 64, 96, 128, 160, 192, 223, 255], Format.new(1, 8, 44100))
-    b.convert!(Format.new(1, 32, 44100))
+    # Stereo
+    b = Buffer.new([[0, 255],  [32, 223], [64, 192], [96, 160], [128, 128],
+                    [160, 96], [192, 64], [223, 32], [255, 0]],
+                   Format.new(:stereo, :pcm_8, 44100))
+    b.convert!(Format.new(:stereo, :pcm_16, 44100))
+    assert_equal([[-32768, 32512], [-24576, 24320], [-16384, 16384], [-8192, 8192], [0, 0],
+                  [8192, -8192],   [16384, -16384], [24320, -24576], [32512, -32768]],
+                 b.samples)
+  end
+
+  def test_convert_buffer_bits_per_sample_8_to_32
+    # Mono
+    b = Buffer.new([0, 32, 64, 96, 128, 160, 192, 223, 255], Format.new(:mono, :pcm_8, 44100))
+    b.convert!(Format.new(:mono, :pcm_32, 44100))
     assert_equal([-2147483648, -1610612736, -1073741824, -536870912, 0, 536870912, 1073741824, 1593835520, 2130706432], b.samples)
 
-    # 16 => 8, Mono
-    b = Buffer.new([-32768, -24576, -16384, -8192, 0, 8192, 16384, 24575, 32767], Format.new(1, 16, 44100))
-    b.convert!(Format.new(1, 8, 44100))
+    # Stereo
+    b = Buffer.new([[0, 255],  [32, 223], [64, 192], [96, 160], [128, 128],
+                    [160, 96], [192, 64], [223, 32], [255, 0]],
+                   Format.new(:stereo, :pcm_8, 44100))
+    b.convert!(Format.new(:stereo, :pcm_32, 44100))
+    assert_equal([[-2147483648, 2130706432], [-1610612736, 1593835520], [-1073741824, 1073741824], [-536870912, 536870912], [0, 0],
+                  [536870912, -536870912],   [1073741824, -1073741824], [1593835520, -1610612736], [2130706432, -2147483648]],
+                 b.samples)
+  end
+
+  def test_convert_buffer_bits_per_sample_8_to_float
+    Format::SUPPORTED_BITS_PER_SAMPLE[:float].each do |bits_per_sample|
+      float_format = "float_#{bits_per_sample}".to_sym
+
+      # Mono
+      b = Buffer.new([0, 32, 64, 96, 128, 160, 192, 223, 255], Format.new(:mono, :pcm_8, 44100))
+      b.convert!(Format.new(:mono, float_format, 44100))
+      assert_equal([-1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.7421875, 0.9921875], b.samples)
+
+      # Stereo
+      b = Buffer.new([[0, 255],  [32, 223], [64, 192], [96, 160], [128, 128],
+                      [160, 96], [192, 64], [223, 32], [255, 0]],
+                     Format.new(:stereo, :pcm_8, 44100))
+      b.convert!(Format.new(:stereo, float_format, 44100))
+      assert_equal([[-1.0, 0.9921875], [-0.75, 0.7421875], [-0.5, 0.5], [-0.25, 0.25], [0.0, 0.0],
+                    [0.25, -0.25],   [0.5, -0.5], [0.7421875, -0.75], [0.9921875, -1.0]],
+                   b.samples)
+    end
+  end
+
+  def test_convert_buffer_bits_per_sample_16_to_8
+    # Mono
+    b = Buffer.new([-32768, -24576, -16384, -8192, 0, 8192, 16384, 24575, 32767], Format.new(:mono, :pcm_16, 44100))
+    b.convert!(Format.new(:mono, :pcm_8, 44100))
     assert_equal([0, 32, 64, 96, 128, 160, 192, 223, 255], b.samples)
 
-    # 16 => 32, Mono
-    b = Buffer.new([-32768, -24576, -16384, -8192, 0, 8192, 16384, 24575, 32767], Format.new(1, 16, 44100))
-    b.convert!(Format.new(1, 32, 44100))
+    # Stereo
+    b = Buffer.new([[-32768, 32767], [-24576, 24575], [-16384, 16384], [-8192, 8192], [0, 0],
+                    [8192, -8192],   [16384, -16384], [24575, -24576], [32767, -32768]],
+                   Format.new(:stereo, :pcm_16, 44100))
+    b.convert!(Format.new(:stereo, :pcm_8, 44100))
+    assert_equal([[0, 255],  [32, 223], [64, 192], [96, 160], [128, 128],
+                  [160, 96], [192, 64], [223, 32], [255, 0]],
+                 b.samples)
+  end
+
+  def test_convert_buffer_bits_per_sample_16_to_32
+    # Mono
+    b = Buffer.new([-32768, -24576, -16384, -8192, 0, 8192, 16384, 24575, 32767], Format.new(:mono, :pcm_16, 44100))
+    b.convert!(Format.new(:mono, :pcm_32, 44100))
     assert_equal([-2147483648, -1610612736, -1073741824, -536870912, 0, 536870912, 1073741824, 1610547200, 2147418112], b.samples)
 
-    # 32 => 8, Mono
+    # Stereo
+    b = Buffer.new([[-32768, 32767], [-24576, 24575], [-16384, 16384], [-8192, 8192], [0, 0],
+                    [8192, -8192],   [16384, -16384], [24575, -24576], [32767, -32768]],
+                   Format.new(:stereo, :pcm_16, 44100))
+    b.convert!(Format.new(:stereo, :pcm_32, 44100))
+    assert_equal([[-2147483648, 2147418112], [-1610612736, 1610547200], [-1073741824, 1073741824], [-536870912, 536870912], [0, 0],
+                  [536870912, -536870912],   [1073741824, -1073741824], [1610547200, -1610612736], [2147418112, -2147483648]],
+                 b.samples)
+  end
+
+  def test_convert_buffer_bits_per_sample_16_to_float
+    Format::SUPPORTED_BITS_PER_SAMPLE[:float].each do |bits_per_sample|
+      float_format = "float_#{bits_per_sample}".to_sym
+
+      # Mono
+      b = Buffer.new([-32768, -24576, -16384, -8192, 0, 8192, 16384, 24575, 32767], Format.new(:mono, :pcm_16, 44100))
+      b.convert!(Format.new(:mono, float_format, 44100))
+      assert_equal([-1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.749969482421875, 0.999969482421875], b.samples)
+
+      # Stereo
+      b = Buffer.new([[-32768, 32767], [-24576, 24575], [-16384, 16384], [-8192, 8192], [0, 0],
+                      [8192, -8192],   [16384, -16384], [24575, -24576], [32767, -32768]],
+                     Format.new(:stereo, :pcm_16, 44100))
+      b.convert!(Format.new(:stereo, float_format, 44100))
+      assert_equal([[-1.0, 0.999969482421875], [-0.75, 0.749969482421875], [-0.5, 0.5], [-0.25, 0.25], [0.0, 0.0],
+                    [0.25, -0.25], [0.5, -0.5], [0.749969482421875, -0.75], [0.999969482421875, -1.0]],
+                   b.samples)
+    end
+  end
+
+  def test_convert_buffer_bits_per_sample_32_to_8
+    # Mono
     b = Buffer.new([-2147483648, -1610612736, -1073741824, -536870912, 0, 536870912, 1073741824, 1610612735, 2147483647],
-                   Format.new(1, 32, 44100))
-    b.convert!(Format.new(1, 8, 44100))
+                   Format.new(:mono, :pcm_32, 44100))
+    b.convert!(Format.new(:mono, :pcm_8, 44100))
     assert_equal([0, 32, 64, 96, 128, 160, 192, 223, 255], b.samples)
 
-    # 32 => 16, Mono
+    # Stereo
+    b = Buffer.new([[-2147483648, 2147483647], [-1610612736, 1610612735], [-1073741824, 1073741824], [-536870912, 536870912], [0, 0],
+                    [536870912, -536870912],   [1073741824, -1073741824], [1610612735, -1610612736], [2147483647, -2147483648]],
+                   Format.new(:stereo, :pcm_32, 44100))
+    b.convert!(Format.new(:stereo, :pcm_8, 44100))
+    assert_equal([[0, 255],  [32, 223], [64, 192], [96, 160], [128, 128],
+                  [160, 96], [192, 64], [223, 32], [255, 0]],
+                 b.samples)
+  end
+
+  def test_convert_buffer_bits_per_sample_32_to_16
+    # Mono
     b = Buffer.new([-2147483648, -1610612736, -1073741824, -536870912, 0, 536870912, 1073741824, 1610612735, 2147483647],
-                   Format.new(1, 32, 44100))
-    b.convert!(Format.new(1, 16, 44100))
+                   Format.new(:mono, :pcm_32, 44100))
+    b.convert!(Format.new(:mono, :pcm_16, 44100))
     assert_equal([-32768, -24576, -16384, -8192, 0, 8192, 16384, 24575, 32767], b.samples)
+
+    # Stereo
+    b = Buffer.new([[-2147483648, 2147483647], [-1610612736, 1610612735], [-1073741824, 1073741824], [-536870912, 536870912], [0, 0],
+                  [536870912, -536870912],   [1073741824, -1073741824], [1610612735, -1610612736], [2147483647, -2147483648]],
+                   Format.new(:stereo, :pcm_32, 44100))
+    b.convert!(Format.new(:stereo, :pcm_16, 44100))
+    assert_equal([[-32768, 32767], [-24576, 24575], [-16384, 16384], [-8192, 8192], [0, 0],
+                  [8192, -8192],   [16384, -16384], [24575, -24576], [32767, -32768]],
+                 b.samples)
+  end
+
+  def test_convert_buffer_bits_per_sample_32_to_float
+    Format::SUPPORTED_BITS_PER_SAMPLE[:float].each do |bits_per_sample|
+      float_format = "float_#{bits_per_sample}".to_sym
+
+      # Mono
+      b = Buffer.new([-2147483648, -1610612736, -1073741824, -536870912, 0, 536870912, 1073741824, 1610612735, 2147483647],
+                     Format.new(:mono, :pcm_32, 44100))
+      b.convert!(Format.new(:mono, float_format, 44100))
+      assert_equal([-1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.7499999995343387, 0.9999999995343387], b.samples)
+
+      # Stereo
+      b = Buffer.new([[-2147483648, 2147483647], [-1610612736, 1610612735], [-1073741824, 1073741824], [-536870912, 536870912], [0, 0],
+                      [536870912, -536870912],   [1073741824, -1073741824], [1610612735, -1610612736], [2147483647, -2147483648]],
+                     Format.new(:stereo, :pcm_32, 44100))
+      b.convert!(Format.new(:stereo, float_format, 44100))
+      assert_equal([[-1.0, 0.9999999995343387], [-0.75, 0.7499999995343387], [-0.5, 0.5], [-0.25, 0.25], [0.0, 0.0],
+                    [0.25, -0.25], [0.5, -0.5], [0.7499999995343387, -0.75], [0.9999999995343387, -1.0]],
+                   b.samples)
+    end
+  end
+
+  def test_convert_buffer_bits_per_sample_float_to_8
+    Format::SUPPORTED_BITS_PER_SAMPLE[:float].each do |bits_per_sample|
+      float_format = "float_#{bits_per_sample}".to_sym
+
+      # Mono
+      b = Buffer.new([-1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.75, 1.0], Format.new(:mono, float_format, 44100))
+      b.convert!(Format.new(:mono, :pcm_8, 44100))
+      assert_equal([1, 33, 64, 96, 128, 160, 192, 223, 255], b.samples)
+
+      # Stereo
+      b = Buffer.new([[-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]],
+                     Format.new(:stereo, float_format, 44100))
+      b.convert!(Format.new(:stereo, :pcm_8, 44100))
+      assert_equal([[1, 255], [33, 223], [64, 192], [96, 160], [128, 128],
+                    [160, 96], [192, 64], [223, 33], [255, 1]],
+                   b.samples)
+    end
+  end
+
+  def test_convert_buffer_bits_per_sample_float_to_16
+    Format::SUPPORTED_BITS_PER_SAMPLE[:float].each do |bits_per_sample|
+      float_format = "float_#{bits_per_sample}".to_sym
+
+      # Mono
+      b = Buffer.new([-1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.75, 1.0], Format.new(:mono, float_format, 44100))
+      b.convert!(Format.new(:mono, :pcm_16, 44100))
+      assert_equal([-32767, -24575, -16384, -8192, 0, 8192, 16384, 24575, 32767], b.samples)
+
+      # Stereo
+      b = Buffer.new([[-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]],
+                     Format.new(:stereo, float_format, 44100))
+      b.convert!(Format.new(:stereo, :pcm_16, 44100))
+      assert_equal([[-32767, 32767], [-24575, 24575], [-16384, 16384], [-8192, 8192], [0, 0],
+                    [8192, -8192], [16384, -16384], [24575, -24575], [32767, -32767]],
+                   b.samples)
+    end
+  end
+
+  def test_convert_buffer_bits_per_sample_float_to_32
+    Format::SUPPORTED_BITS_PER_SAMPLE[:float].each do |bits_per_sample|
+      float_format = "float_#{bits_per_sample}".to_sym
+
+      # Mono
+      b = Buffer.new([-1.0, -0.75, -0.5, -0.25, 0.0, 0.25, 0.5, 0.75, 1.0], Format.new(:mono, float_format, 44100))
+      b.convert!(Format.new(:mono, :pcm_32, 44100))
+      assert_equal([-2147483647, -1610612735, -1073741824, -536870912, 0, 536870912, 1073741824, 1610612735, 2147483647], b.samples)
+
+      # Stereo
+      b = Buffer.new([[-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]],
+                     Format.new(:stereo, float_format, 44100))
+      b.convert!(Format.new(:stereo, :pcm_32, 44100))
+      assert_equal([[-2147483647, 2147483647], [-1610612735, 1610612735], [-1073741824, 1073741824], [-536870912, 536870912], [0, 0],
+                    [536870912, -536870912], [1073741824, -1073741824], [1610612735, -1610612735], [2147483647, -2147483647]],
+                   b.samples)
+    end
   end
 end

data/test/duration_test.rb

@@ -0,0 +1,73 @@
+require 'test/unit'
+require 'wavefile.rb'
+
+include WaveFile
+
+class DurationTest < Test::Unit::TestCase
+  SECONDS_IN_MINUTE = 60
+  SECONDS_IN_HOUR = SECONDS_IN_MINUTE * 60
+
+  def test_constructor
+    # Test common sample rates (22050 and 44100), and some crazy arbitrary sample rate (12346)
+    [22050, 44100, 12346].each do |sample_rate|
+      duration = Duration.new(0, sample_rate)
+      assert_equal(0, duration.hours)
+      assert_equal(0, duration.minutes)
+      assert_equal(0, duration.seconds)
+      assert_equal(0, duration.milliseconds)
+      assert_equal(0, duration.sample_frame_count)
+      assert_equal(sample_rate, duration.sample_rate)
+
+      duration = Duration.new(sample_rate / 2, sample_rate)
+      assert_equal(0, duration.hours)
+      assert_equal(0, duration.minutes)
+      assert_equal(0, duration.seconds)
+      assert_equal(500, duration.milliseconds)
+      assert_equal(sample_rate / 2, duration.sample_frame_count)
+      assert_equal(sample_rate, duration.sample_rate)
+
+      duration = Duration.new(sample_rate, sample_rate)
+      assert_equal(0, duration.hours)
+      assert_equal(0, duration.minutes)
+      assert_equal(1, duration.seconds)
+      assert_equal(0, duration.milliseconds)
+      assert_equal(sample_rate, duration.sample_frame_count)
+      assert_equal(sample_rate, duration.sample_rate)
+
+      duration = Duration.new(sample_rate * SECONDS_IN_MINUTE, sample_rate)
+      assert_equal(0, duration.hours)
+      assert_equal(1, duration.minutes)
+      assert_equal(0, duration.seconds)
+      assert_equal(0, duration.milliseconds)
+      assert_equal(sample_rate * SECONDS_IN_MINUTE, duration.sample_frame_count)
+      assert_equal(sample_rate, duration.sample_rate)
+
+      duration = Duration.new(sample_rate * SECONDS_IN_HOUR, sample_rate)
+      assert_equal(1, duration.hours)
+      assert_equal(0, duration.minutes)
+      assert_equal(0, duration.seconds)
+      assert_equal(0, duration.milliseconds)
+      assert_equal(sample_rate * SECONDS_IN_HOUR, duration.sample_frame_count)
+      assert_equal(sample_rate, duration.sample_rate)
+
+      sample_frame_count = (sample_rate * SECONDS_IN_MINUTE) + sample_rate + (sample_rate / 2)
+      duration = Duration.new(sample_frame_count, sample_rate)
+      assert_equal(0, duration.hours)
+      assert_equal(1, duration.minutes)
+      assert_equal(1, duration.seconds)
+      assert_equal(500, duration.milliseconds)
+      assert_equal(sample_frame_count, duration.sample_frame_count)
+      assert_equal(sample_rate, duration.sample_rate)
+    end
+
+    # Test for when the number of hours is more than a day.
+    samples_per_hour = 44100 * 60 * 60
+    duration = Duration.new(samples_per_hour * 25, 44100)
+    assert_equal(25, duration.hours)
+    assert_equal(0, duration.minutes)
+    assert_equal(0, duration.seconds)
+    assert_equal(0, duration.milliseconds)
+    assert_equal(samples_per_hour * 25, duration.sample_frame_count)
+    assert_equal(44100, duration.sample_rate)
+  end
+end

data/test/format_test.rb

@@ -4,100 +4,130 @@ require 'wavefile.rb'
 include WaveFile
 
 class FormatTest < Test::Unit::TestCase
-  def test_valid_channels()
+  def test_valid_channels
     [1, 2, 3, 4, 65535].each do |valid_channels|
-      assert_equal(valid_channels, Format.new(valid_channels, 16, 44100).channels)
+      assert_equal(valid_channels, Format.new(valid_channels, :pcm_16, 44100).channels)
     end
 
-    assert_equal(1, Format.new(:mono, 16, 44100).channels)
-    assert_equal(2, Format.new(:stereo, 16, 44100).channels)
+    assert_equal(1, Format.new(:mono, :pcm_16, 44100).channels)
+    assert_equal(2, Format.new(:stereo, :pcm_16, 44100).channels)
   end
 
-  def test_invalid_channels()
+  def test_invalid_channels
     ["dsfsfsdf", :foo, 0, -1, 65536].each do |invalid_channels|
-      assert_raise(InvalidFormatError) { Format.new(invalid_channels, 16, 44100) }
+      assert_raise(InvalidFormatError) { Format.new(invalid_channels, :pcm_16, 44100) }
     end
   end
 
-  def test_valid_bits_per_sample()
-    assert_equal(8, Format.new(1, 8, 44100).bits_per_sample)
-    assert_equal(16, Format.new(1, 16, 44100).bits_per_sample)
-    assert_equal(32, Format.new(1, 32, 44100).bits_per_sample)
+  def test_valid_sample_format
+    assert_equal(:pcm, Format.new(:mono, 8, 44100).sample_format)
+    assert_equal(:pcm, Format.new(:mono, 16, 44100).sample_format)
+    assert_equal(:pcm, Format.new(:mono, 32, 44100).sample_format)
+    assert_equal(:pcm, Format.new(:mono, :pcm_8, 44100).sample_format)
+    assert_equal(:pcm, Format.new(:mono, :pcm_16, 44100).sample_format)
+    assert_equal(:pcm, Format.new(:mono, :pcm_32, 44100).sample_format)
+    assert_equal(:float, Format.new(:mono, :float, 44100).sample_format)
+    assert_equal(:float, Format.new(:mono, :float_32, 44100).sample_format)
+    assert_equal(:float, Format.new(:mono, :float_64, 44100).sample_format)
   end
 
-  def test_invalid_bits_per_sample()
-    ["dsfsfsdf", :foo, 0, 12].each do |invalid_bits_per_sample|
-      assert_raise(InvalidFormatError) { Format.new(1, invalid_bits_per_sample, 44100) }
+  def test_invalid_sample_format
+    ["dsfsfsdf", :foo, 12, :pcm_14, :float_20].each do |invalid_sample_format|
+      assert_raise(InvalidFormatError) { Format.new(:mono, invalid_sample_format, 44100) }
     end
   end
 
-  def test_valid_sample_rate()
-    [1, 44100, 4294967296].each do |valid_sample_rate|
-      assert_equal(valid_sample_rate, Format.new(1, 16, valid_sample_rate).sample_rate)
-    end
+  def test_valid_bits_per_sample
+    assert_equal(8, Format.new(:mono, 8, 44100).bits_per_sample)
+    assert_equal(16, Format.new(:mono, 16, 44100).bits_per_sample)
+    assert_equal(32, Format.new(:mono, 32, 44100).bits_per_sample)
+    assert_equal(8, Format.new(:mono, :pcm_8, 44100).bits_per_sample)
+    assert_equal(16, Format.new(:mono, :pcm_16, 44100).bits_per_sample)
+    assert_equal(32, Format.new(:mono, :pcm_32, 44100).bits_per_sample)
+    assert_equal(32, Format.new(:mono, :float, 44100).bits_per_sample)
+    assert_equal(32, Format.new(:mono, :float_32, 44100).bits_per_sample)
+    assert_equal(64, Format.new(:mono, :float_64, 44100).bits_per_sample)
   end
 
-  def test_invalid_sample_rate()
-    ["dsfsfsdf", :foo, 0, -1, 4294967297].each do |invalid_sample_rate|
-      assert_raise(InvalidFormatError) { Format.new(1, 16, invalid_sample_rate) }
+  def test_invalid_bits_per_sample
+    ["dsfsfsdf", :foo, :pcm, 0, 12, :pcm_14, :pcm_abc, :float_40].each do |invalid_sample_format|
+      assert_raise(InvalidFormatError) { Format.new(:mono, invalid_sample_format, 44100) }
     end
   end
 
-  def test_byte_rate()
-    format = Format.new(1, 8, 44100)
-    assert_equal(44100, format.byte_rate)
-
-    format = Format.new(1, 16, 44100)
-    assert_equal(88200, format.byte_rate)
-
-    format = Format.new(1, 32, 44100)
-    assert_equal(176400, format.byte_rate)
-
-    format = Format.new(2, 8, 44100)
-    assert_equal(88200, format.byte_rate)
-
-    format = Format.new(2, 16, 44100)
-    assert_equal(176400, format.byte_rate)
+  def test_valid_sample_rate
+    [1, 44100, 4294967296].each do |valid_sample_rate|
+      assert_equal(valid_sample_rate, Format.new(:mono, :pcm_16, valid_sample_rate).sample_rate)
+    end
+  end
 
-    format = Format.new(2, 32, 44100)
-    assert_equal(352800, format.byte_rate)
+  def test_invalid_sample_rate
+    ["dsfsfsdf", :foo, 0, -1, 4294967297].each do |invalid_sample_rate|
+      assert_raise(InvalidFormatError) { Format.new(:mono, :pcm_16, invalid_sample_rate) }
+    end
   end
 
-  def test_block_align()
+  def test_byte_and_block_align
     [1, :mono].each do |one_channel|
-      format = Format.new(one_channel, 8, 44100)
-      assert_equal(1, format.block_align)
-
-      format = Format.new(one_channel, 16, 44100)
-      assert_equal(2, format.block_align)
-
-      format = Format.new(one_channel, 32, 44100)
-      assert_equal(4, format.block_align)
+      [:pcm_8, 8].each do |format_code|
+        format = Format.new(one_channel, format_code, 44100)
+        assert_equal(44100, format.byte_rate)
+        assert_equal(1, format.block_align)
+      end
+
+      [:pcm_16, 16].each do |format_code|
+        format = Format.new(one_channel, format_code, 44100)
+        assert_equal(88200, format.byte_rate)
+        assert_equal(2, format.block_align)
+      end
+
+      [:pcm_32, 32, :float, :float_32].each do |format_code|
+        format = Format.new(one_channel, format_code, 44100)
+        assert_equal(176400, format.byte_rate)
+        assert_equal(4, format.block_align)
+      end
+
+      format = Format.new(one_channel, :float_64, 44100)
+      assert_equal(352800, format.byte_rate)
+      assert_equal(8, format.block_align) 
     end
 
     [2, :stereo].each do |two_channels|
-      format = Format.new(two_channels, 8, 44100)
-      assert_equal(2, format.block_align)
-
-      format = Format.new(two_channels, 16, 44100)
-      assert_equal(4, format.block_align)
-
-      format = Format.new(two_channels, 32, 44100)
-      assert_equal(8, format.block_align)
+      [:pcm_8, 8].each do |format_code|
+        format = Format.new(two_channels, format_code, 44100)
+        assert_equal(88200, format.byte_rate)
+        assert_equal(2, format.block_align)
+      end
+
+      [:pcm_16, 16].each do |format_code|
+        format = Format.new(two_channels, format_code, 44100)
+        assert_equal(176400, format.byte_rate)
+        assert_equal(4, format.block_align)
+      end
+
+      [:pcm_32, 32, :float, :float_32].each do |format_code|
+        format = Format.new(two_channels, format_code, 44100)
+        assert_equal(352800, format.byte_rate)
+        assert_equal(8, format.block_align)
+      end
+
+      format = Format.new(two_channels, :float_64, 44100)
+      assert_equal(705600, format.byte_rate)
+      assert_equal(16, format.block_align)
     end
   end
 
-  def test_mono?()
+  def test_mono?
     [1, :mono].each do |one_channel|
-      format = Format.new(one_channel, 8, 44100)
+      format = Format.new(one_channel, :pcm_8, 44100)
       assert_equal(true, format.mono?)
       assert_equal(false, format.stereo?)
     end
   end
 
-  def test_stereo?()
+  def test_stereo?
     [2, :stereo].each do |two_channels|
-      format = Format.new(two_channels, 8, 44100)
+      format = Format.new(two_channels, :pcm_8, 44100)
       assert_equal(false, format.mono?)
       assert_equal(true, format.stereo?)
     end