wav-file 0.0.2

data/History.txt

@@ -0,0 +1,8 @@
+=== 0.0.2 2010-11-17
+
+* bug fix
+* add samples
+
+=== 0.0.1 2010-11-17
+
+* created

data/Manifest.txt

@@ -0,0 +1,26 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+lib/wav-file.rb
+lib/wav-file/wav-file.rb
+script/console
+script/destroy
+script/generate
+spec/spec.opts
+spec/spec_helper.rb
+spec/wav-file_spec.rb
+tasks/rspec.rake
+samples/reverse.rb
+samples/double_speed.rb
+samples/read_data_chunk.rb
+samples/dump_wav.rb
+samples/connect_wav_files.rb
+samples/read_format_and_chunks.rb
+samples/copy_wav.rb
+samples/compare_formats.rb
+samples/adjust_wav_format.rb
+samples/split_channels.rb
+samples/maximize_volume.rb
+samples/composite.rb
+samples/read_format.rb

data/README.rdoc

@@ -0,0 +1,90 @@
+= wav-file
+
+* http://github.com/shokai/ruby-wav-file
+
+== DESCRIPTION:
+
+Read wav file format and Edit data chunk
+
+
+== TIPS:
+
+To run samples, you need wav file.
+"ffmpeg" is good tool for making wav file from mp3.
+
+    % ffmpeg -i input.mp3 output.wav
+
+Wav-file gem cannot convert format of wav file.
+Before edit data-chunk of wav files, you should adjust them using ffmpeg.
+
+
+== SYNOPSIS:
+   
+
+Read format and chunks
+
+    require 'rubygems'
+    require 'wav-file'
+    
+    f = open("input.wav")
+    format = WavFile::readFormat(f)
+    dataChunk = WavFile::readDataChunk(f)
+    f.close
+    
+    puts format
+
+
+Extract wav from binary    
+
+    bit = 's*' if format.bitPerSample == 16 # int16_t
+    bit = 'c*' if format.bitPerSample == 8 # signed char
+    wavs = dataChunk.data.unpack(bit) # read binary
+
+
+Change volume half
+
+    wavs = wavs.map{|w| w/2}
+
+
+Reverse wav and encode to binary
+
+    dataChunk.data = wavs.reverse.pack(bit) # reverse
+    
+    
+Save to file
+
+    open("output.wav", "w"){|out|
+      WavFile::write(out, format, [dataChunk])
+    }
+
+See "samples" directory.
+
+
+== INSTALL:
+
+* gem install wav-file
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 Sho Hashimoto
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/wav-file'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'wav-file' do
+  self.developer 'Sho Hashimoto', 'hashimoto@shokai.org'
+  self.rubyforge_name       = self.name # TODO this is default value
+  # self.extra_deps         = [['activesupport','>= 2.0.2']]
+
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/lib/wav-file.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__)+'/wav-file/wav-file.rb'
+
+module WavFile
+  VERSION = '0.0.2'
+end

