wavefile 1.0.1 → 1.1.0

data/lib/wavefile/writer.rb

@@ -93,7 +93,9 @@ module WaveFile
     #   writer.write(buffer)
     #
     # Returns the number of sample frames that have been written to the file so far.
+    #
     # Raises WriterClosedError if the Writer has been closed.
+    #
     # Raises BufferConversionError if the Buffer can't be converted to the Writer's format.
     def write(buffer)
       if @closed
@@ -287,10 +289,14 @@ module WaveFile
       requires_fact_chunk = (format_code != :pcm)
 
       sample_data_byte_count = sample_frame_count * @format.block_align
+      riff_chunk_size = CANONICAL_HEADER_BYTE_LENGTH[format_code] + sample_data_byte_count
+      if sample_data_byte_count.odd?
+        riff_chunk_size += 1
+      end
 
       # Write the header for the RIFF chunk
       header = CHUNK_IDS[:riff]
-      header += [CANONICAL_HEADER_BYTE_LENGTH[format_code] + sample_data_byte_count].pack(UNSIGNED_INT_32)
+      header += [riff_chunk_size].pack(UNSIGNED_INT_32)
       header += WAVEFILE_FORMAT_CODE
 
       # Write the format chunk

data/test/fixtures/wave/invalid/incomplete_riff_header.wav

@@ -1 +1 @@
-RIFF
+RIFF

data/test/fixtures/wave/invalid/riff_chunk_has_incomplete_chunk_size.wav

@@ -0,0 +1 @@
+RIFFaa

data/test/format_test.rb

@@ -14,7 +14,7 @@ class FormatTest < Minitest::Test
   end
 
   def test_invalid_channels
-    ["dsfsfsdf", :foo, 0, -1, 65536, 2.5, 2.0].each do |invalid_channels|
+    ["dsfsfsdf", "1", :foo, 0, -1, 65536, 2.5, 2.0].each do |invalid_channels|
       assert_raises(InvalidFormatError) { Format.new(invalid_channels, :pcm_16, 44100) }
     end
   end
@@ -30,7 +30,7 @@ class FormatTest < Minitest::Test
   end
 
   def test_invalid_sample_format
-    ["dsfsfsdf", :foo, :pcm, 0, 12, :pcm_14, :pcm_abc, :float_40].each do |invalid_sample_format|
+    ["dsfsfsdf", "pcm_16", :foo, :pcm, 0, 12, :pcm_14, :pcm_abc, :float_40].each do |invalid_sample_format|
       assert_raises(InvalidFormatError) { Format.new(:mono, invalid_sample_format, 44100) }
     end
   end
@@ -46,13 +46,13 @@ class FormatTest < Minitest::Test
   end
 
   def test_valid_sample_rate
-    [1, 44100, 4294967296].each do |valid_sample_rate|
+    [1, 44100, 4294967295].each do |valid_sample_rate|
       assert_equal(valid_sample_rate, Format.new(:mono, :pcm_16, valid_sample_rate).sample_rate)
     end
   end
 
   def test_invalid_sample_rate
-    ["dsfsfsdf", :foo, 0, -1, 4294967297, 44100.5, 44100.0].each do |invalid_sample_rate|
+    ["dsfsfsdf", "44100", :foo, 0, -1, 4294967296, 44100.5, 44100.0].each do |invalid_sample_rate|
       assert_raises(InvalidFormatError) { Format.new(:mono, :pcm_16, invalid_sample_rate) }
     end
   end

data/test/reader_test.rb

@@ -22,15 +22,27 @@ class ReaderTest < Minitest::Test
       # File consists of "RIFF" and nothing else
       "invalid/incomplete_riff_header.wav",
 
+      # The RIFF header chunk size field ends prematurely
+      "invalid/riff_chunk_has_incomplete_chunk_size.wav",
+
       # First 4 bytes in the file are not "RIFF"
       "invalid/bad_riff_header.wav",
 
