riff 0.2 → 0.3

data/examples/maketone.rb

@@ -3,52 +3,106 @@
 # simple PCM WAVE file of a 1K tone and encodes some
 # metadata into it.
 
-require 'lib/riff/base.rb'
+require 'lib/riff/reader.rb'
 require 'lib/riff/writer.rb'
 
-
 include Riff
 
+class Bext
+  
+  attr_accessor :description, 
+  :originator, 
+  :originator_reference,
+  :origination_time,
+  :time_reference,
+  :coding_history
+  
+  class << self
+    def sanitize_for_length(field,length)
+      field.to_s[0,length].ljust(length,"\0")
+    end
+    
+    def ethernet_addy
+      md = `/sbin/ifconfig | grep ether`.match(/([a-f0-9]{2})\:([a-f0-9]{2})\:([a-f0-9]{2})\:([a-f0-9]{2})\:([a-f0-9]{2})\:([a-f0-9]{2})/)
+      md[1,6].join.ljust(12,"0")
+    end
+    
+  end
+  
+  def initialize
+    @description = ""
+    @originator = ""
+    @originator_reference = "jamie" + Bext.ethernet_addy + Time.now.strftime("%H%M%S") +
+    (([0] * 10).map {|e| rand(10)}).join
+    @origination_time = Time.now
+    @time_reference = 0
+    @coding_history = ""
+    @smpte_umid = ""
+  end
+  
+  def out
+    time_ref_bytes = Builder::int_to_four_little_endian_bytes(@time_reference).map {|b| b.chr}
+    Bext.sanitize_for_length(@description,256) +
+    Bext.sanitize_for_length(@originator,32) +
+    Bext.sanitize_for_length(@originator_reference,32) +
+    @origination_time.strftime("%Y-%m-%d%H:%M:%S") +
+    "\0\0\0\0\0\0\0\0" + "\001\000\000\000" + 
+    Bext.sanitize_for_length(@smpte_umid,64) +
+    ("\000" * 190)# + @coding_history
+  end
+  
+end
+
 SAMPLES_PER_SECOND = 48000
 FREQ = 1000
 AMPLITUDE = 0x0fff
 FILE_TO_MAKE = "test.wav"
 
