riff 0.3 → 0.3.1

data/Rakefile

@@ -1,6 +1,10 @@
 task :default => [:test , :rdoc]
 
-task :test do
+task :build_c do
+  `make -C libc/riff`
+end
+
+task :test => [:build_c] do
 	ruby "test/riff_test_suite.rb"
 end
 

data/examples/readchunks.rb

@@ -1,4 +1,5 @@
 require 'lib/riff/reader.rb'
+require 'optparse'
 
 def print_chunk(ck,margin = "")
 	if ck.is_list? then
@@ -11,6 +12,34 @@ def print_chunk(ck,margin = "")
 	end
 end
 
-Riff::Reader.open(ARGV[0],"r") do |wav|
-	print_chunk( wav.root_chunk )
-end
+@chunk = nil
+cl_options = OptionParser.new do |ops|
+  ops.on('-c CHUNK','--chunk CHUNK','Output the first first-tier chunk with fourcc',
+                                    'CHUNK to stdout') do |chk|
+    @chunk = chk
+  end
+  ops.on('-h','-?','--help','Print this Message') do
+    puts ops
+    exit 0
+  end
+end
+
+rest = cl_options.parse!
+
+rest.each do |path|
+  if @chunk 
+    Riff::Reader.open(path,"r") do |wav|
+    	wav.root_chunk.each do |a_chunk|
+    	  if a_chunk.fourcc == @chunk
+    	    $stdout.print a_chunk.body
+    	    exit 0
+  	    end
+  	  end
+    end
+    
+  else
+    Riff::Reader.open(path,"r") do |wav|
+    	print_chunk( wav.root_chunk )
+    end
+  end
+end # rest.each

data/lib/riff/info.rb

@@ -1,5 +1,24 @@
-require 'lib/riff/reader.rb'
-require 'lib/riff/writer.rb'
+#--
+#riff.rb -- Library for reading generic Microsoft RIFF Files
+#Copyright (C) 2009  Jamie Hardt
+
+#This library is free software; you can redistribute it and/or
+#modify it under the terms of the GNU Lesser General Public
+#License as published by the Free Software Foundation; either
+#version 2.1 of the License, or (at your option) any later version.
+
+#This library is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#Lesser General Public License for more details.
+
+#You should have received a copy of the GNU Lesser General Public
+#License along with this library; if not, write to the Free Software
+#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+
+require 'riff/reader.rb'
+require 'riff/writer.rb'
 
 module Riff
   
@@ -15,6 +34,10 @@ module Riff
   #   editor['IART'] = "Me Myself"
   #
   # Note that some names map to the same fourcc.
+  #
+  # Also note that RIFF INFO datums are generally encoded using ISO-8859-1 WinANSI.
+  # We expect to be able to support this more fully with Ruby 1.9 and its integrated
+  # text encoding facilities.
   class MetaEditor
     
     # the path to the file being edited
@@ -62,6 +85,7 @@ module Riff
     ATTRIBUTE_FOURCCs.each do |key|
       class_eval <<-TXT
       def #{key.downcase}=(val)
+        @dirty = true
         @metadata['#{key}'] = val
       end
       def #{key.downcase}
@@ -73,6 +97,7 @@ module Riff
     ATTRIBUTE_NAMES.each_pair do |key,value|
       class_eval <<-TXT
       def #{key.downcase.gsub(/ /,'_').gsub(/[^a-z_]/,'')}=(val)
+        @dirty = true
         @metadata['#{value}'] = val
       end
       
@@ -98,30 +123,43 @@ module Riff
     end
     
     # Creates a MetaEditor object for the file locates at +path+
-    def initialize(path)
+    # 
+    # If you provide a block, the MetaEditor itself will be yielded, and
+    # a +save!+ will be called upon the block closing. 
+    def initialize(path) #:yields: self
       reader = Reader.open(path,'r')
       @pad_out = 1024
       @path = path
       @metadata = {}
+      @dirty = false
       infoChunk = reader.root_chunk.find {|c| c.signature == 'INFO'}
       if infoChunk && infoChunk.is_list?
         infoChunk.each do |subChunk|
           @metadata[subChunk.fourcc] = subChunk.body
         end
       end
+      if block_given?
+        yield self
+        save!
+      end
+      self
     end
     
-    def [](k)
-      return @metadata[k]
+    # Get a metadatum by +fourcc+
+    def [](fourcc)
+      return @metadata[fourcc]
     end
     
