riff 0.1

data/Rakefile

@@ -0,0 +1,9 @@
+task :default => [:test , :rdoc]
+
+task :test do
+	ruby "test/riff_test_suite.rb"
+end
+
+task :rdoc do
+	system "rdoc"
+end

data/examples/example1.rb

@@ -0,0 +1,16 @@
+require 'lib/riff/base.rb'
+
+def print_chunk(ck,margin = "")
+	if ck.is_list? then
+		puts margin + "+ '%s' (%s): %i bytes" % [ck.fourcc , ck.signature , ck.length ]
+		ck.each_with_index do |k,i|
+			print_chunk(k,margin + " " + " ")
+		end
+	else
+		puts margin + "- '%s' : %i bytes" % [ck.fourcc , ck.length ]
+	end
+end
+
+Riff::Base.open(ARGV[0],"r") do |wav|
+	print_chunk( wav.root_chunk )
+end

data/examples/example2.rb

@@ -0,0 +1,6 @@
+$: << "lib/"
+
+require 'riff/bwav.rb'
+
+Riff::WaveRiff.open(ARGV[0],"r").close
+puts "This file is a WAV file."

data/lib/riff/base.rb

@@ -0,0 +1,285 @@
+#--
+#riff.rb -- API for reading generic Microsoft RIFF Files
+#Copyright (C) 2006  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
+#++
+
+
+# This library allows for the reading of RIFF (Resource Interchange File Format)
+# files.  Opening a RIFF file with the Riff.open method allows the individual
+# chunks of the file to be accessed through the Riff#root_chunk method, and
+# this object mixes-in Enumerable in order to allow iteration over each chunk
+# and its sub-chunks (when applicable).
+#
+# Author:: 	Jamie Hardt
+# License:: The Lesser GPL
+#
+# ---
+#
+# = Examples
+# === Getting iXML metadata from a broadcast-WAV file
+# 
+#   require 'riff/base'
+#   Riff::Base.open(ARGV[0],"r") do |wav|
+#     xml = wav.root_chunk['ixml'].body
+#   end
+#
+# === Listing all the chunks in a file
+#   require 'riff/base'
+#	
+#   def print_chunk(ck,margin = "")
+#     if ck.is_list? then
+#       puts margin + "+ %s (%s): %i bytes" % \ 
+#           [ck.fourcc , ck.signature , ck.length ]
+#       ck.each_with_index do |k,i|
+#         print_chunk(k,margin + "  ")
+#       end
+#     else
+#       puts margin + "- %s : %i bytes" % [ck.fourcc , ck.length ]
+#     end
+#   end
+#  
+#   Riff::Base.open(ARGV[0],"r") do |wav|
+#     print_chunk( wav.root_chunk )
+#   end
+#  
+module Riff
+  
+  module VERSION
+    MAJOR = 0
+    MINOR = 1
+  end #module version
+  
+  class Base
+    # The Riff 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 Riff object.
+    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 self.open(path,mode) # :yields: riff_object
+      riff_obj = Riff::Base.new(path,mode)
+      if block_given? && riff_obj then
+        yield riff_obj
+        riff_obj.close
+      end
+      riff_obj
+    end
+
+    # Class method for called by subclasses to set-up validations.  If you
+    # write a subclass of the Riff object, say for reading AVIs, you can
+    # add validation code by calling this class method in your class like so:
+    #
+    #   class RiffAVI
+    #     
+    #     validate do |riff|
+    #        riff.root_chunk.signature == 'AVI '
+    #     end
+    #
+    #     ... class continues...
+    #   end
+    #
+    # You provide a block, which is yielded the Riff object at the time
+    # it is created, and ths block should return either +true+ or +false+.
+    # If it returns +true+, the Riff subclass instance will be created.  If 
+    # the block returns +false+, the .new class method will return nil.
+    #
+    # Subclass validation methods are called in the order of the subclasses
+    # inheiritance, so that if you wrote a broadcast-wav class that inheirited
+    # from a wave class that inheirited from Riff, Riff's validate()
+    # would be called first, and then the wave validate(), and the bwav's validate().
+    # Thus, a subclass can run its validations with the guarantee that the Riff
+    # in question passed its validations for its superclass.
+    def self.validate(&block)
+      raise ArgumentError unless block.arity == 1
+
+    end
+  
+    # Returns the Root Chunk of the RIFF file as a ListChunk
+    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
+
+    class FileTypeError < StandardError ; end #:nodoc:
+
+  protected
+
+    def valid?
+
+    end
+
+  private
+  
+    def initialize(path, mode)
+      raise(ArgumentError, "Riff.open only supports mode 'r' or 'rb'.") \
+       unless mode == "r" || mode == "rb" 
+  
+      @file = File.open(path,mode)
+      return nil unless valid?
+    end #def initialize
+  
+  end
+
+
+  class Base
+  
+    # The Chunk object represents a chunk of a larger RIFF file.  The chunk may be
+    # interrogated to reveal its fourcc and the size of its body.  The chunk also
+    # provides the +body+ method to access the stream of data within the chunk.
+    # Keep in mind that this bit of data can be very, very large in media files
+    # (like .wav files) and that reading them in a language like ruby will be quite
+    # slow.
+  
+    class Chunk
+  
+      # the four-character code of this chunk, always four characters long
+      # (shorter fourcc's are padded with spaces)
+      attr_reader :fourcc
+    
+      # the length of the body of the chunk (the length of the chunk minus
+      # the the fourcc and length bytes; thus the length of the chunk - 8)
+      # This data is read directly from the chunk's preamble and calling
+      # this is much, much faster than body.size
+      attr_reader :length
+    
+      # the offset of this chunk from the start of its file
+      attr_reader :offset
+    
+  
+      def self.read_chunk(fp) #:nodoc:
+        code = fp.read(4)  
+        fp.pos -= 4
+        if code == "RIFF" or code == "LIST" then
+          ListChunk.new(fp)
+        else
+          Chunk.new(fp)
+        end
+      end
+    
+      # Reads the entire body of the chunk (all of the data following the fourcc and size)
+      def body
+        @file.pos = @offset + 8
+        @file.read @length
+      end
+    
+      # Returns <tt>true</tt> if this object is a ListChunk.  A convenience to typing
+      # <tt>instance_of? Riff::ListChunk</tt>
+      def is_list?
+        instance_of? Riff::Base::ListChunk
+      end
+  
+      def each_byte
+        while @file.pos < @offset + 8 + @length
+          yield @file.getc
+          @file.pos +=1
+        end
+      end
+  
+    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)
+      end
+  
+    end #class Chunk
+
+    # 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
+    
+      include Enumerable
+    
+      # The four-character signature of the container chunk.  
+      # In the case of a RIFF WAV container, this is "WAVE"
+      attr_reader :signature
+    
+      # Accesses the chunks of the file by either a fourcc, an index, or a range.
+      # Be aware that ListChunks may contain many children chunk with the same
+      # fourcc, so using the index will always get you a paticular one, while
+      # using the fourcc will only get you the first of a class.
+      def [](chunk_spec) # :return: array or Chunk
+        if chunk_spec.instance_of? String then
+          detect {|chunk| chunk.fourcc == "%s" % [ chunk_spec ] }
+        elsif chunk_spec.instance_of? Fixnum or chunk_spec.instance_of? Range then
+          to_a[chunk_spec]
+        else
+          raise ArgumentError , "ListChunk#[] may only accept a String, Fixnum, or Range"
+        end
+      end
+  
+      # Yields each chunk in the order it appears in the file
+      def each # :yields: chunk
+        @file.pos = @offset + 12
+        while @file.eof? == false && @file.pos < @offset + 8 + @length
+          a_chunk = Chunk.read_chunk(@file)
+          yield a_chunk
+          @file.pos = a_chunk.offset + 8 + a_chunk.length + (a_chunk.length % 2 == 0 ? 0 : 1)
+        end
+      end
+  
+      def body # :nodoc:
+        raise NoMethodError , "ListChunk#body is not permitted!"
+      end
+    
+      def each_byte
+        raise NoMethodError
+      end
+  
+    protected
+  
+      def initialize(fp)
+        super(fp)
+        @signature = @file.read(4)  
+      end
+    
+    end #class ListChunk
+  end #class Riff
+
+end #module

