wavefile 0.7.0 → 0.8.0

data/lib/wavefile/unvalidated_format.rb

@@ -1,7 +1,7 @@
 module WaveFile
-  # Represents information about the data format for a Wave file, such as number of 
-  # channels, bits per sample, sample rate, and so forth. A Format instance is used 
-  # by Reader to indicate what format to read samples out as, and by Writer to 
+  # Represents information about the data format for a Wave file, such as number of
+  # channels, bits per sample, sample rate, and so forth. A Format instance is used
+  # by Reader to indicate what format to read samples out as, and by Writer to
   # indicate what format to write samples as.
   #
   # This class is immutable - once a new Format is constructed, it can't be modified.
@@ -9,15 +9,45 @@ module WaveFile
     # Constructs a new immutable UnvalidatedFormat.
     def initialize(fields)
       @audio_format = fields[:audio_format]
+      @sub_audio_format_guid = fields[:sub_audio_format_guid]
       @channels = fields[:channels]
       @sample_rate = fields[:sample_rate]
       @byte_rate = fields[:byte_rate]
       @block_align = fields[:block_align]
       @bits_per_sample = fields[:bits_per_sample]
+      @valid_bits_per_sample = fields[:valid_bits_per_sample]
     end
 
-    # Returns a number indicating the sample format, such as 1 (PCM) or 3 (Float)
-    attr_reader :audio_format
+    attr_reader :audio_format, :sub_audio_format_guid, :valid_bits_per_sample
+
+    def to_validated_format
+      if @sub_audio_format_guid.nil?
+        audio_format_code = @audio_format
+      else
+        if @sub_audio_format_guid == SUB_FORMAT_GUID_PCM
+          audio_format_code = 1
+        elsif @sub_audio_format_guid == SUB_FORMAT_GUID_FLOAT
+          audio_format_code = 3
+        else
+          audio_format_code = nil
+        end
+      end
+
+      if @valid_bits_per_sample
+        if @valid_bits_per_sample != @bits_per_sample
+          raise UnsupportedFormatError,
+                "Sample container size (#{@bits_per_sample}) and valid bits per sample (#{@valid_bits_per_sample}) " +
+                "differ."
+        end
+
+        bits_per_sample = @valid_bits_per_sample
+      else
+        bits_per_sample = @bits_per_sample
+      end
+
+      sample_format = "#{FORMAT_CODES.invert[audio_format_code]}_#{bits_per_sample}".to_sym
+
+      Format.new(@channels, sample_format, @sample_rate)
+    end
   end
 end
-

data/lib/wavefile/writer.rb

@@ -1,14 +1,17 @@
 module WaveFile
-  # Provides the ability to write data to a wave file.
+  # Public: Error that is raised when trying to write to a Writer instance that has been closed.
+  class WriterClosedError < IOError; end
+
+  # Public: Provides the ability to write data to a wave file.
   #
-  # When a Writer is constructed it can be given a block. All samples should be written inside this 
+  # When a Writer is constructed it can be given a block. All samples should be written inside this
   # block, and when the block exits the file will automatically be closed:
   #
   #    Writer.new("my_file.wav", Format.new(:mono, :pcm_16, 44100)) do |writer|
   #      # Write sample data here
   #    end
   #
-  # If no block is given, you'll need to manually close the Writer when done. The underlaying 
+  # If no block is given, you'll need to manually close the Writer when done. The underlaying
   # file will not be valid or playable until close is called.
   #
   #    writer = Writer.new("my_file.wav", Format.new(:mono, :pcm_16, 44100))
@@ -16,20 +19,35 @@ module WaveFile
   #    writer.close
   class Writer
 
-    # Returns a constructed Writer object which is available for writing sample data to the specified 
-    # file (via the write method). When all sample data has been written, the Writer should be closed. 
-    # Note that the wave file being written to will NOT be valid (and playable in other programs) until 
-    # the Writer has been closed.
+    # Public: Returns a constructed Writer object which is available for writing sample data to the
+    # specified file (via the write method). When all sample data has been written, the Writer should
+    # be closed. Note that the wave file being written to will NOT be valid (and playable in other programs)
+    # until the Writer has been closed.
     #
