wavefile 0.6.0 → 0.7.0

data/lib/wavefile/unvalidated_format.rb

@@ -0,0 +1,23 @@
+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 
+  # indicate what format to write samples as.
+  #
+  # This class is immutable - once a new Format is constructed, it can't be modified.
+  class UnvalidatedFormat < Format    # :nodoc:
+    # Constructs a new immutable UnvalidatedFormat.
+    def initialize(fields)
+      @audio_format = fields[:audio_format]
+      @channels = fields[:channels]
+      @sample_rate = fields[:sample_rate]
+      @byte_rate = fields[:byte_rate]
+      @block_align = fields[:block_align]
+      @bits_per_sample = fields[:bits_per_sample]
+    end
+
+    # Returns a number indicating the sample format, such as 1 (PCM) or 3 (Float)
+    attr_reader :audio_format
+  end
+end
+

data/lib/wavefile/writer.rb

@@ -16,25 +16,6 @@ module WaveFile
   #    writer.close
   class Writer
 
-    # Padding value written to the end of chunks whose payload is an odd number of bytes. The RIFF 
-    # specification requires that each chunk be aligned to an even number of bytes, even if the byte 
-    # count is an odd number.
-    #
-    # See http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/Docs/riffmci.pdf, page 11.
-    EMPTY_BYTE = "\000"    # :nodoc:
-
-    # The number of bytes at the beginning of a wave file before the sample data in the data chunk 
-    # starts, assuming this canonical format:
-    #
-    # RIFF Chunk Header (12 bytes)
-    # Format Chunk (16 bytes for PCM, 18 bytes for floating point)
-    # FACT Chunk (0 bytes for PCM, 12 bytes for floating point)
-    # Data Chunk Header (8 bytes)
-    #
-    # All wave files written by Writer use this canonical format.
-    CANONICAL_HEADER_BYTE_LENGTH = {:pcm => 36, :float => 50}    # :nodoc:
-
-
     # Returns a constructed Writer object which is available for writing sample data to the specified 
     # file (via the write method). When all sample data has been written, the Writer should be closed. 
     # Note that the wave file being written to will NOT be valid (and playable in other programs) until 
@@ -76,7 +57,7 @@ module WaveFile
 
       if @format.bits_per_sample == 24 && @format.sample_format == :pcm
         samples.flatten.each do |sample|
-          @file.syswrite([sample].pack("lX"))
+          @file.syswrite([sample].pack("l<X"))
         end
       else
         @file.syswrite(samples.flatten.pack(@pack_code))
@@ -141,6 +122,26 @@ module WaveFile
 
   private
 
+    # Padding value written to the end of chunks whose payload is an odd number of bytes. The RIFF 
+    # specification requires that each chunk be aligned to an even number of bytes, even if the byte 
+    # count is an odd number.
+    #
+    # See http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/Docs/riffmci.pdf, page 11.
+    EMPTY_BYTE = "\000"    # :nodoc:
+
+    # The number of bytes at the beginning of a wave file before the sample data in the data chunk 
+    # starts, assuming this canonical format:
+    #
+    # RIFF Chunk Header (12 bytes)
+    # Format Chunk (16 bytes for PCM, 18 bytes for floating point)
+    # FACT Chunk (0 bytes for PCM, 12 bytes for floating point)
+    # Data Chunk Header (8 bytes)
+    #
+    # All wave files written by Writer use this canonical format.
+    CANONICAL_HEADER_BYTE_LENGTH = {:pcm => 36, :float => 50}    # :nodoc:
+
+    FORMAT_CHUNK_BYTE_LENGTH = {:pcm => 16, :float => 18}    # :nodoc:
+
     # Writes the RIFF chunk header, format chunk, and the header for the data chunk. After this
     # method is called the file will be "queued up" and ready for writing actual sample data.
     def write_header(sample_frame_count)

data/test/buffer_test.rb

@@ -1,9 +1,9 @@
-require 'test/unit'
+require 'minitest/autorun'
 require 'wavefile.rb'
 
 include WaveFile
 