data/lib/wav-file/wav-file.rb

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+module WavFile
+
+  class WavFormatError < StandardError
+  end
+
+  class Chunk
+    attr_accessor(:name, :size, :data)
+
+    def initialize(file)
+      @name = file.read(4)
+      @size = file.read(4).unpack("V")[0].to_i
+      @data = file.read(@size)
+    end
+
+    def to_bin
+      @name + [@data.size].pack('V') + @data
+    end
+  end
+
+  class Format
+    attr_accessor(:id, :channel, :hz, :bytePerSec, :blockSize, :bitPerSample)
+    
+    def initialize(chunk)
+      return if chunk.class != Chunk
+      return if chunk.name != 'fmt '
+      @id = chunk.data.slice(0,2)[0].to_i
+      @channel = chunk.data.slice(2,2)[0].to_i
+      @hz = chunk.data.slice(4,4).unpack('V').join.to_i
+      @bytePerSec = chunk.data.slice(8,4).unpack('V').join.to_i
+      @blockSize = chunk.data.slice(12,2)[0].to_i
+      @bitPerSample = chunk.data.slice(14,2)[0].to_i
+    end
+
+    def to_s
+      <<EOS
+Format ID:      #{@id}
+Channels:       #{@channel}
+Sampling Ratio: #{@hz} (Hz)
+Byte per Sec:   #{@bytePerSec}
+Bit per Sample: #{@bitPerSample} 
+Block Size:     #{blockSize}
+EOS
+    end
+
+    def to_bin
+      [@id].pack('v')+
+        [@channel].pack('v') +
+        [@hz].pack('V') +
+        [@bytePerSec].pack('V') +
+        [@blockSize].pack('v') +
+        [@bitPerSample].pack('v')
+    end
+
+    def ==(target)
+      @id == target.id && 
+        @channel == target.channel &&
+        @hz == target.hz &&
+        @bytePerSec == target.bytePerSec &&
+        @bitPerSample == target.bitPerSample &&
+        @blockSize == target.blockSize
+    end
+
+  end
+
+  def WavFile.readFormat(f)
+    f.binmode
+    f.seek(0)
+    header = f.read(12)
+    riff = header.slice(0,4)
+    data_size = header.slice(4,4).unpack('V')[0].to_i
+    wave = header.slice(8,4)
+    raise(WavFormatError) if riff != 'RIFF' or wave != 'WAVE'
+    
+    formatChunk = Chunk.new(f)
+    Format.new(formatChunk)
+  end
+
+  def WavFile.readAll(f)
+    format = readFormat(f)
+    chunks = Array.new
+    while !f.eof?
+      chunk = Chunk.new(f)
+      chunks << chunk
+    end
+    return format, chunks
+  end
+
+  def WavFile.readDataChunk(f)
+    format, chunks = readAll(f)
+    chunks.each{|c|
+      return c if c.name == 'data'
+    }
+    return nil
+  end
+
+  def WavFile.read(f)
+    return readFormat(f), readDataChunk(f)
+  end
+
+  def WavFile.write(f, format, dataChunks)
+    header_file_size = 4
+    dataChunks.each{|c|
+      header_file_size += c.data.size + 8
+    }
+    f.write('RIFF' + [header_file_size].pack('V') + 'WAVE')
+    f.write("fmt ")
+    f.write([format.to_bin.size].pack('V'))
+    f.write(format.to_bin)
+    dataChunks.each{|c|
+      f.write(c.to_bin)
+    }
+  end
+
+end

data/samples/adjust_wav_format.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# adjust same format using ffmpeg
+
+require 'rubygems'
+require 'wav-file'
+
+if ARGV.size < 2
+  puts 'ruby base.wav input1.wav [..input2.wav]'
+  exit 1
+end
+
+base_file = ARGV.shift
+
+base_format = WavFile::readFormat open(base_file)
+puts base_format
+
+ARGV.each{|f|
+  format = WavFile::readFormat open(f)
+  if format != base_format
+    puts `ffmpeg -i #{f} -ac #{base_format.channel} -ar #{base_format.hz} fixed_#{f}`
+  end
+}
+
+
+

data/samples/compare_formats.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# compare formats
+require 'rubygems'
+require 'wav-file'
+
+if ARGV.size < 2
+  puts 'ruby compare_formats.rb input1.wav input2.wav'
+  exit 1
+end
+
+formats = ARGV.map{|file_name|
+  format = WavFile::readFormat open(file_name)
+  puts format.to_s
+  puts '==='
+  format
+}
+
+if formats[0] == formats[1]
+  puts 'same format'
+else
+  puts 'different format'
+end
+
+

data/samples/composite.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# composite wav files
+require 'rubygems'
+require 'wav-file'
+
+if ARGV.size < 4
+  puts 'e.g. ruby composite.rb base.wav input1.wav 1 3 10 out.wav'
+  puts '     => put "input1.wav" on 1,3,10(sec)'
+  exit 1
+end
+
+out_file = ARGV.pop
+base_file = ARGV.shift
+input_file =ARGV.shift
+times = ARGV.map{|i|i.to_f}.uniq.sort
+
+
+format1, data1 = WavFile::read open(base_file)
+format2, data2 = WavFile::read open(input_file)
+
+puts format1.to_s
+if format1 != format2
+  puts 'file formats are different!'
+  puts format2.to_s
+  exit 1
+end
+
+
+bit = 's*' if format1.bitPerSample == 16 # int16_t
+bit = 'c*' if format1.bitPerSample == 8 # signed char
+wavs1 = data1.data.unpack(bit)
+wavs2 = data2.data.unpack(bit)
+
+times.each{|t|
+  offset = format1.hz * t * format1.channel
+  next if offset+wavs2.size > wavs1.size
+  print "#{t}(sec)..."
+  for i in 0..wavs2.size-1 do
+    wav1 = wavs1[i+offset]
+    wav2 = wavs2[i] * 0.3 # volume down
+    wavs1[i+offset] = ((wav1+wav2)/2).to_i
+  end
+  puts ''
+}
+
+data1.data = wavs1.pack(bit)
+
+open(out_file, "w"){|out|
+  WavFile::write(out, format1, [data1])
+}