-    def []=(k,v)
-      @metadata[k] = v
+    # Set a metadatum by +fourcc+
+    def []=(fourcc,value)
+      @dirty = true
+      @metadata[fourcc] = value
     end
     
+    # Yields each metadatum
     def each_metadatum
-      @metadata.each_pair do |key,value|
-        yield key,value
+      @metadata.each_pair do |fourcc,value|
+        yield fourcc,value
       end
     end
     
@@ -130,8 +168,12 @@ module Riff
     #
     # If a pad_out number is specified, a "JUNK" chunk with a payload of pad_out
     # bytes will be added after the INFO chunk.
+    #
+    # If you have not modified any metadatums of the file, this method will have no
+    # effect on the system.
     def save!
-      tempPath = File.dirname(path) + "/" + (([?a] *8).map {|i| (i + rand(26)).chr}).join + ".tmp"
+      return unless @dirty
+      tempPath = File.dirname(path) + "/" + (([?a] *16).map {|i| (i + rand(26)).chr}).join + ".tmp"
       Reader.open(path,'r') do |reader|
         begin
           Builder.create(tempPath,reader.root_chunk.signature) do |riffwriter|

data/lib/riff/reader.rb

@@ -1,6 +1,6 @@
 #--
-#riff.rb -- API for reading generic Microsoft RIFF Files
-#Copyright (C) 2006  Jamie Hardt
+#riff.rb -- Library for reading generic Microsoft RIFF Files
+#Copyright (C) 2009  Jamie Hardt
 
 #This library is free software; you can redistribute it and/or
 #modify it under the terms of the GNU Lesser General Public
@@ -32,7 +32,7 @@
 # = Examples
 # === Getting iXML metadata from a broadcast-WAV file
 # 
-#   require 'riff/base'
+#   require 'riff/reader'
 #   Riff::Reader.open(ARGV[0],"r") do |wav|
 #     xml = wav.root_chunk['ixml'].body
 #   end
@@ -56,60 +56,55 @@
 #     print_chunk( wav.root_chunk )
 #   end
 #  
+
+require 'libc/riff/riff.bundle'
+#require 'riff/util'
+
 module Riff
-  
-  module VERSION
-    MAJOR = 0
-    MINOR = 3
-  end #module version
-  
+
+  # The Reader class provides a front-end to the other objects of the library.
+  # It's the only object that you interact with directly, and calling its methods
+  # will return the other objects of the class.  
   class Reader
-    # The Reader class provides a front-end to the other objects of the library.
-    # It's the only object that you interact with directly, and calling its methods
-    # will return the other objects of the class.
   
     # Returns the File object for this reader.
-    attr_reader :file
+   # attr_reader :file
   
     # Opens a RIFF file for reading.  Pass a string path and string mode, as you would
     # for File::open.  A Riff object will be returned.
-    # * At this time, only the "r" and "rb" modes are supported, others will raise
-    #   and ArgumentError
     # * If you provide a block, the Riff object will be yielded to the block as the
     #   sole parameter, and will be automatically closed at the end of the block.
     # * If you pass a file which does not start with the RIFF fourcc, the file
     #   is invalid and a FileTypeError will be thrown.
-    def Reader.open(path,mode) # :yields: riff_object
-      riff_obj = Riff::Reader.new(path,"r")
-      if block_given? && riff_obj then
-        yield riff_obj
-        riff_obj.close
-      end
-      riff_obj
-    end
+    # * _mode_ is ignored and will be removed in a future version
+#    def Reader.open(path,mode = nil) # :yields: riff_object
+#      riff_obj = Riff::Reader.new(path)
+#      if block_given? && riff_obj then
+#        yield riff_obj
+#        riff_obj.close
+#      end
+#      riff_obj
+#    end
   
     # Returns the Root Chunk of the RIFF file as a ListChunk
-    def root_chunk
-      @file.rewind
-      the_chunk = Chunk.read_chunk(@file)
-    end
+#    def root_chunk
+#      @file.rewind
+#      the_chunk = Chunk.read_chunk(@file)
+#    end
   
     # Closes the Riff object.  Subsequent calls to the Riff object or any of its
     # chunk objects will fail.
-    def close
-      @file.close
-    end
+#    def close
+#      @file.close
+#    end
 
-    class FileTypeError < StandardError ; end #:nodoc:
+ #   class FileTypeError < StandardError ; end #:nodoc:
 