-class BufferTest < Test::Unit::TestCase
+class BufferTest < MiniTest::Unit::TestCase
   def test_convert
     old_format = Format.new(:mono, :pcm_16, 44100)
     new_format = Format.new(:stereo, :pcm_16, 22050)
@@ -75,7 +75,7 @@ class BufferTest < Test::Unit::TestCase
         # Unsupported conversion (4-channel => 3-channel)
         b = Buffer.new([[-100, 200, -300, 400], [1, 2, 3, 4]],
                        Format.new(4, bits_per_sample, sample_rate))
-        assert_raise(BufferConversionError) { b.convert!(Format.new(3, bits_per_sample, sample_rate)) }
+        assert_raises(BufferConversionError) { b.convert!(Format.new(3, bits_per_sample, sample_rate)) }
       end
     end
   end

data/test/duration_test.rb

@@ -1,9 +1,9 @@
-require 'test/unit'
+require 'minitest/autorun'
 require 'wavefile.rb'
 
 include WaveFile
 
-class DurationTest < Test::Unit::TestCase
+class DurationTest < MiniTest::Unit::TestCase
   SECONDS_IN_MINUTE = 60
   SECONDS_IN_HOUR = SECONDS_IN_MINUTE * 60
 

data/test/format_test.rb

@@ -1,9 +1,9 @@
-require 'test/unit'
+require 'minitest/autorun'
 require 'wavefile.rb'
 
 include WaveFile
 
-class FormatTest < Test::Unit::TestCase
+class FormatTest < MiniTest::Unit::TestCase
   def test_valid_channels
     [1, 2, 3, 4, 65535].each do |valid_channels|
       assert_equal(valid_channels, Format.new(valid_channels, :pcm_16, 44100).channels)
@@ -15,7 +15,7 @@ class FormatTest < Test::Unit::TestCase
 
   def test_invalid_channels
     ["dsfsfsdf", :foo, 0, -1, 65536].each do |invalid_channels|
-      assert_raise(InvalidFormatError) { Format.new(invalid_channels, :pcm_16, 44100) }
+      assert_raises(InvalidFormatError) { Format.new(invalid_channels, :pcm_16, 44100) }
     end
   end
 
@@ -35,7 +35,7 @@ class FormatTest < Test::Unit::TestCase
 
   def test_invalid_sample_format
     ["dsfsfsdf", :foo, 12, :pcm_14, :float_20].each do |invalid_sample_format|
-      assert_raise(InvalidFormatError) { Format.new(:mono, invalid_sample_format, 44100) }
+      assert_raises(InvalidFormatError) { Format.new(:mono, invalid_sample_format, 44100) }
     end
   end
 
@@ -55,7 +55,7 @@ class FormatTest < Test::Unit::TestCase
 
   def test_invalid_bits_per_sample
     ["dsfsfsdf", :foo, :pcm, 0, 12, :pcm_14, :pcm_abc, :float_40].each do |invalid_sample_format|
-      assert_raise(InvalidFormatError) { Format.new(:mono, invalid_sample_format, 44100) }
+      assert_raises(InvalidFormatError) { Format.new(:mono, invalid_sample_format, 44100) }
     end
   end
 
@@ -67,7 +67,7 @@ class FormatTest < Test::Unit::TestCase
 
   def test_invalid_sample_rate
     ["dsfsfsdf", :foo, 0, -1, 4294967297].each do |invalid_sample_rate|
-      assert_raise(InvalidFormatError) { Format.new(:mono, :pcm_16, invalid_sample_rate) }
+      assert_raises(InvalidFormatError) { Format.new(:mono, :pcm_16, invalid_sample_rate) }
     end
   end
 

data/test/reader_test.rb

@@ -1,19 +1,17 @@
-require 'test/unit'
+require 'minitest/autorun'
 require 'wavefile.rb'
 require 'wavefile_io_test_helper.rb'
 
 include WaveFile
 
-class ReaderTest < Test::Unit::TestCase
+class ReaderTest < MiniTest::Unit::TestCase
   include WaveFileIOTestHelper
 
   FIXTURE_ROOT_PATH = "test/fixtures"
 
 
   def test_nonexistent_file
