wavefile 0.8.1 → 1.0.0

data/test/format_test.rb

@@ -14,7 +14,7 @@ class FormatTest < Minitest::Test
   end
 
   def test_invalid_channels
-    ["dsfsfsdf", :foo, 0, -1, 65536].each do |invalid_channels|
+    ["dsfsfsdf", :foo, 0, -1, 65536, 2.5, 2.0].each do |invalid_channels|
       assert_raises(InvalidFormatError) { Format.new(invalid_channels, :pcm_16, 44100) }
     end
   end
@@ -52,11 +52,197 @@ class FormatTest < Minitest::Test
   end
 
   def test_invalid_sample_rate
-    ["dsfsfsdf", :foo, 0, -1, 4294967297].each do |invalid_sample_rate|
+    ["dsfsfsdf", :foo, 0, -1, 4294967297, 44100.5, 44100.0].each do |invalid_sample_rate|
       assert_raises(InvalidFormatError) { Format.new(:mono, :pcm_16, invalid_sample_rate) }
     end
   end
 
+  def test_no_speaker_mapping_set_in_constructor_mono
+    assert_equal([:front_center], Format.new(:mono, :pcm_8, 44100).speaker_mapping)
+  end
+
+  def test_no_speaker_mapping_set_in_constructor__stereo
+    assert_equal([:front_left, :front_right], Format.new(:stereo, :pcm_8, 44100).speaker_mapping)
+  end
+
+  def test_no_speaker_mapping_set_in_constructor_3_channel
+    assert_equal([:front_left, :front_right, :front_center], Format.new(3, :pcm_8, 44100).speaker_mapping)
+  end
+
+  def test_no_speaker_mapping_set_in_constructor_4_channel
+    assert_equal([:front_left, :front_right, :back_left, :back_right], Format.new(4, :pcm_8, 44100).speaker_mapping)
+  end
+
+  def test_no_speaker_mapping_set_in_constructor_5_channel
+    expected_speaker_mapping = [:front_left, :front_right, :front_center, :back_left, :back_right]
+
+    assert_equal(expected_speaker_mapping, Format.new(5, :pcm_8, 44100).speaker_mapping)
+  end
+
+  def test_no_speaker_mapping_set_in_constructor_6_channel
+    expected_speaker_mapping = [:front_left,
+                                :front_right,
+                                :front_center,
+                                :low_frequency,
+                                :back_left,
+                                :back_right]
+
+    assert_equal(expected_speaker_mapping, Format.new(6, :pcm_8, 44100).speaker_mapping)
+  end
+
+  def test_no_speaker_mapping_set_in_constructor_7_channel
+    expected_speaker_mapping = [:front_left,
+                                :front_right,
+                                :front_center,
+                                :low_frequency,
+                                :back_center,
+                                :side_left,
+                                :side_right]
+
+    assert_equal(expected_speaker_mapping, Format.new(7, :pcm_8, 44100).speaker_mapping)
+  end
+
+  def test_no_speaker_mapping_set_in_constructor_8_channel
+    expected_speaker_mapping = [:front_left,
+                                :front_right,
+                                :front_center,
+                                :low_frequency,
+                                :back_left,
+                                :back_right,
+                                :front_left_of_center,
+                                :front_right_of_center]
+
+    assert_equal(expected_speaker_mapping, Format.new(8, :pcm_8, 44100).speaker_mapping)
+  end
+
+  def test_no_speaker_mapping_set_in_constructor_9_channel
+    expected_speaker_mapping = [:front_left,
+                                :front_right,
+                                :front_center,
+                                :low_frequency,
+                                :back_left,
+                                :back_right,
+                                :front_left_of_center,
+                                :front_right_of_center,
+                                :back_center]
+
+    assert_equal(expected_speaker_mapping, Format.new(9, :pcm_8, 44100).speaker_mapping)
+  end
+
+  def test_no_speaker_mapping_set_in_constructor_18_channel
+    expected_speaker_mapping = [
+      :front_left,
+      :front_right,
+      :front_center,
+      :low_frequency,
+      :back_left,
+      :back_right,
+      :front_left_of_center,
+      :front_right_of_center,
+      :back_center,
+      :side_left,
+      :side_right,
+      :top_center,
+      :top_front_left,
+      :top_front_center,
+      :top_front_right,
+      :top_back_left,
+      :top_back_center,
+      :top_back_right,
+    ]
+
+    assert_equal(expected_speaker_mapping, Format.new(18, :pcm_8, 44100).speaker_mapping)
+  end
+
+  def test_no_speaker_mapping_set_in_constructor_20_channel
+    expected_speaker_mapping = [
+      :front_left,
+      :front_right,
+      :front_center,
+      :low_frequency,
+      :back_left,
+      :back_right,
+      :front_left_of_center,
+      :front_right_of_center,
+      :back_center,
+      :side_left,
+      :side_right,
+      :top_center,
+      :top_front_left,
+      :top_front_center,
+      :top_front_right,
+      :top_back_left,
+      :top_back_center,
+      :top_back_right,
+      :undefined,
+      :undefined,
+    ]
+
+    assert_equal(expected_speaker_mapping, Format.new(20, :pcm_8, 44100).speaker_mapping)
+  end
+
+  def test_defined_speaker_mapping_in_constructor
+    assert_equal([:front_left, :front_right], Format.new(:stereo, :pcm_8, 44100, speaker_mapping: [:front_left, :front_right]).speaker_mapping)
+  end
+
+  def test_defined_speaker_mapping_with_explicitly_undefined_channels_in_constructor
+    assert_equal([:front_left, :undefined, :undefined], Format.new(3, :pcm_8, 44100, speaker_mapping: [:front_left, :undefined, :undefined]).speaker_mapping)
+  end
+
+  def test_defined_speaker_mapping_with_implicitly_undefined_channels_in_constructor
+    assert_equal([:front_left, :undefined, :undefined], Format.new(3, :pcm_8, 44100, speaker_mapping: [:front_left]).speaker_mapping)
+  end
+
+  def test_extra_valid_speaker_mapping_fields_in_constructor
+    assert_raises(InvalidFormatError) do
+      Format.new(2, :pcm_8, 44100, speaker_mapping: [:front_left, :front_right, :front_center, :low_frequency])
+    end
+  end
+
+  def test_extra_undefined_speaker_mapping_fields_in_constructor
+    assert_raises(InvalidFormatError) do
+      Format.new(2, :pcm_8, 44100, speaker_mapping: [:front_left, :front_right, :undefined, :undefined])
+    end
+  end
+
+  def test_extra_invalid_speaker_mapping_fields_in_constructor
+    assert_raises(InvalidFormatError) do
+      Format.new(2, :pcm_8, 44100, speaker_mapping: [:front_left, :front_right, :gibberish, :what_is_this])
+    end
+  end
+
+  def test_speaker_mapping_is_frozen_copy
+    original_speaker_mapping = [:front_left, :front_right]
+
+    format = Format.new(:stereo, :pcm_16, 44100, speaker_mapping: original_speaker_mapping)
+
+    # Changing the original input array after constructing the `Format` doesn't change the `Format` speaker mapping
+    assert_equal([:front_left, :front_right], format.speaker_mapping)
+    original_speaker_mapping.push(:front_center)
+    assert_equal([:front_left, :front_right], format.speaker_mapping)
+
+    # Changing the underlaying Array should raise an error, since the Array should be frozen
+    assert_raises(RuntimeError) { format.speaker_mapping.push(:front_center) }
+  end
+
+  def test_invalid_speaker_mapping
+    mapping_with_invalid_speaker = [:front_left, :bad_speaker]
+    mapping_with_duplicate_speaker = [:front_left, :front_right, :front_left]
+    mapping_with_out_of_order_speakers = [:front_center, :front_left, :front_right]
+    mapping_with_out_of_order_speakers_2 = [:undefined, :front_left, :front_right]
+    mapping_with_out_of_order_speakers_3 = [:front_left, :undefined, :front_right]
+
+    assert_raises(InvalidFormatError) { Format.new(:stereo, :pcm_16, 44100, speaker_mapping: mapping_with_invalid_speaker) }
+    assert_raises(InvalidFormatError) { Format.new(3, :pcm_16, 44100, speaker_mapping: mapping_with_duplicate_speaker) }
+    assert_raises(InvalidFormatError) { Format.new(3, :pcm_16, 44100, speaker_mapping: mapping_with_out_of_order_speakers) }
+    assert_raises(InvalidFormatError) { Format.new(3, :pcm_16, 44100, speaker_mapping: mapping_with_out_of_order_speakers_2) }
+    assert_raises(InvalidFormatError) { Format.new(3, :pcm_16, 44100, speaker_mapping: mapping_with_out_of_order_speakers_3) }
+
+    ["dsfsfsdf", :foo, 5].each do |invalid_speaker_mapping|
+      assert_raises(InvalidFormatError) { Format.new(:mono, :pcm_16, 44100, speaker_mapping: invalid_speaker_mapping) }
+    end
+  end
+
   def test_byte_and_block_align
     [1, :mono].each do |one_channel|
       format = Format.new(one_channel, :pcm_8, 44100)
