wavefile 0.3.0 → 0.4.0

data/test/info_test.rb

@@ -0,0 +1,60 @@
+require 'test/unit'
+require 'wavefile.rb'
+
+include WaveFile
+
+class InfoTest < Test::Unit::TestCase
+  FILE_NAME = "foo.wav"
+  SECONDS_IN_MINUTE = 60
+  SECONDS_IN_HOUR = SECONDS_IN_MINUTE * 60
+
+  def test_basic
+    format_chunk = { :audio_format => 1, :channels => 2, :sample_rate => 44100,
+                     :byte_rate => 176400, :block_align => 4, :bits_per_sample => 16 }
+    info = Info.new(FILE_NAME, format_chunk, 44100)
+    
+    assert_equal(FILE_NAME, info.file_name)
+    assert_equal(1, info.audio_format)
+    assert_equal(2, info.channels)
+    assert_equal(44100, info.sample_rate)
+    assert_equal(176400, info.byte_rate)
+    assert_equal(4, info.block_align)
+    assert_equal(16, info.bits_per_sample)
+    assert_equal(44100, info.sample_count)
+    assert_equal({:hours => 0, :minutes => 0, :seconds => 1, :milliseconds => 0}, info.duration)
+  end
+
+  def test_duration
+    format_chunk = { :audio_format => 1, :channels => 2, :byte_rate => 176400, :block_align => 4, :bits_per_sample => 16 }
+
+    # Test common sample rates (22050 and 44100), and some crazy arbitrary sample rate (12346)
+    [22050, 44100, 12346].each do |sample_rate|
+      format_chunk[:sample_rate] = sample_rate
+
+      info = Info.new(FILE_NAME, format_chunk, 0)
+      assert_equal({:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 0}, info.duration)
+
+      info = Info.new(FILE_NAME, format_chunk, sample_rate / 2)
+      assert_equal({:hours => 0, :minutes => 0, :seconds => 0, :milliseconds => 500}, info.duration)
+
+      info = Info.new(FILE_NAME, format_chunk, sample_rate)
+      assert_equal({:hours => 0, :minutes => 0, :seconds => 1, :milliseconds => 0}, info.duration)
+
+      info = Info.new(FILE_NAME, format_chunk, sample_rate * SECONDS_IN_MINUTE)
+      assert_equal({:hours => 0, :minutes => 1, :seconds => 0, :milliseconds => 0}, info.duration)
+
+      info = Info.new(FILE_NAME, format_chunk, sample_rate * SECONDS_IN_HOUR)
+      assert_equal({:hours => 1, :minutes => 0, :seconds => 0, :milliseconds => 0}, info.duration)
+
+      info = Info.new(FILE_NAME, format_chunk, (sample_rate * SECONDS_IN_MINUTE) + sample_rate + (sample_rate / 2))
+      assert_equal({:hours => 0, :minutes => 1, :seconds => 1, :milliseconds => 500}, info.duration)
+    end
+
+    # Test for when the number of hours is more than a day.
+    format_chunk[:sample_rate] = 44100
+    samples_per_hour = 44100 * 60 * 60
+    info = Info.new(FILE_NAME, format_chunk, samples_per_hour * 25)
+    assert_equal({:hours => 25, :minutes => 0, :seconds => 0, :milliseconds => 0}, info.duration)
+  end
+end
+

data/test/reader_test.rb

