wavefile 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee407af48a824f261cca687280e449d0cf8a865e9eb5b17c7b707d0f2df0b691
-  data.tar.gz: f5dae672a110107b4b572d47ed08a16c1a1cb87b913686b6d3c1a0aa100892a8
+  metadata.gz: fa0a930ea1818669c1a2c41b3e69454f55b247aa1f80ce936b3ab2ae2e1285dd
+  data.tar.gz: 2f4fcafe43bdd0db1310d8c120c65d5aac6766407179f8595d4335036d6503fb
 SHA512:
-  metadata.gz: 9ebaf573b2e015968616acac11c333f0a1a98bdcdaa9baf85d67987251eb649aaa31a8fb5f7c8a079e652e6ece7ebeae39fccbc079b61c51c2c6696109bcdbd1
-  data.tar.gz: 5d481c271766b50114450bf483189bd7038b0989a87c813af0d2f3b0d57f6eb4cda3ba95a3d62caff441e1ec97e9575c53c9517f5ff5cc2df3e01e85c310dbea
+  metadata.gz: eb3d947251f2d4167baa7cab3b7595b4eb422e2cd497ee6da3733ce72d20cfb87d0f89169b139075aeb98440e9cfeee186fbf48c1fae5481ed3007ad9804f2d1
+  data.tar.gz: 6136e89c7da66288d829ec0307900d91f16bee06da0f958195048373706ae2a38d3ce18566b7313efdafdb7b0daa51541bbb053f02444391c108b2c9ef851fef

data/LICENSE

@@ -1,24 +1,22 @@
-== WaveFile Ruby Gem
+Copyright (c) 2009-19 Joel Strait
 
-# Copyright (c) 2009-18 Joel Strait
-#
-# Permission is hereby granted, free of charge, to any person
-# obtaining a copy of this software and associated documentation
-# files (the "Software"), to deal in the Software without
-# restriction, including without limitation the rights to use,
-# copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the
-# Software is furnished to do so, subject to the following
-# conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-# OTHER DEALINGS IN THE SOFTWARE.
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -26,75 +26,59 @@ end
 More examples can be found at <http://wavefilegem.com/examples>.
 
 
-# Features
-
-This gem lets you read and write audio data! You can use it to create Ruby programs that work with sound.
-
-* Read and write Wave files with any number of channels, in integer PCM (8/16/24/32 bits per sample) or floating point PCM (32/64 bits per sample) format.
-* 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.
-
-
-# Current Release: v1.0.1
+# Installation
 
-Released on August 2, 2018, this version contains a bug fix: the file(s) written to an arbitrary `IO` instance are no longer corrupt if the initial seek position is greater than 0.
+First, install the WaveFile gem from rubygems.org:
 
+    gem install wavefile
 
-# Previous Release: v1.0.0
+...and include it in your Ruby program:
 
-Released on June 10, 2018, this version has these changes:
+    require 'wavefile'
 
-* **Ruby 2.0 or greater is now required** - the gem no longer works in Ruby 1.9.3.
-* **Backwards incompatible change:** Calling `Reader.close` on a `Reader` instance that is already closed no longer raises `ReaderClosedError`. Instead, it does nothing. Similarly, calling `Writer.close` on a `Writer` instance that is already closed no longer raises `WriterClosedError`. Thanks to [@kylekyle](https://github.com/kylekyle) for raising this as an issue.
-* **Better compatibility when writing Wave files.** `Writer` will now write files using a format called WAVE_FORMAT_EXTENSIBLE where appropriate. This is a behind-the-scenes improvement - for most use cases it won't affect how you use the gem, but can result in better compatibility with other programs.
-  * A file will automatically be written using WAVE_FORMAT_EXTENSIBLE format if any of the following are true:
-    * It has more than 2 channels
-    * It uses integer PCM sample format and the bits per sample is not 8 or 16 (in other words, if the sample format is `:pcm_24` or `:pcm_32`).
-    * A specific channel->speaker mapping is given (see below).
-* **The channel->speaker mapping field can now be read from files that have it defined.** For example, if a file indicates that the first sound channel should be mapped to the back right speaker, the second channel to the top center speaker, etc., this can be read using the `Reader.format.speaker_mapping` field.
-  * Example:
-    * ~~~
-      reader = Reader.new("4_channel_file.wav")
-      puts reader.format.speaker_mapping.inspect  # [:front_left, :front_right, :front_center, :back_center]
-      ~~~
-  * The channel->speaker mapping field isn't present in all Wave files. (Specifically, it's only present if the file uses WAVE_FORMAT_EXTENSIBLE format). For a non-WAVE_FORMAT_EXTENSIBLE file, `Reader.native_format.speaker_mapping` will be `nil`, to reflect that the channel->speaker mapping is undefined. `Reader.format.speaker_mapping` will use a "sensible" default value for the given number of channels.
-* **A channel->speaker mapping array can optionally be given when constructing a `Format` instance.** If not given, a default value will be set for the given number of channels.
-  * Example:
-    * `Format.new(4, :pcm_16, 44100, speaker_mapping: [:front_left, :front_right, :front_center, :low_frequency])`
-* **Errors raised by `Format.new` are improved to provide more detail.**
+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.
 
 
 # Compatibility
 
 WaveFile has been tested with these Ruby versions, and appears to be compatible with them:
 