@@ -79,7 +265,7 @@ class FormatTest < Minitest::Test
 
       format = Format.new(one_channel, :float_64, 44100)
       assert_equal(352800, format.byte_rate)
-      assert_equal(8, format.block_align) 
+      assert_equal(8, format.block_align)
     end
 
     [2, :stereo].each do |two_channels|

data/test/reader_test.rb

@@ -7,7 +7,7 @@ include WaveFile
 class ReaderTest < Minitest::Test
   include WaveFileIOTestHelper
 
-  FIXTURE_ROOT_PATH = "test/fixtures"
+  FIXTURE_ROOT_PATH = "test/fixtures/wave"
 
 
   def test_nonexistent_file
@@ -59,9 +59,11 @@ class ReaderTest < Minitest::Test
       assert_equal(2, reader.native_format.channels)
       assert_equal(20, reader.native_format.bits_per_sample)
       assert_equal(44100, reader.native_format.sample_rate)
+      assert_nil(reader.format.speaker_mapping)
       assert_equal(2, reader.format.channels)
       assert_equal(20, reader.format.bits_per_sample)
       assert_equal(44100, reader.format.sample_rate)
+      assert_nil(reader.format.speaker_mapping)
       assert_equal(false, reader.closed?)
       assert_equal(0, reader.current_sample_frame)
       assert_equal(2240, reader.total_sample_frames)
