wavefile 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 48ad3ca7155a04fd1b674dd9add8f556746db460
-  data.tar.gz: a8f70d7c7ddce88d1bd93a7c2fef2963b80fc2d4
+  metadata.gz: 1b591254c77ebd547a827a0e63c8b39c76ec6189
+  data.tar.gz: f3053ba74f3b4132d9002b9703040d3d1f1d500b
 SHA512:
-  metadata.gz: 3eb29c14f9146190fa8a01bb36e4a1e25259f09bf36d27f390bb99e1229f25abb94dd9438937fcb52f856d088b114717a626b0e78948a0156551cb313a02a2b6
-  data.tar.gz: 91d5abb8d5284a387b267ef951a5974298ceb497bb7b6cb8c7e53c034a32ac5b90c3a2f2e356cfabf788c0f279427fbdf877e5e052f42ebfc20f461de45558d4
+  metadata.gz: deab4d8ce0c1ea47ad4b96a729b25540fd46d9c0cdcc9c68f04c662756a69b3d9d1b67a6a3a13210382e39441326f718f7aeeda136faee2dad27e98f86b736ac
+  data.tar.gz: 8177739fad9a27317666f4d2f6675a64689907ec06d9c0309ac3d0967075881c4b931c91536a4b9f7c6ac2fc8722e587159ce01e79f9078b143c0295c629ddee

data/LICENSE

@@ -1,6 +1,6 @@
 == WaveFile
 
-# Copyright (c) 2009-13 Joel Strait
+# Copyright (c) 2009-16 Joel Strait
 #
 # Permission is hereby granted, free of charge, to any person
 # obtaining a copy of this software and associated documentation

data/README.markdown

@@ -1,6 +1,6 @@
 A pure Ruby gem for reading and writing sound files in Wave format (*.wav).
 