@@ -0,0 +1,222 @@
+require 'test/unit'
+require 'wavefile.rb'
+require 'wavefile_io_test_helper.rb'
+
+include WaveFile
+
+class ReaderTest < Test::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")) }
+  end
+
+  def test_invalid_formats
+    # 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|
+      # File contains 0 bytes
+      assert_raise(InvalidFormatError) { Reader.send(method_name, fixture("invalid/empty.wav")) }
+
+      # File consists of "RIFF" and nothing else
+      assert_raise(InvalidFormatError) { Reader.send(method_name, fixture("invalid/incomplete_riff_header.wav")) }
+
+      # First 4 bytes in the file are not "RIFF"
+      assert_raise(InvalidFormatError) { Reader.send(method_name, fixture("invalid/bad_riff_header.wav")) }
+
+      # The format code in the RIFF header is not "WAVE"
+      assert_raise(InvalidFormatError) { Reader.new(fixture("invalid/bad_wavefile_format.wav")) }
+
+      # The file consists of just a valid RIFF header
+      assert_raise(InvalidFormatError) { Reader.new(fixture("invalid/no_format_chunk.wav")) }
+
+      # The format chunk has 0 bytes in it (despite the chunk size being 16)
+      assert_raise(InvalidFormatError) { Reader.new(fixture("invalid/empty_format_chunk.wav")) }
+
+      # The format chunk has some data, but not all of the minimum required.
+      assert_raise(InvalidFormatError) { Reader.new(fixture("invalid/insufficient_format_chunk.wav")) }
+
+      # The RIFF header and format chunk are OK, but there is no data chunk
+      assert_raise(InvalidFormatError) { Reader.new(fixture("invalid/no_data_chunk.wav")) }
+    end
+  end
+
+  def test_unsupported_formats
+    # Audio format is 2, which is not supported
+    assert_raise(UnsupportedFormatError) { Reader.new(fixture("unsupported/unsupported_audio_format.wav")) }
+
+    # Bits per sample is 24, which is not supported
+    assert_raise(UnsupportedFormatError) { Reader.new(fixture("unsupported/unsupported_bits_per_sample.wav")) }
+
+    # Channel count is 0
+    assert_raise(UnsupportedFormatError) { Reader.new(fixture("unsupported/bad_channel_count.wav")) }
+
+    # Sample rate is 0
+    assert_raise(UnsupportedFormatError) { Reader.new(fixture("unsupported/bad_sample_rate.wav")) }
+  end
+
+  def test_initialize
+    format = Format.new(:stereo, 16, 22050)
+
+    exhaustively_test do |channels, bits_per_sample|
+      file_name = fixture("valid/valid_#{channels}_#{bits_per_sample}_44100.wav")
+
+      # Read native format
+      reader = Reader.new(file_name)
+      assert_equal(CHANNEL_ALIAS[channels], reader.format.channels)
+      assert_equal(bits_per_sample, reader.format.bits_per_sample)
+      assert_equal(44100, reader.format.sample_rate)
+      assert_equal(false, reader.closed?)
+      assert_equal(file_name, reader.file_name)
+      reader.close()
+
+      # Read a non-native format
+      reader = Reader.new(file_name, format)
+      assert_equal(2, 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)
+      reader.close()
+
+      # Block is given.
+      reader = Reader.new(file_name) {|reader| reader.read(1024) }
+      assert_equal(CHANNEL_ALIAS[channels], reader.format.channels)
+      assert_equal(bits_per_sample, reader.format.bits_per_sample)
+      assert_equal(44100, reader.format.sample_rate)
+      assert(reader.closed?)
+      assert_equal(file_name, reader.file_name)
+    end
+  end
+
+  def test_read_native_format
+    exhaustively_test do |channels, bits_per_sample|
+      buffers = read_file("valid/valid_#{channels}_#{bits_per_sample}_44100.wav", 1024)
+
+      assert_equal(3, buffers.length)
+      assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
+      assert_equal(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 128, buffers[0].samples)
+      assert_equal(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 128, buffers[1].samples)
+      assert_equal(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 24,  buffers[2].samples)
+    end
+  end
+
+  def test_read_with_format_conversion
+    buffers = read_file("valid/valid_mono_16_44100.wav", 1024, Format.new(:stereo, 8, 22100))
+
+    assert_equal(3, buffers.length)
+    assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][8] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][8] * 128, buffers[1].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][8] * 24,  buffers[2].samples)
+  end
+
+  def test_read_with_padding_byte
+    buffers = read_file("valid/valid_mono_8_44100_with_padding_byte.wav", 1024)
+
+    assert_equal(3, buffers.length)
+    assert_equal([1024, 1024, 191], buffers.map {|buffer| buffer.samples.length })
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][8] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][8] * 128, buffers[1].samples)
+    assert_equal((SQUARE_WAVE_CYCLE[:mono][8] * 23) + [88, 88, 88, 88, 167, 167, 167], 
+                 buffers[2].samples)
+  end
+
+  def test_each_buffer_no_block_given
+    reader = Reader.new(fixture("valid/valid_mono_16_44100.wav"))
+    assert_raise(LocalJumpError) { reader.each_buffer(1024) }
+  end
+
+  def test_each_buffer_native_format
+    exhaustively_test do |channels, bits_per_sample|  
+      reader = Reader.new(fixture("valid/valid_#{channels}_#{bits_per_sample}_44100.wav"))
+
+      buffers = []
+      reader.each_buffer(1024) {|buffer| buffers << buffer }
+    
+      assert(reader.closed?)
+      assert_equal(3, buffers.length)
+      assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
+      assert_equal(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 128, buffers[0].samples)
+      assert_equal(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 128, buffers[1].samples)
+      assert_equal(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 24,  buffers[2].samples)
+    end
+  end
+
+  def test_each_buffer_with_format_conversion
+    reader = Reader.new(fixture("valid/valid_mono_16_44100.wav"), Format.new(:stereo, 8, 22050))
+    assert_equal(2, reader.format.channels)
+    assert_equal(8, reader.format.bits_per_sample)
+    assert_equal(22050, reader.format.sample_rate)
+
+    buffers = []
+    reader.each_buffer(1024) {|buffer| buffers << buffer }
+    
+    assert_equal(3, buffers.length)
+    assert_equal([1024, 1024, 192], buffers.map {|buffer| buffer.samples.length })
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][8] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][8] * 128, buffers[1].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:stereo][8] * 24,  buffers[2].samples)
+  end
+
+  def test_each_buffer_with_padding_byte
+    buffers = []
+    reader = Reader.new(fixture("valid/valid_mono_8_44100_with_padding_byte.wav"))
+    reader.each_buffer(1024) {|buffer| buffers << buffer }
+
+    assert_equal(3, buffers.length)
+    assert_equal([1024, 1024, 191], buffers.map {|buffer| buffer.samples.length })
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][8] * 128, buffers[0].samples)
+    assert_equal(SQUARE_WAVE_CYCLE[:mono][8] * 128, buffers[1].samples)
+    assert_equal((SQUARE_WAVE_CYCLE[:mono][8] * 23) + [88, 88, 88, 88, 167, 167, 167], 
+                 buffers[2].samples)
+  end
+
+  def test_closed?
+    reader = Reader.new(fixture("valid/valid_mono_16_44100.wav"))
+    assert_equal(false, reader.closed?)
+    reader.close()
+    assert(reader.closed?)
+
+    # For Reader.each_buffer()
+    reader = Reader.new(fixture("valid/valid_mono_16_44100.wav"))
+    assert_equal(false, reader.closed?)
+    reader.each_buffer(1024) do |buffer|
+      # No-op
+    end
+    assert_equal(true, reader.closed?)
+  end
+
+  def test_read_after_close
+    reader = Reader.new(fixture("valid/valid_mono_16_44100.wav"))
+    buffer = reader.read(1024)
+    reader.close()
+    assert_raise(IOError) { reader.read(1024) }
+  end
+
+private
+
+  def read_file(file_name, buffer_size, format=nil)
+    buffers = []
+    reader = Reader.new(fixture(file_name), format)
+
+    begin
+      while true do
+        buffers << reader.read(buffer_size)
+      end
+    rescue EOFError
+      reader.close()
+    end
+
+    return buffers
+  end
+
+  def fixture(fixture_name)
+    return "#{FIXTURE_ROOT_PATH}/#{fixture_name}"
+  end
+end