-    assert_raise(Errno::ENOENT) { Reader.new(fixture("i_do_not_exist.wav")) }
-
-    assert_raise(Errno::ENOENT) { Reader.info(fixture("i_do_not_exist.wav")) }
+    assert_raises(Errno::ENOENT) { Reader.new(fixture("i_do_not_exist.wav")) }
   end
 
   def test_invalid_formats
@@ -45,10 +43,8 @@ class ReaderTest < Test::Unit::TestCase
 
     # Reader.new and Reader.info should raise the same errors for invalid files,
     # so run the tests for both methods.
-    [:new, :info].each do |method_name|
-      invalid_fixtures.each do |fixture_name|
-        assert_raise(InvalidFormatError) { Reader.send(method_name, fixture(fixture_name)) }
-      end
+    invalid_fixtures.each do |fixture_name|
+      assert_raises(InvalidFormatError) { Reader.new(fixture(fixture_name)) }
     end
   end
 
@@ -68,18 +64,58 @@ class ReaderTest < Test::Unit::TestCase
     ]
 
     unsupported_fixtures.each do |fixture_name|
-      assert_raise(UnsupportedFormatError) { Reader.new(fixture(fixture_name)) }
+      reader = Reader.new(fixture(fixture_name))
+      assert_equal(false, reader.readable_format?)
+      assert_raises(UnsupportedFormatError) { reader.read(1024) }
+      assert_raises(UnsupportedFormatError) { reader.each_buffer(1024) {|buffer| buffer } }
     end
   end
 
+  def test_initialize_unsupported_format
+    file_name = fixture("unsupported/unsupported_bits_per_sample.wav")
+
+    # Unsupported format, no read format given
+    reader = Reader.new(file_name)
+    assert_equal(2, reader.native_format.channels)
+    assert_equal(20, reader.native_format.bits_per_sample)
+    assert_equal(44100, reader.native_format.sample_rate)
+    assert_equal(2, reader.format.channels)
+    assert_equal(20, reader.format.bits_per_sample)
+    assert_equal(44100, reader.format.sample_rate)
+    assert_equal(false, reader.closed?)
+    assert_equal(file_name, reader.file_name)
+    assert_equal(0, reader.current_sample_frame)
+    assert_equal(2240, reader.total_sample_frames)
+    assert_equal(false, reader.readable_format?)
+    reader.close
+
+    # Unsupported format, different read format given
+    reader = Reader.new(file_name, Format.new(:mono, :pcm_16, 22050))
+    assert_equal(2, reader.native_format.channels)
+    assert_equal(20, reader.native_format.bits_per_sample)
+    assert_equal(44100, reader.native_format.sample_rate)
+    assert_equal(1, reader.format.channels)
+    assert_equal(16, reader.format.bits_per_sample)
+    assert_equal(22050, reader.format.sample_rate)
+    assert_equal(false, reader.closed?)
+    assert_equal(file_name, reader.file_name)
+    assert_equal(0, reader.current_sample_frame)
+    assert_equal(2240, reader.total_sample_frames)
+    assert_equal(false, reader.readable_format?)
+    reader.close
+  end
+
   def test_initialize
     format = Format.new(:stereo, :pcm_16, 22050)
 
     exhaustively_test do |channels, sample_format|
       file_name = fixture("valid/valid_#{channels}_#{sample_format}_44100.wav")
 
-      # Read native format
+      # Native format
       reader = Reader.new(file_name)
+      assert_equal(CHANNEL_ALIAS[channels], reader.native_format.channels)
+      assert_equal(extract_bits_per_sample(sample_format), reader.native_format.bits_per_sample)
+      assert_equal(44100, reader.native_format.sample_rate)
       assert_equal(CHANNEL_ALIAS[channels], reader.format.channels)
       assert_equal(extract_bits_per_sample(sample_format), reader.format.bits_per_sample)
       assert_equal(44100, reader.format.sample_rate)
