wavefile 0.7.0 → 0.8.0

data/test/unvalidated_format_test.rb

@@ -3,16 +3,19 @@ require 'wavefile.rb'
 
 include WaveFile
 
-class UnvalidatedFormatTest < MiniTest::Unit::TestCase
+class UnvalidatedFormatTest < Minitest::Test
   def test_initialize
-    format = UnvalidatedFormat.new({:audio_format => 1,
+    format = UnvalidatedFormat.new({:audio_format => 65534,
+                                    :sub_audio_format_guid => SUB_FORMAT_GUID_PCM,
                                     :channels => 2,
                                     :sample_rate => 44100,
                                     :byte_rate => 176400,
                                     :block_align => 4,
-                                    :bits_per_sample => 16})
+                                    :bits_per_sample => 16,
+                                    :valid_bits_per_sample => 14})
 
-    assert_equal(1,      format.audio_format)
+    assert_equal(65534,  format.audio_format)
+    assert_equal(SUB_FORMAT_GUID_PCM, format.sub_audio_format_guid)
     assert_equal(2,      format.channels)
     assert_equal(false,  format.mono?)
     assert_equal(true,   format.stereo?)
@@ -20,5 +23,128 @@ class UnvalidatedFormatTest < MiniTest::Unit::TestCase
     assert_equal(176400, format.byte_rate)
     assert_equal(4,      format.block_align)
     assert_equal(16,     format.bits_per_sample)