-    # If a block is given to this method, sample data can be written inside the given block. When the 
-    # block terminates, the Writer will be automatically closed (and no more sample data can be written). 
+    # If a block is given to this method, sample data can be written inside the given block. When the
+    # block terminates, the Writer will be automatically closed (and no more sample data can be written).
     #
     # If no block is given, then sample data can be written until the close method is called.
-    def initialize(file_name, format)
-      @file_name = file_name
-      @file = File.open(file_name, "wb")
+    #
+    # io_or_file_name - The name of the wave file to read from, or an open IO object to read from.
+    #                   Only implementations of IO that support seeking are supported, because
+    #                   closing the Writer requires seeking back to the beginning of the file to
+    #                   update information in the file's header.
+    # format - The sample data format that the file should contain
+    #
+    # Returns a Writer object that is ready to start writing the specified file's sample data.
+    def initialize(io_or_file_name, format)
+      if io_or_file_name.is_a?(String)
+        @io = File.open(io_or_file_name, "wb")
+        @io_source = :file_name
+      else
+        @io = io_or_file_name
+        @io_source = :io
+      end
       @format = format
 
+      @closed = false
+
       @total_sample_frames = 0
       @pack_code = PACK_CODES[format.sample_format][format.bits_per_sample]
 
@@ -48,42 +66,115 @@ module WaveFile
     end
 
 
-    # Appends the sample data in the given Buffer to the end of the wave file.
+    # Public: Appends the sample data in the given Buffer to the end of the wave file.
+    #
+    # buffer - A Buffer instance containing the sample data to be written to the
+    #          file. The format of the Buffer doesn't have to match the format of the
+    #          file being written to by the Writer - if it doesn't match, it will
+    #          automatically be converted to the correct format.
+    #
+    # Examples
+    #
+    #   square_wave_samples = ([0.5] * 100) + ([-0.5] * 100)
+    #   buffer = Buffer.new(square_wave_samples, Format.new(1, :float, 44100))
+    #
+    #   Writer.new("my_file.wav", Format.new(:stereo, :pcm_16, 44100)) do |writer|
+    #     writer.write(buffer)
+    #   end
+    #
+    #   Writer.new("my_file.wav", Format.new(:stereo, :pcm_16, 44100)) do |writer|
+    #     writer.write(buffer)
+    #   end
+    #   # This will raise WriterClosedError because the Writer has already been closed.
+    #   writer.write(buffer)
     #
     # Returns the number of sample frames that have been written to the file so far.
-    # Raises IOError if the Writer has been closed.
+    # 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
+        raise WriterClosedError
+      end
+
       samples = buffer.convert(@format).samples
 
       if @format.bits_per_sample == 24 && @format.sample_format == :pcm
         samples.flatten.each do |sample|
-          @file.syswrite([sample].pack("l<X"))
+          @io.write([sample].pack("l<X"))
         end
       else
-        @file.syswrite(samples.flatten.pack(@pack_code))
+        @io.write(samples.flatten.pack(@pack_code))
       end
 
       @total_sample_frames += samples.length
     end
 
 
-    # Returns true if the Writer is closed, and false if it is open and available for writing.
+    # Public: Returns true if the Writer is closed, and false if it is open and available
+    # for writing.
     def closed?
-      @file.closed?
+      @closed
     end
 
 
-    # Closes the Writer. After a Writer is closed, no more sample data can be written to it.
+    # Public: Closes the Writer. After a Writer is closed, no more sample data can be written
+    # to it.
     #
-    # Note that the wave file will NOT be valid until this method is called. The wave file 
-    # format requires certain information about the amount of sample data, and this can't be 
-    # determined until all samples have been written. (This method doesn't need to be called 
-    # when passing a block to Writer.new, as this method will automatically be called when 
+    # Note that the wave file will NOT be valid until this method is called. The wave file
+    # format requires certain information about the amount of sample data, and this can't be
+    # determined until all samples have been written. (This method doesn't need to be called
+    # when passing a block to Writer.new, as this method will automatically be called when
     # the block exits).
     #