@@ -87,10 +123,14 @@ class ReaderTest < Test::Unit::TestCase
       assert_equal(file_name, reader.file_name)
       assert_equal(0, reader.current_sample_frame)
       assert_equal(2240, reader.total_sample_frames)
+      assert_equal(true, reader.readable_format?)
       reader.close
 
-      # Read a non-native format
+      # Non-native format
       reader = Reader.new(file_name, format)
+      assert_equal(CHANNEL_ALIAS[channels], reader.native_format.channels)
+      assert_equal(extract_bits_per_sample(sample_format), reader.native_format.bits_per_sample)
+      assert_equal(44100, reader.native_format.sample_rate)
       assert_equal(2, reader.format.channels)
       assert_equal(16, reader.format.bits_per_sample)
       assert_equal(22050, reader.format.sample_rate)
@@ -98,10 +138,14 @@ class ReaderTest < Test::Unit::TestCase
       assert_equal(file_name, reader.file_name)
       assert_equal(0, reader.current_sample_frame)
       assert_equal(2240, reader.total_sample_frames)
+      assert_equal(true, reader.readable_format?)
       reader.close
 
       # Block is given.
       reader = Reader.new(file_name) {|reader| reader.read(1024) }
+      assert_equal(CHANNEL_ALIAS[channels], reader.native_format.channels)
+      assert_equal(extract_bits_per_sample(sample_format), reader.native_format.bits_per_sample)
+      assert_equal(44100, reader.native_format.sample_rate)
       assert_equal(CHANNEL_ALIAS[channels], reader.format.channels)
       assert_equal(extract_bits_per_sample(sample_format), reader.format.bits_per_sample)
       assert_equal(44100, reader.format.sample_rate)
@@ -109,6 +153,7 @@ class ReaderTest < Test::Unit::TestCase
       assert_equal(file_name, reader.file_name)
       assert_equal(1024, reader.current_sample_frame)
       assert_equal(2240, reader.total_sample_frames)
+      assert_equal(true, reader.readable_format?)
     end
   end
 
@@ -147,7 +192,7 @@ class ReaderTest < Test::Unit::TestCase
 
   def test_each_buffer_no_block_given
     reader = Reader.new(fixture("valid/valid_mono_pcm_16_44100.wav"))
-    assert_raise(LocalJumpError) { reader.each_buffer(1024) }
+    assert_raises(LocalJumpError) { reader.each_buffer(1024) }
   end
 
   def test_each_buffer_native_format
@@ -231,7 +276,7 @@ class ReaderTest < Test::Unit::TestCase
     reader = Reader.new(fixture("valid/valid_mono_pcm_16_44100.wav"))
     buffer = reader.read(1024)
     reader.close
-    assert_raise(IOError) { reader.read(1024) }
+    assert_raises(IOError) { reader.read(1024) }
   end
 
   def test_sample_counts_manual_reads

data/test/unvalidated_format_test.rb

@@ -0,0 +1,24 @@
+require 'minitest/autorun'
+require 'wavefile.rb'
+
+include WaveFile
+
+class UnvalidatedFormatTest < MiniTest::Unit::TestCase
+  def test_initialize
+    format = UnvalidatedFormat.new({:audio_format => 1,
+                                    :channels => 2,
+                                    :sample_rate => 44100,
+                                    :byte_rate => 176400,
+                                    :block_align => 4,
+                                    :bits_per_sample => 16})
+
+    assert_equal(1,      format.audio_format)
+    assert_equal(2,      format.channels)
+    assert_equal(false,  format.mono?)
+    assert_equal(true,   format.stereo?)
+    assert_equal(44100,  format.sample_rate)
+    assert_equal(176400, format.byte_rate)
+    assert_equal(4,      format.block_align)
+    assert_equal(16,     format.bits_per_sample)
+  end
+end

data/test/writer_test.rb

@@ -1,10 +1,10 @@
-require 'test/unit'
+require 'minitest/autorun'
 require 'wavefile.rb'
 require 'wavefile_io_test_helper.rb'
 
 include WaveFile
 