+    assert_equal(14,     format.valid_bits_per_sample)
+  end
+
+  def test_to_validated_format_pcm
+    unvalidated_format = UnvalidatedFormat.new({:audio_format => 1,
+                                                :channels => 2,
+                                                :sample_rate => 44100,
+                                                :byte_rate => 176400,
+                                                :block_align => 4,
+                                                :bits_per_sample => 16})
+
+    validated_format = unvalidated_format.to_validated_format
+    assert_equal(:pcm, validated_format.sample_format)
+    assert_equal(2, validated_format.channels)
+    assert_equal(16, validated_format.bits_per_sample)
+    assert_equal(44100, validated_format.sample_rate)
+    assert_equal(176400, validated_format.byte_rate)
+    assert_equal(4, validated_format.block_align)
+  end
+
+  def test_to_validated_format_float
+    unvalidated_format = UnvalidatedFormat.new({:audio_format => 3,
+                                                :channels => 2,
+                                                :sample_rate => 44100,
+                                                :byte_rate => 352800,
+                                                :block_align => 8,
+                                                :bits_per_sample => 32})
+
+    validated_format = unvalidated_format.to_validated_format
+    assert_equal(:float, validated_format.sample_format)
+    assert_equal(2, validated_format.channels)
+    assert_equal(32, validated_format.bits_per_sample)
+    assert_equal(44100, validated_format.sample_rate)
+    assert_equal(352800, validated_format.byte_rate)
+    assert_equal(8, validated_format.block_align)
+  end
+
+  def test_to_validated_format_unsupported
+    unvalidated_format = UnvalidatedFormat.new({:audio_format => 2,
+                                                :channels => 2,
+                                                :sample_rate => 44100,
+                                                :byte_rate => 176400,
+                                                :block_align => 4,
+                                                :bits_per_sample => 16})
+
+    assert_raises(InvalidFormatError) { unvalidated_format.to_validated_format }
+  end
+
+  def test_to_validated_format_wave_format_extensible_pcm
+    unvalidated_format = UnvalidatedFormat.new({:audio_format => 65534,
+                                                :sub_audio_format_guid => SUB_FORMAT_GUID_PCM,
+                                                :channels => 2,
+                                                :sample_rate => 44100,
+                                                :byte_rate => 176400,
+                                                :block_align => 4,
+                                                :bits_per_sample => 16,
+                                                :valid_bits_per_sample => 16})
+
+    validated_format = unvalidated_format.to_validated_format
+    assert_equal(:pcm, validated_format.sample_format)
+    assert_equal(2, validated_format.channels)
+    assert_equal(16, validated_format.bits_per_sample)
+    assert_equal(44100, validated_format.sample_rate)
+    assert_equal(176400, validated_format.byte_rate)
+    assert_equal(4, validated_format.block_align)
+  end
+
+  def test_to_validated_format_wave_format_extensible_float
+    unvalidated_format = UnvalidatedFormat.new({:audio_format => 65534,
+                                                :sub_audio_format_guid => SUB_FORMAT_GUID_FLOAT,
+                                                :channels => 2,
+                                                :sample_rate => 44100,
+                                                :byte_rate => 352800,
+                                                :block_align => 8,
+                                                :bits_per_sample => 32,
+                                                :valid_bits_per_sample => 32})
+
+    validated_format = unvalidated_format.to_validated_format
+    assert_equal(:float, validated_format.sample_format)
+    assert_equal(2, validated_format.channels)
+    assert_equal(32, validated_format.bits_per_sample)
+    assert_equal(44100, validated_format.sample_rate)
+    assert_equal(352800, validated_format.byte_rate)
+    assert_equal(8, validated_format.block_align)
+  end
+
+  def test_to_validated_format_wave_format_extensible_unsupported_sub_format
+    unvalidated_format = UnvalidatedFormat.new({:audio_format => 65534,
+                                                :sub_audio_format_guid => "\x02\x00\x00\x00\x00\x00\x10\x00\x80\x00\x00\xAA\x00\x38\x9B\x71",  # ADPCM
+                                                :channels => 2,
+                                                :sample_rate => 44100,
+                                                :byte_rate => 176400,
+                                                :block_align => 4,
+                                                :bits_per_sample => 16,
+                                                :valid_bits_per_sample => 16})
+
+    assert_raises(InvalidFormatError) { unvalidated_format.to_validated_format }
+  end
+
+  def test_to_validated_format_wave_format_extensible_unsupported_valid_bits_per_sample
+    unvalidated_format = UnvalidatedFormat.new({:audio_format => 65534,
+                                                :sub_audio_format_guid => SUB_FORMAT_GUID_PCM,
+                                                :channels => 2,
+                                                :sample_rate => 44100,
+                                                :byte_rate => 176400,
+                                                :block_align => 4,
+                                                :bits_per_sample => 14,
+                                                :valid_bits_per_sample => 14})
+
+    assert_raises(InvalidFormatError) { unvalidated_format.to_validated_format }
+  end
+
+  def test_to_validated_format_wave_format_extensible_valid_bits_per_sample_differs_from_container_size
+    unvalidated_format = UnvalidatedFormat.new({:audio_format => 65534,
+                                                :sub_audio_format_guid => SUB_FORMAT_GUID_PCM,
+                                                :channels => 2,
+                                                :sample_rate => 44100,
+                                                :byte_rate => 176400,
+                                                :block_align => 4,
+                                                :bits_per_sample => 16,
+                                                :valid_bits_per_sample => 14})
+
+    assert_raises(UnsupportedFormatError) { unvalidated_format.to_validated_format }
   end
 end

data/test/wavefile_io_test_helper.rb

@@ -53,10 +53,12 @@ module WaveFileIOTestHelper
 
   # Executes the given block against different combinations of number of channels and sample_format
   def exhaustively_test
-    [:mono, :stereo, :tri].each do |channels|
-      [: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)
+    ["", "extensible_"].each do |format_chunk_format|
+      [:mono, :stereo, :tri].each do |channels|
+        [:pcm, :float].each do |sample_format|
+          Format::SUPPORTED_BITS_PER_SAMPLE[sample_format].each do |bits_per_sample|
+            yield(format_chunk_format, channels, "#{sample_format}_#{bits_per_sample}".to_sym)
+          end
         end
       end
     end

data/test/writer_test.rb