data/test/wavefile_io_test_helper.rb

@@ -0,0 +1,47 @@
+module WaveFileIOTestHelper
+  CHANNEL_ALIAS = { :mono => 1, :stereo => 2, :tri => 3}
+
+  SQUARE_WAVE_CYCLE = {}
+  SQUARE_WAVE_CYCLE[:mono] = {}
+
+  SQUARE_WAVE_CYCLE[:mono][8] =    [88, 88, 88, 88, 167, 167, 167, 167]
+  SQUARE_WAVE_CYCLE[:mono][16] =   [-10000, -10000, -10000, -10000, 10000, 10000, 10000, 10000]
+  SQUARE_WAVE_CYCLE[:mono][32] =   [-1000000000, -1000000000, -1000000000, -1000000000,
+                                     1000000000, 1000000000, 1000000000, 1000000000]
+
+  SQUARE_WAVE_CYCLE[:stereo] = {}
+  SQUARE_WAVE_CYCLE[:stereo][8] =  [[88, 88], [88, 88], [88, 88], [88, 88],
+                                    [167, 167], [167, 167], [167, 167], [167, 167]]
+  SQUARE_WAVE_CYCLE[:stereo][16] = [[-10000, -10000], [-10000, -10000], [-10000, -10000], [-10000, -10000],
+                                    [10000, 10000], [10000, 10000], [10000, 10000], [10000, 10000]]
+  SQUARE_WAVE_CYCLE[:stereo][32] = [[-1000000000, -1000000000], [-1000000000, -1000000000],
+                                    [-1000000000, -1000000000], [-1000000000, -1000000000],
+                                    [ 1000000000,  1000000000], [ 1000000000,  1000000000],
+                                    [ 1000000000,  1000000000], [ 1000000000,  1000000000]]
+
+  SQUARE_WAVE_CYCLE[:tri] = {}
+  SQUARE_WAVE_CYCLE[:tri][8] =    [[88, 88, 88], [88, 88, 88], [88, 88, 88], [88, 88, 88],
+                                    [167, 167, 167], [167, 167, 167], [167, 167, 167], [167, 167, 167]]
+  SQUARE_WAVE_CYCLE[:tri][16] =   [[-10000, -10000, -10000], [-10000, -10000, -10000],
+                                   [-10000, -10000, -10000], [-10000, -10000, -10000],
+                                   [ 10000,  10000,  10000], [ 10000,  10000,  10000],
+                                   [ 10000,  10000,  10000], [ 10000,  10000,  10000]]
+  SQUARE_WAVE_CYCLE[:tri][32] =   [[-1000000000, -1000000000, -1000000000],
+                                   [-1000000000, -1000000000, -1000000000],
+                                   [-1000000000, -1000000000, -1000000000],
+                                   [-1000000000, -1000000000, -1000000000],
+                                   [ 1000000000,  1000000000,  1000000000],
+                                   [ 1000000000,  1000000000,  1000000000],
+                                   [ 1000000000,  1000000000,  1000000000],
+                                   [ 1000000000,  1000000000,  1000000000]]
+  
+  
+  # Executes the given block against different combinations of number of channels and bits per sample.
+  def exhaustively_test
+    [:mono, :stereo, :tri].each do |channels|
+      Format::SUPPORTED_BITS_PER_SAMPLE.each do |bits_per_sample|
+        yield(channels, bits_per_sample)
+      end
+    end
+  end
+end