@@ -75,9 +77,11 @@ class ReaderTest < Minitest::Test
       assert_equal(2, reader.native_format.channels)
       assert_equal(20, reader.native_format.bits_per_sample)
       assert_equal(44100, reader.native_format.sample_rate)
+      assert_nil(reader.native_format.speaker_mapping)
       assert_equal(1, reader.format.channels)
       assert_equal(16, reader.format.bits_per_sample)
       assert_equal(22050, reader.format.sample_rate)
+      assert_equal([:front_center], reader.format.speaker_mapping)
       assert_equal(false, reader.closed?)
       assert_equal(0, reader.current_sample_frame)
       assert_equal(2240, reader.total_sample_frames)
@@ -198,9 +202,11 @@ class ReaderTest < Minitest::Test
     assert_equal(2, reader.native_format.channels)
     assert_equal(16, reader.native_format.bits_per_sample)
     assert_equal(44100, reader.native_format.sample_rate)
+    assert_equal([:front_left, :front_right], reader.native_format.speaker_mapping)
     assert_equal(2, reader.format.channels)
     assert_equal(16, reader.format.bits_per_sample)
     assert_equal(44100, reader.format.sample_rate)
+    assert_equal([:front_left, :front_right], reader.format.speaker_mapping)
     assert_equal(false, reader.closed?)
     assert_equal(0, reader.current_sample_frame)
     assert_equal(2240, reader.total_sample_frames)
@@ -216,6 +222,157 @@ class ReaderTest < Minitest::Test
     assert_equal(SQUARE_WAVE_CYCLE[channels][sample_format] * 24,  buffers[2].samples)
   end
 