-  private
-  
-    def initialize(path, mode) #:nodoc:
-      raise(ArgumentError, "Riff.open only supports mode 'r' or 'rb'.") \
-       unless mode == "r" || mode == "rb" 
-  
-      @file = File.open(path,mode)
-    end #def initialize
+#  private
+#  
+#    def initialize(path) #:nodoc:  
+#      @file = File.open(path)
+#    end #def initialize
   
   end
 
@@ -169,25 +164,11 @@ module Riff
   
     protected
   
-      def Chunk.read_bytes_to_int(file,bytes) # :nodoc:
-    
-        ary = [ ]
-        bytes.times { ary << file.getc }
-    
-        result = 0
-        ary.each_with_index do |n, i|
-          7.downto(0) do |bit|
-            result += 2 ** ((bit) + i * 8) if n[bit] == 1
-          end
-        end
-        return result
-      end
-    
       def initialize(fp) #:nodoc:
         @file = fp
         @offset = @file.pos
         @fourcc = @file.read(4)
-        @length = Chunk.read_bytes_to_int(@file,4)
+        @length = Util.read_bytes_to_int(@file,4)
       end
   
     end #class Chunk
@@ -195,7 +176,7 @@ module Riff
     # ListChunk is a subclass of Chunk, and so you can access its fourcc and size
     #
     # <em>Note:</em> The +body+ method is not permitted on ListChunk
-    class ListChunk < Chunk
+    class ListChunk #< Chunk
     
       include Enumerable
     

data/lib/riff/util.rb

@@ -0,0 +1,46 @@
+require 'libc/riff/riff.bundle'
+
+module Riff
+  
+#  module VERSION
+#    MAJOR = 0
+#    MINOR = 4
+#  end #module version
+  
+  # The Util module contains various methods
+  module Util
+    
+    # Reads +bytes+ bytes from file and converts the bytes into an unsigned int, assuming that
+    # the bytes are little-endian
+#    def self.read_bytes_to_int(file,bytes)
+#      ary = [ ]
+#      bytes.times { ary << file.getc }
+#  
+#      result = 0
+#      ary.each_with_index do |n, i|
+#        7.downto(0) do |bit|
+#          result += 2 ** ((bit) + i * 8) if n[bit] == 1
+#        end
+#      end
+#      return result
+#    end
+    
+#    def self.int_to_four_little_endian_bytes(i)
+#      n = [ i.abs , 2 ** 32 ].min
+#      [(n.to_i & 0xff) , (n.to_i & 0xff00)>>8, 
+#        (n.to_i & 0xff0000)>>16,(n.to_i & 0xff000000)>>24 ]
+#    end
+
+#    def self.int_to_four_big_endian_bytes(i)
+#      return int_to_four_little_endian_bytes(i).reverse
+#    end
+
+
+#    def self.sanitize_fourcc(fourcc)
+#      fourcc[0,4].ljust(4,"\0")
+#    end
+    
+    
+  end
+  
+end

data/lib/riff/writer.rb

@@ -1,9 +1,80 @@
+#--
+#riff.rb -- Library for reading generic Microsoft RIFF Files
+#Copyright (C) 2009  Jamie Hardt
+
+#This library is free software; you can redistribute it and/or
+#modify it under the terms of the GNU Lesser General Public
+#License as published by the Free Software Foundation; either
+#version 2.1 of the License, or (at your option) any later version.
+
+#This library is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#Lesser General Public License for more details.
+
+#You should have received a copy of the GNU Lesser General Public
+#License along with this library; if not, write to the Free Software
+#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+
 require 'stringio'
+require 'riff/util.rb'
 
 module Riff
   
   # A Builder allows you to create a 'de novo' RIFF file recursively, similar