data/test/writer_test.rb

@@ -0,0 +1,118 @@
+require 'test/unit'
+require 'wavefile.rb'
+require 'wavefile_io_test_helper.rb'
+
+include WaveFile
+
+class WriterTest < Test::Unit::TestCase
+  include WaveFileIOTestHelper
+
+  OUTPUT_FOLDER = "test/fixtures/actual_output"
+
+  def setup
+    clean_output_folder()
+  end
+
+  def test_write_file_with_no_sample_data
+    writer = Writer.new("#{OUTPUT_FOLDER}/no_samples.wav", Format.new(1, 8, 44100))
+    writer.close()
+    
+    assert_equal(read_file(:expected, "no_samples.wav"), read_file(:actual, "no_samples.wav"))
+  end
+
+  def test_write_basic_file
+    exhaustively_test do |channels, bits_per_sample|
+      file_name = "valid_#{channels}_#{bits_per_sample}_44100.wav"
+      format = Format.new(CHANNEL_ALIAS[channels], bits_per_sample, 44100)
+
+      writer = Writer.new("#{OUTPUT_FOLDER}/#{file_name}", format)
+      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 128, format))
+      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 128, format))
+      writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 24, format))
+      writer.close()
+
+      assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
+    end
+  end
+
+  def test_write_basic_file_with_a_block
+    exhaustively_test do |channels, bits_per_sample|
+      file_name = "valid_#{channels}_#{bits_per_sample}_44100.wav"
+      format = Format.new(CHANNEL_ALIAS[channels], bits_per_sample, 44100)
+
+      writer = Writer.new("#{OUTPUT_FOLDER}/#{file_name}", format) do |writer|
+        4.times do
+          writer.write(Buffer.new(SQUARE_WAVE_CYCLE[channels][bits_per_sample] * 70, format))
+        end
+      end
+
+      assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
+      assert(writer.closed?)
+    end
+  end
+
+  def test_write_buffers_of_different_formats
+    file_name = "valid_mono_8_44100.wav"
+    format_8bit_mono    = Format.new(:mono,   8,  44100)
+    format_16_bit_mono  = Format.new(:mono,   16, 22050)
+    format_16bit_stereo = Format.new(:stereo, 16, 44100)
+
+    writer = Writer.new("#{OUTPUT_FOLDER}/#{file_name}", format_8bit_mono)
+    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:stereo][16] * 128, format_16bit_stereo))
+    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][16] * 128,   format_16_bit_mono))
+    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:stereo][16] * 24,  format_16bit_stereo))
+    writer.close()
+
+    assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
+  end
+
+  def test_write_file_with_padding_byte
+    file_name = "valid_mono_8_44100_with_padding_byte.wav"
+    format = Format.new(1, 8, 44100)
+
+    writer = Writer.new("#{OUTPUT_FOLDER}/#{file_name}", format)
+    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][8] * 128, format))
+    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][8] * 128, format))
+    writer.write(Buffer.new(SQUARE_WAVE_CYCLE[:mono][8] * 23 + [88, 88, 88, 88, 167, 167, 167], format))
+    writer.close()
+
+    assert_equal(read_file(:expected, file_name), read_file(:actual, file_name))
+  end
+  
+  def test_closed?
+    writer = Writer.new("#{OUTPUT_FOLDER}/closed_test.wav", Format.new(1, 16, 44100))
+    assert_equal(false, writer.closed?)
+    writer.close()
+    assert(writer.closed?)
+  end
+
+  def test_attempt_to_write_after_close
+    format = Format.new(1, 8, 44100)
+
+    writer = Writer.new("#{OUTPUT_FOLDER}/write_after_close.wav", format)
+    writer.write(Buffer.new([1, 2, 3, 4], format))
+    writer.close()
+
+    assert_raise(IOError) { writer.write(Buffer.new([5, 6, 7, 8], format)) }
+  end
+
+private
+
+  def read_file(type, file_name)
+    # For Windows compatibility with binary files, File.read() is not directly used
+    return File.open("test/fixtures/#{type}_output/#{file_name}", "rb") {|f| f.read() }
+  end
+
+  def clean_output_folder()
+    # Make the folder if it doesn't already exist
+    Dir.mkdir(OUTPUT_FOLDER) unless File.exists?(OUTPUT_FOLDER)
+
+    dir = Dir.new(OUTPUT_FOLDER)
+    file_names = dir.entries
+    file_names.each do |file_name|
+      if(file_name != "." && file_name != "..")
+        File.delete("#{OUTPUT_FOLDER}/#{file_name}")
+      end
+    end
+  end
+end