-* MRI 2.5.1, 2.4.4, 2.3.7, 2.2.10, 2.1.10, 2.0
+* MRI 2.6.0, 2.5.3, 2.4.5, 2.3.8, 2.2.10, 2.1.10, 2.0
 
 2.0 is the minimum supported Ruby version.
 
 If you find any compatibility issues, please let me know by opening a GitHub issue.
 
 
-# Installation
+# Dependencies
 
-First, install the WaveFile gem from rubygems.org:
+WaveFile has no external dependencies when used as a gem.
 
-    gem install wavefile
+However, it does have dependencies for local development, in order to run the tests. See below in section "Local Development".
 
-...and include it in your Ruby program:
 
-    require 'wavefile'
+# Features
 
-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.
+This gem lets you read and write audio data! You can use it to create Ruby programs that work with sound.
 
+* Read and write Wave files with any number of channels, in integer PCM (8/16/24/32 bits per sample) or floating point PCM (32/64 bits per sample) format.
+* 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.
 
-# Dependencies
 
-WaveFile has no external dependencies when used as a gem.
+# Current Release: v1.1.0
 
-However, it does have dependencies for local development, in order to run the tests. See below in section "Local Development".
+Released on January 20, 2019, this version has these changes:
+
+* **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.
+
+For changes in previous versions, visit <https://github.com/jstrait/wavefile/releases>.
 
 
 # Local Development

data/lib/wavefile.rb

@@ -3,11 +3,14 @@ require 'wavefile/chunk_readers'
 require 'wavefile/duration'
 require 'wavefile/format'
 require 'wavefile/reader'
+require 'wavefile/sampler_info'
+require 'wavefile/sampler_loop'
+require 'wavefile/smpte_timecode'
 require 'wavefile/unvalidated_format'
 require 'wavefile/writer'
 
 module WaveFile
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 
   WAVEFILE_FORMAT_CODE = "WAVE"    # :nodoc:
   FORMAT_CODES = {:pcm => 1, :float => 3, :extensible => 65534}.freeze    # :nodoc:

data/lib/wavefile/buffer.rb

@@ -1,11 +1,11 @@
 module WaveFile
   # Public: Error that is raised when an attempt is made to perform an unsupported or
   # undefined conversion between two sample data formats. For example, converting a Buffer
-  # with 3 channels into a Buffer with 2 channels is undefined.
+  # with 4 channels into a Buffer with 3 channels is undefined.
   class BufferConversionError < StandardError; end
 
 
-  # Public: Represents a collection of samples in a certain format (e.g. 16-bit mono).
+  # Public: Represents a collection of samples in a certain format (e.g. 16-bit mono Integer PCM).
   # Reader returns sample data contained in Buffers, and Writer expects incoming sample
   # data to be contained in a Buffer as well.
   #
@@ -15,9 +15,9 @@ module WaveFile
     # Public: Creates a new Buffer.
     #
     # samples - An array of samples. If the Format has 1 channel (i.e. is mono), this