-    # Returns nothing.
-    # Raises IOError if the Writer is already closed.
+    # If you initialized the Writer with an externally created IO instance, note that
+    # the IO instance won't be closed when the Writer is closed. You'll need to manually close
+    # the IO yourself. This is on purpose, because the Writer can't know what you may/may not
+    # want to do with the IO after closing the Writer.
+    #
+    # Examples
+    #
+    #   square_wave_samples = ([0.5] * 100) + ([-0.5] * 100)
+    #   buffer = Buffer.new(square_wave_samples, Format.new(1, :float, 44100))
+    #
+    #   # Basic example of closing a Writer
+    #   writer = Writer.new("my_file.wav", Format.new(:mono, :pcm_16, 44100))
+    #   writer.write(buffer)
+    #   writer.close
+    #
+    #   # Closing a Writer writing to an externally opened IO
+    #   file = File.open("my_file.wav", "wb")
+    #   writer = Writer.new(file, Format.new(:mono, :pcm_16, 44100))
+    #   writer.close
+    #   # file is still open at this point, so it should be manually closed
+    #   file.close
+    #
+    #   # Trying to write to a Writer that has already been closed
+    #   writer = Writer.new("my_file.wav", Format.new(:mono, :pcm_16, 44100))
+    #   writer.close
+    #   # This will raise WriterClosedError, since the Writer is already closed
+    #   writer.write(buffer)
+    #
+    #   # close() needs to be called for the Wave file to be valid
+    #   writer = Writer.new("my_file.wav", Format.new(:mono, :pcm_16, 44100))
+    #   writer.write(buffer)
+    #   exit
+    #   # At this point "my_file.wav" won't be a valid Wave file, because close
+    #   # was never called
+    #
+    #   # But, close() doesn't need to be called when constructing the Writer
+    #   # with a block, because it is automatically called when the block exits.
+    #   Writer.new("my_file.wav", Format.new(:mono, :pcm_16, 44100)) do |writer|
+    #     writer.write(buffer)
+    #   end
+    #   # Writer is automatically closed here, because block has exited
+    #
+    # Returns nothing. Has side effect of closing the Writer.
+    # Raises WriterClosedError if the Writer is already closed.
     def close
+      if @closed
+        raise WriterClosedError
+      end
+
       # The RIFF specification requires that each chunk be aligned to an even number of bytes,
       # even if the byte count is an odd number. Therefore if an odd number of bytes has been
       # written, write an empty padding byte.
@@ -91,45 +182,51 @@ module WaveFile
       # See http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/Docs/riffmci.pdf, page 11.
       bytes_written = @total_sample_frames * @format.block_align
       if bytes_written.odd?
-        @file.syswrite(EMPTY_BYTE)
+        @io.write(EMPTY_BYTE)
       end
 
       # We can't know what chunk sizes to write for the RIFF and data chunks until all
       # samples have been written, so go back to the beginning of the file and re-write
       # those chunk headers with the correct sizes.
-      @file.sysseek(0)
+      @io.seek(0)
       write_header(@total_sample_frames)
 
-      @file.close
+      if @io_source == :file_name
+        @io.close
+      else
+        # If writing to an injected IO instance, seek back to the end of the file, which
+        # seems like a more expected place for the position to be than at the end of the
+        # header. For example, seeking back to the end allows writing consecutive files
+        # to the same IO without overwriting the previous file.
+        @io.seek(0, IO::SEEK_END)
+      end
+      @closed = true
     end
 
-    # Returns a Duration instance for the number of sample frames that have been written so far
+    # Public: Returns a Duration instance for the number of sample frames that have been written so far
     def total_duration
       Duration.new(@total_sample_frames, @format.sample_rate)
     end
 
-    # Returns the name of the Wave file that is being written to
-    attr_reader :file_name
-
-    # Returns a Format object describing the Wave file being written (number of channels, sample 
+    # Public: Returns a Format object describing the Wave file being written (number of channels, sample
     # format and bits per sample, sample rate, etc.)
     attr_reader :format
 