+DESCRIPTION = "This file is a 1K tone generated programatically with Ruby libRiff"
+AUTHOR = "Jamie Hardt"
+
 Builder.create(FILE_TO_MAKE,"WAVE") do |w|
   w.list("INFO") { |info|
-    info.chunk("ICOP") { |c| #"copyright"
+    info.chunk("ICOP") {|c|  # "copyright"
       c << "(c) 2007 Jamie Hardt. All Rights Reserved."
     }
-    info.chunk("ICMT") {|c| # "comment"
-      c << "This file is a 1K tone generated programatically with Ruby libRiff"
+    info.chunk("ICMT") {|c|  # "comment"
+      c << DESCRIPTION
     }
-    info.chunk("INAM") {|c| # "name" or "title"
-      c<< "1K tone with metadata"
+    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] 
+      c << "libRiff v" + "%i.%i" % [Riff::VERSION::MAJOR, Riff::VERSION::MINOR] 
     }
     info.chunk("IART") {|c|  # "artist" (maps to kMDItemAuthors in Spotlight)
-      c << "Jamie Hardt"
+      c << AUTHOR
     }
   }
+  w.chunk("bext") {|b|
+    bext = Bext.new
+    bext.description = DESCRIPTION
+    bext.originator  = AUTHOR
+    bext.coding_history = "Created by #{__FILE__}"
+    b << bext.out
+  }
   w.chunk("fmt ") { |c|
-    c.putc(1);c.putc(0); #format 1, PCM
+    c.putc(1);c.putc(0) #format 1, PCM
     c.putc(1);c.putc(0) #1 channel
     
     # samples per second
-    int_to_four_little_endian_bytes(SAMPLES_PER_SECOND).each {|byte| c.putc(byte)}
+    Builder.int_to_four_little_endian_bytes(SAMPLES_PER_SECOND).each {|byte| c.putc(byte)}
     
     # avg. bytes per second
-    int_to_four_little_endian_bytes(SAMPLES_PER_SECOND * 2).each {|byte| c.putc(byte)}
+    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|
-    denom = SAMPLES_PER_SECOND / (FREQ * 2)
-    0.upto(SAMPLES_PER_SECOND) do |i|
-      val = (Math::sin(Math::PI * i/denom) * AMPLITUDE).floor
-      int_to_four_little_endian_bytes(val)[0,2].each {|byte| c.putc(byte)}
+    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

data/examples/metariff.rb

@@ -0,0 +1,15 @@
+require 'lib/riff/info.rb'
+
+i = Riff::MetaEditor.new(ARGV[0])
+
+i.comment = "This is a test comment written by metariff"
+
+i.save!
+
+j = Riff::MetaEditor.new(ARGV[0])
+
+puts   "%-4s  %s" % ['4CC','Value']
+puts   "%-4s  %s" % ["-"*4,"-"*74]
+j.each_metadatum do |fourcc, value|
+  puts "%-4s  %s" % [fourcc, value[0,74]]
+end

data/examples/readchunks.rb

@@ -1,4 +1,4 @@
-require 'lib/riff/base.rb'
+require 'lib/riff/reader.rb'
 
 def print_chunk(ck,margin = "")
 	if ck.is_list? then
@@ -11,6 +11,6 @@ def print_chunk(ck,margin = "")
 	end
 end
 
-Riff::Base.open(ARGV[0],"r") do |wav|
+Riff::Reader.open(ARGV[0],"r") do |wav|
 	print_chunk( wav.root_chunk )
 end

data/lib/riff/info.rb

@@ -0,0 +1,162 @@
+require 'lib/riff/reader.rb'
+require 'lib/riff/writer.rb'
+
+module Riff
+  
+  # Th MetaEditor class provides a reader-writer for the INFO meta-chunk on RIFF 
+  # AVI and WAVE files.
+  #
+  # Aside from the stated methods, there is a convenience method for every attribute
+  # name listed in the <tt>MetaEditor.available_names</tt> array, thus, these lines are
+  # equivalent:
+  #
+  #   editor.author = "Me Myself"
+  #   editor.artist = "Me Myself"
+  #   editor['IART'] = "Me Myself"
+  #
+  # Note that some names map to the same fourcc.
+  class MetaEditor
+    
+    # the path to the file being edited
+    attr_reader :path
+    
+    # the number of bytes padding to add after the INFO
+    # chunk.  The default is 1024 bytes.
+    attr_accessor :pad_out 
+    
+    ATTRIBUTE_FOURCCs = [ 'IARL', 'IART','ICSM','ICMT', 'ICOP', 'ICRD',
+    'ICRP', 'IDIM', 'IDPI', 'IENG','IGNR', 'IKEY',
+    'ILGT', 'IMED', 'INAM', 'IPLT', 'IPRD', 'ISBJ',
+    'ISFT', 'ISHP', 'ISRC', 'ISRF', 'ITCH']
+    
+    ATTRIBUTE_NAMES = {
+     'Archival Location' =>  'IARL', 
+     'Artist'            =>  'IART',
+     'Author'            =>  'IART', 
+     'Comissioned'       =>  'ICSM', 
+     'Comment'           =>  'ICMT',
+     'Description'       =>  'ICMT', 
+     'Copyright'         =>  'ICOP', 
+     'Date Created'      =>  'ICRD', 
+     'Cropped'           =>  'ICRP', 
+     'Dimensions'        =>  'IDIM', 
+     'Dots Per Inch'     =>  'IDPI', 
+     'Engineer'          =>  'IENG', 
+     'Genre'             =>  'IGNR', 
+     'Keywords'          =>  'IKEY', 
+     'Lightness'         =>  'ILGT', 
+     'Medium'            =>  'IMED', 
+     'Title'             =>  'INAM',
+     'Name'              =>  'INAM', 
+     'Number of Colors'  =>  'IPLT', 
+     'Product'           =>  'IPRD', 
+     'Subject'           =>  'ISBJ', 
+     'Software'          =>  'ISFT', 
+     'Encoding Application' =>  'ISFT', 
+     'Sharpness'         =>  'ISHP', 
+     'Source'            =>  'ISRC', 
+     'Source Form'       =>  'ISRF', 
+     'Technician'        =>  'ITCH' 
+    }
+    
+    ATTRIBUTE_FOURCCs.each do |key|
+      class_eval <<-TXT
+      def #{key.downcase}=(val)
+        @metadata['#{key}'] = val
+      end
+      def #{key.downcase}
+        return @metadata['#{key}']
+      end
+      TXT
+    end
+    
+    ATTRIBUTE_NAMES.each_pair do |key,value|
+      class_eval <<-TXT
+      def #{key.downcase.gsub(/ /,'_').gsub(/[^a-z_]/,'')}=(val)
+        @metadata['#{value}'] = val
+      end
+      
+      def #{key.downcase.gsub(/ /,'_').gsub(/[^a-z_]/,'')}
+        return @metadata['#{value}']
+      end
+      TXT
+    end
+    
+    # Returns an array of English names for a fourcc tag
+    def MetaEditor.names_for_fourcc(fourcc)
+      return (ATTRIBUTE_NAMES.select {|k,v| v == fourcc}).map {|a| a[0]}
+    end
+    
+    # Returns an array of all the settable attributes for the file
+    def MetaEditor.available_names(fourcc)
+      return ATTRIBUTE_NAMES.keys
+    end
+    
+    # Gives the fourcc the class will map to a given English name
+    def MetaEditor.fourcc_for_name(name)
+      return ATTRIBUTE_NAMES[name]
+    end
+    
+    # Creates a MetaEditor object for the file locates at +path+
+    def initialize(path)
+      reader = Reader.open(path,'r')
+      @pad_out = 1024
+      @path = path
+      @metadata = {}
+      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
+    end
+    
+    def [](k)
+      return @metadata[k]
+    end
+    
+    def []=(k,v)
+      @metadata[k] = v
+    end
+    
+    def each_metadatum
+      @metadata.each_pair do |key,value|
+        yield key,value
+      end
+    end
+    
+    # Commit the changed metadata to the file.  Presently, the complete file
+    # is rewritten to a temp file and then is moved to the name of the target.
+    #
+    # If a pad_out number is specified, a "JUNK" chunk with a payload of pad_out
+    # bytes will be added after the INFO chunk.
+    def save!
+      tempPath = File.dirname(path) + "/" + (([?a] *8).map {|i| (i + rand(26)).chr}).join + ".tmp"
+      Reader.open(path,'r') do |reader|
+        begin
+          Builder.create(tempPath,reader.root_chunk.signature) do |riffwriter|
+            riffwriter.list('INFO') do |infochunk|
+              @metadata.each_pair do |key,value|
+                infochunk.chunk(key) { |io| io << value }
+              end
+            end
+            if @pad_out > 0
+              riffwriter.chunk("JUNK") do |jnk|
+                jnk << "\0" * @pad_out
+              end
+            end
+            reader.root_chunk.each do |ck|
+              unless ck.is_list? && ck.signature == 'INFO' then
+                riffwriter.chunk(ck.fourcc) {|io| io << ck.body}
+              end #unless
+            end
+          end
+        rescue Exception => e
+          File.unlink(tempPath) if FileTest.exist?(tempPath)
+          raise e
+        end
+      end
+      File.rename(tempPath,path)
+    end #save!
+  end #class
+end # moule Riff

data/lib/riff/{base.rb → reader.rb}

@@ -33,12 +33,12 @@
 # === Getting iXML metadata from a broadcast-WAV file
 # 
 #   require 'riff/base'
-#   Riff::Base.open(ARGV[0],"r") do |wav|
+#   Riff::Reader.open(ARGV[0],"r") do |wav|
 #     xml = wav.root_chunk['ixml'].body
 #   end
 #
 # === Listing all the chunks in a file
-#   require 'riff/base'
+#   require 'riff/reader'
 #	
 #   def print_chunk(ck,margin = "")
 #     if ck.is_list? then
@@ -52,7 +52,7 @@
 #     end
 #   end
 #  
-#   Riff::Base.open(ARGV[0],"r") do |wav|
+#   Riff::Reader.open(ARGV[0],"r") do |wav|
 #     print_chunk( wav.root_chunk )
 #   end
 #  
@@ -60,15 +60,15 @@ module Riff
   
   module VERSION
     MAJOR = 0
-    MINOR = 2
+    MINOR = 3
   end #module version
   
-  class Base
-    # The Riff class provides a front-end to the other objects of the library.
+  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 Riff object.
+    # Returns the File object for this reader.
     attr_reader :file
   
     # Opens a RIFF file for reading.  Pass a string path and string mode, as you would
@@ -79,8 +79,8 @@ module Riff
     #   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)
+    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
@@ -102,26 +102,19 @@ module Riff
 
     class FileTypeError < StandardError ; end #:nodoc:
 
-  protected
-
-    def valid?
-
-    end
-
   private
   
-    def initialize(path, mode)
+    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)
-      return nil unless valid?
     end #def initialize
   
   end
 
 
-  class Base
+  class Reader
   
     # 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
@@ -129,7 +122,6 @@ module Riff
     # 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
@@ -145,7 +137,7 @@ module Riff
       # 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
@@ -165,9 +157,10 @@ module Riff
       # 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
+        instance_of? Riff::Reader::ListChunk
       end
-  
+      
+      # Yields each byte of the data chunk.
       def each_byte
         while @file.pos < @offset + 8 + @length
           yield @file.getc  
@@ -234,14 +227,6 @@ module Riff
         end
       end
   
-      def body # :nodoc:
-        raise NoMethodError , "ListChunk#body is not permitted!"
-      end
-    
-      def each_byte
-        raise NoMethodError
-      end
-  
     protected
   
       def initialize(fp)

data/lib/riff/writer.rb

@@ -2,21 +2,11 @@ require 'stringio'
 
 module Riff
   
-  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)
-    fourcc[0,4].ljust(4,"\0")
-  end
-  
-  # A Builder allows you to create a 'de novo' RIFF file.  At this time
-  # we do not support modifying RIFF files, only creating new ones.
+  # A Builder allows you to create a 'de novo' RIFF file recursively, similar
+  # in style to the XML Builder class.
   class Builder
     