-    #           should be a flat array of samples such as [0.5, 0.4, -0.3, ...]. If the
-    #           Format has 2 or more channels the array should include a sub-array for
-    #           each sample frame. For example, [[0.5, 0.2], [0.1, 0.6], [-0.2, 0.4], ...]
+    #           should be a flat array of samples such as <code>[0.5, 0.4, -0.3, ...]</code>.
+    #           If the Format has 2 or more channels the array should include a sub-array for
+    #           each sample frame. For example, <code>[[0.5, 0.2], [0.1, 0.6], [-0.2, 0.4], ...]</code>
     #           for a stereo file.
     #
     #           The individual samples should match the given format:
@@ -75,6 +75,7 @@ module WaveFile
     #   new_buffer = old_buffer.convert(new_format)
     #
     # Returns a new Buffer; the existing Buffer is unmodified.
+    #
     # Raises BufferConversionError if the Buffer can't be converted to the given format
     def convert(new_format)
       new_samples = convert_buffer(@samples.dup, @format, new_format)
@@ -95,6 +96,7 @@ module WaveFile
     #   old_buffer.convert!(new_format)
     #
     # Returns self.
+    #
     # Raises BufferConversionError if the Buffer can't be converted to the given format
     def convert!(new_format)
       @samples = convert_buffer(@samples, @format, new_format)

data/lib/wavefile/chunk_readers.rb

@@ -1,9 +1,8 @@
 require 'wavefile/chunk_readers/riff_reader'
 require 'wavefile/chunk_readers/base_chunk_reader'
-require 'wavefile/chunk_readers/generic_chunk_reader'
-require 'wavefile/chunk_readers/riff_chunk_reader'
 require 'wavefile/chunk_readers/format_chunk_reader'
 require 'wavefile/chunk_readers/data_chunk_reader'
+require 'wavefile/chunk_readers/sample_chunk_reader'
 
 module WaveFile
   # Internal

data/lib/wavefile/chunk_readers/base_chunk_reader.rb

@@ -2,6 +2,19 @@ module WaveFile
   module ChunkReaders
     # Internal
     class BaseChunkReader    # :nodoc:
+      def read_entire_chunk_body(chunk_id)
+        raw_bytes = @io.read(@chunk_size)
+        if raw_bytes.nil?
+          raw_bytes = ""
+        end
+
+        if raw_bytes.length < @chunk_size
+          raise_error InvalidFormatError, "'#{chunk_id}' chunk indicated size of #{@chunk_size} bytes, but could only read #{raw_bytes.length} bytes."
+        end
+
+        raw_bytes
+      end
+
       def raise_error(exception_class, message)
         raise exception_class, "Not a supported wave file. #{message}"
       end

data/lib/wavefile/chunk_readers/data_chunk_reader.rb

@@ -26,14 +26,21 @@ module WaveFile
         raise UnsupportedFormatError unless @readable_format
 
         if @current_sample_frame >= @total_sample_frames
-          #FIXME: Do something different here, because the end of the file has not actually necessarily been reached
+          # The end of the file has not necessarily been reached if there is another chunk after
+          # the data chunk, but EOFError is raised for backwards compatibility with older versions
+          # of the gem, and because it is also generally semantically correct that the "relevant"
+          # end of the file has been reached.
           raise EOFError
         elsif sample_frame_count > sample_frames_remaining
           sample_frame_count = sample_frames_remaining
         end
 
-        samples = @io.sysread(sample_frame_count * @native_format.block_align).unpack(@pack_code)
-        @current_sample_frame += sample_frame_count
+        byte_count = sample_frame_count * @native_format.block_align
+        samples = @io.read(byte_count)
+        if samples.nil?
+          raise EOFError
+        end
+        samples = samples.unpack(@pack_code)
 
         if @native_format.bits_per_sample == 24
           samples = convert_24_bit_samples(samples)
@@ -43,6 +50,8 @@ module WaveFile
           samples = samples.each_slice(@native_format.channels).to_a
         end
 
+        @current_sample_frame += samples.length
+
         buffer = Buffer.new(samples, @native_format)
         buffer.convert(@format)
       end

data/lib/wavefile/chunk_readers/format_chunk_reader.rb

@@ -9,10 +9,10 @@ module WaveFile
 
       def read
         if @chunk_size < MINIMUM_CHUNK_SIZE