data/lib/riff/bwav.rb

@@ -0,0 +1,8 @@
+require 'riff/wav'
+
+module Riff
+  class BroadcastWave < WaveRiff
+  
+
+  end
+end

data/lib/riff/wav.rb

@@ -0,0 +1,8 @@
+require 'riff/base'
+
+module Riff
+  class WaveRiff < Riff::Base
+  
+
+  end
+end

data/test/riff_test.rb

@@ -0,0 +1,130 @@
+#--
+#riff_test.rb -- Test suite for riff.rb -- API for reading generic Microsoft RIFF Files
+#Copyright (C) 2006  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 'test/unit'
+require 'lib/riff/base'
+
+class Riff_Test < Test::Unit::TestCase
+
+	def setup
+		@test_media_basepath = "test_media/"
+		@test_media = [ ]
+
+		@enumerable_file = "Pop.wav"
+    @malformed_file = "bad.riff"
+		@test_media << @enumerable_file
+		
+		@riff_obj_array = []
+		
+	end
+
+	def test_open_close
+	
+		@test_media.each do |file|
+			@riff_obj_array << Riff::Base.open(@test_media_basepath + file ,"r")
+		end
+		
+		@riff_obj_array.each do |r|
+			assert_instance_of File , r.file
+			r.close
+		end
+	end
+	
+	def test_root
+		
+		@test_media.each do |file|
+			Riff::Base.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
+			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 ']
+			assert_equal riff.root_chunk[0].fourcc , 'bext'
+			assert_equal riff.root_chunk[0..1].collect {|c|c.fourcc} , ['bext','fmt ']
+		end
+	end
+	
+	def test_riff_validation
+
+    
+  end
+	
+	def test_simple_read
+		Riff::Base.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.root_chunk['fmt '].each_byte do |b|
+	      assert b >= 0 and b <= 255
+      end
+    end
+  end
+	
+	def test_is_list
+		Riff::Base.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|
+		
+			count = 0
+			r.root_chunk.each_with_index do |chunk, i|
+				count +=1
+				case i
+					when 0; assert_equal chunk.fourcc , 'bext'
+					when 1; assert_equal chunk.fourcc , 'fmt '
+					when 2; assert_equal chunk.fourcc , 'minf'
+					when 3; assert_equal chunk.fourcc , 'elm1'
+					when 4; assert_equal chunk.fourcc , 'data'
+					when 5; assert_equal chunk.fourcc , 'regn'
+					when 6; assert_equal chunk.fourcc , 'ovwf'
+					when 7; assert_equal chunk.fourcc , 'umid'
+					when 8; assert(false,"Read too many chunks!")
+				end
+			end
+			assert_equal count , 8
+			
+			lengths = r.root_chunk.collect {|c| c.length }
+			
+			assert_equal lengths , [ 602 , 16 , 16 , 3410 , 4000 , 92 , 44 , 24]
+			
+			assert_equal r.root_chunk.inject(0) {|i , c| c.length + i} , 8204
+		end
+	end
+	
+
+	def teardown
+	
+	end
+
+end

