wavefile 0.7.0 → 0.8.0

data/lib/wavefile/chunk_readers/format_chunk_reader.rb

@@ -0,0 +1,59 @@
+module WaveFile
+  module ChunkReaders
+    # Internal
+    class FormatChunkReader < BaseChunkReader    # :nodoc:
+      def initialize(io, chunk_size)
+        @io = io
+        @chunk_size = chunk_size
+      end
+
+      def read
+        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
+
+          if format_chunk[:extension_size] == 22
+            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
+          end
+        end
+
+        UnvalidatedFormat.new(format_chunk)
+      end
+
+      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/generic_chunk_reader.rb

@@ -0,0 +1,15 @@
+module WaveFile
+  module ChunkReaders
+    # Internal
+    class GenericChunkReader < BaseChunkReader    # :nodoc:
+      def initialize(io, chunk_size)
+        @io = io
+        @chunk_size = chunk_size
+      end
+
+      def read
+        @io.sysread(@chunk_size)
+      end
+    end
+  end
+end

data/lib/wavefile/chunk_readers/riff_chunk_reader.rb

@@ -0,0 +1,19 @@
+module WaveFile
+  module ChunkReaders
+    # Internal
+    class RiffChunkReader < BaseChunkReader    # :nodoc:
+      def initialize(io, chunk_size)
+        @io = io
+        @chunk_size = chunk_size
+      end
+
+      def read
+        riff_format = @io.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
+  end
+end

data/lib/wavefile/chunk_readers/riff_reader.rb