-  # in style to the XML Builder class.
+  # in style to the XML Builder class.  The client uses +Builder.create+
+  # to create an empty file at a given filesystem location, and yields a block,
+  # allowing the client to construct chunks and LISTs semantically with Ruby
+  # blocks.
+  #
+  # In the following example, a new .wav file is created containing 1 second 
+  # of 1 K tone and descriptive metadata.
+  #
+  ##    require 'lib/riff/reader.rb'
+  ##    require 'lib/riff/writer.rb'
+  ##
+  ##    include Riff
+  ##    SAMPLES_PER_SECOND = 48000
+  ##    FREQ = 1000
+  ##    AMPLITUDE = 0x0fff
+  ##
+  ##    Builder.create(ARGV[0],"WAVE") do |w|
+  ##      w.list("INFO") { |info|
+  ##        info.chunk("ICOP") {|c|  # "copyright"
+  ##          c << "(c) 2007 Joe User.
+  ##        }
+  ##        info.chunk("INAM") {|c|  # "name" or "title"
+  ##          c << "1K tone with metadata"
+  ##        }
+  ##        info.chunk("ISFT") {|c|  # "software"
+  ##          c << "libRiff v" + "%i.%i" % [Riff::VERSION::MAJOR, Riff::VERSION::MINOR] 
+  ##        }
+  ##        info.chunk("IART") {|c|  # "artist" (maps to kMDItemAuthors in Spotlight)
+  ##          c << "Joe User"
+  ##        }
+  ##      }
+  ##      w.chunk("fmt ") { |c|
+  ##        c.putc(1);c.putc(0) #format 1, PCM
+  ##        c.putc(1);c.putc(0) #1 channel
+  ##    
+  ##        # samples per second
+  ##        Builder.int_to_four_little_endian_bytes(SAMPLES_PER_SECOND).each {|byte| c.putc(byte)}
+  ##    
+  ##        # avg. bytes per second
+  ##        Builder.int_to_four_little_endian_bytes(SAMPLES_PER_SECOND * 2).each {|byte| c.putc(byte)}
+  ##        c.putc(2);c.putc(0) #block alignment 2
+  ##        c.putc(16);c.putc(0) #16 bits per sample
+  ##      }
+  ##      w.chunk("data") { |c|
+  ##        factor = Math::PI / (SAMPLES_PER_SECOND / (FREQ * 2))
+  ##        1.upto(SAMPLES_PER_SECOND) do |i|
+  ##          val = ( Math::sin(  i * factor ) * AMPLITUDE ).floor
+  ##          Builder::int_to_four_little_endian_bytes(val)[0,2].each {|byte| c.putc(byte)}
+  ##        end
+  ##      }
+  ##    end
+  
   class Builder
     
     class IOProxy #:nodoc:
@@ -36,8 +107,12 @@ module Riff
     end #class IOProxy
 
     class << self
-      # Create a new RIFF file at +path+, using +type+ for the top-level chunk's type or signature.
-      def create(path,type) #:yields: riff_file
+      # Create a new RIFF file at +path+, using +type+ for the top-level 
+      # chunk's type or signature.
+      #
+      # At this time, you must provide a block to this method to add chunks.
+      def create(path,type) #:yields: builder
+        raise RuntimeError unless block_given?
         file = File.open(path,"w")
         w = Builder.new(file)
         w.container('RIFF',type) do |body_io|
@@ -46,16 +121,6 @@ module Riff
         file.close
       end
     
-      def int_to_four_little_endian_bytes(i) #:nodoc:
-        n =i # [ i.abs , 2^32 ].min
-        [(n.to_i & 0xff) , (n.to_i & 0xff00)>>8, 
-          (n.to_i & 0xff0000)>>16,(n.to_i & 0xff000000)>>24 ]
-      end
-
-      def sanitize_fourcc(fourcc) #:nodoc:
-        fourcc[0,4].ljust(4,"\0")
-      end
-    
     end #class << self
     
     # Add a data chunk to the Builder.  The method yields a write-only pseudo-IO
@@ -63,14 +128,14 @@ module Riff
     # here; the fourcc and size will be written for you.  Do not pad the data you write to
     # an even boundary, either.
     def chunk(fourcc) #:yields: stream
-      @io.write(self.class.sanitize_fourcc(fourcc))
-      4.times {@io.putc(0)}
+      @io.write( Util::sanitize_fourcc(fourcc) )
+      4.times { @io.putc(0) }
       oldPos = @io.pos
       yield IOProxy.new(@io)
       length = @io.pos - oldPos
       @io.putc(0) if (length % 2) == 1
       @io.seek(oldPos-4,IO::SEEK_SET)
-      bytes = self.class.int_to_four_little_endian_bytes(length)
+      bytes = Util::int_to_four_little_endian_bytes(length)
       bytes.each {|byte| @io.putc(byte)}
       @io.seek(0,IO::SEEK_END)
     end
@@ -88,8 +153,8 @@ module Riff
     end
     
     def container(fourcc,type) # :nodoc:
-      chunk(self.class.sanitize_fourcc(fourcc)) do |io|
-        io.write(self.class.sanitize_fourcc(type))
+      chunk(Util::sanitize_fourcc(fourcc)) do |io|
+        io.write(Util::sanitize_fourcc(type))
         yield io
       end
     end

data/test/builder_test.rb