@@ -4,7 +4,7 @@ require 'wavefile_io_test_helper.rb'
 
 include WaveFile
 
-class WriterTest < MiniTest::Unit::TestCase
+class WriterTest < Minitest::Test
   include WaveFileIOTestHelper
 
   OUTPUT_FOLDER = "test/fixtures/actual_output"
@@ -21,33 +21,37 @@ class WriterTest < MiniTest::Unit::TestCase
   end
 
   def test_write_basic_file
-    exhaustively_test do |channels, sample_format|
+    exhaustively_test do |format_chunk_format, channels, sample_format|
       file_name = "valid_#{channels}_#{sample_format}_44100.wav"
       format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100)
 
-      writer = Writer.new("#{OUTPUT_FOLDER}/#{file_name}", format)
-      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 128, format))
-      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 128, format))
-      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 24, format))
-      writer.close
+      ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+        writer = Writer.new(io_or_file_name, format)
+        writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 128, format))
+        writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 128, format))
+        writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 24, format))
+        writer.close
 
-      assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
+        assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
+      end
     end
   end
 
   def test_write_basic_file_with_a_block
-    exhaustively_test do |channels, sample_format|
+    exhaustively_test do |format_chunk_format, channels, sample_format|
       file_name = "valid_#{channels}_#{sample_format}_44100.wav"
       format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100)
 
-      writer = Writer.new("#{OUTPUT_FOLDER}/#{file_name}", format) do |writer|
-        4.times do
-          writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 70, format))
+      ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+        writer = Writer.new(io_or_file_name, format) do |w|
+          4.times do
+            w.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 70, format))
+          end
         end
-      end
 
-      assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
-      assert(writer.closed?)
+        assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
+        assert(writer.closed?)
+      end
     end
   end
 
@@ -57,103 +61,119 @@ class WriterTest < MiniTest::Unit::TestCase
     format_16_bit_mono  = Format.new(:mono,   :pcm_16, 22050)
     format_16bit_stereo = Format.new(:stereo, :pcm_16, 44100)
 
-    writer = Writer.new("#{OUTPUT_FOLDER}/#{file_name}", format_8bit_mono)
-    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:stereo][:pcm_16] * 128, format_16bit_stereo))
-    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][:pcm_16] * 128,   format_16_bit_mono))
-    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:stereo][:pcm_16] * 24,  format_16bit_stereo))
-    writer.close
+    ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+      writer = Writer.new(io_or_file_name, format_8bit_mono)
+      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:stereo][:pcm_16] * 128, format_16bit_stereo))
+      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][:pcm_16] * 128,   format_16_bit_mono))
+      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:stereo][:pcm_16] * 24,  format_16bit_stereo))
+      writer.close
 
-    assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
+      assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
+    end
   end
 
   def test_write_file_with_padding_byte
     file_name = "valid_mono_pcm_8_44100_with_padding_byte.wav"
     format = Format.new(:mono, :pcm_8, 44100)
 
-    writer = Writer.new("#{OUTPUT_FOLDER}/#{file_name}", format)
-    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 128, format))
-    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 128, format))
-    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 23 + [88, 88, 88, 88, 167, 167, 167], format))
-    writer.close
+    ["#{OUTPUT_FOLDER}/#{file_name}", StringIO.new].each do |io_or_file_name|
+      writer = Writer.new(io_or_file_name, format)
+      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 128, format))
+      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 128, format))
+      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 23 + [88, 88, 88, 88, 167, 167, 167], format))
+      writer.close
 
-    assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
+      assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
+    end
   end
 
-  def test_file_name
-    file_name = "#{OUTPUT_FOLDER}/example.wav"
-
-    writer = Writer.new(file_name, Format.new(:mono, :pcm_8, 44100))
-    assert_equal("#{OUTPUT_FOLDER}/example.wav", writer.file_name)
-
+  def test_close_when_constructed_from_file_name
+    writer = Writer.new("#{OUTPUT_FOLDER}/closed_test.wav", Format.new(:mono, :pcm_16, 44100))
+    assert_equal(false, writer.closed?)
     writer.close