-You can use this gem to create Ruby programs that produce audio, such as [drum machine](http://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.
+You can use this gem to create Ruby programs that work with audio, such as [drum machine](http://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/>
 
@@ -47,24 +47,28 @@ More examples can be [found on the wiki](https://github.com/jstrait/wavefile/wik
 * Pure Ruby, so no need to compile a separate extension in order to use it.
 
 
-# Current Release: v0.6.0
+# Current Release: v0.7.0
 
-This release includes these improvements:
+Released on March 6, 2016, this version includes these changes:
 
-* Support for reading and writing Wave files containing 24-bit PCM sample data, and the ability to convert buffers containing 24-bit PCM sample data to/from other formats. (Thanks to [Rich Orton](https://github.com/richorton) for suggesting this).
-* Reading files with 2 or more channels is now faster.
-* Converting buffers from one format to another is now faster in certain cases.
-* Bug fix: Files containing certain chunks with an odd size are now read properly. According to the Wave file spec, all chunks should be aligned to an even number of bytes. If the chunk has an odd size, a padding byte should be appended to bring the chunk to an even size. The `Reader` class now properly takes this expected padding byte into account for all chunks when reading files. (Previously it just took this into account for the main `data` chunk). (Thanks to [Andrew Kuklewicz](https://github.com/kookster) for reporting this).
+* The minimum supported Ruby version is now 1.9.3 - earlier versions are no longer supported.
+* New method: `Reader.native_format`. Returns a `Format` instance with information about the underlaying format of the Wave file being read, which is not necessarily the same format the sample data is being converted to as it's being read.
+* `Reader.info()` has been removed. Instead, construct a new `Reader` instance and use `Reader.native_format()` - this will return a `Format` instance with the same info that would have been returned by `Reader.info()`.
+* Similarly, the `Info` class has been removed, due to `Reader.info()` being removed.
+* Constructing a `Reader` instance will no longer raise an exception if the file is valid Wave file, but in a format unsupported by this gem. The purpose of this is to allow calling `Reader.native_format()` on this instance, to get format information for files not supported by this gem.
+* New method: `Reader.readable_format?` returns true if the file is a valid format that the gem can read, false otherwise.
+* `Reader.read()` and `Reader.each_buffer()` will now raise an exception if the file is a valid Wave file, but not a format that the gem can read. Or put differently, if `Reader.readable_format?` returns `false`, any subsequent calls to `Reader.read()` or `Reader.each_buffer()` will raise an exception.
+* Some constants have been made private since they are intended for internal use.
+* Bug fix: Files will now be read/written correctly on big-endian platforms. Or in other words, sample data is always read as little-endian, regardless of the native endianness of the platform.
 
 
 # Compatibility
 
 WaveFile has been tested with these Ruby versions, and appears to be compatible with them:
 
-* MRI 2.0.0, 1.9.3, 1.9.2, 1.9.1, 1.8.7
-* JRuby 1.7.8
-* Rubinius 1.2.4
-* MacRuby 0.12
+* MRI 2.3, 2.2, 2.1, 2.0, 1.9.3
+
+1.9.3 is the minimum supported Ruby version.
 
 If you find any compatibility issues, please let me know by opening a GitHub issue.
 
@@ -84,7 +88,7 @@ First, install the WaveFile gem from rubygems.org:
 
     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://beginrescueend.com/) 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](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.
 
 
 # Contributing

data/lib/wavefile.rb

@@ -1,15 +1,15 @@
 require 'wavefile/buffer'
+require 'wavefile/chunk_readers'
 require 'wavefile/duration'
 require 'wavefile/format'
-require 'wavefile/info'
 require 'wavefile/reader'
+require 'wavefile/unvalidated_format'
 require 'wavefile/writer'
 
 module WaveFile
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 
   WAVEFILE_FORMAT_CODE = "WAVE"    # :nodoc:
-  FORMAT_CHUNK_BYTE_LENGTH = {:pcm => 16, :float => 18}    # :nodoc:
   FORMAT_CODES = {:pcm => 1, :float => 3}    # :nodoc:
   CHUNK_IDS = {:riff         => "RIFF",
                :format       => "fmt ",
@@ -25,10 +25,9 @@ module WaveFile
                :sample       => "smpl",
                :instrument   => "inst" }    # :nodoc:
 
-  PACK_CODES = {:pcm => {8 => "C*", 16 => "s*", 24 => "C*", 32 => "l*"},
+  PACK_CODES = {:pcm   => { 8  => "C*", 16 => "s<*", 24 => "C*", 32 => "l<*"},
                 :float => { 32 => "e*", 64 => "E*"}}    # :nodoc:
 
   UNSIGNED_INT_16 = "v"    # :nodoc:
   UNSIGNED_INT_32 = "V"    # :nodoc:
 end
-

data/lib/wavefile/chunk_readers.rb

@@ -0,0 +1,6 @@
+require 'wavefile/chunk_readers/header_reader'
+
+module WaveFile
+  module ChunkReaders    # :nodoc:
+  end
+end

data/lib/wavefile/chunk_readers/header_reader.rb

@@ -0,0 +1,163 @@
+module WaveFile
+  module ChunkReaders
+    # Used to read the RIFF chunks in a wave file up until the data chunk. Thus is can be used
+    # to open a wave file and "queue it up" to the start of the actual sample data, as well as
+    # extract information out of pre-data chunks, such as the format chunk.
+    class RiffReader    # :nodoc:
+      def initialize(file, file_name)
+        @file = file
+        @file_name = file_name
+
+        read_until_data_chunk
+      end
+
+      attr_reader :native_format, :data_chunk_reader
+
+    private
+
+      def read_until_data_chunk
+        begin
+          chunk_id = @file.sysread(4)
+          unless chunk_id == CHUNK_IDS[:riff]
+            raise_error InvalidFormatError, "Expected chunk ID '#{CHUNK_IDS[:riff]}', but was '#{chunk_id}'"
+          end
+          RiffChunkReader.new(@file).read
+
+          chunk_id = @file.sysread(4)
+          while chunk_id != CHUNK_IDS[:data]
+            if chunk_id == CHUNK_IDS[:format]
+              @native_format = FormatChunkReader.new(@file).read
+            else
+              # Other chunk types besides the format chunk are ignored. This may change in the future.
+              GenericChunkReader.new(@file).read              
+            end
+
+            chunk_id = @file.sysread(4)
+          end
+        rescue EOFError
+          raise_error InvalidFormatError, "It doesn't have a data chunk."
+        end
+
+        if @native_format == nil
+          raise_error InvalidFormatError, "The format chunk is either missing, or it comes after the data chunk."
+        end
+
+        @data_chunk_reader = DataChunkReader.new(@file, @native_format)
+      end
+
+      class BaseChunkReader    # :nodoc:
+        def read_chunk_size
+          chunk_size = @file.sysread(4).unpack(UNSIGNED_INT_32).first || 0
+
+          # 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?
+            chunk_size += 1
+          end
+
+          chunk_size
+        end
+
+        def raise_error(exception_class, message)
+          raise exception_class, "File '#{@file_name}' is not a supported wave file. #{message}"
+        end
+      end
+
+      class GenericChunkReader < BaseChunkReader    # :nodoc:
+        def initialize(file)
+          @file = file
+        end
+
+        def read
+          chunk_size = read_chunk_size
+          @file.sysread(chunk_size)
+        end
+      end
+
+      class RiffChunkReader < BaseChunkReader    # :nodoc:
+        def initialize(file)
+          @file = file
+        end
+
+        def read
+          chunk_size = read_chunk_size
+          riff_format = @file.sysread(4)
+
+          unless riff_format == WAVEFILE_FORMAT_CODE
+            raise_error InvalidFormatError, "Expected RIFF format of '#{WAVEFILE_FORMAT_CODE}', but was '#{riff_format}'"
+          end
+        end
+      end
+
+      class DataChunkReader < BaseChunkReader    # :nodoc:
+        def initialize(file, native_format)
+          @file = file
+          @native_format = native_format
+
+          data_chunk_size = @file.sysread(4).unpack(UNSIGNED_INT_32).first
+          @sample_frame_count = data_chunk_size / @native_format.block_align
+        end
+
+        attr_reader :sample_frame_count
+      end
+
+      class FormatChunkReader < BaseChunkReader    # :nodoc:
+        def initialize(file)
+          @file = file
+        end
+
+        def read
+          chunk_size = read_chunk_size
+
+          if chunk_size < MINIMUM_CHUNK_SIZE
+            raise_error InvalidFormatError, "The format chunk is incomplete."
+          end
+
+          raw_bytes = read_chunk_body(CHUNK_IDS[:format], chunk_size)
+
+          format_chunk = {}
+          format_chunk[:audio_format],
+          format_chunk[:channels],
+          format_chunk[:sample_rate],
+          format_chunk[:byte_rate],
+          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
+              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."
+            end
+
+            # TODO: Parse the extension
+          end
+
+          UnvalidatedFormat.new(format_chunk)
+        end
+
+        private
+
+        MINIMUM_CHUNK_SIZE = 16
+
+        def read_chunk_body(chunk_id, chunk_size)
+          begin
+            return @file.sysread(chunk_size)
+          rescue EOFError
+            raise_error InvalidFormatError, "The #{chunk_id} chunk has incomplete data."
+          end
+        end
+      end
+
+      def raise_error(exception_class, message)
+        raise exception_class, "File '#{@file_name}' is not a supported wave file. #{message}"
+      end
+    end
+  end
+end

data/lib/wavefile/format.rb

@@ -1,6 +1,4 @@
 module WaveFile
-  class InvalidFormatError < StandardError; end
-
   # 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 
@@ -8,18 +6,6 @@ module WaveFile
   #
   # This class is immutable - once a new Format is constructed, it can't be modified.
   class Format
-    # Not using ranges because of 1.8.7 performance problems with Range.max
-    MIN_CHANNELS = 1    # :nodoc:
-    MAX_CHANNELS = 65535    # :nodoc:
-
-    MIN_SAMPLE_RATE = 1    # :nodoc:
-    MAX_SAMPLE_RATE = 4_294_967_296    # :nodoc:
-
-    SUPPORTED_SAMPLE_FORMATS = [:pcm, :float]    # :nodoc:
-    SUPPORTED_BITS_PER_SAMPLE = {
-                                  :pcm => [8, 16, 24, 32],
-                                  :float => [32, 64],
-                                }    # :nodoc:
 
     # Constructs a new immutable Format.
     #
@@ -89,6 +75,15 @@ module WaveFile
 
   private
 
+    VALID_CHANNEL_RANGE     = 1..65535    # :nodoc:
+    VALID_SAMPLE_RATE_RANGE = 1..4_294_967_296    # :nodoc:
+
+    SUPPORTED_SAMPLE_FORMATS = [:pcm, :float]    # :nodoc:
+    SUPPORTED_BITS_PER_SAMPLE = {
+                                  :pcm => [8, 16, 24, 32],
+                                  :float => [32, 64],
+                                }    # :nodoc:
+
     def normalize_channels(channels)
       if channels == :mono
         return 1
@@ -119,8 +114,9 @@ module WaveFile
     end
 
     def validate_channels(candidate_channels)
-      unless (MIN_CHANNELS..MAX_CHANNELS) === candidate_channels
-        raise InvalidFormatError, "Invalid number of channels. Must be between 1 and #{MAX_CHANNELS}."
+      unless VALID_CHANNEL_RANGE === candidate_channels
+        raise InvalidFormatError,
+              "Invalid number of channels. Must be between #{VALID_CHANNEL_RANGE.min} and #{VALID_CHANNEL_RANGE.max}."
       end
     end
 
@@ -133,8 +129,9 @@ module WaveFile
     end
 
     def validate_sample_rate(candidate_sample_rate)
-      unless (MIN_SAMPLE_RATE..MAX_SAMPLE_RATE) === candidate_sample_rate
-        raise InvalidFormatError, "Invalid sample rate. Must be between 1 and #{MAX_SAMPLE_RATE}"
+      unless VALID_SAMPLE_RATE_RANGE === candidate_sample_rate
+        raise InvalidFormatError,
+              "Invalid sample rate. Must be between #{VALID_SAMPLE_RATE_RANGE.min} and #{VALID_SAMPLE_RATE_RANGE.max}"
       end
     end
   end

data/lib/wavefile/reader.rb

@@ -1,11 +1,16 @@
 module WaveFile
+  # Error that is raised when a file is not in a format supported by this Gem,
+  # because it's a valid Wave file whose format is not supported by this Gem,
+  # because it's a not a valid Wave file period, etc.
+  class FormatError < StandardError; end
+
   # Error that is raised when trying to read from a file that is either not a wave file, 
   # or that is not valid according to the wave file spec.
-  class InvalidFormatError < StandardError; end
+  class InvalidFormatError < FormatError; end
 
   # Error that is raised when trying to read from a valid wave file that has its sample data 
   # stored in a format that Reader doesn't understand.
-  class UnsupportedFormatError < StandardError; end
+  class UnsupportedFormatError < FormatError; end
 
 
   # Provides the ability to read sample data out of a wave file, as well as query a 
@@ -33,25 +38,34 @@ module WaveFile
     # Returns a Reader object that is ready to start reading the specified file's sample data.
     # Raises Errno::ENOENT if the specified file can't be found
     # Raises InvalidFormatError if the specified file isn't a valid wave file
-    # Raises UnsupportedFormatError if the specified file has its sample data stored in a format
-    #                               that Reader doesn't know how to process.
     def initialize(file_name, format=nil)
       @file_name = file_name
       @file = File.open(file_name, "rb")
 
-      raw_format_chunk, sample_frame_count = HeaderReader.new(@file, @file_name).read_until_data_chunk
+      begin
+        @riff_reader = ChunkReaders::RiffReader.new(@file, @file_name)
+      rescue InvalidFormatError
+        raise InvalidFormatError, "'#{@file_name}' does not appear to be a valid Wave file"
+      end
+      
+      @raw_native_format = @riff_reader.native_format
+      @total_sample_frames = @riff_reader.data_chunk_reader.sample_frame_count
       @current_sample_frame = 0
-      @total_sample_frames = sample_frame_count
 
-      # Make file is in a format we can actually read
-      validate_format_chunk(raw_format_chunk)
+      native_sample_format = "#{FORMAT_CODES.invert[native_format.audio_format]}_#{native_format.bits_per_sample}".to_sym
+
+      @readable_format = true
+      begin
+        @native_format = Format.new(@raw_native_format.channels,
+                                    native_sample_format,
+                                    @raw_native_format.sample_rate)
+        @pack_code = PACK_CODES[@native_format.sample_format][@native_format.bits_per_sample]
+      rescue FormatError
+        @readable_format = false
+        @pack_code = nil
+      end
 
-      native_sample_format = "#{FORMAT_CODES.invert[raw_format_chunk[:audio_format]]}_#{raw_format_chunk[:bits_per_sample]}".to_sym
-      @native_format = Format.new(raw_format_chunk[:channels],
-                                  native_sample_format,
-                                  raw_format_chunk[:sample_rate])
-      @pack_code = PACK_CODES[@native_format.sample_format][@native_format.bits_per_sample]
-      @format = (format == nil) ? @native_format : format
+      @format = (format == nil) ? (@native_format || @raw_native_format) : format
 
       if block_given?
         begin
@@ -63,30 +77,6 @@ module WaveFile
     end
 
 
-    # Reads metadata from the specified wave file and returns an Info object with the results. 
-    # Metadata includes things like the number of channels, bits per sample, number of sample 
-    # frames, sample encoding format (i.e. PCM, IEEE float, uLaw etc). See the Info object for 
-    # more detail on exactly what metadata is available.
-    #
-    # file_name - The name of the wave file to read from
-    #
-    # Examples:
-    #
-    #   info = Reader.info("my_docs/my_sounds/my_file.wav")
-    #
-    # Returns an Info object containing metadata about the wave file.
-    # Raises Errno::ENOENT if the specified file can't be found
-    # Raises InvalidFormatError if the specified file isn't a valid wave file, or is in a format
-    #                           that WaveFile can't read.
-    def self.info(file_name)
-      file = File.open(file_name, "rb")
-      raw_format_chunk, sample_frame_count = HeaderReader.new(file, file_name).read_until_data_chunk
-      file.close
-
-      Info.new(file_name, raw_format_chunk, sample_frame_count)
-    end
-
-
     # 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.
@@ -119,8 +109,11 @@ module WaveFile
     #                      each channel.
     #
     # Returns a Buffer containing sample_frame_count sample frames
+    # Raises UnsupportedFormatError if file is in a format that can't be read by this gem
     # Raises EOFError if no samples could be read due to reaching the end of the file
     def read(sample_frame_count)
+      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
         raise EOFError
@@ -169,6 +162,20 @@ module WaveFile
       Duration.new(total_sample_frames, @format.sample_rate)
     end
 
+    # Returns a Format object describing the sample format of the Wave file being read.
+    # This is not necessarily the format that the sample data will be read as - to determine
+    # that, use #format.
+    def native_format
+      @raw_native_format
+    end
+
+    # Returns true if this is a valid Wave file and contains sample data that is in a format
+    # that this class can read, and returns false if this is a valid Wave file but does not
+    # contain a sample format supported by this class.
+    def readable_format?
+      @readable_format
+    end
+
     # Returns the name of the Wave file that is being read
     attr_reader :file_name
 
@@ -194,145 +201,5 @@ module WaveFile
     def sample_frames_remaining
       @total_sample_frames - @current_sample_frame
     end
-
-    def validate_format_chunk(raw_format_chunk)
-      # :byte_rate and :block_align are not checked to make sure that match :channels/:sample_rate/bits_per_sample
-      # because this library doesn't use them.
-
-      unless FORMAT_CODES.values.include? raw_format_chunk[:audio_format]
-        raise UnsupportedFormatError, "Audio format is #{raw_format_chunk[:audio_format]}, " +
-                                      "but only format code 1 (PCM) or 3 (floating point) is supported."
-      end
-
-      unless Format::SUPPORTED_BITS_PER_SAMPLE[FORMAT_CODES.invert[raw_format_chunk[:audio_format]]].include?(raw_format_chunk[:bits_per_sample])
-        raise UnsupportedFormatError, "Bits per sample is #{raw_format_chunk[:bits_per_sample]}, " +
-                                      "but only #{Format::SUPPORTED_BITS_PER_SAMPLE[:pcm].inspect} are supported."
-      end
-
-      unless raw_format_chunk[:channels] > 0
-        raise UnsupportedFormatError, "Number of channels is #{raw_format_chunk[:channels]}, " +
-                                      "but only #{Format::MIN_CHANNELS}-#{Format::MAX_CHANNELS} are supported."
-      end
-
-      unless raw_format_chunk[:sample_rate] > 0
-        raise UnsupportedFormatError, "Sample rate is #{raw_format_chunk[:sample_rate]}, " +
-                                      "but only #{Format::MIN_SAMPLE_RATE}-#{Format::MAX_SAMPLE_RATE} are supported."
-      end
-    end
-  end
-
-
-  # Used to read the RIFF chunks in a wave file up until the data chunk. Thus is can be used
-  # to open a wave file and "queue it up" to the start of the actual sample data, as well as
-  # extract information out of pre-data chunks, such as the format chunk.
-  class HeaderReader    # :nodoc:
-    RIFF_CHUNK_HEADER_SIZE = 12
-    FORMAT_CHUNK_MINIMUM_SIZE = 16
-
-    def initialize(file, file_name)
-      @file = file
-      @file_name = file_name
-    end
-
-    def read_until_data_chunk
-      read_riff_chunk
-
-      begin
-        chunk_id = @file.sysread(4)
-        chunk_size = @file.sysread(4).unpack(UNSIGNED_INT_32).first
-        while chunk_id != CHUNK_IDS[:data]
-          if chunk_id == CHUNK_IDS[:format]
-            format_chunk = read_format_chunk(chunk_id, chunk_size)
-          else
-            # 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?
-              chunk_size += 1
-            end
-
-            # Other chunk types besides the format chunk are ignored. This may change in the future.
-            @file.sysread(chunk_size)
-          end
-
-          chunk_id = @file.sysread(4)
-          chunk_size = @file.sysread(4).unpack(UNSIGNED_INT_32).first
-        end
-      rescue EOFError
-        raise_error InvalidFormatError, "It doesn't have a data chunk."
-      end
-
-      if format_chunk == nil
-        raise_error InvalidFormatError, "The format chunk is either missing, or it comes after the data chunk."
-      end
-
-      sample_frame_count = chunk_size / format_chunk[:block_align]
-
-      return format_chunk, sample_frame_count
-    end
-
-  private
-
-    def read_riff_chunk
-      riff_header = {}
-      riff_header[:chunk_id],
-      riff_header[:chunk_size],
-      riff_header[:riff_format] = read_chunk_body(CHUNK_IDS[:riff], RIFF_CHUNK_HEADER_SIZE).unpack("a4Va4")
-
-      unless riff_header[:chunk_id] == CHUNK_IDS[:riff]
-        raise_error InvalidFormatError, "Expected chunk ID '#{CHUNK_IDS[:riff]}', but was '#{riff_header[:chunk_id]}'"
-      end
-
-      unless riff_header[:riff_format] == WAVEFILE_FORMAT_CODE
-        raise_error InvalidFormatError, "Expected RIFF format of '#{WAVEFILE_FORMAT_CODE}', but was '#{riff_header[:riff_format]}'"
-      end
-
-      riff_header
-    end
-
-    def read_format_chunk(chunk_id, chunk_size)
-      if chunk_size < FORMAT_CHUNK_MINIMUM_SIZE
-        raise_error InvalidFormatError, "The format chunk is incomplete."
-      end
-
-      raw_bytes = read_chunk_body(CHUNK_IDS[:format], chunk_size)
-
-      format_chunk = {}
-      format_chunk[:audio_format],
-      format_chunk[:channels],
-      format_chunk[:sample_rate],
-      format_chunk[:byte_rate],
-      format_chunk[:block_align],
-      format_chunk[:bits_per_sample] = raw_bytes.slice!(0...FORMAT_CHUNK_MINIMUM_SIZE).unpack("vvVVvv")
-
-      if chunk_size > FORMAT_CHUNK_MINIMUM_SIZE
-        format_chunk[:extension_size] = raw_bytes.slice!(0...2).unpack(UNSIGNED_INT_16).first
-
-        if format_chunk[:extension_size] == nil
-          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."
-        end
-
-        # TODO: Parse the extension
-      end
-
-      format_chunk
-    end
-
-    def read_chunk_body(chunk_id, chunk_size)
-      begin
-        return @file.sysread(chunk_size)
-      rescue EOFError
-        raise_error InvalidFormatError, "The #{chunk_id} chunk has incomplete data."
-      end
-    end
-
-    def raise_error(exception_class, message)
-      raise exception_class, "File '#{@file_name}' is not a supported wave file. #{message}"
-    end
   end
 end