-    # Returns the number of samples (per channel) that have been written to the file so far. 
-    # For example, if 1000 "left" samples and 1000 "right" samples have been written to a stereo file, 
+    # Public: Returns the number of samples (per channel) that have been written to the file so far.
+    # For example, if 1000 "left" samples and 1000 "right" samples have been written to a stereo file,
     # this will return 1000.
     attr_reader :total_sample_frames
 
   private
 
-    # Padding value written to the end of chunks whose payload is an odd number of bytes. The RIFF 
-    # specification requires that each chunk be aligned to an even number of bytes, even if the byte 
+    # Internal: Padding value written to the end of chunks whose payload is an odd number of bytes. The RIFF
+    # specification requires that each chunk be aligned to an even number of bytes, even if the byte
     # count is an odd number.
     #
     # See http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/Docs/riffmci.pdf, page 11.
     EMPTY_BYTE = "\000"    # :nodoc:
 
-    # The number of bytes at the beginning of a wave file before the sample data in the data chunk 
+    # Internal: The number of bytes at the beginning of a wave file before the sample data in the data chunk
     # starts, assuming this canonical format:
     #
     # RIFF Chunk Header (12 bytes)
@@ -140,9 +237,10 @@ module WaveFile
     # All wave files written by Writer use this canonical format.
     CANONICAL_HEADER_BYTE_LENGTH = {:pcm => 36, :float => 50}    # :nodoc:
 
+    # Internal
     FORMAT_CHUNK_BYTE_LENGTH = {:pcm => 16, :float => 18}    # :nodoc:
 
-    # Writes the RIFF chunk header, format chunk, and the header for the data chunk. After this
+    # Internal: Writes the RIFF chunk header, format chunk, and the header for the data chunk. After this
     # method is called the file will be "queued up" and ready for writing actual sample data.
     def write_header(sample_frame_count)
       sample_data_byte_count = sample_frame_count * @format.block_align
@@ -176,7 +274,7 @@ module WaveFile
       header += CHUNK_IDS[:data]
       header += [sample_data_byte_count].pack(UNSIGNED_INT_32)
 
-      @file.syswrite(header)
+      @io.write(header)
     end
   end
 end

data/test/buffer_test.rb

@@ -3,7 +3,7 @@ require 'wavefile.rb'
 
 include WaveFile
 
-class BufferTest < MiniTest::Unit::TestCase
+class BufferTest < Minitest::Test
   def test_convert
     old_format = Format.new(:mono, :pcm_16, 44100)
     new_format = Format.new(:stereo, :pcm_16, 22050)
@@ -39,51 +39,55 @@ class BufferTest < MiniTest::Unit::TestCase
 
   def test_convert_buffer_channels
     Format::SUPPORTED_BITS_PER_SAMPLE[:pcm].each do |bits_per_sample|
+      format_code = "pcm_#{bits_per_sample}".to_sym
+
       [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(:mono, bits_per_sample, sample_rate))
-        b.convert!(Format.new(:mono, bits_per_sample, sample_rate))
+        b = Buffer.new([-100, 0, 200], Format.new(:mono, format_code, sample_rate))
+        b.convert!(Format.new(:mono, format_code, sample_rate))
         assert_equal([-100, 0, 200], b.samples)
 
         # Mono => Stereo
-        b = Buffer.new([-100, 0, 200], Format.new(:mono, bits_per_sample, sample_rate))
-        b.convert!(Format.new(:stereo, bits_per_sample, sample_rate))
+        b = Buffer.new([-100, 0, 200], Format.new(:mono, format_code, sample_rate))
+        b.convert!(Format.new(:stereo, format_code, sample_rate))
         assert_equal([[-100, -100], [0, 0], [200, 200]], b.samples)
 
         # Mono => 3-channel