-    assert_equal("#{OUTPUT_FOLDER}/example.wav", writer.file_name)
+    assert(writer.closed?)
   end
 
-  def test_closed?
-    writer = Writer.new("#{OUTPUT_FOLDER}/closed_test.wav", Format.new(:mono, :pcm_16, 44100))
+  def test_close_when_constructed_from_io
+    io = StringIO.new
+    assert_equal(false, io.closed?)
+    assert_equal(0, io.pos)
+
+    writer = Writer.new(io, Format.new(:mono, :pcm_16, 44100))
     assert_equal(false, writer.closed?)
+
+    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][:pcm_16] * 128, Format.new(:mono, :pcm_16, 44100)))
+
     writer.close
     assert(writer.closed?)
+
+    assert_equal(false, io.closed?)
+    assert_equal(2092, io.pos)    # 44 bytes for header, plus 2 bytes per sample, with 8 * 128 samples 
+    io.close
   end
 
   def test_attempt_to_write_after_close
     format = Format.new(:mono, :pcm_8, 44100)
 
-    writer = Writer.new("#{OUTPUT_FOLDER}/write_after_close.wav", format)
-    writer.write(Buffer.new([1, 2, 3, 4], format))
-    writer.close
+    ["#{OUTPUT_FOLDER}/write_after_close.wav", StringIO.new].each do |io_or_file_name|
+      writer = Writer.new(io_or_file_name, format)
+      writer.write(Buffer.new([1, 2, 3, 4], format))
+      writer.close
 
-    assert_raises(IOError) { writer.write(Buffer.new([5, 6, 7, 8], format)) }
+      assert_raises(WriterClosedError) { writer.write(Buffer.new([5, 6, 7, 8], format)) }
+    end
   end
 
   def test_total_duration
-    exhaustively_test do |channels, sample_format|
+    exhaustively_test do |format_chunk_format, channels, sample_format|
       format = Format.new(CHANNEL_ALIAS[channels], sample_format, 44100)
 