data/samples/connect_wav_files.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# connect files
+require 'rubygems'
+require 'wav-file'
+
+if ARGV.size < 3
+  puts 'ruby connect_wav_files.rb input1.wav input2.wav output.wav'
+  exit 1
+end
+
+out_file = ARGV.pop
+
+formats = ARGV.uniq.map{|file_name|
+  WavFile::readFormat open(file_name)
+}
+for i in 0..formats.size-2 do
+  if formats[i] != formats[i+1]
+    puts 'different format!'
+    exit 1
+  end
+end
+
+format = formats.first
+dataChunk = WavFile::readDataChunk(open(ARGV.shift))
+
+ARGV.each{|f|
+  data = WavFile::readDataChunk(open(f))
+  dataChunk.data += data.data
+}
+
+puts format
+
+open(out_file, "w"){|out|
+  WavFile::write(out, format, [dataChunk])
+}

data/samples/copy_wav.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# read and write
+require 'rubygems'
+require 'wav-file'
+
+if ARGV.size < 2
+  puts 'ruby copy_wav.rb input.wav output.wav'
+  exit 1
+end
+
+f = open(ARGV.shift)
+format, chunks = WavFile::readAll(f)
+f.close
+
+puts format.to_s
+chunks.each{|c|
+  puts "#{c.name} #{c.size}"
+}
+
+open(ARGV.shift, "w"){|out|
+  WavFile::write(out, format, chunks)
+}

data/samples/double_speed.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+# double speed
+require 'rubygems'
+require 'wav-file'
+
+if ARGV.size < 2
+  puts 'ruby double_speed.rb input.rb output.wav'
+  exit 1
+end
+
+f = open(ARGV.shift)
+format, chunks = WavFile::readAll(f)
+f.close
+
+puts format.to_s
+puts '===double speed==='
+format.hz *= 2
+format.bytePerSec *= 2
+puts format.to_s
+
+
+open(ARGV.shift, "w"){|out|
+  WavFile::write(out, format, chunks)
+}
+

data/samples/dump_wav.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# using this script and Excel, you can make a graph.
+# => http://www.flickr.com/photos/shokai/4081858478/sizes/o/
+
+require 'rubygems'
+require 'wav-file'
+
+if ARGV.size < 2
+  puts 'ruby dump_wav.rb input.wav dump.txt'
+  exit 1
+end
+
+format = nil
+dataChunk = nil
+File.open(ARGV[0]){|file|
+  format, chunks = WavFile::readAll(file)
+  puts format.to_s
+  chunks.each{|c|
+    puts "chunk - #{c.name} #{c.size}"
+    dataChunk = c if c.name == 'data'
+  }
+}
+
+bit = 's*' if format.bitPerSample == 16 # int16_t
+bit = 'c*' if format.bitPerSample == 8 # signed char
+wavs = dataChunk.data.unpack(bit) # read binary
+
+open(ARGV[1],'w'){|dump|
+  wavs.each{|i|
+    dump.puts i
+    puts i
+  }
+}
+puts wavs.size
+

data/samples/maximize_volume.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+# maximize volume
+require 'rubygems'
+require 'wav-file'
+
+if ARGV.size < 2
+  puts 'ruby maximize_volume.rb input.wav output.wav'
+  exit 1
+end
+
+in_file = ARGV.shift
+out_file = ARGV.shift
+
+format, data = WavFile::read open(in_file)
+
+puts format.to_s
+
+bit = 's*' if format.bitPerSample == 16 # int16_t
+bit = 'c*' if format.bitPerSample == 8 # signed char
+wavs = data.data.unpack(bit)
+
+puts "max of this file: #{wavs.max}"
+
+volume_ratio = 32768/wavs.max.to_f if format.bitPerSample == 16
+volume_ratio = 128/wavs.max.to_f if format.bitPerSample == 8
+puts "maximize ratio: #{volume_ratio}"
+
+wavs_fixed = wavs.map{|w|
+  (w*volume_ratio).to_i
+}
+puts "maximized: #{wavs_fixed.max}"
+
+data.data = wavs_fixed.pack(bit)
+
+open(out_file, "w"){|out|
+  WavFile::write(out, format, [data])
+}

data/samples/read_data_chunk.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# wav file has multiple chunks.
+# using WavFile::readDataChunk, you can find data chunk from chunks
+require 'rubygems'
+require 'wav-file'
+
+if ARGV.size < 1
+  puts 'ruby read_data_chunk.rb input.wav'
+  exit 1
+end
+
+File.open(ARGV[0]){|file|
+  format = WavFile::readFormat(file)
+  puts format.to_s
+
+  dataChunk = WavFile::readDataChunk(file)
+  puts "#{dataChunk.name} #{dataChunk.size}"
+}