-        b = Buffer.new([-100, 0, 200], Format.new(:mono, bits_per_sample, sample_rate))
-        b.convert!(Format.new(3, bits_per_sample, sample_rate))
+        b = Buffer.new([-100, 0, 200], Format.new(:mono, format_code, sample_rate))
+        b.convert!(Format.new(3, format_code, 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(:stereo, bits_per_sample, sample_rate))
-        b.convert!(Format.new(:mono, bits_per_sample, sample_rate))
+        b = Buffer.new([[-100, -100], [0, 0], [200, 50], [8, 1]], Format.new(:stereo, format_code, sample_rate))
+        b.convert!(Format.new(:mono, format_code, 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(:mono, bits_per_sample, sample_rate))
+                       Format.new(3, format_code, sample_rate))
+        b.convert!(Format.new(:mono, format_code, 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(:stereo, bits_per_sample, sample_rate))
+                       Format.new(3, format_code, sample_rate))
+        b.convert!(Format.new(:stereo, format_code, sample_rate))
         assert_equal([[-100, -100], [1, 2], [200, 50]], b.samples)
 
         # Unsupported conversion (4-channel => 3-channel)
         b = Buffer.new([[-100, 200, -300, 400], [1, 2, 3, 4]],
-                       Format.new(4, bits_per_sample, sample_rate))
-        assert_raises(BufferConversionError) { b.convert!(Format.new(3, bits_per_sample, sample_rate)) }
+                       Format.new(4, format_code, sample_rate))
+        assert_raises(BufferConversionError) { b.convert!(Format.new(3, format_code, sample_rate)) }
       end
     end
   end
 
   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))
+      format_code = "pcm_#{bits_per_sample}".to_sym
+
+      b = Buffer.new([0, 128, 255], Format.new(:mono, format_code, 44100))
+      b.convert!(Format.new(:mono, format_code, 44100))
 
       # Target format is the same as the original format, so the sample data should not change
       assert_equal([0, 128, 255], b.samples)

data/test/chunk_readers/format_chunk_reader_test.rb