-          raise_error InvalidFormatError, "The format chunk is incomplete."
+          raise_error InvalidFormatError, "The format chunk is incomplete; it contains fewer than the required number of fields."
         end
 
-        raw_bytes = read_chunk_body(CHUNK_IDS[:format], @chunk_size)
+        raw_bytes = read_entire_chunk_body(CHUNK_IDS[:format])
 
         format_chunk = {}
         format_chunk[:audio_format],
@@ -46,14 +46,6 @@ module WaveFile
       private
 
       MINIMUM_CHUNK_SIZE = 16
-
-      def read_chunk_body(chunk_id, chunk_size)
-        begin
-          return @io.sysread(chunk_size)
-        rescue EOFError
-          raise_error InvalidFormatError, "The #{chunk_id} chunk has incomplete data."
-        end
-      end
     end
   end
 end

data/lib/wavefile/chunk_readers/riff_reader.rb

@@ -10,51 +10,98 @@ module WaveFile
         read_until_data_chunk(format)
       end
 
-      attr_reader :native_format, :data_chunk_reader
+      attr_reader :native_format, :data_chunk_reader, :sample_chunk
 
     private
 
+      def read_riff_format_code
+        riff_format = @io.read(4)
+
+        unless riff_format == WAVEFILE_FORMAT_CODE
+          raise_error InvalidFormatError, "Expected RIFF format of '#{WAVEFILE_FORMAT_CODE}', but was '#{riff_format}'"
+        end
+      end
+
       def read_until_data_chunk(format)
-        begin
-          chunk_id, chunk_size = read_chunk_header
-          unless chunk_id == CHUNK_IDS[:riff]
-            raise_error InvalidFormatError, "Expected chunk ID '#{CHUNK_IDS[:riff]}', but was '#{chunk_id}'"
-          end
-          RiffChunkReader.new(@io, chunk_size).read
+        chunk_id, riff_chunk_size = read_chunk_header
+        unless chunk_id == CHUNK_IDS[:riff]
+          raise_error InvalidFormatError, "Expected chunk ID '#{CHUNK_IDS[:riff]}', but was '#{chunk_id}'"
+        end
+
+        end_of_file_pos = @io.pos + riff_chunk_size
+
+        read_riff_format_code()
 
+        data_chunk_seek_pos = nil
+        data_chunk_size = nil
+        data_chunk_is_final_chunk = nil
+
+        loop do
           chunk_id, chunk_size = read_chunk_header
-          while chunk_id != CHUNK_IDS[:data]
-            if chunk_id == CHUNK_IDS[:format]
-              @native_format = FormatChunkReader.new(@io, chunk_size).read
-            else
-              # Other chunk types besides the format chunk are ignored. This may change in the future.
-              GenericChunkReader.new(@io, chunk_size).read
+
+          case chunk_id
+          when CHUNK_IDS[:format]
+            if data_chunk_seek_pos != nil
+              raise_error InvalidFormatError, "The format chunk is after the data chunk; it must come before."
             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.
-            #
-            # See http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/Docs/riffmci.pdf, page 11.
-            if chunk_size.odd?
-              @io.sysread(1)
+            @native_format = FormatChunkReader.new(@io, chunk_size).read
+          when CHUNK_IDS[:sample]
+            @sample_chunk = SampleChunkReader.new(@io, chunk_size).read
+          when CHUNK_IDS[:data]
+            data_chunk_seek_pos = @io.pos
+            data_chunk_size = chunk_size
+
+            # Only look for chunks after the data chunk if there are enough bytes
+            # left in the file for that to be possible.
+            start_of_next_chunk_pos = (@io.pos + data_chunk_size)
+            start_of_next_chunk_pos += 1 if chunk_size.odd?
+            if start_of_next_chunk_pos < end_of_file_pos
+              @io.seek(data_chunk_seek_pos + chunk_size, IO::SEEK_SET)
+            else
+              data_chunk_is_final_chunk = true
             end
+          else
+            # Unsupported chunk types are ignored
+            @io.read(chunk_size)
+          end
 
-            chunk_id, chunk_size = read_chunk_header
+          # 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.
+          if chunk_size.odd?
+            @io.read(1)
           end
-        rescue EOFError
-          raise_error InvalidFormatError, "It doesn't have a data chunk."
+
+          break if @io.pos >= end_of_file_pos || data_chunk_is_final_chunk
         end
 
         if @native_format == nil