@@ -0,0 +1,67 @@
+require 'test/unit'
+
+require 'riff/writer'
+
+class RiffBuilder_Test < Test::Unit::TestCase
+  
+  def setup
+    Riff::Builder.create("testfile.wav","WAVE") do |w|
+      w.list("INFO") { |info|
+        info.chunk("ICOP") {|c|  # "copyright"
+          c << "00000000."
+        }
+      }
+      w.chunk("JUNK") { |c|
+        c << "00000000"
+      }
+    end
+    
+  end
+  
+  def teardown
+    %x{rm testfile.wav}
+  end
+  
+  def test_file_made
+    assert(File.exist?("testfile.wav"))
+  end
+  
+  def test_length
+    assert_equal(58, File.stat("testfile.wav").size)
+  end
+  
+  def test_file_fourcc
+    sig = IO.read("testfile.wav",4,0)
+    assert_equal("RIFF",sig)
+  end
+
+  def test_riff_chunk_size
+    File.open("testfile.wav",'r') do |f|
+      f.read(4);
+      assert_equal(50, Riff::Util::read_bytes_to_int(f,4) )  
+    end
+  end
+  
+  def test_icop_chunk
+    File.open("testfile.wav",'r') do |f|
+      f.read(24);
+      assert_equal('ICOP',f.read(4))
+      assert_equal(9, Riff::Util::read_bytes_to_int(f,4) )  
+    end
+  end
+
+  def test_info_chunk
+    File.open("testfile.wav",'r') do |f|
+      f.read(12);
+      assert_equal('LIST',f.read(4))
+      assert_equal(22, Riff::Util::read_bytes_to_int(f,4) )  
+      assert_equal('INFO',f.read(4))
+    end
+  end
+
+  def test_file_sig
+    sig = IO.read("testfile.wav",4,8)
+    assert_equal("WAVE",sig)
+  end
+
+end #class

data/test/riff_test.rb

@@ -18,7 +18,8 @@
 #++
 
 require 'test/unit'
-require 'lib/riff/base'
+
+require 'riff/reader'
 
 class Riff_Test < Test::Unit::TestCase
 
@@ -37,7 +38,7 @@ class Riff_Test < Test::Unit::TestCase
 	def test_open_close
 	
 		@test_media.each do |file|
-			@riff_obj_array << Riff::Base.open(@test_media_basepath + file ,"r")
+			@riff_obj_array << Riff::Reader.open(@test_media_basepath + file ,"r")
 		end
 		
 		@riff_obj_array.each do |r|
@@ -46,23 +47,30 @@ class Riff_Test < Test::Unit::TestCase
 		end
 	end
 	
+	def test_file_accessor
+	  @test_media.each do |file|
+			r = Riff::Reader.open(@test_media_basepath + file , "r")
+			assert(r.file,"file accessor failed")
+		end
+  end
+	
 	def test_root
 		
 		@test_media.each do |file|
-			Riff::Base.open(@test_media_basepath + file,"r") do |riff|
+			Riff::Reader.open(@test_media_basepath + file,"r") do |riff|
 				root_chunk = riff.root_chunk
 				
 				assert_equal root_chunk.fourcc , "RIFF"
 				assert_equal root_chunk.signature , "WAVE"
-				assert_instance_of Riff::Base::ListChunk , root_chunk
+				assert_instance_of Riff::Reader::ListChunk , root_chunk
 			end
 		end
 	end
 	
 	def test_hashing
-		Riff::Base.open(@test_media_basepath + @enumerable_file,"r") do |riff|
-			assert_instance_of Riff::Base::Chunk , riff.root_chunk['bext']
-			assert_instance_of Riff::Base::Chunk , riff.root_chunk['fmt ']
+		Riff::Reader.open(@test_media_basepath + @enumerable_file,"r") do |riff|
+			assert_instance_of Riff::Reader::Chunk , riff.root_chunk['bext']
+			assert_instance_of Riff::Reader::Chunk , riff.root_chunk['fmt ']
 			assert_equal riff.root_chunk[0].fourcc , 'bext'
 			assert_equal riff.root_chunk[0..1].collect {|c|c.fourcc} , ['bext','fmt ']
 		end
@@ -74,13 +82,13 @@ class Riff_Test < Test::Unit::TestCase
   end
 	
 	def test_simple_read