@@ -0,0 +1,130 @@
+require 'minitest/autorun'
+require 'wavefile.rb'
+
+include WaveFile
+include WaveFile::ChunkReaders
+
+class FormatChunkReaderTest < Minitest::Test
+  def test_basic_pcm_no_extension
+    io = StringIO.new
+    io.syswrite([1].pack(UNSIGNED_INT_16))   # Audio format
+    io.syswrite([2].pack(UNSIGNED_INT_16))   # Channels
+    io.syswrite([44100].pack(UNSIGNED_INT_32))   # Sample rate
+    io.syswrite([176400].pack(UNSIGNED_INT_32))   # Byte rate
+    io.syswrite([4].pack(UNSIGNED_INT_16))   # Block align
+    io.syswrite([16].pack(UNSIGNED_INT_16))   # Bits per sample
+    io.syswrite("data")   # Start of the next chunk
+    io.rewind
+
+    format_chunk_reader = FormatChunkReader.new(io, 16)
+    unvalidated_format = format_chunk_reader.read
+
+    assert_equal(1, unvalidated_format.audio_format)
+    assert_equal(2, unvalidated_format.channels)
+    assert_equal(44100, unvalidated_format.sample_rate)
+    assert_equal(176400, unvalidated_format.byte_rate)
+    assert_equal(4, unvalidated_format.block_align)
+    assert_equal(16, unvalidated_format.bits_per_sample)
+
+    io.close
+  end
+
+  # Test that a file with data that isn't valid configuration
+  # is still read properly.
+  def test_gibberish_no_extension
+    io = StringIO.new
+    io.syswrite([555].pack(UNSIGNED_INT_16))   # Audio format
+    io.syswrite([111].pack(UNSIGNED_INT_16))   # Channels
+    io.syswrite([12345].pack(UNSIGNED_INT_32))   # Sample rate
+    io.syswrite([9].pack(UNSIGNED_INT_32))   # Byte rate
+    io.syswrite([8000].pack(UNSIGNED_INT_16))   # Block align
+    io.syswrite([23433].pack(UNSIGNED_INT_16))   # Bits per sample
+    io.syswrite("data")   # Start of the next chunk
+    io.rewind
+
+    format_chunk_reader = FormatChunkReader.new(io, 16)
+    unvalidated_format = format_chunk_reader.read
+
+    assert_equal(555, unvalidated_format.audio_format)
+    assert_equal(111, unvalidated_format.channels)
+    assert_equal(12345, unvalidated_format.sample_rate)
+    assert_equal(9, unvalidated_format.byte_rate)
+    assert_equal(8000, unvalidated_format.block_align)
+    assert_equal(23433, unvalidated_format.bits_per_sample)
+
+    io.close
+  end
+
+  def test_basic_float_with_empty_extension
+    io = StringIO.new
+    io.syswrite([3].pack(UNSIGNED_INT_16))   # Audio format
+    io.syswrite([2].pack(UNSIGNED_INT_16))   # Channels
+    io.syswrite([44100].pack(UNSIGNED_INT_32))   # Sample rate
+    io.syswrite([352800].pack(UNSIGNED_INT_32))   # Byte rate
+    io.syswrite([8].pack(UNSIGNED_INT_16))   # Block align
+    io.syswrite([32].pack(UNSIGNED_INT_16))   # Bits per sample
+    io.syswrite([0].pack(UNSIGNED_INT_16))   # Extension size
+    io.syswrite("data")   # Start of the next chunk
+    io.rewind
+
+    format_chunk_reader = FormatChunkReader.new(io, 18)
+    unvalidated_format = format_chunk_reader.read
+
+    assert_equal(3, unvalidated_format.audio_format)
+    assert_equal(2, unvalidated_format.channels)
+    assert_equal(44100, unvalidated_format.sample_rate)
+    assert_equal(352800, unvalidated_format.byte_rate)
+    assert_equal(8, unvalidated_format.block_align)
+    assert_equal(32, unvalidated_format.bits_per_sample)
+
+    io.close
+  end
+
+  def test_wave_format_extensible
+    io = StringIO.new
+    io.syswrite([65534].pack(UNSIGNED_INT_16))   # Audio format
+    io.syswrite([2].pack(UNSIGNED_INT_16))   # Channels
+    io.syswrite([44100].pack(UNSIGNED_INT_32))   # Sample rate
+    io.syswrite([264600].pack(UNSIGNED_INT_32))   # Byte rate
+    io.syswrite([6].pack(UNSIGNED_INT_16))   # Block align
+    io.syswrite([24].pack(UNSIGNED_INT_16))   # Bits per sample
+    io.syswrite([22].pack(UNSIGNED_INT_16))   # Extension size
+    io.syswrite([20].pack(UNSIGNED_INT_16))   # Valid bits per sample
+    io.syswrite([0].pack(UNSIGNED_INT_32))   # Channel mask
+    io.syswrite(SUB_FORMAT_GUID_PCM)
+    io.syswrite("data")   # Start of the next chunk
+    io.rewind
+
+    format_chunk_reader = FormatChunkReader.new(io, 40)
+    unvalidated_format = format_chunk_reader.read
+
+    assert_equal(65534, unvalidated_format.audio_format)
+    assert_equal(2, unvalidated_format.channels)
+    assert_equal(44100, unvalidated_format.sample_rate)
+    assert_equal(264600, unvalidated_format.byte_rate)
+    assert_equal(6, unvalidated_format.block_align)
+    assert_equal(24, unvalidated_format.bits_per_sample)
+
+    assert_equal(20, unvalidated_format.valid_bits_per_sample)
+    assert_equal(SUB_FORMAT_GUID_PCM, unvalidated_format.sub_audio_format_guid)
+
+    io.close
+  end
+
+  def test_chunk_size_too_small
+    io = StringIO.new
+    io.syswrite([1].pack(UNSIGNED_INT_16))   # Audio format
+    io.syswrite([2].pack(UNSIGNED_INT_16))   # Channels
+    io.syswrite([44100].pack(UNSIGNED_INT_32))   # Sample rate
+    io.syswrite([176400].pack(UNSIGNED_INT_32))   # Byte rate
+    io.syswrite([4].pack(UNSIGNED_INT_16))   # Block align
+    io.syswrite([16].pack(UNSIGNED_INT_16))   # Bits per sample
+    io.syswrite("data")   # Start of the next chunk
+    io.rewind
+
+    format_chunk_reader = FormatChunkReader.new(io, 15)
+    assert_raises(InvalidFormatError) { format_chunk_reader.read }
+
+    io.close
+  end
+end