+  def test_read_extensible_no_speaker_mapping
+    reader = Reader.new(fixture("valid/valid_extensible_stereo_pcm_24_44100_no_speaker_mapping.wav"))
+
+    assert_equal(2, reader.native_format.channels)
+    assert_equal(24, reader.native_format.bits_per_sample)
+    assert_equal(44100, reader.native_format.sample_rate)
+    assert_equal([:undefined, :undefined], reader.native_format.speaker_mapping)
+    assert_equal(2, reader.format.channels)
+    assert_equal(24, reader.format.bits_per_sample)
+    assert_equal(44100, reader.format.sample_rate)
+    assert_equal([:undefined, :undefined], reader.format.speaker_mapping)
+    assert_equal(false, reader.closed?)
+    assert_equal(0, reader.current_sample_frame)
+    assert_equal(2240, reader.total_sample_frames)
+    assert_equal(true, reader.readable_format?)
+    reader.close
+
+    buffers = read_file("valid/valid_extensible_stereo_pcm_24_44100_no_speaker_mapping.wav", 1024)
+
+    assert_equal(3, buffers.length)
+    assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_24] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_24] * 128, buffers[1].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_24] * 24,  buffers[2].samples)
+  end
+
+  def test_read_extensible_more_speakers_than_channels
+    reader = Reader.new(fixture("valid/valid_extensible_stereo_pcm_16_44100_more_speakers_than_channels.wav"))
+
+    assert_equal(2, reader.native_format.channels)
+    assert_equal(16, reader.native_format.bits_per_sample)
+    assert_equal(44100, reader.native_format.sample_rate)
+    assert_equal([:front_left, :front_right, :front_center, :low_frequency], reader.native_format.speaker_mapping)
+    assert_equal(2, reader.format.channels)
+    assert_equal(16, reader.format.bits_per_sample)
+    assert_equal(44100, reader.format.sample_rate)
+    assert_equal([:front_left, :front_right], reader.format.speaker_mapping)
+    assert_equal(false, reader.closed?)
+    assert_equal(0, reader.current_sample_frame)
+    assert_equal(2240, reader.total_sample_frames)
+    assert_equal(true, reader.readable_format?)
+    reader.close
+
+    buffers = read_file("valid/valid_extensible_stereo_pcm_16_44100_more_speakers_than_channels.wav", 1024)
+
+    assert_equal(3, buffers.length)
+    assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_16] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_16] * 128, buffers[1].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_16] * 24,  buffers[2].samples)
+  end
+
+  def test_read_extensible_more_speakers_than_defined_by_spec
+    reader = Reader.new(fixture("valid/valid_extensible_stereo_pcm_16_44100_more_speakers_than_defined_by_spec.wav"))
+
+    assert_equal(2, reader.native_format.channels)
+    assert_equal(16, reader.native_format.bits_per_sample)
+    assert_equal(44100, reader.native_format.sample_rate)
+    # Extra bits for speakers beyond the first 18 are set in the file, but these bits should be ignored
+    assert_equal([:front_left,
+                  :front_right,
+                  :front_center,
+                  :low_frequency,
+                  :back_left,
+                  :back_right,
+                  :front_left_of_center,
+                  :front_right_of_center,
+                  :back_center,
+                  :side_left,
+                  :side_right,
+                  :top_center,
+                  :top_front_left,
+                  :top_front_center,
+                  :top_front_right,
+                  :top_back_left,
+                  :top_back_center,
+                  :top_back_right], reader.native_format.speaker_mapping)
+    assert_equal(2, reader.format.channels)
+    assert_equal(16, reader.format.bits_per_sample)
+    assert_equal(44100, reader.format.sample_rate)
+    assert_equal([:front_left, :front_right], reader.format.speaker_mapping)
+    assert_equal(false, reader.closed?)
+    assert_equal(0, reader.current_sample_frame)
+    assert_equal(2240, reader.total_sample_frames)
+    assert_equal(true, reader.readable_format?)
+    reader.close
+
+    buffers = read_file("valid/valid_extensible_stereo_pcm_16_44100_more_speakers_than_defined_by_spec.wav", 1024)
+
+    assert_equal(3, buffers.length)
+    assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_16] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_16] * 128, buffers[1].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_16] * 24,  buffers[2].samples)
+  end
+
+  def test_read_extensible_only_undefined_high_bit_speakers
+    reader = Reader.new(fixture("valid/valid_extensible_stereo_pcm_16_44100_only_undefined_high_bit_speakers.wav"))
+
+    assert_equal(2, reader.native_format.channels)
+    assert_equal(16, reader.native_format.bits_per_sample)
+    assert_equal(44100, reader.native_format.sample_rate)
+    assert_equal([:undefined, :undefined], reader.native_format.speaker_mapping)
+    assert_equal(2, reader.format.channels)
+    assert_equal(16, reader.format.bits_per_sample)
+    assert_equal(44100, reader.format.sample_rate)
+    assert_equal([:undefined, :undefined], reader.format.speaker_mapping)
+    assert_equal(false, reader.closed?)
+    assert_equal(0, reader.current_sample_frame)
+    assert_equal(2240, reader.total_sample_frames)
+    assert_equal(true, reader.readable_format?)
+    reader.close
+
+    buffers = read_file("valid/valid_extensible_stereo_pcm_16_44100_only_undefined_high_bit_speakers.wav", 1024)
+
+    assert_equal(3, buffers.length)
+    assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_16] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_16] * 128, buffers[1].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][:pcm_16] * 24,  buffers[2].samples)
+  end
+
+  def test_read_non_extensible_that_has_extension
+    reader = Reader.new(fixture("valid/valid_mono_pcm_16_44100_with_extension.wav"))
+
+    assert_equal(1, reader.native_format.audio_format)
+    assert_equal(1, reader.native_format.channels)
+    assert_equal(16, reader.native_format.bits_per_sample)
+    assert_equal(44100, reader.native_format.sample_rate)
+    assert_nil(reader.native_format.speaker_mapping)
+    assert_nil(reader.native_format.sub_audio_format_guid)
+    assert_nil(reader.native_format.valid_bits_per_sample)
+    assert_equal(1, reader.format.channels)
+    assert_equal(16, reader.format.bits_per_sample)
+    assert_equal(44100, reader.format.sample_rate)
+    assert_equal([:front_center], reader.format.speaker_mapping)
+    assert_equal(false, reader.closed?)
+    assert_equal(0, reader.current_sample_frame)
+    assert_equal(2240, reader.total_sample_frames)
+    assert_equal(true, reader.readable_format?)
+    reader.close
+
+    buffers = read_file("valid/valid_mono_pcm_16_44100_with_extension.wav", 1024)
+
+    assert_equal(3, buffers.length)
+    assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:pcm_16] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:pcm_16] * 128, buffers[1].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:pcm_16] * 24,  buffers[2].samples)
+  end
+
   def test_read_with_format_conversion
     buffers = read_file("valid/valid_mono_pcm_16_44100.wav", 1024, Format.new(:stereo, :pcm_8, 22100))
 