-		Riff::Base.open(@test_media_basepath + @enumerable_file,"r") do |riff|
+		Riff::Reader.open(@test_media_basepath + @enumerable_file,"r") do |riff|
 			assert_equal riff.root_chunk.length , 8272
 		end
 	end
 	
 	def test_each_byte
-	  Riff::Base.open(@test_media_basepath + @enumerable_file,"r") do |riff|
+	  Riff::Reader.open(@test_media_basepath + @enumerable_file,"r") do |riff|
 	    riff.root_chunk['fmt '].each_byte do |b|
 	      assert b >= 0 and b <= 255
       end
@@ -88,14 +96,14 @@ class Riff_Test < Test::Unit::TestCase
   end
 	
 	def test_is_list
-		Riff::Base.open(@test_media_basepath + @enumerable_file, 'r') do |r|
+		Riff::Reader.open(@test_media_basepath + @enumerable_file, 'r') do |r|
 			assert r.root_chunk.is_list?
 			assert_equal r.root_chunk['bext'].is_list? , false
 		end
 	end
 	
 	def test_riff_enumerable
-		Riff::Base.open(@test_media_basepath + @enumerable_file, 'r') do |r|
+		Riff::Reader.open(@test_media_basepath + @enumerable_file, 'r') do |r|
 		
 			count = 0
 			r.root_chunk.each_with_index do |chunk, i|

data/test/riff_test_suite.rb

@@ -1,4 +1,7 @@
+$: << "./lib/"
+
 require 'test/unit'
 
+require 'test/builder_test.rb'
 require 'test/riff_test.rb'
 require 'test/wav_test.rb'

data/test/wav_test.rb

@@ -18,27 +18,27 @@
 #Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 #++
 
-$: << 'lib/'
-
-require 'test/unit'
-require 'lib/riff/wav.rb'
-
-class Wav_Test < Test::Unit::TestCase
-
-  def setup
-    @test_wav = "Pop.wav"
-    @test_path = "test_media/"
-    @bad_wav = "bad.riff"
-  end
-  
-  def teardown   
-    
-  end
-  
-  def test_validation
-
-
-  end
-
-
-end
+#$: << 'lib/'
+#
+#require 'test/unit'
+#require 'lib/riff/wav.rb'
+#
+#class Wav_Test < Test::Unit::TestCase
+#
+#  def setup
+#    @test_wav = "Pop.wav"
+#    @test_path = "test_media/"
+#    @bad_wav = "bad.riff"
+#  end
+#  
+#  def teardown   
+#    
+#  end
+#  
+#  def test_validation
+#
+#
+#  end
+#
+#
+#end

metadata

@@ -1,38 +1,33 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.1
-specification_version: 1
 name: riff
 version: !ruby/object:Gem::Version 
-  version: "0.3"
-date: 2007-12-27 00:00:00 -08:00
-summary: Library for reading and writing RIFF (Resource Interchange File Format) files. RIFF is a meta-format which is a common wrapper for multimedia files, such as .wav and .avi files.  Classes for reading and writing generic RIFF files are provided, as well as convenient INFO tag editing.
-require_paths: 
-- lib
-email: 
-homepage: http://riff.rubyforge.org
-rubyforge_project: riff
-description: 
+  version: 0.3.1
+platform: ruby
+authors: 
+- Jamie Hardt
 autorequire: 
-default_executable: 
 bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: 1.8.2
-  version: 
-platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
-authors: []
+cert_chain: []
+
+date: 2009-11-22 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: jhardt@soundepartment.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
 
 files: 
 - lib/riff/info.rb
 - lib/riff/reader.rb
+- lib/riff/util.rb
 - lib/riff/writer.rb
 - Rakefile
+- test/builder_test.rb
 - test/riff_test.rb
 - test/riff_test_suite.rb
 - test/wav_test.rb
@@ -41,17 +36,33 @@ files:
 - examples/maketone.rb
 - examples/metariff.rb
 - examples/readchunks.rb
-test_files: 
-- test/riff_test_suite.rb
-rdoc_options: []
-
-extra_rdoc_files: []
-
-executables: []
+has_rdoc: true
+homepage: http://riff.rubyforge.org
+licenses: []
 
-extensions: []
+post_install_message: 
+rdoc_options: []
 
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.2
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
-
+rubyforge_project: riff
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Library for reading and writing RIFF (Resource Interchange File Format) files. RIFF is a meta-format which is a common wrapper for multimedia files, such as .wav and .avi files.  Classes for reading and writing generic RIFF files are provided, as well as convenient INFO tag editing.
+test_files: 
+- test/riff_test_suite.rb