-    class IOProxy
+    class IOProxy #:nodoc:
       
       def initialize(i)
         @io = i
@@ -56,39 +46,50 @@ module Riff
         file.close
       end
     
-    end #class << self
+      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
     
-    attr_reader :io
+    end #class << self
     
+    # Add a data chunk to the Builder.  The method yields a write-only pseudo-IO
+    # object that you write the chunk data to.  Only write the payload of the chunk
+    # 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
-      $stderr.print("descending into chunk     #{fourcc}, starts at #{@io.pos}\n")
-      @io.write(sanitize_fourcc(fourcc))
+      @io.write(self.class.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 = int_to_four_little_endian_bytes(length)
-      $stderr.print("will write bytes size: #{bytes.inspect}\n")
+      bytes = self.class.int_to_four_little_endian_bytes(length)
       bytes.each {|byte| @io.putc(byte)}
       @io.seek(0,IO::SEEK_END)
-      $stderr.print("ascending from chunk      #{fourcc}, total written #{length}\n")
     end
     
-    def list(type)
+    # Add a RIFF "LIST" chunk.  The method yields a builder, which you can add
+    # chunks and other lists to.
+    def list(type) #:yields: builder
       container("LIST",type) do |io|
         yield Builder.new(io)
       end
     end
     
-    def initialize(stream)
+    def initialize(stream) # :nodoc:
       @io = stream
     end
     
-    def container(fourcc,type)
-      chunk(sanitize_fourcc(fourcc)) do |io|
-        io.write(sanitize_fourcc(type))
+    def container(fourcc,type) # :nodoc:
+      chunk(self.class.sanitize_fourcc(fourcc)) do |io|
+        io.write(self.class.sanitize_fourcc(type))
         yield io
       end
     end

metadata

@@ -3,9 +3,9 @@ rubygems_version: 0.9.1
 specification_version: 1
 name: riff
 version: !ruby/object:Gem::Version 
-  version: "0.2"
-date: 2007-12-24 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.
+  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: 
@@ -29,7 +29,8 @@ post_install_message:
 authors: []
 
 files: 
-- lib/riff/base.rb
+- lib/riff/info.rb
+- lib/riff/reader.rb
 - lib/riff/writer.rb
 - Rakefile
 - test/riff_test.rb
@@ -38,6 +39,7 @@ files:
 - test_media/bad.riff
 - test_media/Pop.wav
 - examples/maketone.rb
+- examples/metariff.rb
 - examples/readchunks.rb
 test_files: 
 - test/riff_test_suite.rb