@@ -309,6 +466,21 @@ class ReaderTest < Minitest::Test
     assert_equal(2239, reader.total_sample_frames)
   end
 
+  def test_each_buffer_inside_reader_block
+    buffers = []
+
+    # This should not raise a ReaderClosedError
+    Reader.new(fixture("valid/valid_mono_pcm_16_44100.wav")) do |reader|
+      reader.each_buffer(1024) {|buffer| buffers << buffer }
+    end
+
+    assert_equal(3, buffers.length)
+    assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:pcm_16] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:pcm_16] * 128, buffers[1].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:pcm_16] * 24,  buffers[2].samples)
+  end
+
   def test_read_non_data_chunk_with_padding_byte
     # This fixture file contains a JUNK chunk with an odd size, aligned to an even number of
     # bytes via an appended padding byte. If the padding byte is not taken into account, this
@@ -325,6 +497,9 @@ class ReaderTest < Minitest::Test
     assert_equal(false, reader.closed?)
     reader.close
     assert(reader.closed?)
+    # Closing an already closed Reader should be a no-op
+    reader.close
+    assert(reader.closed?)
 
     # For Reader.each_buffer
     reader = Reader.new(fixture("valid/valid_mono_pcm_16_44100.wav"))
@@ -367,7 +542,7 @@ class ReaderTest < Minitest::Test
   def test_sample_counts_manual_reads
     exhaustively_test do |format_chunk_format, channels, sample_format|
       reader = Reader.new(fixture("valid/valid_#{format_chunk_format}#{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},
@@ -393,7 +568,7 @@ class ReaderTest < Minitest::Test
       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)
@@ -419,7 +594,7 @@ class ReaderTest < Minitest::Test
         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