-      writer = Writer.new("#{OUTPUT_FOLDER}/total_duration_#{channels}_#{sample_format}_44100.wav", format)
-
-      assert_equal(0, writer.total_sample_frames)
-      duration = writer.total_duration
-      assert_equal(0, duration.sample_frame_count)
-      assert_equal(44100, duration.sample_rate)
-      assert_equal(0, duration.hours)
-      assert_equal(0, duration.minutes)
-      assert_equal(0, duration.seconds)
-      assert_equal(0, duration.milliseconds)
-
-      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 2756, format))
-
-      assert_equal(8 * 2756, writer.total_sample_frames)
-      duration = writer.total_duration
-      assert_equal(8 * 2756, duration.sample_frame_count)
-      assert_equal(44100, duration.sample_rate)
-      assert_equal(0, duration.hours)
-      assert_equal(0, duration.minutes)
-      assert_equal(0, duration.seconds)
-      assert_equal(499, duration.milliseconds)
-
-      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 2756, format))
-      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 2756, format))
-
-      assert_equal(8 * 2756 * 3, writer.total_sample_frames)
-      duration = writer.total_duration
-      assert_equal(8 * 2756 * 3, duration.sample_frame_count)
-      assert_equal(44100, duration.sample_rate)
-      assert_equal(0, duration.hours)
-      assert_equal(0, duration.minutes)
-      assert_equal(1, duration.seconds)
-      assert_equal(499, duration.milliseconds)
-
-      writer.close
-
-      assert_equal(8 * 2756 * 3, writer.total_sample_frames)
-      duration = writer.total_duration
-      assert_equal(8 * 2756 * 3, duration.sample_frame_count)
-      assert_equal(44100, duration.sample_rate)
-      assert_equal(0, duration.hours)
-      assert_equal(0, duration.minutes)
-      assert_equal(1, duration.seconds)
-      assert_equal(499, duration.milliseconds)
+      ["#{OUTPUT_FOLDER}/total_duration_#{channels}_#{sample_format}_44100.wav", StringIO.new].each do |io_or_file_name|
+        writer = Writer.new(io_or_file_name, format)
+
+        assert_equal(0, writer.total_sample_frames)
+        duration = writer.total_duration
+        assert_equal(0, duration.sample_frame_count)
+        assert_equal(44100, duration.sample_rate)
+        assert_equal(0, duration.hours)
+        assert_equal(0, duration.minutes)
+        assert_equal(0, duration.seconds)
+        assert_equal(0, duration.milliseconds)
+
+        writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 2756, format))
+
+        assert_equal(8 * 2756, writer.total_sample_frames)
+        duration = writer.total_duration
+        assert_equal(8 * 2756, duration.sample_frame_count)
+        assert_equal(44100, duration.sample_rate)
+        assert_equal(0, duration.hours)
+        assert_equal(0, duration.minutes)
+        assert_equal(0, duration.seconds)
+        assert_equal(499, duration.milliseconds)
+
+        writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 2756, format))
+        writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][sample_format] * 2756, format))
+
+        assert_equal(8 * 2756 * 3, writer.total_sample_frames)
+        duration = writer.total_duration
+        assert_equal(8 * 2756 * 3, duration.sample_frame_count)
+        assert_equal(44100, duration.sample_rate)
+        assert_equal(0, duration.hours)
+        assert_equal(0, duration.minutes)
+        assert_equal(1, duration.seconds)
+        assert_equal(499, duration.milliseconds)
+
+        writer.close
+
+        assert_equal(8 * 2756 * 3, writer.total_sample_frames)
+        duration = writer.total_duration
+        assert_equal(8 * 2756 * 3, duration.sample_frame_count)
+        assert_equal(44100, duration.sample_rate)
+        assert_equal(0, duration.hours)
+        assert_equal(0, duration.minutes)
+        assert_equal(1, duration.seconds)
+        assert_equal(499, duration.milliseconds)
+      end
     end
   end
 
@@ -162,17 +182,20 @@ class WriterTest < MiniTest::Unit::TestCase
   def test_exception_with_block
     format = Format.new(:mono, :pcm_8, 44100)
     samples = [1, 2, 3, 4, 5, 6]
-    Writer.new("#{OUTPUT_FOLDER}/exception_with_block.wav", format) do |writer|
-      begin
-        writer.write(Buffer.new(samples, format))
-        1 / 0 # cause divide-by-zero exception
-      rescue
-        # catch the exception and ignore, so test passes OK
+
+    ["#{OUTPUT_FOLDER}/exception_with_block.wav", StringIO.new].each do |io_or_file_name|
+      Writer.new(io_or_file_name, format) do |writer|
+        begin
+          writer.write(Buffer.new(samples, format))
+          1 / 0 # cause divide-by-zero exception
+        rescue
+          # catch the exception and ignore, so test passes
+        end
       end
+
+      reader = Reader.new("#{OUTPUT_FOLDER}/exception_with_block.wav")
+      assert_equal(samples.size, reader.total_sample_frames)
     end
-    
-    reader = Reader.new("#{OUTPUT_FOLDER}/exception_with_block.wav")
-    assert_equal(samples.size, reader.total_sample_frames)
   end
 
 private
@@ -192,7 +215,7 @@ private
 
   def clean_output_folder
     # Make the folder if it doesn't already exist
-    Dir.mkdir(OUTPUT_FOLDER) unless File.exists?(OUTPUT_FOLDER)
+    Dir.mkdir(OUTPUT_FOLDER) unless File.exist?(OUTPUT_FOLDER)
 
     dir = Dir.new(OUTPUT_FOLDER)
     file_names = dir.entries