-class WriterTest < Test::Unit::TestCase
+class WriterTest < MiniTest::Unit::TestCase
   include WaveFileIOTestHelper
 
   OUTPUT_FOLDER = "test/fixtures/actual_output"
@@ -103,7 +103,7 @@ class WriterTest < Test::Unit::TestCase
     writer.write(Buffer.new([1, 2, 3, 4], format))
     writer.close
 
-    assert_raise(IOError) { writer.write(Buffer.new([5, 6, 7, 8], format)) }
+    assert_raises(IOError) { writer.write(Buffer.new([5, 6, 7, 8], format)) }
   end
 
   def test_total_duration

metadata

@@ -1,18 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: wavefile
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Joel Strait
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-08 00:00:00.000000000 Z
+date: 2016-03-06 00:00:00.000000000 Z
 dependencies: []
-description: You can use this gem to create Ruby programs that produce audio. 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.
+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
+  opposed to wrapping an existing C library), you can use it without having to compile
+  a separate extension.
 email: joel dot strait at Google's popular web mail service
 executables: []
 extensions: []
@@ -21,18 +22,19 @@ files:
 - LICENSE
 - README.markdown
 - Rakefile
+- lib/wavefile.rb
 - lib/wavefile/buffer.rb
+- lib/wavefile/chunk_readers.rb
+- lib/wavefile/chunk_readers/header_reader.rb
 - lib/wavefile/duration.rb
 - lib/wavefile/format.rb
-- lib/wavefile/info.rb
 - lib/wavefile/reader.rb
+- lib/wavefile/unvalidated_format.rb
 - lib/wavefile/writer.rb
-- lib/wavefile.rb
 - test/buffer_test.rb
-- test/buffer_test.rbc
 - test/duration_test.rb
-- test/duration_test.rbc
-- test/fixtures/actual_output/valid_mono_pcm_8_44100_with_padding_byte.wav
+- test/fixtures/actual_output/no_samples.wav
+- test/fixtures/invalid/README.markdown
 - test/fixtures/invalid/bad_riff_header.wav
 - test/fixtures/invalid/bad_wavefile_format.wav
 - test/fixtures/invalid/empty.wav
@@ -41,15 +43,14 @@ files:
 - test/fixtures/invalid/insufficient_format_chunk.wav
 - test/fixtures/invalid/no_data_chunk.wav
 - test/fixtures/invalid/no_format_chunk.wav
-- test/fixtures/invalid/README.markdown
+- test/fixtures/unsupported/README.markdown
 - test/fixtures/unsupported/bad_audio_format.wav
 - test/fixtures/unsupported/bad_channel_count.wav
 - test/fixtures/unsupported/bad_sample_rate.wav
-- test/fixtures/unsupported/README.markdown
 - test/fixtures/unsupported/unsupported_audio_format.wav
 - test/fixtures/unsupported/unsupported_bits_per_sample.wav
-- test/fixtures/valid/no_samples.wav
 - test/fixtures/valid/README.markdown
+- test/fixtures/valid/no_samples.wav
 - test/fixtures/valid/valid_mono_float_32_44100.wav
 - test/fixtures/valid/valid_mono_float_64_44100.wav
 - test/fixtures/valid/valid_mono_pcm_16_44100.wav
@@ -71,17 +72,13 @@ files:
 - test/fixtures/valid/valid_tri_pcm_32_44100.wav
 - test/fixtures/valid/valid_tri_pcm_8_44100.wav
 - test/format_test.rb
-- test/format_test.rbc
-- test/info_test.rb
-- test/info_test.rbc
 - test/reader_test.rb
-- test/reader_test.rbc
+- test/unvalidated_format_test.rb
 - test/wavefile_io_test_helper.rb
-- test/wavefile_io_test_helper.rbc
 - test/writer_test.rb
-- test/writer_test.rbc
-homepage: http://www.joelstrait.com/
-licenses: []
+homepage: http://wavefilegem.com/
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -89,17 +86,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.6.1
 signing_key: 
 specification_version: 4
 summary: A pure Ruby library for reading and writing Wave sound files (*.wav)