+      # The format code in the RIFF header is missing
+      "invalid/no_riff_format.wav",
+
+      # The format code in the RIFF header is truncated; i.e. not a full 4 bytes
+      "invalid/incomplete_riff_format.wav",
+
       # The format code in the RIFF header is not "WAVE"
       "invalid/bad_wavefile_format.wav",
 
       # The file consists of just a valid RIFF header
       "invalid/no_format_chunk.wav",
 
+      # The format chunk only includes the chunk ID
+      "invalid/no_format_chunk_size.wav",
+
       # The format chunk has 0 bytes in it (despite the chunk size being 16)
       "invalid/empty_format_chunk.wav",
 
@@ -39,6 +51,27 @@ class ReaderTest < Minitest::Test
 
       # The RIFF header and format chunk are OK, but there is no data chunk
       "invalid/no_data_chunk.wav",
+
+      # The data chunk only contains the chunk ID, nothing else
+      "invalid/data_chunk_ends_after_chunk_id.wav",
+
+      # The data chunk size field ends prematurely
+      "invalid/data_chunk_has_incomplete_chunk_size.wav",
+
+      # The format chunk comes after the data chunk; it must come before
+      "invalid/format_chunk_after_data_chunk.wav",
+
+      # Contains a `smpl` chunk that has a size of 0 and no data
+      "invalid/smpl_chunk_empty.wav",
+
+      # Contains a `smpl` chunk that doesn't have enough bytes to match the chunk's size
+      "invalid/truncated_smpl_chunk.wav",
+
+      # `smpl` chunk does not contain as many loops as the 'loop count' field indicates
+      "invalid/smpl_chunk_loop_count_too_high.wav",
+
+      # `smpl` chunk does not contain as bytes as 'sampler specific data size' field indicates
+      "invalid/smpl_chunk_truncated_sampler_specific_data.wav",
     ]
 
     invalid_fixtures.each do |fixture_name|
@@ -66,8 +99,9 @@ class ReaderTest < Minitest::Test
       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)
+      assert_equal(0, reader.total_sample_frames)
       assert_equal(false, reader.readable_format?)
+      assert_nil(reader.sampler_info)
       reader.close
     end
 
@@ -84,8 +118,9 @@ class ReaderTest < Minitest::Test
       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(0, reader.total_sample_frames)
       assert_equal(false, reader.readable_format?)
+      assert_nil(reader.sampler_info)
       reader.close
     end
   end
@@ -146,6 +181,7 @@ class ReaderTest < Minitest::Test
         assert_equal(0, reader.current_sample_frame)
         assert_equal(2240, reader.total_sample_frames)
         assert_equal(true, reader.readable_format?)
+        assert_nil(reader.sampler_info)
         reader.close
       end
 
@@ -162,6 +198,7 @@ class ReaderTest < Minitest::Test
         assert_equal(0, reader.current_sample_frame)
         assert_equal(2240, reader.total_sample_frames)
         assert_equal(true, reader.readable_format?)
+        assert_nil(reader.sampler_info)
         reader.close
       end
 
@@ -178,6 +215,7 @@ class ReaderTest < Minitest::Test
         assert_equal(1024, reader.current_sample_frame)
         assert_equal(2240, reader.total_sample_frames)
         assert_equal(true, reader.readable_format?)
+        assert_nil(reader.sampler_info)
       end
     end
   end
@@ -211,6 +249,7 @@ class ReaderTest < Minitest::Test
     assert_equal(0, reader.current_sample_frame)
     assert_equal(2240, reader.total_sample_frames)
     assert_equal(true, reader.readable_format?)
+    assert_nil(reader.sampler_info)
     reader.close
 
     buffers = read_file("valid/valid_extensible_stereo_pcm_16_44100.wav", 1024)
@@ -237,6 +276,7 @@ class ReaderTest < Minitest::Test
     assert_equal(0, reader.current_sample_frame)
     assert_equal(2240, reader.total_sample_frames)
     assert_equal(true, reader.readable_format?)
