wavefile 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74dc03a8b43dd34032083def685191fb8795bcc19f0d6dc2459377249e72b262
-  data.tar.gz: 9388445c1d4f394ea3929b7bb49e01b4db1c3058ec497d17a7e783f94389d093
+  metadata.gz: 00fb7f8e8dc794a4cb669d3709cc05a1776f752a27d501668760bf14bae70746
+  data.tar.gz: 0a86b94b3c8891b365be3c9ffc17f824b5a97b31d22a9d9a884caf66657a935e
 SHA512:
-  metadata.gz: '087d89fb1b379afb39afa0173e41ee67a6c609b4969054bfe3b81eff367410dc46623a4e5e5bf52de1f59b13186f40a935c2eef70168a4b2a75cce5a9fd5487f'
-  data.tar.gz: cd180b60e9f70e2ec60ff8431192d9aec10aaf06554591a725a9594d5ed8efd1479abb2219495addbe8dd91c4f6ee5220c10371be95dc1836c5f863ba27b7227
+  metadata.gz: 7c0978db16d2ea9baca96c9880b8816bd9829bbb7e2c34404d815e58219eb7dc715b0e9e30d6b4b75f6fb2dc1b22b517ececd0fcfd3ac43d76ff148761ed2bf7
+  data.tar.gz: a57b221b66a60962d3ad7e3c90ff66b0bee00e848f7aafd2eebc282ef0fefed7998f5a4c2b6297ade454566ff0fbeacf0e7887d892c6e22939e4490edaec80cc

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009-19 Joel Strait
+Copyright (c) 2009-22 Joel Strait
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/README.markdown