data/test/riff_test_suite.rb

@@ -0,0 +1,4 @@
+require 'test/unit'
+
+require 'test/riff_test.rb'
+require 'test/wav_test.rb'

data/test/wav_test.rb

@@ -0,0 +1,44 @@
+#--
+#wav_test.rb -- Test suite for riff/wav
+# .rb -- API for reading generic Microsoft RIFF Files
+#Copyright (C) 2006  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
+#++
+
+$: << '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

data/test_media/bad.riff

@@ -0,0 +1 @@
+RIHS 82 eouorf 2u3hro 23

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: riff
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+date: 2006-06-03 00:00:00 -07:00
+summary: "Library for accessing chunks of 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."
+require_paths: 
+  - lib
+email: 
+homepage: http://riff.rubyforge.org
+rubyforge_project: riff
+description: 
+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: 
+authors: []
+files: 
+  - lib/riff/base.rb
+  - lib/riff/bwav.rb
+  - lib/riff/wav.rb
+  - Rakefile
+  - test/riff_test.rb
+  - test/riff_test_suite.rb
+  - test/wav_test.rb
+  - test_media/bad.riff
+  - test_media/Pop.wav
+  - examples/example1.rb
+  - examples/example2.rb
+test_files: 
+  - test/riff_test_suite.rb
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: []