+    assert_nil(reader.sampler_info)
     reader.close
 
     buffers = read_file("valid/valid_extensible_stereo_pcm_24_44100_no_speaker_mapping.wav", 1024)
@@ -263,6 +303,7 @@ class ReaderTest < Minitest::Test
     assert_equal(0, reader.current_sample_frame)
     assert_equal(2240, reader.total_sample_frames)
     assert_equal(true, reader.readable_format?)
+    assert_nil(reader.sampler_info)
     reader.close
 
     buffers = read_file("valid/valid_extensible_stereo_pcm_16_44100_more_speakers_than_channels.wav", 1024)
@@ -307,6 +348,7 @@ class ReaderTest < Minitest::Test
     assert_equal(0, reader.current_sample_frame)
     assert_equal(2240, reader.total_sample_frames)
     assert_equal(true, reader.readable_format?)
+    assert_nil(reader.sampler_info)
     reader.close
 
     buffers = read_file("valid/valid_extensible_stereo_pcm_16_44100_more_speakers_than_defined_by_spec.wav", 1024)
@@ -333,6 +375,7 @@ class ReaderTest < Minitest::Test
     assert_equal(0, reader.current_sample_frame)
     assert_equal(2240, reader.total_sample_frames)
     assert_equal(true, reader.readable_format?)
+    assert_nil(reader.sampler_info)
     reader.close
 
     buffers = read_file("valid/valid_extensible_stereo_pcm_16_44100_only_undefined_high_bit_speakers.wav", 1024)
@@ -362,6 +405,7 @@ class ReaderTest < Minitest::Test
     assert_equal(0, reader.current_sample_frame)
     assert_equal(2240, reader.total_sample_frames)
     assert_equal(true, reader.readable_format?)
+    assert_nil(reader.sampler_info)
     reader.close
 
     buffers = read_file("valid/valid_mono_pcm_16_44100_with_extension.wav", 1024)
@@ -387,13 +431,34 @@ class ReaderTest < Minitest::Test
     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([1024, 1024, 193], buffers.map {|buffer| buffer.samples.length })
     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],
+    assert_equal((SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 24) + [88],
                  buffers[2].samples)
   end
 
+  def test_read_truncated_file
+    reader = Reader.new(fixture("invalid/data_chunk_truncated.wav"), Format.new(:mono, :pcm_8, 44100))
+
+    # The chunk does not actually contain this many sample frames, it actually has 2240
+    assert_equal(100000, reader.total_sample_frames)
+    assert_equal(0, reader.current_sample_frame)
+
+    # First set of requested sample frames should be read correctly
+    buffer = reader.read(2000)
+    assert_equal(2000, buffer.samples.length)
+    assert_equal(2000, reader.current_sample_frame)
+
+    # All of the remaining sample frames are returned, which is fewer than were requested.
+    buffer = reader.read(2000)
+    assert_equal(240, buffer.samples.length)
+    assert_equal(2240, reader.current_sample_frame)
+
+    # Since there are no more sample frames, an end-of-file error should be raised
+    assert_raises(EOFError) { reader.read(2000) }
+  end
+
   def test_each_buffer_no_block_given
     reader = Reader.new(fixture("valid/valid_mono_pcm_16_44100.wav"))
     assert_raises(LocalJumpError) { reader.each_buffer(1024) }
@@ -457,13 +522,13 @@ class ReaderTest < Minitest::Test
     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([1024, 1024, 193], buffers.map {|buffer| buffer.samples.length })
     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],
+    assert_equal((SQUARE_WAVE_CYCLE[:mono][:pcm_8] * 24) + [88],
                  buffers[2].samples)
-    assert_equal(2239, reader.current_sample_frame)
-    assert_equal(2239, reader.total_sample_frames)
+    assert_equal(2241, reader.current_sample_frame)
+    assert_equal(2241, reader.total_sample_frames)
   end
 
   def test_each_buffer_inside_reader_block