@@ -0,0 +1,67 @@
+module WaveFile
+  module ChunkReaders
+    # Internal: Used to read the RIFF chunks in a wave file up until the data chunk. Thus it
+    # 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(io, format=nil)
+        @io = io
+
+        read_until_data_chunk(format)
+      end
+
+      attr_reader :native_format, :data_chunk_reader
+
+    private
+
+      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, 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
+            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)
+            end
+
+            chunk_id, chunk_size = read_chunk_header
+          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(@io, 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
+
+        return chunk_id, chunk_size
+      end
+
+      def raise_error(exception_class, message)
+        raise exception_class, "Not a supported wave file. #{message}"
+      end
+    end
+  end
+end

data/lib/wavefile/duration.rb

@@ -1,18 +1,18 @@
 module WaveFile
-  # Calculates playback time given the number of sample frames and the sample rate. For 
-  # example, you can use this to calculate how long a given Wave file is. 
+  # Public: Calculates playback time given the number of sample frames and the sample rate.
+  # For example, you can use this to calculate how long a given Wave file is.
   #
-  # The hours, minutes, seconds, and milliseconds fields return values like you would 
-  # see on a stopwatch, and not the total amount of time in that unit. For example, a 
-  # stopwatch running for exactly 2 hours would show something like "2:00:00.000". 
-  # Accordingly, if the given sample frame count and sample rate add up to exactly 
+  # The hours, minutes, seconds, and milliseconds fields return values like you would
+  # see on a stopwatch, and not the total amount of time in that unit. For example, a
+  # stopwatch running for exactly 2 hours would show something like "2:00:00.000".
+  # Accordingly, if the given sample frame count and sample rate add up to exactly
   # 2 hours, then hours will be 2, and minutes, seconds, and milliseconds will all be 0.
   #
   # This class is immutable - once a new Duration is constructed, it can't be modified.
   class Duration
-    # Constructs a new immutable Duration.
+    # Public: Constructs a new immutable Duration.
     #
-    # sample_frame_count - The number of sample frames, i.e. the number 
+    # sample_frame_count - The number of sample frames, i.e. the number
     #                      samples in each channel.
     # sample_rate - The number of samples per second, such as 44100
     #
@@ -24,9 +24,11 @@ module WaveFile
     #   duration.seconds       # => 10
     #   duration.milliseconds  # => 294
     #
-    # Note that the hours, minutes, seconds, and milliseconds fields do not return 
-    # the total of the respective unit in the entire duration. For example, if a 
-    # duration is exactly 2 hours, then minutes will be 0, not 120.
+    # The hours, minutes, seconds, and milliseconds fields return values like you would
+    # see on a stopwatch, and not the total amount of time in that unit. For example, a
+    # stopwatch running for exactly 2 hours would show something like "2:00:00.000".
+    # Accordingly, if the given sample frame count and sample rate add up to exactly
+    # 2 hours, then hours will be 2, and minutes, seconds, and milliseconds will all be 0.
     def initialize(sample_frame_count, sample_rate)
       @sample_frame_count = sample_frame_count
       @sample_rate = sample_rate
@@ -54,12 +56,45 @@ module WaveFile
 
       @milliseconds = (sample_frame_count / sample_frames_per_millisecond).floor
     end
+
+    # Public: Returns true if this Duration represents that same amount of time as
+    # other_duration.
+    #
+    # Two Duration instances will evaluate as == if they correspond
+    # to the same "stopwatch time". This means that two Durations constructed
+    # from a different number of sample frames or different sample rates can be
+    # considered equal if they correspond to the same amount
+    # of time. For example, a Duration from 44,100 sample frames
+    # at 44,100 samples/sec will be considered equal to a Duration
+    # from 22,050 sample frames at 22,050 samples/sec, because
+    # both correspond to 1 second of audio.
+    #
+    # Since the finest resolution of a duration is 1 millisecond,
+    # two Durations that represent different amounts of time but
+    # differ by less than 1 millisecond will be considered equal.
+    def ==(other_duration)
+      @hours == other_duration.hours &&
+      @minutes == other_duration.minutes &&
+      @seconds == other_duration.seconds &&
+      @milliseconds == other_duration.milliseconds
+    end
  
+    # Public
     attr_reader :sample_frame_count
-    attr_reader :sample_rate 
+
+    # Public
+    attr_reader :sample_rate
+
+    # Public
     attr_reader :hours
+
+    # Public
     attr_reader :minutes
+
+    # Public
     attr_reader :seconds
+
+    # Public
     attr_reader :milliseconds
   end
 end

data/lib/wavefile/format.rb

@@ -1,21 +1,34 @@
 module WaveFile
-  # Represents information about the data format for a Wave file, such as number of 
-  # channels, bits per sample, sample rate, and so forth. A Format instance is used 
-  # by Reader to indicate what format to read samples out as, and by Writer to 
+  # Public: Error that is raised when a file is not in a format supported by this Gem.
+  # For example, because it's a valid Wave file whose format is not supported by
+  # this Gem. Or, because it's a not a valid Wave file period.
+  class FormatError < StandardError; end
+
+  # Public: 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 < FormatError; end
+
+  # Public: 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 < FormatError; end
+
+  # Public: Represents information about the data format for a Wave file, such as number of
+  # channels, bits per sample, sample rate, and so forth. A Format instance is used
+  # by Reader to indicate what format to read samples out as, and by Writer to
   # indicate what format to write samples as.
   #
   # This class is immutable - once a new Format is constructed, it can't be modified.
   class Format
 
-    # Constructs a new immutable Format.
+    # Public: Constructs a new immutable Format.
     #
-    # channels - The number of channels in the format. Can either be a Fixnum 
-    #            (e.g. 1, 2, 3) or the symbols :mono (equivalent to 1) or 
+    # channels - The number of channels in the format. Can either be an Integer
+    #            (e.g. 1, 2, 3) or the symbols :mono (equivalent to 1) or
     #            :stereo (equivalent to 2).
-    # format_code - A symbol indicating the format of each sample. Consists of 
-    #               two parts: a format code, and the bits per sample. The valid 
-    #               values are :pcm_8, :pcm_16, :pcm_32, :float_32, :float_64,
-    #               and :float (equivalent to :float_32)
+    # format_code - A symbol indicating the format of each sample. Consists of
+    #               two parts: a format code, and the bits per sample. The valid
+    #               values are :pcm_8, :pcm_16, :pcm_24, :pcm_32, :float_32,
+    #               :float_64, and :float (equivalent to :float_32)
     # sample_rate - The number of samples per second, such as 44100
     #
     # Examples
@@ -24,7 +37,7 @@ module WaveFile
     #   format = Format.new(:mono, :pcm_16, 44100)  # Equivalent to above
     #
     #   format = Format.new(:stereo, :float_32, 44100)
-    #   format = Format.new(:stereo, :float, 44100)
+    #   format = Format.new(:stereo, :float, 44100)  # Equivalent to above
     def initialize(channels, format_code, sample_rate)
       channels = normalize_channels(channels)
       sample_format, bits_per_sample = normalize_format_code(format_code)
@@ -41,49 +54,54 @@ module WaveFile
       @byte_rate = @block_align * @sample_rate
     end
 
-    # Returns true if the format has 1 channel, false otherwise.
+    # Public: Returns true if the format has 1 channel, false otherwise.
     def mono?
       @channels == 1
     end
 
-    # Returns true if the format has 2 channels, false otherwise.
+    # Public: Returns true if the format has 2 channels, false otherwise.
     def stereo?
       @channels == 2
     end
 
-    # Returns the number of channels, such as 1 or 2. This will always return a 
-    # Fixnum, even if the number of channels is specified with a symbol (e.g. :mono) 
+    # Public: Returns the number of channels, such as 1 or 2. This will always return a
+    # Integer, even if the number of channels is specified with a symbol (e.g. :mono)
     # in the constructor.
     attr_reader :channels
 
-    # Returns a symbol indicating the sample format, such as :pcm or :float
+    # Public: Returns a symbol indicating the sample format, such as :pcm or :float
     attr_reader :sample_format
 
-    # Returns the number of bits per sample, such as 8, 16, 24, 32, or 64.
+    # Public: Returns the number of bits per sample, such as 8, 16, 24, 32, or 64.
     attr_reader :bits_per_sample
 
-    # Returns the number of samples per second, such as 44100.
+    # Public: Returns the number of samples per second, such as 44100.
     attr_reader :sample_rate
 
-    # Returns the number of bytes in each sample frame. For example, in a 16-bit stereo file, 
+    # Public: Returns the number of bytes in each sample frame. For example, in a 16-bit stereo file,
     # this will be 4 (2 bytes for each 16-bit sample, times 2 channels).
     attr_reader :block_align
 
-    # Returns the number of bytes contained in 1 second of sample data. 
+    # Public: Returns the number of bytes contained in 1 second of sample data.
     # Is equivalent to block_align * sample_rate.
     attr_reader :byte_rate
 
   private
 
+    # Internal
     VALID_CHANNEL_RANGE     = 1..65535    # :nodoc:
+    # Internal
     VALID_SAMPLE_RATE_RANGE = 1..4_294_967_296    # :nodoc:
 
+    # Internal
     SUPPORTED_SAMPLE_FORMATS = [:pcm, :float]    # :nodoc:
+    # Internal
     SUPPORTED_BITS_PER_SAMPLE = {
                                   :pcm => [8, 16, 24, 32],
                                   :float => [32, 64],
                                 }    # :nodoc:
 
+    # Internal
     def normalize_channels(channels)
       if channels == :mono
         return 1
@@ -94,10 +112,9 @@ module WaveFile
       end
     end
 
+    # Internal
     def normalize_format_code(format_code)
-      if SUPPORTED_BITS_PER_SAMPLE[:pcm].include? format_code
-        [:pcm, format_code]
-      elsif format_code == :float
+      if format_code == :float
         [:float, 32]
       else
         sample_format, bits_per_sample = format_code.to_s.split("_")
@@ -105,6 +122,7 @@ module WaveFile
       end
     end
 
+    # Internal
     def validate_sample_format(candidate_sample_format)
       unless SUPPORTED_SAMPLE_FORMATS.include? candidate_sample_format
         raise InvalidFormatError,
@@ -113,6 +131,7 @@ module WaveFile
       end
     end
 
+    # Internal
     def validate_channels(candidate_channels)
       unless VALID_CHANNEL_RANGE === candidate_channels
         raise InvalidFormatError,
@@ -120,6 +139,7 @@ module WaveFile
       end
     end
 
+    # Internal
     def validate_bits_per_sample(candidate_sample_format, candidate_bits_per_sample)
       unless SUPPORTED_BITS_PER_SAMPLE[candidate_sample_format].include? candidate_bits_per_sample
         raise InvalidFormatError,
@@ -128,6 +148,7 @@ module WaveFile
       end
     end
 
+    # Internal
     def validate_sample_rate(candidate_sample_rate)
       unless VALID_SAMPLE_RATE_RANGE === candidate_sample_rate
         raise InvalidFormatError,

data/lib/wavefile/reader.rb

@@ -1,22 +1,11 @@
 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
+  # Public: Error that is raised when trying to read from a Reader instance that has been closed.
+  class ReaderClosedError < IOError; 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 < 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 < FormatError; end
-
-
-  # Provides the ability to read sample data out of a wave file, as well as query a 
-  # wave file about its metadata (e.g. number of channels, sample rate, etc).
+  # Public: Provides the ability to read sample data out of a wave file, as well as query
+  # a wave file about its metadata (e.g. number of channels, sample rate, etc).
   #
-  # When constructing a Reader a block can be given. All data should be read inside this 
+  # When constructing a Reader a block can be given. All data should be read inside this
   # block, and when the block exits the Reader will automatically be closed.
   #
   #     Reader.new("my_file.wav") do |reader|
@@ -29,43 +18,35 @@ module WaveFile
   #     # Read sample data here
   #     reader.close
   class Reader
-    # Returns a Reader object that is ready to start reading the specified file's sample data. 
+    # Public: Returns a Reader object that is ready to start reading the specified file's
+    # sample data.
     #
-    # file_name - The name of the wave file to read from.
-    # format - The format that read sample data should be returned in 
+    # io_or_file_name - The name of the wave file to read from,
+    #                   or an open IO object to read from.
+    # format - The format that read sample data should be returned in
     #          (default: the wave file's internal format).
     #
     # 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
-    def initialize(file_name, format=nil)
-      @file_name = file_name
-      @file = File.open(file_name, "rb")
-
-      begin
-        @riff_reader = ChunkReaders::RiffReader.new(@file, @file_name)
-      rescue InvalidFormatError
-        raise InvalidFormatError, "'#{@file_name}' does not appear to be a valid Wave file"
+    def initialize(io_or_file_name, format=nil)
+      if io_or_file_name.is_a?(String)
+        @io = File.open(io_or_file_name, "rb")
+        @io_source = :file_name
+      else
+        @io = io_or_file_name
+        @io_source = :io
       end
-      
-      @raw_native_format = @riff_reader.native_format
-      @total_sample_frames = @riff_reader.data_chunk_reader.sample_frame_count
-      @current_sample_frame = 0
 
-      native_sample_format = "#{FORMAT_CODES.invert[native_format.audio_format]}_#{native_format.bits_per_sample}".to_sym
+      @closed = false
 
-      @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
+        riff_reader = ChunkReaders::RiffReader.new(@io, format)
+      rescue InvalidFormatError
+        raise InvalidFormatError, "Does not appear to be a valid Wave file"
       end
-
-      @format = (format == nil) ? (@native_format || @raw_native_format) : format
+      
+      @data_chunk_reader = riff_reader.data_chunk_reader
 
       if block_given?
         begin
@@ -77,21 +58,45 @@ module WaveFile
     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.
+    # 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.
     #
-    # Note that sample_frame_count indicates the number of sample frames to read, not number of samples. 
-    # A sample frame include one sample for each channel. For example, if sample_frame_count is 1024, then 
-    # for a stereo file 1024 samples will be read from the left channel, and 1024 samples will be read from 
+    # 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
+    # result in an error.
+    #
+    # Note that sample_frame_count indicates the number of sample frames to read, not number of samples.
+    # A sample frame include one sample for each channel. For example, if sample_frame_count is 1024, then
+    # for a stereo file 1024 samples will be read from the left channel, and 1024 samples will be read from
     # the right channel.
     #
-    # sample_frame_count - The number of sample frames to read into each Buffer from each channel. The number 
-    #                      of sample frames read into the final Buffer could be less than this size, if there 
+    # sample_frame_count - The number of sample frames to read into each Buffer from each channel. The number
+    #                      of sample frames read into the final Buffer could be less than this size, if there
     #                      are not enough remaining.
     #
-    # Returns nothing.
-    def each_buffer(sample_frame_count)
+    # Examples
+    #
+    #   # sample_frame_count not given, so default buffer size
+    #   Reader.new("my_file.wav").each_buffer do |buffer|
+    #     puts "#{buffer.samples.length} sample frames read"
+    #   end
+    #
+    #   # Specific sample_frame_count given for each buffer
+    #   Reader.new("my_file.wav").each_buffer(1024) do |buffer|
+    #     puts "#{buffer.samples.length} sample frames read"
+    #   end
+    #
+    #   # Reading each buffer from an externally created IO
+    #   file = File.open("my_file.wav", "rb")
+    #   Reader.new(file).each_buffer do |buffer|
+    #     puts "#{buffer.samples.length} sample frames read"
+    #   end
+    #   # Although Reader is closed, file still needs to be manually closed
+    #   file.close
+    #
+    # Returns nothing. Has side effect of closing the Reader.
+    def each_buffer(sample_frame_count=4096)
       begin
         while true do
           yield(read(sample_frame_count))
@@ -102,104 +107,89 @@ module WaveFile
     end
 
 
-    # Reads the specified number of sample frames from the wave file into a Buffer. Note that the Buffer will have 
-    # at most sample_frame_count sample frames, but could have less if the file doesn't have enough remaining.
+    # Public: Reads the specified number of sample frames from the wave file into a Buffer. Note that the Buffer
+    # will have at most sample_frame_count sample frames, but could have less if the file doesn't have enough
+    # remaining.
     #
-    # sample_frame_count - The number of sample frames to read. Note that each sample frame includes a sample for 
+    # sample_frame_count - The number of sample frames to read. Note that each sample frame includes a sample for
     #                      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 ReaderClosedError if the Writer has been closed.
     # 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
-      elsif sample_frame_count > sample_frames_remaining
-        sample_frame_count = sample_frames_remaining
-      end
-
-      samples = @file.sysread(sample_frame_count * @native_format.block_align).unpack(@pack_code)
-      @current_sample_frame += sample_frame_count
-
-      if @native_format.bits_per_sample == 24
-        # Since the sample data is little endian, the 3 bytes will go from least->most significant
-        samples = samples.each_slice(3).map {|least_significant_byte, middle_byte, most_significant_byte|
-          # Convert the byte read as "C" to one read as "c"
-          most_significant_byte = [most_significant_byte].pack("c").unpack("c").first
-          
-          (most_significant_byte << 16) | (middle_byte << 8) | least_significant_byte
-        }
+      if @closed
+        raise ReaderClosedError
       end
 
-      if @native_format.channels > 1
-        samples = samples.each_slice(@native_format.channels).to_a
-      end
-
-      buffer = Buffer.new(samples, @native_format)
-      buffer.convert(@format)
+      @data_chunk_reader.read(sample_frame_count)
     end
 
 
-    # Returns true if the Reader is closed, and false if it is open and available for reading.
+    # Public: Returns true if the Reader is closed, and false if it is open and available for reading.
     def closed?
-      @file.closed?
+      @closed
     end
 
 
-    # Closes the Reader. After a Reader is closed, no more sample data can be read from it.
+    # Public: Closes the Reader. After a Reader is closed, no more sample data can be read from it.
+    # Note: If the Reader is constructed from an open IO instance (as opposed to a file name),
+    # the IO instance will _not_ be closed. You'll have to manually close it yourself.
     #
     # Returns nothing.
-    # Raises IOError if the Reader is already closed.
+    # Raises ReaderClosedError if the Reader is already closed.
     def close
-      @file.close
+      if @closed
+        raise ReaderClosedError
+      end
+
+      if @io_source == :file_name
+        @io.close
+      end
+
+      @closed = true
     end
 
-    # Returns a Duration instance for the total number of sample frames in the file
+    # Public: Returns a Duration instance for the total number of sample frames in the file
     def total_duration
-      Duration.new(total_sample_frames, @format.sample_rate)
+      Duration.new(total_sample_frames, @data_chunk_reader.format.sample_rate)
     end
 
-    # Returns a Format object describing the sample format of the Wave file being read.
+    # Public: 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
+      @data_chunk_reader.raw_native_format
     end
 
-    # Returns true if this is a valid Wave file and contains sample data that is in a format
+    # Public: 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
+      @data_chunk_reader.readable_format
     end
 
-    # Returns the name of the Wave file that is being read
-    attr_reader :file_name
-
-    # Returns a Format object describing how sample data is being read from the Wave file (number of 
-    # channels, sample format and bits per sample, etc). Note that this might be different from the 
+    # Public: Returns a Format object describing how sample data is being read from the Wave file (number of
+    # channels, sample format and bits per sample, etc). Note that this might be different from the
     # underlying format of the Wave file on disk.
-    attr_reader :format
+    def format
+      @data_chunk_reader.format
+    end
 
-    # Returns the index of the sample frame which is "cued up" for reading. I.e., the index 
-    # of the next sample frame that will be read. A sample frame contains a single sample 
-    # for each channel. So if there are 1,000 sample frames in a stereo file, this means 
+    # Public: Returns the index of the sample frame which is "cued up" for reading. I.e., the index
+    # of the next sample frame that will be read. A sample frame contains a single sample
+    # for each channel. So if there are 1,000 sample frames in a stereo file, this means
     # there are 1,000 left-channel samples and 1,000 right-channel samples.
-    attr_reader :current_sample_frame
+    def current_sample_frame
+      @data_chunk_reader.current_sample_frame
+    end
 
-    # Returns the total number of sample frames in the file. A sample frame contains a single 
-    # sample for each channel. So if there are 1,000 sample frames in a stereo file, this means 
+    # Public: Returns the total number of sample frames in the file. A sample frame contains a single
+    # sample for each channel. So if there are 1,000 sample frames in a stereo file, this means
     # there are 1,000 left-channel samples and 1,000 right-channel samples.
-    attr_reader :total_sample_frames
-
-  private
-
-    # The number of sample frames in the file after the current sample frame
-    def sample_frames_remaining
-      @total_sample_frames - @current_sample_frame
+    def total_sample_frames
+      @data_chunk_reader.total_sample_frames
     end
   end
 end