data/samples/read_format.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'wav-file'
+
+if ARGV.size < 1
+  puts 'ruby readWav.rb input.wav'
+  exit 1
+end
+
+File.open(ARGV[0]){|file|
+  format = WavFile::readFormat(file)
+  puts format
+}

data/samples/read_format_and_chunks.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'wav-file'
+
+if ARGV.size < 1
+  puts 'ruby read_format_and_chanks.rb input.wav'
+  exit 1
+end
+
+File.open(ARGV.first){|file|
+  format, chunks = WavFile::readAll(file)
+  puts format.to_s
+  chunks.each{|c|
+    puts "chunk - #{c.name} #{c.size}"
+  }
+}

data/samples/reverse.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# reverse wav file
+
+require 'rubygems'
+require 'wav-file'
+
+if ARGV.size < 2
+  puts 'ruby reverse.rb input.rb output.wav'
+  exit 1
+end
+
+f = open(ARGV.shift)
+format = WavFile::readFormat(f)
+dataChunk = WavFile::readDataChunk(f)
+f.close
+
+puts format
+
+if dataChunk == nil
+  puts 'no data chunk'
+  exit 1
+end
+
+bit = 's*' if format.bitPerSample == 16 # int16_t
+bit = 'c*' if format.bitPerSample == 8 # signed char
+wavs = dataChunk.data.unpack(bit) # read binary
+dataChunk.data = wavs.reverse.pack(bit) # reverse
+
+open(ARGV.shift, "w"){|out|
+  WavFile::write(out, format, [dataChunk])
+}
+

data/samples/split_channels.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+# split left/right channels.
+require 'rubygems'
+require 'wav-file'
+
+if ARGV.size < 2
+  puts 'e.g. ruby splitChannelWav.rb input.rb output_left.wav output_right.wav'
+  puts '    => make 2 wav files'
+  exit 1
+end
+
+f = open(ARGV.shift)
+format, chunks = WavFile::readAll(f)
+f.close
+
+puts format.to_s
+
+dataChunk = nil
+chunks.each{|c|
+  puts "#{c.name} #{c.size}"
+  dataChunk = c if c.name == 'data' # find data chank
+}
+if dataChunk == nil
+  puts 'no data chunk'
+  exit 1
+end
+
+bit = 's*' if format.bitPerSample == 16 # int16_t
+bit = 'c*' if format.bitPerSample == 8 # signed char
+wavs = dataChunk.data.unpack(bit) # read binary
+
+off = 32768 if format.bitPerSample == 16
+off = 128 if format.bitPerSample == 8
+
+for i in 0..1 do # LR
+  wavs_mono = wavs.dup
+  for j in 0..wavs_mono.size-1 do
+    if j%2 != i
+      wavs_mono[j] = off # LRLRLR..
+    end
+  end
+  dataChunk.data = wavs_mono.pack(bit)
+  open(ARGV.shift, "w"){|out|
+    WavFile::write(out, format, [dataChunk])
+  }
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/wav-file.rb'}"
+puts "Loading wav-file gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'wav-file'

data/spec/wav-file_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+# Time to add your specs!
+# http://rspec.info/
+describe "Place your specs here" do
+  
+  it "find this spec in spec directory" do
+    # violated "Be sure to write your specs"
+  end
+  
+end

data/tasks/rspec.rake

@@ -0,0 +1,21 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  require 'spec'
+end
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts <<-EOS
+To use rspec for testing you must install rspec gem:
+    gem install rspec
+EOS
+  exit(0)
+end
+
+desc "Run the specs under spec/models"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification 
+name: wav-file
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Sho Hashimoto
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-18 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 2
+        - 7
+        - 0
+        version: 2.7.0
+  type: :development
+  version_requirements: *id002
+description: Read wav file format and Edit data chunk
+email: 
+- hashimoto@shokai.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- lib/wav-file.rb
+- lib/wav-file/wav-file.rb
+- script/console
+- script/destroy
+- script/generate
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/wav-file_spec.rb
+- tasks/rspec.rake
+- samples/reverse.rb
+- samples/double_speed.rb
+- samples/read_data_chunk.rb
+- samples/dump_wav.rb
+- samples/connect_wav_files.rb
+- samples/read_format_and_chunks.rb
+- samples/copy_wav.rb
+- samples/compare_formats.rb
+- samples/adjust_wav_format.rb
+- samples/split_channels.rb
+- samples/maximize_volume.rb
+- samples/composite.rb
+- samples/read_format.rb
+has_rdoc: true
+homepage: http://github.com/shokai/ruby-wav-file
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: wav-file
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Read wav file format and Edit data chunk
+test_files: []
+