@@ -492,6 +557,17 @@ class ReaderTest < Minitest::Test
     assert_equal(2240, reader.total_sample_frames)
   end
 
+  def test_read_non_data_chunk_is_final_chunk_without_padding_byte
+    # This fixture file contains a JUNK chunk with an odd size, but no padding byte. When a chunk
+    # is the final chunk in the file, a missing padding byte won't cause an error as long as the
+    # RIFF chunk size field matches the actual number of bytes in the file.
+    reader = Reader.new(fixture("valid/valid_mono_pcm_16_44100_junk_chunk_final_chunk_missing_padding_byte.wav"))
+    buffer = reader.read(1024)
+    assert_equal(buffer.samples, SQUARE_WAVE_CYCLE[:mono][:pcm_16] * 128)
+    assert_equal(1024, reader.current_sample_frame)
+    assert_equal(2240, reader.total_sample_frames)
+  end
+
   def test_closed?
     reader = Reader.new(fixture("valid/valid_mono_pcm_16_44100.wav"))
     assert_equal(false, reader.closed?)
@@ -600,6 +676,188 @@ class ReaderTest < Minitest::Test
     end
   end
 
+  def test_smpl_chunk
+    file_name = fixture("valid/valid_with_sample_chunk_before_data_chunk.wav")
+    sampler_info = Reader.new(file_name).sampler_info
+
+    assert_equal(0, sampler_info.manufacturer_id)
+    assert_equal(0, sampler_info.product_id)
+    assert_equal(0, sampler_info.sample_nanoseconds)
+    assert_equal(60, sampler_info.midi_note)
+    assert_equal(50.0, sampler_info.fine_tuning_cents)
+    assert_equal(0, sampler_info.smpte_format)
+    assert_equal(0, sampler_info.smpte_offset.hours)
+    assert_equal(0, sampler_info.smpte_offset.minutes)
+    assert_equal(0, sampler_info.smpte_offset.seconds)
+    assert_equal(0, sampler_info.smpte_offset.frames)
+    assert_equal(1, sampler_info.loops.length)
+    assert_equal(0, sampler_info.loops[0].id)
+    assert_equal(:backward, sampler_info.loops[0].type)
+    assert_equal(0, sampler_info.loops[0].start_sample_frame)
+    assert_equal(0, sampler_info.loops[0].end_sample_frame)
+    assert_equal(0.5, sampler_info.loops[0].fraction)
+    assert_equal(1, sampler_info.loops[0].play_count)
+    assert_equal("", sampler_info.sampler_specific_data)
+  end
+
+  # Several field values are out of the expected range, but the file should be successfully
+  # read anyway because the sample chunk has the correct structure
+  def test_smpl_chunk_field_values_out_of_range
+    file_name = fixture("invalid/smpl_chunk_fields_out_of_range.wav")
+    sampler_info = Reader.new(file_name).sampler_info
+
+    assert_equal(0, sampler_info.manufacturer_id)
+    assert_equal(0, sampler_info.product_id)
+    assert_equal(0, sampler_info.sample_nanoseconds)
+    assert_equal(10000, sampler_info.midi_note)
+    assert_equal(50.0, sampler_info.fine_tuning_cents)
+    assert_equal(99999, sampler_info.smpte_format)
+    assert_equal(-128, sampler_info.smpte_offset.hours)
+    assert_equal(128, sampler_info.smpte_offset.minutes)
+    assert_equal(8, sampler_info.smpte_offset.seconds)
+    assert_equal(1, sampler_info.smpte_offset.frames)
+    assert_equal(1, sampler_info.loops.length)
+    assert_equal(0, sampler_info.loops[0].id)
+    assert_equal(88888, sampler_info.loops[0].type)
+    assert_equal(9999999, sampler_info.loops[0].start_sample_frame)
+    assert_equal(9999999, sampler_info.loops[0].end_sample_frame)
+    assert_equal(0.5, sampler_info.loops[0].fraction)
+    assert_equal(1, sampler_info.loops[0].play_count)
+    assert_equal("", sampler_info.sampler_specific_data)
+  end
+
+  def test_smpl_chunk_after_data_chunk
+    file_name = fixture("valid/valid_with_sample_chunk_after_data_chunk.wav")
+    sampler_info = Reader.new(file_name).sampler_info
+
+    assert_equal(0, sampler_info.manufacturer_id)
+    assert_equal(0, sampler_info.product_id)
+    assert_equal(0, sampler_info.sample_nanoseconds)
+    assert_equal(60, sampler_info.midi_note)
+    assert_equal(50.0, sampler_info.fine_tuning_cents)
+    assert_equal(0, sampler_info.smpte_format)
+    assert_equal(0, sampler_info.smpte_offset.hours)
+    assert_equal(0, sampler_info.smpte_offset.minutes)
+    assert_equal(0, sampler_info.smpte_offset.seconds)
+    assert_equal(0, sampler_info.smpte_offset.frames)
+    assert_equal(1, sampler_info.loops.length)
+    assert_equal(0, sampler_info.loops[0].id)
+    assert_equal(:backward, sampler_info.loops[0].type)
+    assert_equal(0, sampler_info.loops[0].start_sample_frame)
+    assert_equal(0, sampler_info.loops[0].end_sample_frame)
+    assert_equal(0.5, sampler_info.loops[0].fraction)
+    assert_equal(1, sampler_info.loops[0].play_count)
+    assert_equal("", sampler_info.sampler_specific_data)
+  end
+
+  def test_smpl_chunk_after_data_chunk_and_data_chunk_has_padding_byte
+    file_name = fixture("valid/valid_with_sample_chunk_after_data_chunk_and_data_chunk_has_padding_byte.wav")
+
+    reader = Reader.new(file_name)
+    sampler_info = reader.sampler_info
+
+    # Should correctly deal with data chunk with odd number of bytes, followed
+    # by a padding byte.
+    assert_equal(2241, reader.total_sample_frames)
+    # Test that data chunk read is correctly queued up to start of data chunk
+    assert_equal([88, 88, 88, 88, 167, 167, 167, 167], reader.read(8).samples)
+
+    # Sample chunk should be correctly located despite the padding byte following
+    # the data chunk.
+    assert_equal(0, sampler_info.manufacturer_id)
+    assert_equal(0, sampler_info.product_id)
+    assert_equal(0, sampler_info.sample_nanoseconds)
+    assert_equal(60, sampler_info.midi_note)
+    assert_equal(50.0, sampler_info.fine_tuning_cents)
+    assert_equal(0, sampler_info.smpte_format)
+    assert_equal(0, sampler_info.smpte_offset.hours)
+    assert_equal(0, sampler_info.smpte_offset.minutes)
+    assert_equal(0, sampler_info.smpte_offset.seconds)
+    assert_equal(0, sampler_info.smpte_offset.frames)
+    assert_equal(1, sampler_info.loops.length)
+    assert_equal(0, sampler_info.loops[0].id)
+    assert_equal(:backward, sampler_info.loops[0].type)
+    assert_equal(0, sampler_info.loops[0].start_sample_frame)
+    assert_equal(0, sampler_info.loops[0].end_sample_frame)
+    assert_equal(0.5, sampler_info.loops[0].fraction)
+    assert_equal(1, sampler_info.loops[0].play_count)
+    assert_equal("", sampler_info.sampler_specific_data)
+  end
+
+  def test_smpl_chunk_with_sampler_specific_data
+    file_name = fixture("valid/valid_with_sample_chunk_with_sampler_specific_data.wav")
+    sampler_info = Reader.new(file_name).sampler_info
+
+    assert_equal(0, sampler_info.manufacturer_id)
+    assert_equal(0, sampler_info.product_id)
+    assert_equal(0, sampler_info.sample_nanoseconds)
+    assert_equal(60, sampler_info.midi_note)
+    assert_equal(50.0, sampler_info.fine_tuning_cents)
+    assert_equal(0, sampler_info.smpte_format)
+    assert_equal(0, sampler_info.smpte_offset.hours)
+    assert_equal(0, sampler_info.smpte_offset.minutes)
+    assert_equal(0, sampler_info.smpte_offset.seconds)
+    assert_equal(0, sampler_info.smpte_offset.frames)
+    assert_equal(1, sampler_info.loops.length)
+    assert_equal(0, sampler_info.loops[0].id)
+    assert_equal(:backward, sampler_info.loops[0].type)
+    assert_equal(0, sampler_info.loops[0].start_sample_frame)
+    assert_equal(0, sampler_info.loops[0].end_sample_frame)
+    assert_equal(0.5, sampler_info.loops[0].fraction)
+    assert_equal(Float::INFINITY, sampler_info.loops[0].play_count)
+    assert_equal("\x04\x01\x03\x02", sampler_info.sampler_specific_data)
+    assert_equal(Encoding::ASCII_8BIT, sampler_info.sampler_specific_data.encoding)
+  end
+
+  def test_smpl_chunk_with_extra_unused_bytes
+    file_name = fixture("valid/valid_with_sample_chunk_with_extra_unused_bytes.wav")
+    reader = Reader.new(file_name)
+    sampler_info = reader.sampler_info
+
+    assert_equal(0, sampler_info.manufacturer_id)
+    assert_equal(0, sampler_info.product_id)
+    assert_equal(0, sampler_info.sample_nanoseconds)
+    assert_equal(60, sampler_info.midi_note)
+    assert_equal(50.0, sampler_info.fine_tuning_cents)
+    assert_equal(0, sampler_info.smpte_format)
+    assert_equal(0, sampler_info.smpte_offset.hours)
+    assert_equal(0, sampler_info.smpte_offset.minutes)
+    assert_equal(0, sampler_info.smpte_offset.seconds)
+    assert_equal(0, sampler_info.smpte_offset.frames)
+    assert_equal(1, sampler_info.loops.length)
+    assert_equal(0, sampler_info.loops[0].id)
+    assert_equal(:backward, sampler_info.loops[0].type)
+    assert_equal(0, sampler_info.loops[0].start_sample_frame)
+    assert_equal(0, sampler_info.loops[0].end_sample_frame)
+    assert_equal(0.5, sampler_info.loops[0].fraction)
+    assert_equal(1, sampler_info.loops[0].play_count)
+    assert_equal("\x04\x01\x05", sampler_info.sampler_specific_data)
+    assert_equal(Encoding::ASCII_8BIT, sampler_info.sampler_specific_data.encoding)
+
+    # Data chunk should be queued correctly and not raise an error, despite extra bytes
+    # at end of `smpl` chunk.
+    buffer = reader.read(1)
+    assert_equal([[-10000, -10000]], buffer.samples)
+  end
+
+  def test_smpl_chunk_no_loops
+    file_name = fixture("valid/valid_with_sample_chunk_no_loops.wav")
+    sampler_info = Reader.new(file_name).sampler_info
+
+    assert_equal(0, sampler_info.manufacturer_id)
+    assert_equal(0, sampler_info.product_id)
+    assert_equal(0, sampler_info.sample_nanoseconds)
+    assert_equal(60, sampler_info.midi_note)
+    assert_equal(50.0, sampler_info.fine_tuning_cents)
+    assert_equal(0, sampler_info.smpte_format)
+    assert_equal(0, sampler_info.smpte_offset.hours)
+    assert_equal(0, sampler_info.smpte_offset.minutes)
+    assert_equal(0, sampler_info.smpte_offset.seconds)
+    assert_equal(0, sampler_info.smpte_offset.frames)
+    assert_equal([], sampler_info.loops)
+    assert_equal("", sampler_info.sampler_specific_data)
+  end
+
 private
 
   def read_file(file_name, buffer_size, format=nil)