@@ -2,14 +2,14 @@ A Ruby gem for reading and writing sound files in Wave format (*.wav).
 
 You can use this gem to create Ruby programs that work with audio, such as a [command-line drum machine](https://beatsdrummachine.com). Since it is written in pure Ruby (as opposed to wrapping an existing C library), you can use it without having to compile a separate extension.
 
-For more info, check out the website: <http://wavefilegem.com/>
+For more info, check out the website: <https://wavefilegem.com/>
 
 # Example Usage
 
-This short example shows how to append three separate Wave files into a single file:
+This example shows how to append three separate Wave files into a single file:
 
 ```ruby
-require 'wavefile'
+require "wavefile"
 include WaveFile
 
 FILES_TO_APPEND = ["file1.wav", "file2.wav", "file3.wav"]
@@ -23,7 +23,7 @@ Writer.new("append.wav", Format.new(:stereo, :pcm_16, 44100)) do |writer|
 end
 ```
 
-More examples can be found at <http://wavefilegem.com/examples>.
+More examples can be found at <https://wavefilegem.com/examples>.
 
 
 # Installation
@@ -34,16 +34,16 @@ First, install the WaveFile gem from rubygems.org:
 
 ...and include it in your Ruby program:
 
-    require 'wavefile'
+    require "wavefile"
 
-Note that if you're installing the gem into the default Ruby that comes pre-installed on MacOS (as opposed to a Ruby installed via [RVM](http://rvm.io/) or [rbenv](https://github.com/sstephenson/rbenv/)), you should used `sudo gem install wavefile`. Otherwise you might run into a file permission error.
+Note that if you're installing the gem into the default Ruby that comes pre-installed on MacOS (as opposed to a Ruby installed via [RVM](https://rvm.io/) or [rbenv](https://github.com/sstephenson/rbenv/)), you should used `sudo gem install wavefile`. Otherwise you might run into a file permission error.
 
 
 # Compatibility
 
 WaveFile has been tested with these Ruby versions, and appears to be compatible with them:
 
-* MRI 2.7.0, 2.6.5, 2.5.7, 2.4.9, 2.3.8, 2.2.10, 2.1.10, 2.0.0-p648
+* MRI 3.2.0, 3.1.3, 3.0.5, 2.7.7, 2.6.10, 2.5.9, 2.4.10, 2.3.8, 2.2.10, 2.1.10, 2.0.0-p648
 
 2.0 is the minimum supported Ruby version.
 
@@ -65,25 +65,46 @@ This gem lets you read and write audio data! You can use it to create Ruby progr
 * Seamlessly convert between sample formats. Read sample data from a file into any format supported by this gem, regardless of how the sample data is stored in the actual file. Or, create sample data in one format (such as floats between -1.0 and 1.0), but write it to a file in a different format (such as 16-bit PCM).
 * Automatic file management, similar to how `IO.open` works. That is, you can open a file for reading or writing, and if a block is given, the file will automatically be closed when the block exits.
 * Query metadata about Wave files (sample rate, number of channels, number of sample frames, etc.), including files that are in a format this gem can't read or write.
-* Written in pure Ruby, so it's easy to include in your program. There's no need to compile a separate extension in order to use it.
+* Easy to install, since it's written in pure Ruby. There's no need to compile a separate extension in order to use it.
 
 
-# Current Release: v1.1.1
+# Current Release: v1.1.2
 
-Released on December 29, 2019, this version contains this change:
+Released on December 30, 2022, this version fixes several edge case bugs related to reading a *.wav file's `"fmt "` chunk. In particular, reading a `"fmt "` chunk that has extra trailing bytes; reading a `"fmt "` chunk in WAVE_FORMAT_EXTENSIBLE format whose chunk extension is missing, incomplete, or has extra trailing bytes; and reading a `"fmt "` chunk whose chunk extension is too large to fit in the chunk. In short, some valid files that were previously rejected can now be read, and some invalid files are handled more properly.
 
-* Removes `warning: Using the last argument as keyword parameters is deprecated; maybe ** should be added to the call` output when reading a file with a `smpl` chunk using Ruby 2.7.0. (And presumably, higher Ruby versions as well, but Ruby 2.7.0 is the most recent Ruby version at the time of this release).
+The full details:
+
+* **Bug Fix:** Files that have extra bytes at the end of the `"fmt "` chunk can now be read.
+
+    If the format code is `1`, the `"fmt "` chunk has extra bytes if the chunk body size is greater than 16 bytes. Otherwise, "extra bytes" means the chunk contains bytes after the chunk extension (not including the required padding byte for an odd-sized chunk).
+
+    Previously, attempting to open certain files like this via `Reader.new` would result in `InvalidFormatError` being raised with a misleading `"Not a supported wave file. The format chunk extension is shorter than expected."` message. This was misleading because if the format code is `1`, the `"fmt "` chunk won't actually have a chunk extension, and for other format codes the chunk extension might actually be the expected size or larger. When reading a file like this, any extra data in the `"fmt "` chunk beyond what is expected based on the relevant format code will now be ignored.
+
+  * There was a special case where a file like this _could_ be opened correctly. If the format code was `1`, and the value of bytes 16 and 17 (0-based), when interpreted as a 16-bit unsigned little-endian integer, happened to be the same as the number of subsequent bytes in the chunk, the file could be opened without issue. For example, if the `"fmt "` chunk size was `22`, the format code was `1`, and the value of bytes 16 and 17 was `4` (when interpreted as a 16-bit unsigned little-endian integer), the file could be opened correctly.
+  * There was another special case where `InvalidFormatError` would be incorrectly raised, but the error message would be different (and also misleading). If the format code was `1`, and there was exactly 1 extra byte in the `"fmt "` chunk (i.e. the chunk size was 17 bytes), the error message would be `"Not a supported wave file. The format chunk is missing an expected extension."` This was misleading because when the format code is `1`, the `"fmt "` chunk doesn't have a chunk extension.
+  * Thanks to [@CromonMS](https://github.com/CromonMS) for reporting this as an issue.
+
+* **Bug Fix:** Files in WAVE_FORMAT_EXTENSIBLE format with a missing or incomplete `"fmt "` chunk extension can no longer be opened using `Reader.new`.
+
+    Previously, a `Reader` instance could be constructed for a file like this, but the relevant fields on the object returned by `Reader#native_format` would contain `nil` or `""` values for these fields, and no sample data could be read from the file. Since files like this are missing required fields that don't necessarily have sensible default values, it seems like it shouldn't be possible to create a `Reader` instance from them. After this fix, attempting to do so will cause `InvalidFormatError` to be raised.
 
+* **Bug Fix:** Files in WAVE_FORMAT_EXTENSIBLE format that have extra bytes at the end of the `"fmt "` chunk extension can now be read.
 
-# Previous Release: v1.1.0
+    This is similar but different from the first bug above; that bug refers to extra bytes _after_ the chunk extension, while this bug refers to extra bytes _inside_ the chunk extension. A WAVE_FORMAT_EXTENSIBLE `"fmt "` chunk extension has extra bytes if it is larger than 22 bytes.
 
-Released on January 20, 2019, this version has these changes:
+    Previously, a `Reader` instance could be constructed for a file like this, but `Reader#native_format#sub_audio_format_guid` would have an incorrect value, and sample data could not be read from the file. After this fix, this field will have the correct value, and if it is one of the supported values then sample data can be read. Any extra data at the end of the chunk extension will be ignored.
 
-* **Can read `smpl` chunk data from files that contain this kind of chunk.** If a *.wav file contains a `smpl` chunk, then `Reader.sampler_info` will return a `SamplerInfo` instance with the relevant data (or `nil` otherwise). Thanks to [@henrikj242](https://github.com/henrikj242) for suggesting this feature and providing the base implementation.
-* **More informative errors raised by `Reader.new`**. When attempting to read an invalid file, the error message now provides more detail about why the file is invalid.
-* **Bug Fix**: The master RIFF chunk size for files written by the gem will now take into account padding bytes written for child chunks. For example, when writing a file with a `data` chunk whose body has an odd number of bytes, the master RIFF chunk's size will be 1 byte larger (to take the empty padding byte at the end of the `data` chunk into account).
-* **Bug Fix**: If the stated `data` chunk size is larger than the actual number of bytes in the file, `Reader.current_sample_frame` will be correct when attempting to read past the end of the chunk. For example, if a `data` chunk says it has 2000 sample frames, but there are only 1000 sample frames remaining in the file, then after calling `Reader.read(1500)`, `Reader.current_sample_frame` will have a value of `1000`, not `1500`. (This bug did not occur for files in which the data chunk listed the correct size).
-* **Bug Fix**: Fixed off-by-one error in the maximum allowed value for `Format#sample rate`. The correct maximum sample rate is now 4_294_967_295; previously it allowed a maximum of 4_294_967_296.
+    Implicit in this scenario is that the `"fmt "` chunk has a stated size large enough to fit the oversized chunk extension. For cases where it doesn't, see the next bug fix below.
+
+* **Bug Fix:** More accurate message on the `InvalidFormatError` raised when reading a file whose `"fmt "` chunk extension is too large to fit in the chunk.
+
+    The message will now correctly state that the chunk extension is too large, rather than `"Not a supported wave file. The format chunk extension is shorter than expected."`. As an example of what "too large" means, if a `"fmt "` chunk has a size of 50 bytes, then any chunk extension larger than 32 bytes will be too large and overflow out of the chunk, since a chunk extension's content always starts at byte 18 (0-based).
+
+# Previous Release: v1.1.1
+
+Released on December 29, 2019, this version contains this change:
+
+* Removes `warning: Using the last argument as keyword parameters is deprecated; maybe ** should be added to the call` output when reading a file with a `smpl` chunk using Ruby 2.7.0. (And presumably, higher Ruby versions as well, but Ruby 2.7.0 is the most recent Ruby version at the time of this release).
 
 For changes in previous versions, visit <https://github.com/jstrait/wavefile/releases>.
 

data/lib/wavefile/buffer.rb

@@ -37,15 +37,17 @@ module WaveFile
     #          don't match, unexpected things will happen.
     #
     # Examples
+    #   # One cycle of a floating point 441Hz mono square wave
+    #   samples = ([0.5] * 50) + ([-0.5] * 50)
+    #   buffer = Buffer.new(samples, Format.new(:mono, :float, 44100))
     #
-    #   samples = ([0.5] * 50) + ([-0.5] * 50)   # A floating point 440Hz mono square wave
-    #   buffer = Buffer.new(samples, Format.new(:mono, :float, 44100)
+    #   # One cycle of a floating point 441Hz stereo square wave
+    #   samples = ([0.5, 0.5] * 50) + ([-0.5, -0.5] * 50)
+    #   buffer = Buffer.new(samples, Format.new(2, :float, 44100))
     #
-    #   samples = ([0.5, 0.5] * 50) + ([-0.5, -0.5] * 50)   # A 440Hz stereo square wave
-    #   buffer = Buffer.new(samples, Format.new(2, :float, 44100)
-    #
-    #   samples = ([16000] * 50) + ([-16000] * 50)   # A 16-bit PCM 440Hz mono square wave
-    #   buffer = Buffer.new(samples, Format.new(1, :pcm_16, 44100)
+    #   # One cycle of a 16-bit PCM 441Hz mono square wave
+    #   samples = ([16000] * 50) + ([-16000] * 50)
+    #   buffer = Buffer.new(samples, Format.new(1, :pcm_16, 44100))
     #
     # Returns a constructed Buffer.
     def initialize(samples, format)

data/lib/wavefile/chunk_readers/format_chunk_reader.rb

@@ -22,21 +22,25 @@ module WaveFile
         format_chunk[:block_align],
         format_chunk[:bits_per_sample] = raw_bytes.slice!(0...MINIMUM_CHUNK_SIZE).unpack("vvVVvv")
 
-        if @chunk_size > MINIMUM_CHUNK_SIZE
-          format_chunk[:extension_size] = raw_bytes.slice!(0...2).unpack(UNSIGNED_INT_16).first
-
-          if format_chunk[:extension_size] == nil
+        if format_chunk[:audio_format] == FORMAT_CODES[:extensible] || (format_chunk[:audio_format] != FORMAT_CODES[:pcm] && @chunk_size > MINIMUM_CHUNK_SIZE)
+          if raw_bytes.length < 2
             raise_error InvalidFormatError, "The format chunk is missing an expected extension."
           end
 
-          if format_chunk[:extension_size] != raw_bytes.length
-            raise_error InvalidFormatError, "The format chunk extension is shorter than expected."
+          format_chunk[:extension_size] = raw_bytes.slice!(0...2).unpack(UNSIGNED_INT_16).first
+
+          if format_chunk[:extension_size] > raw_bytes.length
+            raise_error InvalidFormatError, "The format chunk extension size of #{format_chunk[:extension_size]} bytes is too large to fit in the format chunk. The format chunk has a stated size of #{@chunk_size} bytes, with #{raw_bytes.length} bytes available for the extension."
           end
 
           if format_chunk[:audio_format] == FORMAT_CODES[:extensible]
+            if format_chunk[:extension_size] < 22
+              raise_error InvalidFormatError, "The format chunk extension size of #{format_chunk[:extension_size]} bytes is too small. Since the format chunk has a format code of #{FORMAT_CODES[:extensible]} (i.e. WAVE_FORMAT_EXTENSIBLE), the extension size must be at least 22 bytes."
+            end
+
             format_chunk[:valid_bits_per_sample] = raw_bytes.slice!(0...2).unpack(UNSIGNED_INT_16).first
             format_chunk[:speaker_mapping] = raw_bytes.slice!(0...4).unpack(UNSIGNED_INT_32).first
-            format_chunk[:sub_audio_format_guid] = raw_bytes
+            format_chunk[:sub_audio_format_guid] = raw_bytes.slice!(0...16)
           end
         end
 

data/lib/wavefile/duration.rb

@@ -37,17 +37,17 @@ module WaveFile
       sample_frames_per_hour = sample_frames_per_minute * 60
       @hours, @minutes, @seconds, @milliseconds = 0, 0, 0, 0
 
-      if(sample_frame_count >= sample_frames_per_hour)
+      if sample_frame_count >= sample_frames_per_hour
         @hours = sample_frame_count / sample_frames_per_hour
         sample_frame_count -= sample_frames_per_hour * @hours
       end
 
-      if(sample_frame_count >= sample_frames_per_minute)
+      if sample_frame_count >= sample_frames_per_minute
         @minutes = sample_frame_count / sample_frames_per_minute
         sample_frame_count -= sample_frames_per_minute * @minutes
       end
 
-      if(sample_frame_count >= sample_frames_per_second)
+      if sample_frame_count >= sample_frames_per_second
         @seconds = sample_frame_count / sample_frames_per_second
         sample_frame_count -= sample_frames_per_second * @seconds
       end

data/lib/wavefile/reader.rb

@@ -56,9 +56,9 @@ module WaveFile
     end
 
 
-    # Public: Reads sample data of the into successive Buffers of the specified size, until there is
-    # no more sample data to be read. When all sample data has been read, the Reader is automatically
-    # closed. Each Buffer is passed to the given block.
+    # Public: Starting from the current reading position, reads sample frames into successive Buffers
+    # of the specified size, until there are no more sample frames to be read. When the final sample
+    # frame has been read the Reader is automatically closed. Each Buffer is passed to the given block.
     #
     # If the Reader is constructed from an open IO, the IO is NOT closed after all sample data is
     # read. However, the Reader will be closed and any attempt to continue to read from it will
@@ -93,6 +93,15 @@ module WaveFile
     #   # Although Reader is closed, file still needs to be manually closed
     #   file.close
     #
+    #   reader = Reader.new("my_file.wav")
+    #   reader.read(100)
+    #   # Reading using `each_buffer` will start at the 101st sample frame:
+    #   reader.each_buffer do |buffer|
+    #     puts "#{buffer.samples.length} sample frames read"
+    #   end
+    #   # At this point, the Reader is now closed (even without
+    #   # a call to `close()`)
+    #
     # Returns nothing. Has side effect of closing the Reader.
     def each_buffer(sample_frame_count=4096)
       begin
@@ -116,7 +125,7 @@ module WaveFile
     #
     # Raises UnsupportedFormatError if file is in a format that can't be read by this gem.
     #
-    # Raises ReaderClosedError if the Writer has been closed.
+    # Raises ReaderClosedError if the Reader has been closed.
     #
     # Raises EOFError if no samples could be read due to reaching the end of the file.
     def read(sample_frame_count)

data/lib/wavefile/sampler_info.rb

@@ -11,7 +11,7 @@ module WaveFile
   # Public: Provides a way to indicate the data contained in a "smpl" chunk.
   #         That is, information about how the *.wav file could be used by a
   #         sampler, such as the file's MIDI note or loop points. If a *.wav
-  #         file contains a "smpl" chunk, then Reader.sampler_info will
+  #         file contains a "smpl" chunk, then Reader#sampler_info will
   #         return an instance of this object with the relevant info.
   class SamplerInfo
     VALID_32_BIT_INTEGER_RANGE = 0..4_294_967_295    # :nodoc:

data/lib/wavefile/sampler_loop.rb

@@ -12,7 +12,7 @@ module WaveFile
   # Public: Provides a way to indicate the data about sampler loop points
   #         in a file's "smpl" chunk. That is, information about how a sampler
   #         could loop between a sample range while playing this *.wav as a note.
-  #         If a *.wav file contains a "smpl" chunk, then Reader.sampler_info.loops
+  #         If a *.wav file contains a "smpl" chunk, then Reader#sampler_info#loops
   #         will return an array of SamplerLoop objects with the relevant info.
   class SamplerLoop
     VALID_32_BIT_INTEGER_RANGE = 0..4_294_967_295    # :nodoc:

data/lib/wavefile/smpte_timecode.rb

@@ -6,7 +6,7 @@ module WaveFile
   class InvalidSMPTETimecodeError < StandardError; end
 
   # Public: Represents an SMPTE timecode: https://en.wikipedia.org/wiki/SMPTE_timecode
-  #         If a *.wav file has a "smpl" chunk, then Reader.sampler_info.smpte_offset
+  #         If a *.wav file has a "smpl" chunk, then Reader#sampler_info#smpte_offset
   #         will return an instance of this class.
   class SMPTETimecode
     VALID_8_BIT_UNSIGNED_INTEGER_RANGE = 0..255    # :nodoc:

data/lib/wavefile/writer.rb

@@ -242,10 +242,10 @@ module WaveFile
     # Data Chunk Header (8 bytes)
     #
     # All wave files written by Writer use this canonical format.
-    CANONICAL_HEADER_BYTE_LENGTH = {:pcm => 36, :float => 50, :extensible => 72}.freeze    # :nodoc:
+    CANONICAL_HEADER_BYTE_LENGTH = {pcm: 36, float: 50, extensible: 72}.freeze    # :nodoc:
 
     # Internal
-    FORMAT_CHUNK_BYTE_LENGTH = {:pcm => 16, :float => 18, :extensible => 40}.freeze    # :nodoc:
+    FORMAT_CHUNK_BYTE_LENGTH = {pcm: 16, float: 18, extensible: 40}.freeze    # :nodoc:
 
     # Internal
     SPEAKER_MAPPING_BIT_VALUES = {
@@ -273,7 +273,7 @@ module WaveFile
     # Internal
     def pack_speaker_mapping(speaker_mapping)
       speaker_mapping.inject(0) do |result, speaker|
-        result |= SPEAKER_MAPPING_BIT_VALUES[speaker]
+        result | SPEAKER_MAPPING_BIT_VALUES[speaker]
       end
     end
 

data/lib/wavefile.rb

@@ -10,28 +10,28 @@ require 'wavefile/unvalidated_format'
 require 'wavefile/writer'
 
 module WaveFile
-  VERSION = "1.1.1"
+  VERSION = "1.1.2"
 
   WAVEFILE_FORMAT_CODE = "WAVE"    # :nodoc:
-  FORMAT_CODES = {:pcm => 1, :float => 3, :extensible => 65534}.freeze    # :nodoc:
+  FORMAT_CODES = {pcm: 1, float: 3, extensible: 65534}.freeze    # :nodoc:
   SUB_FORMAT_GUID_PCM = String.new("\x01\x00\x00\x00\x00\x00\x10\x00\x80\x00\x00\xAA\x00\x38\x9B\x71").force_encoding("ASCII-8BIT").freeze   # :nodoc:
   SUB_FORMAT_GUID_FLOAT = String.new("\x03\x00\x00\x00\x00\x00\x10\x00\x80\x00\x00\xAA\x00\x38\x9B\x71").force_encoding("ASCII-8BIT").freeze   # :nodoc:
-  CHUNK_IDS = {:riff         => "RIFF",
-               :format       => "fmt ",
-               :data         => "data",
-               :fact         => "fact",
-               :silence      => "slnt",
-               :cue          => "cue ",
-               :playlist     => "plst",
-               :list         => "list",
-               :label        => "labl",
-               :labeled_text => "ltxt",
-               :note         => "note",
-               :sample       => "smpl",
-               :instrument   => "inst" }.freeze    # :nodoc:
+  CHUNK_IDS = {riff:         "RIFF",
+               format:       "fmt ",
+               data:         "data",
+               fact:         "fact",
+               silence:      "slnt",
+               cue:          "cue ",
+               playlist:     "plst",
+               list:         "list",
+               label:        "labl",
+               labeled_text: "ltxt",
+               note:         "note",
+               sample:       "smpl",
+               instrument:   "inst" }.freeze    # :nodoc:
 
-  PACK_CODES = {:pcm   => { 8  => "C*", 16 => "s<*", 24 => "C*", 32 => "l<*"}.freeze,
-                :float => { 32 => "e*", 64 => "E*"}.freeze}.freeze    # :nodoc:
+  PACK_CODES = {pcm:   { 8  => "C*", 16 => "s<*", 24 => "C*", 32 => "l<*"}.freeze,
+                float: { 32 => "e*", 64 => "E*"}.freeze}.freeze    # :nodoc:
 
   UNSIGNED_INT_16 = "v"    # :nodoc:
   UNSIGNED_INT_32 = "V"    # :nodoc:

data/test/reader_test.rb

@@ -49,6 +49,73 @@ class ReaderTest < Minitest::Test
       # The format chunk has some data, but not all of the minimum required.
       "invalid/insufficient_format_chunk.wav",
 
+      # The format chunk has a size of 17, but is missing the required padding byte
+      # The extra byte is part of what would be the chunk extension size if the format
+      # code weren't 1.
+      "invalid/format_chunk_with_extra_byte_and_missing_padding_byte.wav",
+
+      # The format chunk has an odd size with extra bytes at the end, but is
+      # missing the required padding byte
+      "invalid/format_chunk_extra_bytes_with_odd_size_and_missing_padding_byte.wav",
+
+      # The format chunk is floating point but the extension size field is incomplete
+      "invalid/float_format_chunk_extension_size_incomplete.wav",
+
+      # The format chunk is floating point but the extension size field is incomplete.
+      # The padding byte which is present should not be interpreted as part of the size field.
+      "invalid/float_format_chunk_extension_size_incomplete_with_padding_byte.wav",
+
+      # The format chunk is floating point and has an oversized extension,
+      # and the extension is too large to fit in the stated size of the chunk
+      "invalid/float_format_chunk_oversized_extension_too_large.wav",
+
+      # The format chunk is extensible, but the required extension is not present
+      "invalid/extensible_format_chunk_extension_missing.wav",
+
+      # The format chunk is extensible, but the extension size field is incomplete.
+      # The required padding byte is present.
+      "invalid/extensible_format_chunk_extension_size_incomplete_with_padding_byte.wav",
+
+      # The format chunk is extensible, but the extension size field is incomplete.
+      # The required padding byte is not present.
+      "invalid/extensible_format_chunk_extension_size_incomplete.wav",
+
+      # The format chunk is extensible, but the extension is shorter than required
+      "invalid/extensible_format_chunk_extension_incomplete.wav",
+
+      # The format chunk is extensible, but the extension is shorter than required
+      # (even though the chunk is large enough to contain a full extension).
+      "invalid/extensible_format_chunk_extension_incomplete_in_large_enough_chunk.wav",
+
+      # The format chunk is extensible, but the extension is shorter than required
+      # (the chunk has a stated size that is large enough, although it is larger than the actual amount of data).
+      "invalid/extensible_format_chunk_extension_incomplete_in_incorrectly_sized_chunk.wav",
+
+      # The format chunk is extensible, but the chunk doesn't have enough room for the extension
+      "invalid/extensible_format_chunk_extension_truncated.wav",
+
+      # The format chunk is extensible and has an oversized extension,
+      # and the extension is too large to fit in the stated size of the chunk
+      "invalid/extensible_format_chunk_oversized_extension_too_large.wav",
+
+      # The format chunk has an unsupported format code (not an error),
+      # but the extension size field is incomplete.
+      "invalid/unsupported_format_extension_size_incomplete.wav",
+
+      # The format chunk has an unsupported format code (not an error),
+      # but the extension size field is incomplete.
+      # The padding byte which is present should not be interpreted as part of the size field.
+      "invalid/unsupported_format_extension_size_incomplete_with_padding_byte.wav",
+
+      # The format chunk has an unsupported format code (not an error),
+      # but the chunk doesn't have enough room for the extension.
+      "invalid/unsupported_format_extension_truncated.wav",
+
+      # The format chunk has an unsupported format code (not an error),
+      # and an oversized extension. The extension is too large to fit in
+      # the stated size of the chunk.
+      "invalid/unsupported_format_oversized_extension_too_large.wav",
+
       # The RIFF header and format chunk are OK, but there is no data chunk
       "invalid/no_data_chunk.wav",
 
@@ -127,9 +194,36 @@ class ReaderTest < Minitest::Test
 
   def test_read_from_unsupported_format
     unsupported_fixtures = [
-      # Audio format is 2, which is not supported
+      # Format code has an unsupported value
       "unsupported/unsupported_audio_format.wav",
 
+      # Format code has an unsupported value, and the format
+      # chunk has an extension.
+      "unsupported/unsupported_format_code_with_extension.wav",
+
+      # Format code has an unsupported value, and the format chunk does not
+      # have the expected "extension size" field. This field is not required
+      # by the gem so this should not cause `InvalidFormatError` to be raised.
+      "unsupported/unsupported_format_code_missing_extension_size.wav",
+
+      # Format code has an unsupported value, the format chunk has an extension,
+      # and extra bytes follow the extension.
+      "unsupported/unsupported_format_code_with_extension_and_extra_bytes.wav",
+
+      # Format code has an unsupported value, and a chunk extension that
+      # is smaller than is should be for the given format code. However,
+      # this should not cause an error because chunk extensions for unsupported
+      # formats are not parsed.
+      "unsupported/unsupported_format_code_with_incomplete_extension.wav",
+
+      # Format code has an unsupported value, and the format chunk has an oversized
+      # extension with extra bytes at the end.
+      "unsupported/unsupported_format_code_with_oversized_extension.wav",
+
+      # Format code has an unsupported value, the format chunk has an oversized extension
+      # with extra bytes at the end, and extra bytes follow the extension.
+      "unsupported/unsupported_format_code_with_oversized_extension_and_extra_bytes.wav",
+
       # Bits per sample is 20, which is not supported
       "unsupported/unsupported_bits_per_sample.wav",
 
@@ -240,7 +334,9 @@ 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(16, reader.native_format.valid_bits_per_sample)
     assert_equal([:front_left, :front_right], reader.native_format.speaker_mapping)
+    assert_equal(WaveFile::SUB_FORMAT_GUID_PCM, reader.native_format.sub_audio_format_guid)
     assert_equal(2, reader.format.channels)
     assert_equal(16, reader.format.bits_per_sample)
     assert_equal(44100, reader.format.sample_rate)
@@ -267,7 +363,9 @@ class ReaderTest < Minitest::Test
     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(24, reader.native_format.valid_bits_per_sample)
     assert_equal([:undefined, :undefined], reader.native_format.speaker_mapping)
+    assert_equal(WaveFile::SUB_FORMAT_GUID_PCM, reader.native_format.sub_audio_format_guid)
     assert_equal(2, reader.format.channels)
     assert_equal(24, reader.format.bits_per_sample)
     assert_equal(44100, reader.format.sample_rate)
@@ -294,7 +392,9 @@ 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(16, reader.native_format.valid_bits_per_sample)
     assert_equal([:front_left, :front_right, :front_center, :low_frequency], reader.native_format.speaker_mapping)
+    assert_equal(WaveFile::SUB_FORMAT_GUID_PCM, reader.native_format.sub_audio_format_guid)
     assert_equal(2, reader.format.channels)
     assert_equal(16, reader.format.bits_per_sample)
     assert_equal(44100, reader.format.sample_rate)
@@ -321,6 +421,7 @@ 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(16, reader.native_format.valid_bits_per_sample)
     # 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,
@@ -340,6 +441,7 @@ class ReaderTest < Minitest::Test
                   :top_back_left,
                   :top_back_center,
                   :top_back_right], reader.native_format.speaker_mapping)
+    assert_equal(WaveFile::SUB_FORMAT_GUID_PCM, reader.native_format.sub_audio_format_guid)
     assert_equal(2, reader.format.channels)
     assert_equal(16, reader.format.bits_per_sample)
     assert_equal(44100, reader.format.sample_rate)
@@ -366,7 +468,9 @@ 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(16, reader.native_format.valid_bits_per_sample)
     assert_equal([:undefined, :undefined], reader.native_format.speaker_mapping)
+    assert_equal(WaveFile::SUB_FORMAT_GUID_PCM, reader.native_format.sub_audio_format_guid)
     assert_equal(2, reader.format.channels)
     assert_equal(16, reader.format.bits_per_sample)
     assert_equal(44100, reader.format.sample_rate)
@@ -417,6 +521,308 @@ class ReaderTest < Minitest::Test
     assert_equal(SQUARE_WAVE_CYCLE[:mono][:pcm_16] * 24,  buffers[2].samples)
   end
 
+  def test_read_float_format_chunk_missing_extension_size
+    reader = Reader.new(fixture("valid/valid_float_format_chunk_missing_extension_size.wav"))
+
+    assert_equal(3, reader.native_format.audio_format)
+    assert_equal(1, reader.native_format.channels)
+    assert_equal(32, 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(32, 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?)
+    assert_nil(reader.sampler_info)
+    reader.close
+
+    buffers = read_file("valid/valid_float_format_chunk_missing_extension_size.wav", 1024)
+
+    assert_equal(3, buffers.length)
+    assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:float] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:float] * 128, buffers[1].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:float] * 24,  buffers[2].samples)
+  end
+
+  def test_read_format_chunk_with_extra_bytes
+    reader = Reader.new(fixture("valid/valid_format_chunk_with_extra_bytes.wav"))
+
+    assert_equal(1, reader.native_format.audio_format)
+    assert_equal(1, reader.native_format.channels)
+    assert_equal(8, 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(8, 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?)
+    assert_nil(reader.sampler_info)
+    reader.close
+
+    buffers = read_file("valid/valid_format_chunk_with_extra_bytes.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_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] * 24,  buffers[2].samples)
+  end
+
+  def test_read_format_chunk_with_extra_byte_and_padding_byte
+    reader = Reader.new(fixture("valid/valid_format_chunk_with_extra_byte_and_padding_byte.wav"))
+
+    assert_equal(1, reader.native_format.audio_format)
+    assert_equal(1, reader.native_format.channels)
+    assert_equal(8, 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(8, 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?)
+    assert_nil(reader.sampler_info)
+    reader.close
+
+    buffers = read_file("valid/valid_format_chunk_with_extra_byte_and_padding_byte.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_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] * 24,  buffers[2].samples)
+  end
+
+  def test_read_format_chunk_with_extra_bytes_with_odd_size_and_padding_byte
+    reader = Reader.new(fixture("valid/valid_format_chunk_extra_bytes_with_odd_size_and_padding_byte.wav"))
+
+    assert_equal(1, reader.native_format.audio_format)
+    assert_equal(1, reader.native_format.channels)
+    assert_equal(8, 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(8, 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?)
+    assert_nil(reader.sampler_info)
+    reader.close
+
+    buffers = read_file("valid/valid_format_chunk_extra_bytes_with_odd_size_and_padding_byte.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_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] * 24,  buffers[2].samples)
+  end
+
+  def test_read_float_format_chunk_with_oversized_extension
+    reader = Reader.new(fixture("valid/valid_float_format_chunk_oversized_extension.wav"))
+
+    assert_equal(3, reader.native_format.audio_format)
+    assert_equal(1, reader.native_format.channels)
+    assert_equal(32, 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(32, 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?)
+    assert_nil(reader.sampler_info)
+    reader.close
+
+    buffers = read_file("valid/valid_float_format_chunk_oversized_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][:float] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:float] * 128, buffers[1].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:float] * 24,  buffers[2].samples)
+  end
+
+  def test_read_float_format_chunk_with_extra_bytes
+    reader = Reader.new(fixture("valid/valid_float_format_chunk_with_extra_bytes.wav"))
+
+    assert_equal(3, reader.native_format.audio_format)
+    assert_equal(1, reader.native_format.channels)
+    assert_equal(32, 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(32, 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?)
+    assert_nil(reader.sampler_info)
+    reader.close
+
+    buffers = read_file("valid/valid_float_format_chunk_with_extra_bytes.wav", 1024)
+
+    assert_equal(3, buffers.length)
+    assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:float] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:float] * 128, buffers[1].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:float] * 24,  buffers[2].samples)
+  end
+
+  def test_read_float_format_chunk_with_oversized_extension_and_extra_bytes
+    reader = Reader.new(fixture("valid/valid_float_format_chunk_oversized_extension_and_extra_bytes.wav"))
+
+    assert_equal(3, reader.native_format.audio_format)
+    assert_equal(1, reader.native_format.channels)
+    assert_equal(32, 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(32, 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?)
+    assert_nil(reader.sampler_info)
+    reader.close
+
+    buffers = read_file("valid/valid_float_format_chunk_with_extra_bytes.wav", 1024)
+
+    assert_equal(3, buffers.length)
+    assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:float] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:float] * 128, buffers[1].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:float] * 24,  buffers[2].samples)
+  end
+
+  def test_read_extensible_format_chunk_with_oversized_extension
+    reader = Reader.new(fixture("valid/valid_extensible_format_chunk_oversized_extension.wav"))
+
+    assert_equal(65534, reader.native_format.audio_format)
+    assert_equal(1, reader.native_format.channels)
+    assert_equal(8, reader.native_format.bits_per_sample)
+    assert_equal(44100, reader.native_format.sample_rate)
+    assert_equal(8, reader.native_format.valid_bits_per_sample)
+    assert_equal([:front_center], reader.native_format.speaker_mapping)
+    assert_equal(WaveFile::SUB_FORMAT_GUID_PCM, reader.native_format.sub_audio_format_guid)
+    assert_equal(1, reader.format.channels)
+    assert_equal(8, 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?)
+    assert_nil(reader.sampler_info)
+    reader.close
+
+    buffers = read_file("valid/valid_extensible_format_chunk_oversized_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_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] * 24,  buffers[2].samples)
+  end
+
+  def test_read_extensible_format_chunk_with_extra_bytes
+    reader = Reader.new(fixture("valid/valid_extensible_format_chunk_with_extra_bytes.wav"))
+
+    assert_equal(65534, reader.native_format.audio_format)
+    assert_equal(1, reader.native_format.channels)
+    assert_equal(8, reader.native_format.bits_per_sample)
+    assert_equal(44100, reader.native_format.sample_rate)
+    assert_equal(8, reader.native_format.valid_bits_per_sample)
+    assert_equal([:front_center], reader.native_format.speaker_mapping)
+    assert_equal(WaveFile::SUB_FORMAT_GUID_PCM, reader.native_format.sub_audio_format_guid)
+    assert_equal(8, reader.native_format.valid_bits_per_sample)
+    assert_equal(1, reader.format.channels)
+    assert_equal(8, 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?)
+    assert_nil(reader.sampler_info)
+    reader.close
+
+    buffers = read_file("valid/valid_extensible_format_chunk_with_extra_bytes.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_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] * 24,  buffers[2].samples)
+  end
+
+  def test_read_extensible_format_chunk_with_oversized_extension_and_extra_bytes
+    reader = Reader.new(fixture("valid/valid_extensible_format_chunk_oversized_extension_and_extra_bytes.wav"))
+
+    assert_equal(65534, reader.native_format.audio_format)
+    assert_equal(1, reader.native_format.channels)
+    assert_equal(8, reader.native_format.bits_per_sample)
+    assert_equal(44100, reader.native_format.sample_rate)
+    assert_equal(8, reader.native_format.valid_bits_per_sample)
+    assert_equal([:front_center], reader.native_format.speaker_mapping)
+    assert_equal(WaveFile::SUB_FORMAT_GUID_PCM, reader.native_format.sub_audio_format_guid)
+    assert_equal(8, reader.native_format.valid_bits_per_sample)
+    assert_equal(1, reader.format.channels)
+    assert_equal(8, 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?)
+    assert_nil(reader.sampler_info)
+    reader.close
+
+    buffers = read_file("valid/valid_extensible_format_chunk_with_extra_bytes.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_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] * 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))
 
@@ -531,6 +937,21 @@ class ReaderTest < Minitest::Test
     assert_equal(2241, reader.total_sample_frames)
   end
 
+  def test_each_buffer_not_at_beginning_of_file
+    reader = Reader.new(fixture("valid/valid_mono_pcm_16_44100.wav"))
+
+    buffers = []
+    reader.read(8)
+    reader.each_buffer {|buffer| buffers << buffer }
+
+    assert(reader.closed?)
+    assert_equal(1, buffers.length)
+    assert_equal([2232], buffers.map {|buffer| buffer.samples.length })
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][:pcm_16] * 279, buffers[0].samples)
+    assert_equal(2240, reader.current_sample_frame)
+    assert_equal(2240, reader.total_sample_frames)
+  end
+
   def test_each_buffer_inside_reader_block
     buffers = []
 
@@ -546,6 +967,21 @@ class ReaderTest < Minitest::Test
     assert_equal(SQUARE_WAVE_CYCLE[:mono][:pcm_16] * 24,  buffers[2].samples)
   end
 
+  def test_read_after_each_buffer_inside_block_raises_error
+    buffers = []
+
+    Reader.new(fixture("valid/valid_mono_pcm_16_44100.wav")) do |reader|
+      reader.each_buffer(1024) {|buffer| buffers << buffer }
+      assert_raises(ReaderClosedError) { reader.read(100) }
+    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
@@ -621,35 +1057,35 @@ class ReaderTest < Minitest::Test
 
       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},
+      test_duration({hours: 0, minutes: 0, seconds: 0, milliseconds: 50, sample_count: 2240},
                     reader.total_duration)
 
 
       reader.read(1024)
       assert_equal(1024, reader.current_sample_frame)
       assert_equal(2240, reader.total_sample_frames)
-      test_duration({:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 50, :sample_count => 2240},
+      test_duration({hours: 0, minutes: 0, seconds: 0, milliseconds: 50, sample_count: 2240},
                     reader.total_duration)
 
 
       reader.read(1024)
       assert_equal(2048, reader.current_sample_frame)
       assert_equal(2240, reader.total_sample_frames)
-      test_duration({:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 50, :sample_count => 2240},
+      test_duration({hours: 0, minutes: 0, seconds: 0, milliseconds: 50, sample_count: 2240},
                     reader.total_duration)
 
 
       reader.read(192)
       assert_equal(2240, reader.current_sample_frame)
       assert_equal(2240, reader.total_sample_frames)
-      test_duration({:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 50, :sample_count => 2240},
+      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)
       assert_equal(2240, reader.total_sample_frames)
-      test_duration({:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 50, :sample_count => 2240},
+      test_duration({hours: 0, minutes: 0, seconds: 0, milliseconds: 50, sample_count: 2240},
                     reader.total_duration)
     end
   end

data/test/wavefile_io_test_helper.rb

@@ -1,9 +1,9 @@
 module WaveFileIOTestHelper
-  CHANNEL_ALIAS = { :mono => 1, :stereo => 2, :tri => 3}
+  CHANNEL_ALIAS = {mono: 1, stereo: 2, tri: 3}
 
   SUPPORTED_BITS_PER_SAMPLE = {
-                                :pcm => [8, 16, 24, 32].freeze,
-                                :float => [32, 64].freeze,
+                                pcm: [8, 16, 24, 32].freeze,
+                                float: [32, 64].freeze,
                               }.freeze
 
   SQUARE_WAVE_CYCLE = {}

data/test/writer_test.rb

@@ -414,7 +414,7 @@ private
     dir = Dir.new(OUTPUT_FOLDER)
     file_names = dir.entries
     file_names.each do |file_name|
-      if(file_name != "." && file_name != "..")
+      if file_name != "." && file_name != ".."
         File.delete("#{OUTPUT_FOLDER}/#{file_name}")
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wavefile
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.2
 platform: ruby
 authors:
 - Joel Strait
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-12-29 00:00:00.000000000 Z
+date: 2022-12-30 00:00:00.000000000 Z
 dependencies: []
 description: You can use this gem to create Ruby programs that work with audio, by
   reading and writing Wave sound files (*.wav). Since it is written in pure Ruby (as
@@ -48,7 +48,20 @@ files:
 - test/fixtures/wave/invalid/data_chunk_truncated.wav
 - test/fixtures/wave/invalid/empty.wav
 - test/fixtures/wave/invalid/empty_format_chunk.wav
+- test/fixtures/wave/invalid/extensible_format_chunk_extension_incomplete.wav
+- test/fixtures/wave/invalid/extensible_format_chunk_extension_incomplete_in_incorrectly_sized_chunk.wav
+- test/fixtures/wave/invalid/extensible_format_chunk_extension_incomplete_in_large_enough_chunk.wav
+- test/fixtures/wave/invalid/extensible_format_chunk_extension_missing.wav
+- test/fixtures/wave/invalid/extensible_format_chunk_extension_size_incomplete.wav
+- test/fixtures/wave/invalid/extensible_format_chunk_extension_size_incomplete_with_padding_byte.wav
+- test/fixtures/wave/invalid/extensible_format_chunk_extension_truncated.wav
+- test/fixtures/wave/invalid/extensible_format_chunk_oversized_extension_too_large.wav
+- test/fixtures/wave/invalid/float_format_chunk_extension_size_incomplete.wav
+- test/fixtures/wave/invalid/float_format_chunk_extension_size_incomplete_with_padding_byte.wav
+- test/fixtures/wave/invalid/float_format_chunk_oversized_extension_too_large.wav
 - test/fixtures/wave/invalid/format_chunk_after_data_chunk.wav
+- test/fixtures/wave/invalid/format_chunk_extra_bytes_with_odd_size_and_missing_padding_byte.wav
+- test/fixtures/wave/invalid/format_chunk_with_extra_byte_and_missing_padding_byte.wav
 - test/fixtures/wave/invalid/incomplete_riff_format.wav
 - test/fixtures/wave/invalid/incomplete_riff_header.wav
 - test/fixtures/wave/invalid/insufficient_format_chunk.wav
@@ -62,15 +75,27 @@ files:
 - test/fixtures/wave/invalid/smpl_chunk_loop_count_too_high.wav
 - test/fixtures/wave/invalid/smpl_chunk_truncated_sampler_specific_data.wav
 - test/fixtures/wave/invalid/truncated_smpl_chunk.wav
-- test/fixtures/wave/unsupported/bad_audio_format.wav
+- test/fixtures/wave/invalid/unsupported_format_extension_size_incomplete.wav
+- test/fixtures/wave/invalid/unsupported_format_extension_size_incomplete_with_padding_byte.wav
+- test/fixtures/wave/invalid/unsupported_format_extension_truncated.wav
+- test/fixtures/wave/invalid/unsupported_format_oversized_extension_too_large.wav
 - test/fixtures/wave/unsupported/bad_channel_count.wav
 - test/fixtures/wave/unsupported/bad_sample_rate.wav
 - test/fixtures/wave/unsupported/extensible_container_size_bigger_than_sample_size.wav
 - test/fixtures/wave/unsupported/extensible_unsupported_subformat_guid.wav
 - test/fixtures/wave/unsupported/unsupported_audio_format.wav
 - test/fixtures/wave/unsupported/unsupported_bits_per_sample.wav
+- test/fixtures/wave/unsupported/unsupported_format_code_missing_extension_size.wav
+- test/fixtures/wave/unsupported/unsupported_format_code_with_extension.wav
+- test/fixtures/wave/unsupported/unsupported_format_code_with_extension_and_extra_bytes.wav
+- test/fixtures/wave/unsupported/unsupported_format_code_with_incomplete_extension.wav
+- test/fixtures/wave/unsupported/unsupported_format_code_with_oversized_extension.wav
+- test/fixtures/wave/unsupported/unsupported_format_code_with_oversized_extension_and_extra_bytes.wav
 - test/fixtures/wave/valid/no_samples.wav
 - test/fixtures/wave/valid/valid_extensible_20_pcm_16_44100_speaker_mapping_overflow.wav
+- test/fixtures/wave/valid/valid_extensible_format_chunk_oversized_extension.wav
+- test/fixtures/wave/valid/valid_extensible_format_chunk_oversized_extension_and_extra_bytes.wav
+- test/fixtures/wave/valid/valid_extensible_format_chunk_with_extra_bytes.wav
 - test/fixtures/wave/valid/valid_extensible_mono_float_32_44100.wav
 - test/fixtures/wave/valid/valid_extensible_mono_float_64_44100.wav
 - test/fixtures/wave/valid/valid_extensible_mono_pcm_16_44100.wav
@@ -97,6 +122,13 @@ files:
 - test/fixtures/wave/valid/valid_extensible_tri_pcm_24_44100.wav
 - test/fixtures/wave/valid/valid_extensible_tri_pcm_32_44100.wav
 - test/fixtures/wave/valid/valid_extensible_tri_pcm_8_44100.wav
+- test/fixtures/wave/valid/valid_float_format_chunk_missing_extension_size.wav
+- test/fixtures/wave/valid/valid_float_format_chunk_oversized_extension.wav
+- test/fixtures/wave/valid/valid_float_format_chunk_oversized_extension_and_extra_bytes.wav
+- test/fixtures/wave/valid/valid_float_format_chunk_with_extra_bytes.wav
+- test/fixtures/wave/valid/valid_format_chunk_extra_bytes_with_odd_size_and_padding_byte.wav
+- test/fixtures/wave/valid/valid_format_chunk_with_extra_byte_and_padding_byte.wav
+- test/fixtures/wave/valid/valid_format_chunk_with_extra_bytes.wav
 - test/fixtures/wave/valid/valid_mono_float_32_44100.wav
 - test/fixtures/wave/valid/valid_mono_float_64_44100.wav
 - test/fixtures/wave/valid/valid_mono_pcm_16_44100.wav
@@ -133,12 +165,12 @@ files:
 - test/unvalidated_format_test.rb
 - test/wavefile_io_test_helper.rb
 - test/writer_test.rb
-homepage: http://wavefilegem.com/
+homepage: https://wavefilegem.com/
 licenses:
 - MIT
 metadata: {}
 post_install_message: Thanks for installing the WaveFile gem! For documentation and
-  examples, visit http://wavefilegem.com
+  examples, visit https://wavefilegem.com
 rdoc_options: []
 require_paths:
 - lib
@@ -153,8 +185,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.4.1
+signing_key:
 specification_version: 4
 summary: A pure Ruby library for reading and writing Wave sound files (*.wav)
 test_files: []