-          raise_error InvalidFormatError, "The format chunk is either missing, or it comes after the data chunk."
+          raise_error InvalidFormatError, "Format chunk couldn't be found."
+        end
+
+        if data_chunk_seek_pos.nil?
+          raise_error InvalidFormatError, "Data chunk couldn't be found."
         end
 
-        @data_chunk_reader = DataChunkReader.new(@io, chunk_size, @native_format, format)
+        if @io.pos != data_chunk_seek_pos
+          @io.seek(data_chunk_seek_pos, IO::SEEK_SET)
+        end
+        @data_chunk_reader = DataChunkReader.new(@io, data_chunk_size, @native_format, format)
       end
 
       def read_chunk_header
-        chunk_id = @io.sysread(4)
-        chunk_size = @io.sysread(4).unpack(UNSIGNED_INT_32).first || 0
+        chunk_id = @io.read(4)
+        chunk_size = @io.read(4)
+
+        unless chunk_size.nil?
+          chunk_size = chunk_size.unpack(UNSIGNED_INT_32).first
+        end
+
+        if chunk_size.nil?
+          raise_error InvalidFormatError, "Unexpected end of file."
+        end
 
         return chunk_id, chunk_size
       end

data/lib/wavefile/chunk_readers/sample_chunk_reader.rb

@@ -0,0 +1,74 @@
+module WaveFile
+  module ChunkReaders
+    # Internal
+    class SampleChunkReader < BaseChunkReader    # :nodoc:
+      def initialize(io, chunk_size)
+        @io = io
+        @chunk_size = chunk_size
+      end
+
+      def read
+        if @chunk_size < CORE_BYTE_COUNT
+          raise_error InvalidFormatError, "The sample chunk is incomplete; it contains fewer than the required number of fields."
+        end
+
+        raw_bytes = read_entire_chunk_body(CHUNK_IDS[:sample])
+
+        fields = {}
+        fields[:manufacturer_id],
+        fields[:product_id],
+        fields[:sample_nanoseconds],
+        fields[:midi_note],
+        fields[:fine_tuning_cents],
+        fields[:smpte_format],
+        smpte_offset_frames,
+        smpte_offset_seconds,
+        smpte_offset_minutes,
+        smpte_offset_hours,
+        loop_count,
+        sampler_data_size = raw_bytes.slice!(0...CORE_BYTE_COUNT).unpack("VVVVVVCCCcVV")
+        fields[:fine_tuning_cents] = (fields[:fine_tuning_cents] / 4_294_967_296.0) * 100
+        fields[:smpte_offset] = SMPTETimecode.new(hours: smpte_offset_hours,
+                                                  minutes: smpte_offset_minutes,
+                                                  seconds: smpte_offset_seconds,
+                                                  frames: smpte_offset_frames)
+
+        fields[:loops] = []
+        loop_count.times do
+          if raw_bytes.length < LOOP_BYTE_COUNT
+            raise_error InvalidFormatError, "`smpl` chunk loop count is #{loop_count}, but it does not contain that many loops"
+          end
+
+          loop_fields = {}
+          loop_fields[:id],
+          loop_fields[:type],
+          loop_fields[:start_sample_frame],
+          loop_fields[:end_sample_frame],
+          loop_fields[:fraction],
+          loop_fields[:play_count] = raw_bytes.slice!(0...LOOP_BYTE_COUNT).unpack("VVVVVV")
+          loop_fields[:type] = loop_fields[:type]
+          loop_fields[:fraction] /= 4_294_967_296.0
+
+          fields[:loops] << SamplerLoop.new(loop_fields)
+        end
+
+        if sampler_data_size > 0
+          if raw_bytes.length < sampler_data_size
+            raise_error InvalidFormatError, "`smpl` chunk \"sampler specific data\" field is smaller than expected."
+          end
+
+          fields[:sampler_specific_data] = raw_bytes.slice!(0...sampler_data_size)
+        else
+          fields[:sampler_specific_data] = ""
+        end
+
+        SamplerInfo.new(fields)
+      end
+
+      private
+
+      CORE_BYTE_COUNT = 36
+      LOOP_BYTE_COUNT = 24
+    end
+  end
+end