ruby-ogginfo 0.5 → 0.6.5

data/History.txt

@@ -1,3 +1,11 @@
+=== 0.6.5 / 2011-04-07
+
+* internal reorganization, leading to more robust and faster library 
+
+=== 0.6 / 2011-03-01
+
+* pure ruby tag writing (thanks to Grant Gardner)
+
 === 0.5 / 2011-01-13
 
 * speex support (thanks to Grant Gardner)

data/Manifest.txt

@@ -2,6 +2,14 @@ History.txt
 Manifest.txt
 README.rdoc
 Rakefile
-setup.rb
+lib/ogg/codecs/comments.rb
+lib/ogg/codecs/speex.rb
+lib/ogg/codecs/vorbis.rb
+lib/ogg/page.rb
+lib/ogg/reader.rb
+lib/ogg/writer.rb
+lib/ogg.rb
 lib/ogginfo.rb
+setup.rb
 test/test_ruby-ogginfo.rb
+test/test_ruby-spxinfo.rb

data/Rakefile

@@ -4,19 +4,13 @@ require 'rubygems'
 require 'hoe'
 
 Hoe.plugin :yard
+Hoe.plugin :git
+Hoe.plugin :rcov
 
-require 'lib/ogginfo.rb'
-
-Hoe.new('ruby-ogginfo', OggInfo::VERSION) do |p|
-  p.rubyforge_name = 'ruby-ogginfo'
-  p.author = 'Guillaume Pierronnet'
-  p.email = 'moumar@rubyforge.org'
-  p.summary = 'ruby-ogginfo is a pure-ruby library that gives low level informations on ogg files'
-  p.description = p.paragraphs_of('README.rdoc', 3).first
-  p.url = p.paragraphs_of('README.rdoc', 1).first
-  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
-  p.remote_rdoc_dir = ''
-  p.rdoc_locations << "rubyforge.org:/var/www/gforge-projects/ruby-ogginfo/"
+Hoe.spec('ruby-ogginfo') do 
+  developer('Guillaume Pierronnet','moumar@rubyforge.org')
+  developer('Grant Gardner','grant@lastweekend.com.au')
+  summary = 'ruby-ogginfo is a pure-ruby library that gives low level informations on ogg files'
 end
 
 # vim: syntax=Ruby

data/lib/ogg/codecs/comments.rb

@@ -0,0 +1,50 @@
+require "stringio"
+
+module Ogg::Codecs
+  # See http://www.xiph.org/vorbis/doc/v-comment.html
+  # Methods to pack/unpack vorbis comment packets
+  # intended to be included into Codec classes
+  module VorbisComments
+    # unpack a packet, skipping the preamble
+    # returns a 2 element array being a Hash of tag/value pairs and the vendor string
+    def unpack_comments(packet, preamble="")
+      pio = StringIO.new(packet)
+      pio.read(preamble.length)
+      
+      vendor_length = pio.read(4).unpack("V").first
+      vendor = pio.read(vendor_length)
+      
+      tag = {}
+      tag_size = pio.read(4).unpack("V")[0]
+      
+      tag_size.times do |i|
+        size = pio.read(4).unpack("V")[0]
+        comment = pio.read(size)
+        key, val = comment.split(/=/, 2)
+        tag[key.downcase] = val
+      end
+      
+      #framing bit = pio.read(1).unpack("C")[0] 
+      [ tag, vendor ]
+    end
+    
+    # Pack tag Hash and vendor string into an ogg packet.
+    def pack_comments(tag, vendor, preamble="")
+      packet_data = ""
+      packet_data << preamble
+      
+      packet_data << [ vendor.length ].pack("V")
+      packet_data << vendor
+      
+      packet_data << [tag.size].pack("V")
+      tag.each do |k,v|
+        tag_data = "#{ k }=#{ v }"
+        packet_data << [ tag_data.length ].pack("V")
+        packet_data << tag_data
+      end
+      
+      packet_data << "\001"
+      packet_data
+    end
+  end
+end

data/lib/ogg/codecs/speex.rb

@@ -0,0 +1,40 @@
+module Ogg::Codecs
+  class Speex
+    class << self
+      include VorbisComments
+
+      def match?(packet)
+        /^Speex/ =~ packet
+      end
+      
+      def decode_headers(reader)
+        init_packet, tag_packet = reader.read_packets(2)
+        info = extract_info(init_packet)
+        info[:tag], info[:tag_vendor] = unpack_comments(tag_packet)
+        return info
+      end
+      
+      def replace_tags(reader, writer, new_tags, vendor)
+        tag_packet = reader.read_packets(1)
+        writer.write_packets(0, pack_comments(new_tags, vendor))
+      end
+      
+      def extract_info(info_packet)
+        speex_string,
+        speex_version,
+        speex_version_id,
+        header_size,
+        samplerate,
+        mode,
+        mode_bitstream_version,
+        channels,
+        nominal_bitrate,
+        framesize,
+        vbr = info_packet.unpack("A8A20VVVVVVVVV")
+        #not sure how to make sense of the bitrate info,picard doesn't show it either...
+        
+        return { :channels => channels, :samplerate => samplerate, :nominal_bitrate => nominal_bitrate }
+      end
+    end
+  end
+end

data/lib/ogg/codecs/vorbis.rb

@@ -0,0 +1,46 @@
+module Ogg::Codecs
+  class Vorbis
+    class << self
+      include VorbisComments
+      # return true/false based on whether the header packet belongs to us
+      def match?(header_packet)
+        /^\001vorbis.*/ =~ header_packet
+      end
+      
+      #consume header and tag pages, return array of two hashes, info and tags 
+      def decode_headers(reader)
+        init_pkt, tag_pkt, setup_pkt = reader.read_packets(3)
+        info = extract_info(init_pkt)
+        info[:tag], info[:tag_vendor] = unpack_comments(tag_pkt, "\003vorbis")
+        info
+      end
+      
+      # consume pages with old tags/setup packets and rewrite newtags,setup packets
+      # return the number of pages written
+      def replace_tags(reader, writer, new_tags, vendor)
+        tag_pkt, setup_pkt = reader.read_packets(2)
+        writer.write_packets(0, pack_comments(new_tags, vendor, "\003vorbis"), setup_pkt)
+      end
+      
+      def extract_info(packet)
+        vorbis_string,
+        vorbis_version,
+        channels,
+        samplerate,
+        upper_bitrate,
+        nominal_bitrate,
+        lower_bitrate = packet.unpack("a7VCV4")
+        
+        if nominal_bitrate == 0
+          if (upper_bitrate == 2**32 - 1) || (lower_bitrate == 2**32 - 1)
+            nominal_bitrate = 0
+          else
+            nominal_bitrate = ( upper_bitrate + lower_bitrate) / 2
+          end
+        end
+        
+        return { :channels => channels, :samplerate => samplerate, :nominal_bitrate => nominal_bitrate }
+      end
+    end
+  end
+end

data/lib/ogg/page.rb

@@ -0,0 +1,78 @@
+module Ogg
+  class Page
+    attr_accessor :granule_pos, :bitstream_serial_no, :sequence_no, :segments, :header
+    attr_reader :checksum
+    
+    # read an ogg frame from the +file+
+    # file must be positioned at end of frame after this loop
+    # options - :skip_body = seek to end of frame rather than reading in the data
+    def self.read(io, options = {})
+      return nil if io.eof?
+      
+      chunk = io.read(27)
+      
+      capture_pattern,
+      version,
+      header,
+      granule_pos,
+      bitstream_serial_no,
+      sequence_no,
+      @checksum,
+      segments = chunk.unpack("a4CCQVVVC") #a4CCQNNNC
+      
+      if capture_pattern != "OggS"
+        raise(StreamError, "bad magic number '#{ capture_pattern }'")
+      end
+      
+      page = Page.new(bitstream_serial_no, granule_pos)
+      page.header = header
+      page.sequence_no = sequence_no
+      raise(StreamError, "got EOF when reading page") if io.eof?
+      
+      segment_sizes = io.read(segments).unpack("C*")
+      if options[:skip_body]
+        body_size = segment_sizes.inject(0) { |sum, i| sum + i }
+        io.seek(body_size, IO::SEEK_CUR)
+      else
+        segment_sizes.each do |size| 
+          break if io.eof?
+          page.segments << io.read(size)
+        end
+        if options[:checksum] 
+          if @checksum != Ogg.compute_checksum(page.pack)
+            raise(StreamError, "bad checksum: expected #{ @checksum }, got #{ page.checksum }")
+          end
+        end
+      end
+      
+      page
+    end
+    
+    def initialize(bitstream_serial_no = 0, granule_pos = 0)
+      @bitstream_serial_no = bitstream_serial_no
+      @granule_pos = granule_pos
+      @segments = []
+      @header = 0
+    end
+    
+    def pack
+      packed =  [
+        "OggS",
+        0, #version
+        @header,
+        @granule_pos,
+        @bitstream_serial_no,
+        @sequence_no,
+        0, #checksum
+        @segments.length
+      ].pack("a4CCQVVVC")
+      
+      packed << @segments.collect { |segment| segment.length }.pack("C*")
+      packed << @segments.join
+      crc = Ogg.compute_checksum(packed)
+      packed[22..25] = [crc].pack("V")
+      packed
+    end
+   
+  end
+end

data/lib/ogg/reader.rb

@@ -0,0 +1,37 @@
+module Ogg
+  #Reads pages and packets from an ogg stream
+  class Reader
+    attr_reader :input
+
+    def initialize(input)
+      @input = input
+    end
+    
+    def each_pages(options = {})
+      until @input.eof?
+        yield Page.read(@input, options)
+      end
+    end
+    
+    def read_packets(max_packets)
+      result = []
+      partial_packet = ""
+      each_pages do |page|
+        partial_packet = page.segments.inject(partial_packet) do |packet,segment|
+          packet << segment
+          if segment.length < 255
+            #end of packet
+            result << packet
+            return result if result.length == max_packets
+            ""
+          else
+            packet
+          end
+        end
+      end
+      # We expect packets to reach page boundaries, consider raising exception if partial_packet here.
+      result
+    end
+  end
+  
+end

data/lib/ogg/writer.rb

@@ -0,0 +1,48 @@
+require 'stringio'
+
+module Ogg
+  # Writes pages or packets to an output io
+
+  class Writer
+    attr_reader :output
+
+    def initialize(bitstream_serial_no, output)
+      @output = output
+      @page_sequence = 0
+      @bitstream_serial_no = bitstream_serial_no
+    end
+    
+    # Writes a page to the output, the serial number and page sequence are
+    # are overwritten to be appropriate for this stream.
+    def write_page(page)
+      page.sequence_no = @page_sequence
+      @output << page.pack
+      @page_sequence += 1
+    end
+    
+    def write_packets(granule_pos, *packets)
+      written_pages_count = 1
+      page = Page.new(@bitstream_serial_no, granule_pos)
+      packets.each do |packet|
+        io = StringIO.new(packet)
+        
+        while !io.eof? do
+          page.segments << io.read(255)
+          if (page.segments.length == 255)
+            page.granule_pos = -1
+            write_page(page)
+            page = Page.new(@bitstream_serial_no, granule_pos)
+            written_pages_count += 1
+          end
+        end
+        #If our packet was an exact multiple of 255 we need to put in an empty closing segment
+        if (page.segments.length == 0 || page.segments.last.length == 255)
+          page.segments << ""
+        end
+      end
+      #we always need to flush the final page.
+      write_page(page)
+      written_pages_count
+    end
+  end
+end

data/lib/ogg.rb

@@ -0,0 +1,139 @@
+#Ogg framing
+# see http://www.xiph.org/ogg/vorbis/docs.html for documentation on vorbis format
+# http://www.xiph.org/vorbis/doc/framing.html
+
+%w{page reader writer codecs/comments codecs/vorbis codecs/speex}.each do |file|
+  require File.join(File.dirname(__FILE__), "ogg", file)
+end
+
+module Ogg
+  # Raised on any kind of Ogg parsing/writing error
+  class StreamError < StandardError; end
+  CHECKSUM_TABLE = [
+    0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9,
+    0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005,
+    0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61,
+    0x350c9b64,0x31cd86d3,0x3c8ea00a,0x384fbdbd,
+    0x4c11db70,0x48d0c6c7,0x4593e01e,0x4152fda9,
+    0x5f15adac,0x5bd4b01b,0x569796c2,0x52568b75,
+    0x6a1936c8,0x6ed82b7f,0x639b0da6,0x675a1011,
+    0x791d4014,0x7ddc5da3,0x709f7b7a,0x745e66cd,
+    0x9823b6e0,0x9ce2ab57,0x91a18d8e,0x95609039,
+    0x8b27c03c,0x8fe6dd8b,0x82a5fb52,0x8664e6e5,
+    0xbe2b5b58,0xbaea46ef,0xb7a96036,0xb3687d81,
+    0xad2f2d84,0xa9ee3033,0xa4ad16ea,0xa06c0b5d,
+    0xd4326d90,0xd0f37027,0xddb056fe,0xd9714b49,
+    0xc7361b4c,0xc3f706fb,0xceb42022,0xca753d95,
+    0xf23a8028,0xf6fb9d9f,0xfbb8bb46,0xff79a6f1,
+    0xe13ef6f4,0xe5ffeb43,0xe8bccd9a,0xec7dd02d,
+    0x34867077,0x30476dc0,0x3d044b19,0x39c556ae,
+    0x278206ab,0x23431b1c,0x2e003dc5,0x2ac12072,
+    0x128e9dcf,0x164f8078,0x1b0ca6a1,0x1fcdbb16,
+    0x018aeb13,0x054bf6a4,0x0808d07d,0x0cc9cdca,
+    0x7897ab07,0x7c56b6b0,0x71159069,0x75d48dde,
+    0x6b93dddb,0x6f52c06c,0x6211e6b5,0x66d0fb02,
+    0x5e9f46bf,0x5a5e5b08,0x571d7dd1,0x53dc6066,
+    0x4d9b3063,0x495a2dd4,0x44190b0d,0x40d816ba,
+    0xaca5c697,0xa864db20,0xa527fdf9,0xa1e6e04e,
+    0xbfa1b04b,0xbb60adfc,0xb6238b25,0xb2e29692,
+    0x8aad2b2f,0x8e6c3698,0x832f1041,0x87ee0df6,
+    0x99a95df3,0x9d684044,0x902b669d,0x94ea7b2a,
+    0xe0b41de7,0xe4750050,0xe9362689,0xedf73b3e,
+    0xf3b06b3b,0xf771768c,0xfa325055,0xfef34de2,
+    0xc6bcf05f,0xc27dede8,0xcf3ecb31,0xcbffd686,
+    0xd5b88683,0xd1799b34,0xdc3abded,0xd8fba05a,
+    0x690ce0ee,0x6dcdfd59,0x608edb80,0x644fc637,
+    0x7a089632,0x7ec98b85,0x738aad5c,0x774bb0eb,
+    0x4f040d56,0x4bc510e1,0x46863638,0x42472b8f,
+    0x5c007b8a,0x58c1663d,0x558240e4,0x51435d53,
+    0x251d3b9e,0x21dc2629,0x2c9f00f0,0x285e1d47,
+    0x36194d42,0x32d850f5,0x3f9b762c,0x3b5a6b9b,
+    0x0315d626,0x07d4cb91,0x0a97ed48,0x0e56f0ff,
+    0x1011a0fa,0x14d0bd4d,0x19939b94,0x1d528623,
+    0xf12f560e,0xf5ee4bb9,0xf8ad6d60,0xfc6c70d7,
+    0xe22b20d2,0xe6ea3d65,0xeba91bbc,0xef68060b,
+    0xd727bbb6,0xd3e6a601,0xdea580d8,0xda649d6f,
+    0xc423cd6a,0xc0e2d0dd,0xcda1f604,0xc960ebb3,
+    0xbd3e8d7e,0xb9ff90c9,0xb4bcb610,0xb07daba7,
+    0xae3afba2,0xaafbe615,0xa7b8c0cc,0xa379dd7b,
+    0x9b3660c6,0x9ff77d71,0x92b45ba8,0x9675461f,
+    0x8832161a,0x8cf30bad,0x81b02d74,0x857130c3,
+    0x5d8a9099,0x594b8d2e,0x5408abf7,0x50c9b640,
+    0x4e8ee645,0x4a4ffbf2,0x470cdd2b,0x43cdc09c,
+    0x7b827d21,0x7f436096,0x7200464f,0x76c15bf8,
+    0x68860bfd,0x6c47164a,0x61043093,0x65c52d24,
+    0x119b4be9,0x155a565e,0x18197087,0x1cd86d30,
+    0x029f3d35,0x065e2082,0x0b1d065b,0x0fdc1bec,
+    0x3793a651,0x3352bbe6,0x3e119d3f,0x3ad08088,
+    0x2497d08d,0x2056cd3a,0x2d15ebe3,0x29d4f654,
+    0xc5a92679,0xc1683bce,0xcc2b1d17,0xc8ea00a0,
+    0xd6ad50a5,0xd26c4d12,0xdf2f6bcb,0xdbee767c,
+    0xe3a1cbc1,0xe760d676,0xea23f0af,0xeee2ed18,
+    0xf0a5bd1d,0xf464a0aa,0xf9278673,0xfde69bc4,
+    0x89b8fd09,0x8d79e0be,0x803ac667,0x84fbdbd0,
+    0x9abc8bd5,0x9e7d9662,0x933eb0bb,0x97ffad0c,
+    0xafb010b1,0xab710d06,0xa6322bdf,0xa2f33668,
+    0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4
+  ]
+
+
+  class << self
+    def detect_codec(input)
+      if input.kind_of?(Page)
+        first_page = input
+      else
+        first_page = Page.read(input)
+        input.rewind
+      end
+      
+      codecs = Ogg::Codecs.constants.map { |module_name| Ogg::Codecs.class_eval(module_name) }.select { |c| c.is_a?(Class) }
+      codec = codecs.detect { |c| c.match?(first_page.segments.first) }
+      unless codec
+        raise(StreamError,"unknown codec")
+      end
+      
+      return codec
+    end
+
+    # Calculate the checksum from the page (or the pre packed data)
+    # If data it supplied it will be updated to record the checksum value 
+    def compute_checksum(data_)
+      data = data_.dup
+      data[22..25] = [0].pack("V")
+      crc = 0
+      
+      data.each_byte do |byte|
+        crc = (crc << 8)^CHECKSUM_TABLE[((crc >> 24)&0xff) ^ byte]
+        crc = crc & 0xffffffff
+      end
+      crc
+    end
+  end
+
+end
+
+if __FILE__ == $0
+  require 'pp'
+  infile = ARGV[0]
+  outfile = ARGV[1]
+  
+  vendor = ""
+  tags = { }
+  File.open(infile,"r") do |input|
+    info = Ogg.read_headers(input)
+    pp info
+    vendor = info[:tag_vendor]
+    tag = info[:tag]
+  end
+  
+  File.open(infile,"r") do | input |
+    File.open(outfile,"w") do | output |
+      Ogg.replace_tags(input,output,tags,vendor)
+    end
+  end
+  
+  File.open(outfile,"r") do | output |
+    pp Ogg.read_headers(output)
+  end
+  
+end

data/lib/ogginfo.rb

@@ -5,6 +5,9 @@
 # License: ruby
 
 require "iconv"
+require 'forwardable'
+require "tempfile"
+require File.join(File.dirname(__FILE__), 'ogg.rb')
 
 class Hash 
    ### lets you specify hash["key"] as hash.key
@@ -23,95 +26,59 @@ end
 class OggInfoError < StandardError ; end
 
 class OggInfo
-  VERSION = "0.5"
-  CHECKSUM_TABLE = [
-    0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9,
-    0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005,
-    0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61,
-    0x350c9b64,0x31cd86d3,0x3c8ea00a,0x384fbdbd,
-    0x4c11db70,0x48d0c6c7,0x4593e01e,0x4152fda9,
-    0x5f15adac,0x5bd4b01b,0x569796c2,0x52568b75,
-    0x6a1936c8,0x6ed82b7f,0x639b0da6,0x675a1011,
-    0x791d4014,0x7ddc5da3,0x709f7b7a,0x745e66cd,
-    0x9823b6e0,0x9ce2ab57,0x91a18d8e,0x95609039,
-    0x8b27c03c,0x8fe6dd8b,0x82a5fb52,0x8664e6e5,
-    0xbe2b5b58,0xbaea46ef,0xb7a96036,0xb3687d81,
-    0xad2f2d84,0xa9ee3033,0xa4ad16ea,0xa06c0b5d,
-    0xd4326d90,0xd0f37027,0xddb056fe,0xd9714b49,
-    0xc7361b4c,0xc3f706fb,0xceb42022,0xca753d95,
-    0xf23a8028,0xf6fb9d9f,0xfbb8bb46,0xff79a6f1,
-    0xe13ef6f4,0xe5ffeb43,0xe8bccd9a,0xec7dd02d,
-    0x34867077,0x30476dc0,0x3d044b19,0x39c556ae,
-    0x278206ab,0x23431b1c,0x2e003dc5,0x2ac12072,
-    0x128e9dcf,0x164f8078,0x1b0ca6a1,0x1fcdbb16,
-    0x018aeb13,0x054bf6a4,0x0808d07d,0x0cc9cdca,
-    0x7897ab07,0x7c56b6b0,0x71159069,0x75d48dde,
-    0x6b93dddb,0x6f52c06c,0x6211e6b5,0x66d0fb02,
-    0x5e9f46bf,0x5a5e5b08,0x571d7dd1,0x53dc6066,
-    0x4d9b3063,0x495a2dd4,0x44190b0d,0x40d816ba,
-    0xaca5c697,0xa864db20,0xa527fdf9,0xa1e6e04e,
-    0xbfa1b04b,0xbb60adfc,0xb6238b25,0xb2e29692,
-    0x8aad2b2f,0x8e6c3698,0x832f1041,0x87ee0df6,
-    0x99a95df3,0x9d684044,0x902b669d,0x94ea7b2a,
-    0xe0b41de7,0xe4750050,0xe9362689,0xedf73b3e,
-    0xf3b06b3b,0xf771768c,0xfa325055,0xfef34de2,
-    0xc6bcf05f,0xc27dede8,0xcf3ecb31,0xcbffd686,
-    0xd5b88683,0xd1799b34,0xdc3abded,0xd8fba05a,
-    0x690ce0ee,0x6dcdfd59,0x608edb80,0x644fc637,
-    0x7a089632,0x7ec98b85,0x738aad5c,0x774bb0eb,
-    0x4f040d56,0x4bc510e1,0x46863638,0x42472b8f,
-    0x5c007b8a,0x58c1663d,0x558240e4,0x51435d53,
-    0x251d3b9e,0x21dc2629,0x2c9f00f0,0x285e1d47,
-    0x36194d42,0x32d850f5,0x3f9b762c,0x3b5a6b9b,
-    0x0315d626,0x07d4cb91,0x0a97ed48,0x0e56f0ff,
-    0x1011a0fa,0x14d0bd4d,0x19939b94,0x1d528623,
-    0xf12f560e,0xf5ee4bb9,0xf8ad6d60,0xfc6c70d7,
-    0xe22b20d2,0xe6ea3d65,0xeba91bbc,0xef68060b,
-    0xd727bbb6,0xd3e6a601,0xdea580d8,0xda649d6f,
-    0xc423cd6a,0xc0e2d0dd,0xcda1f604,0xc960ebb3,
-    0xbd3e8d7e,0xb9ff90c9,0xb4bcb610,0xb07daba7,
-    0xae3afba2,0xaafbe615,0xa7b8c0cc,0xa379dd7b,
-    0x9b3660c6,0x9ff77d71,0x92b45ba8,0x9675461f,
-    0x8832161a,0x8cf30bad,0x81b02d74,0x857130c3,
-    0x5d8a9099,0x594b8d2e,0x5408abf7,0x50c9b640,
-    0x4e8ee645,0x4a4ffbf2,0x470cdd2b,0x43cdc09c,
-    0x7b827d21,0x7f436096,0x7200464f,0x76c15bf8,
-    0x68860bfd,0x6c47164a,0x61043093,0x65c52d24,
-    0x119b4be9,0x155a565e,0x18197087,0x1cd86d30,
-    0x029f3d35,0x065e2082,0x0b1d065b,0x0fdc1bec,
-    0x3793a651,0x3352bbe6,0x3e119d3f,0x3ad08088,
-    0x2497d08d,0x2056cd3a,0x2d15ebe3,0x29d4f654,
-    0xc5a92679,0xc1683bce,0xcc2b1d17,0xc8ea00a0,
-    0xd6ad50a5,0xd26c4d12,0xdf2f6bcb,0xdbee767c,
-    0xe3a1cbc1,0xe760d676,0xea23f0af,0xeee2ed18,
-    0xf0a5bd1d,0xf464a0aa,0xf9278673,0xfde69bc4,
-    0x89b8fd09,0x8d79e0be,0x803ac667,0x84fbdbd0,
-    0x9abc8bd5,0x9e7d9662,0x933eb0bb,0x97ffad0c,
-    0xafb010b1,0xab710d06,0xa6322bdf,0xa2f33668,
-    0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4 
-  ]
-
-  attr_reader :channels, :samplerate, :bitrate, :nominal_bitrate, :length
+  VERSION = "0.6.5"
+  extend Forwardable
+  include Ogg
+  
+  attr_reader :channels, :samplerate, :nominal_bitrate
   
   # +tag+ is a hash containing the vorbis tag like "Artist", "Title", and the like
   attr_reader :tag
-
-  # create new instance of OggInfo, using +charset+ to convert tags to
+  		
+  # create new instance of OggInfo, using +charset+ to convert tags
   def initialize(filename, charset = "utf-8")
     @filename = filename
     @charset = charset
-    @file = File.new(@filename, "rb")
+    @length = nil
+    @bitrate = nil
+    filesize = File.size(@filename)
+    File.open(@filename) do |file|
+      begin
+     	info = read_headers(file)
+        @samplerate = info[:samplerate]
+        @nominal_bitrate = info[:nominal_bitrate]
+        @channels = info[:channels]
+        @tag = info[:tag]
+        # filesize is used to calculate bitrate
+        # but we don't want to include the headers
+        @filesize = file.stat.size - file.pos
+      rescue Ogg::StreamError => se
+        raise(OggInfoError, se.message, se.backtrace)
+      end
+    end
 
-    frames = (1..2).collect { |i| OggInfo.read_frame(@file) }
-    extract_bitstream_infos(frames[0])
-    extract_tag(frames[1])
     convert_tag_charset("utf-8", @charset)
     @original_tag = @tag.dup
-    @length = get_length
-    @bitrate = @file.stat.size.to_f*8/@length
-    @file.close
   end
 
+  # The length in seconds of the track
+  # since this requires reading the whole file we only get it
+  # if called
+  def length
+    unless @length
+      File.open(@filename) do |file|
+        @length = compute_length(file)
+      end
+    end
+    return @length 
+  end
+  
+  # Calculated bit rate, also lazily loaded
+  # since we depend on the length
+  def bitrate
+    @bitrate ||= (@filesize * 8).to_f / length()
+  end
+  
   # "block version" of ::new()
   def self.open(*args)
     m = self.new(*args)
@@ -130,148 +97,87 @@ class OggInfo
 
   # commits any tags to file
   def close
-    if @bitstream_format == "vorbis" && @tag != @original_tag
-      cmd = %w{vorbiscomment -w} 
+    if tag != @original_tag
       convert_tag_charset(@charset, "utf-8")
-
-      @tag.each do |k,v|
-        cmd.concat(["-t", k.upcase+"="+v])
+      
+      tempfile = Tempfile.new("ruby-ogginfo")
+      begin
+        File.open(@filename, "rb") do | input |
+          replace_tags(input, tempfile, tag)
+        end
+        tempfile.close
+        FileUtils.cp(tempfile.path, @filename)
+      ensure
+        tempfile.close!
       end
-      cmd << @filename
-      system(*cmd)
     end
   end
 
   # check the presence of a tag
   def hastag?
-    !@tag.empty?
+    !tag.empty?
   end
   
   def to_s
-    "channels #{@channels} samplerate #{@samplerate} bitrate #{@nominal_bitrate} bitrate #{@bitrate} length #{@length} #{@tag.inspect}"
-  end
-
-  # read an ogg frame from the +file+
-  def self.read_frame(file)
-    frame = {}
-
-    frame[:file_position] = file.pos
-
-    return nil if file.eof?
-    chunk = file.read(27)
-    raise OggInfoError if file.eof?
-
-    capture_pattern,
-    frame[:version],
-    frame[:header_type], 
-    frame[:granule_pos], 
-    frame[:bitstream_serial_number], 
-    frame[:page_sequence_number],
-    frame[:checksum],
-    frame[:page_segments] = chunk.unpack("a4CCQNNNC")
-
-    if capture_pattern != "OggS"
-      raise(OggInfoError, "bad magic number '#{capture_pattern}'")
-    end
-    
-    segment_sizes = file.read(frame[:page_segments]).unpack("C*")
-    frame[:body_size] = segment_sizes.inject(0) { |sum, i| sum += i }
-    frame[:header_size] = 27 + frame[:page_segments]
-    frame[:size] = frame[:header_size] + frame[:body_size]
-    file.seek(frame[:body_size], IO::SEEK_CUR)
-    frame
-  end
-
-  # compute the checksum of a given +frame+ from a given +file+, you can compare it with frame[:checksum].
-  def self.checksum(file, frame)
-    original_pos = file.pos
-    file.seek(frame[:file_position])
-    data = file.read(frame[:size])
-    data[22] = data[23] = data[24] = data[25] = 0
-
-    crc = 0
-    data.each_byte do |byte|
-      crc = (crc << 8)^CHECKSUM_TABLE[((crc >> 24)&0xff) ^ byte]
-      crc = crc & 0xffffffff
-    end
-
-    # "reverse" it
-    crc = [crc].pack("V").unpack("N").first
-    file.seek(original_pos)
-    crc
+    "channels #{channels} samplerate #{samplerate} bitrate #{nominal_bitrate} #{tag.inspect}"
   end
 
 private
-  def extract_bitstream_infos(frame)
-     @file.seek(frame[:file_position] + frame[:header_size] + 1)
-     @bitstream_format = @file.read(6).rstrip()
-     case @bitstream_format
-	when "vorbis" : extract_vorbis_infos(frame)
-        when "peex"  :
-             #Speex does not align itself to a 4 byte boundary.
-             @bitstream_format="Speex" 
-             extract_speex_infos(frame)
-        else raise(OggInfoError,"Unknown bitstream format #{@bitstream_format}") 
-     end
-  end
 
-  def extract_speex_infos(frame)
-    @file.seek(frame[:file_position] + frame[:header_size] ) 
-    speex_string,speex_version,speex_version_id,header_size,@samplerate,mode,mode_bitstream_version,
-         @channels,bitrate,framesize,vbr = @file.read(28+ 9 * 4).unpack("A8A20VVVVVVVVV")
-    #not sure how to make sense of the bitrate info,picard doesn't show it either...
+  def read_headers(input)
+    reader = Reader.new(input)
+    codec = Ogg.detect_codec(input)
+    codec.decode_headers(reader)
   end
-
-  def extract_vorbis_infos(frame)
-    @file.seek(frame[:file_position] + frame[:header_size] + 1 ) 
-    
-    vorbis_string, vorbis_version, @channels, @samplerate, upper_bitrate, @nominal_bitrate, lower_bitrate = @file.read(27).unpack("a6VCV4")
-    if @nominal_bitrate == 0
-      if upper_bitrate == 2**32 - 1 or lower_bitrate == 2**32 - 1 
-	@nominal_bitrate = 0
-      else
-	@nominal_bitrate = (upper_bitrate + lower_bitrate)/2
-      end 
-    end
+  
+  # For both Vorbis and Speex, the granule_pos is the number of samples
+  # strictly this should be a codec function.
+  def compute_length(input)
+    reader = Reader.new(input)
+    last_page = nil
+    reader.each_pages({ :skip_body => true, :skip_checksum => true }) { |page| last_page = page }
+    return last_page.granule_pos.to_f / @samplerate
   end
+  
 
-  def extract_tag(frame)
-    @file.seek(frame[:file_position] + frame[:header_size] )
-    # GG: Vorbis includes a preamble "vorbis", which is not included in the comments,
-    # but is definitely in the /libvorbis/lib/info.c _vorbis_pack_comment reference implementation.
-    # Speex does not seem to include this preamble.
-    @file.read(7) if @bitstream_format=="vorbis"
-    vendor_length = @file.read(4).unpack("V").first
-    @vendor = @file.read(vendor_length)
-
-    @tag = {}
-    tag_size = @file.read(4).unpack("V")[0]
-
-    tag_size.times do |i|
-      size = @file.read(4).unpack("V")[0]
-      comment = @file.read(size)
-      key, val = comment.split(/=/, 2)
-      @tag[key.downcase] = val
+  # Pipe input to output transforming tags along the way
+  # input/output must be open streams reading for reading/writing  
+  def replace_tags(input, output, new_tags, vendor = "ruby-ogginfo")
+    # use the same serial number...
+    first_page = Page.read(input)
+    codec = Ogg.detect_codec(first_page)
+    bitstream_serial_no = first_page.bitstream_serial_no
+    reader = Reader.new(input)
+    writer = Writer.new(bitstream_serial_no, output)
+
+    # Write the first page as is (including presumably the b_o_s header)
+    writer.write_page(first_page)
+    
+    upcased_tags = new_tags.inject({}) do |memo, (k, v)| 
+      memo[k.upcase] = v
+      memo
     end
-  end
-
-  def get_length
-    @file.seek(0)
-    last_frame = nil
-    begin
-      while f = OggInfo.read_frame(@file) 
-        last_frame = f
+    # The codecs we know about put comments etc in following pages
+    # as suggested by the spec
+    written_pages_count = codec.replace_tags(reader, writer, upcased_tags, vendor)
+    if written_pages_count > 1
+      # Write the rest of the pages. We have to do page at a time
+      # because our tag replacement may have changed the number of
+      # pages and thus every subsequent page needs to have its
+      # sequence_no updated.
+      reader.each_pages(:skip_checksum => true) do |page|
+        writer.write_page(page)
       end
-    rescue OggInfoError
+    else
+      FileUtils.copy_stream(reader.input, writer.output)
     end
-    last_frame[:granule_pos].to_f / @samplerate
   end
 
   def convert_tag_charset(from_charset, to_charset)
     return if from_charset == to_charset
     Iconv.open(to_charset, from_charset) do |ic|
-      @tag.each do |k, v|
-        @tag[k] = ic.iconv(v)
+      tag.each do |k, v|
+        tag[k] = ic.iconv(v)
       end
     end
   end

data/test/test_ruby-ogginfo.rb

@@ -101,7 +101,7 @@ EOF
 
 class OggInfoTest < Test::Unit::TestCase
 
-  TEMP_FILE = File.join(Dir.tmpdir, "test_mp3info.ogg")
+  TEMP_FILE = File.join(Dir.tmpdir, "test_ogginfo.ogg")
 
   def setup
     valid_ogg_file = VALID_OGG.unpack("m*").first
@@ -123,40 +123,101 @@ class OggInfoTest < Test::Unit::TestCase
   end
 
   def test_length
-    generate_ogg
-    OggInfo.open("test.ogg") do |ogg|
-      assert_in_delta(17.0, ogg.length, 1)
-      assert_in_delta(67000.0, ogg.bitrate, 5000)
+    tf = generate_ogg
+    OggInfo.open(tf.path) do |ogg|
+      assert_in_delta(17.0, ogg.length, 1, "length has not been correctly guessed")
+      assert_in_delta(67000.0, ogg.bitrate, 2000, "bitrate has not been correctly guessed")
     end
   end
 
   def test_tag_writing
-    generate_ogg
-    tag = {"title" => "mytitle", "artist" => "myartist" }
-    OggInfo.open("test.ogg") do |ogg|
-      tag.each { |k,v| ogg.tag[k] = v }
-    end
+    tag_test("title" => generate_random_string, "artist" => generate_random_string )
+  end
 
-    OggInfo.open("test.ogg") do |ogg|
-      assert_equal tag, ogg.tag
-    end
+  def test_big_tags
+    tag_test("title" => generate_random_string(60000), "artist" => generate_random_string(60000) )
   end
+  
 
   def test_charset
-    generate_ogg
-    OggInfo.open("test.ogg", "utf-8") do |ogg|
+    tf = generate_ogg
+    OggInfo.open(tf.path, "utf-8") do |ogg|
       ogg.tag["title"] = "hello\303\251"
     end
 
-    OggInfo.open("test.ogg", "iso-8859-1") do |ogg|
+    OggInfo.open(tf.path, "iso-8859-1") do |ogg|
       assert_equal "hello\xe9", ogg.tag["title"] 
     end
   end
 
+  def test_should_not_fail_when_input_is_truncated
+    valid_ogg = generate_ogg
+    ogg_length = nil
+    OggInfo.open(valid_ogg.path) do |ogg|
+      ogg_length = ogg.length
+    end
+
+    tf = generate_truncated_ogg
+    OggInfo.open(tf.path) do |truncated_ogg|
+      assert ogg_length != truncated_ogg.length
+    end
+
+    reader = Ogg::Reader.new(open(tf.path, "r"))
+    last_page = nil
+    reader.each_pages do |page|
+      last_page = page
+    end
+    assert_not_equal Ogg.compute_checksum(last_page.pack), last_page.checksum
+  end
+
+  def test_checksum
+    tf = generate_truncated_ogg
+    reader = Ogg::Reader.new(open(tf.path))
+    assert_raises(Ogg::StreamError) do
+      reader.each_pages(:checksum => true) do |page|
+        page
+      end
+    end
+  end
+
+  protected
+
+
   def generate_ogg
-    unless test(?f, "test.ogg")
-      system("dd if=/dev/urandom bs=1024 count=3000 | oggenc -q0 --raw -o test.ogg -") or
-        flunk("cannot generate \"test.ogg\", tests cannot be fully performed")
+    generated_ogg_file_path = File.join(File.dirname(__FILE__), "test.ogg")
+    unless test(?f, generated_ogg_file_path)
+      system("dd if=/dev/urandom bs=1024 count=3000 | oggenc -q0 --raw -o #{generated_ogg_file_path} -") or
+        flunk("cannot generate \"#{generated_ogg_file_path}\", tests cannot be fully performed")
+    end
+    tf = Tempfile.new("ruby-ogginfo")
+    tf.close
+    FileUtils.cp(generated_ogg_file_path, tf.path)
+    tf
+  end
+
+  def generate_random_string(size = 256)
+    File.read("/dev/urandom", size)
+  end
+
+  def generate_truncated_ogg
+    valid_ogg = generate_ogg
+    tf = Tempfile.new("ruby-ogginfo")
+    data = File.read(valid_ogg.path, File.size(valid_ogg.path) - 10000)
+    tf.write(data)
+    tf.close
+    tf
+  end
+
+  def tag_test(tag) 
+    tf = generate_ogg
+
+    OggInfo.open(tf.path) do |ogg|
+      tag.each { |k,v| ogg.tag[k] = v }
+    end
+
+    OggInfo.open(tf.path) do |ogg|
+      assert_equal tag, ogg.tag
     end
+    test_length
   end
 end

data/test/test_ruby-spxinfo.rb

@@ -58,6 +58,7 @@ EOF
 class SpxInfoTest < Test::Unit::TestCase
 
   TEMP_FILE = File.join(Dir.tmpdir, "test.spxinfo.spx")
+  GEN_FILE = File.join(Dir.tmpdir,"test.spxgen.spx")
 
   def setup
     valid_spx_file = VALID_SPX.unpack("m*").first
@@ -73,6 +74,7 @@ class SpxInfoTest < Test::Unit::TestCase
       assert_equal 1, spx.channels
       assert_equal 32000, spx.samplerate
       assert_in_delta(0.5, spx.length, 1)
+      assert_equal "cityrail",spx.tag["author"]
     end
   end
 
@@ -81,20 +83,36 @@ class SpxInfoTest < Test::Unit::TestCase
     OggInfo.open("test.spx") do |spx|
       assert_equal 2, spx.channels
       assert_equal 44100, spx.samplerate
+      assert_equal "spxinfotest", spx.tag.author
     end
   end
 
 
   def test_charset
     generate_spx
-    OggInfo.open("test.spx", "utf-8") do |spx|
-      assert_equal "spxinfotest", spx.tag["author"]
+    FileUtils.cp("test.spx",GEN_FILE)
+    OggInfo.open(GEN_FILE, "utf-8") do |spx|
+    	assert_equal "hello\303\251",spx.tag["test"] 
     end
 
-    OggInfo.open("test.spx", "iso-8859-1") do |spx|
+    OggInfo.open(GEN_FILE, "iso-8859-1") do |spx|
       assert_equal "hello\xe9", spx.tag["test"] 
     end
   end
+  
+  def test_tag_writing
+    generate_spx
+    FileUtils.cp("test.spx",GEN_FILE)
+    tag = {"title" => "mytitle", "test" => "myartist" }
+    OggInfo.open(GEN_FILE) do |spx|
+      spx.tag.clear
+      tag.each { |k,v| spx.tag[k] = v }
+    end
+
+    OggInfo.open(GEN_FILE) do |spx|
+      assert_equal tag, spx.tag
+    end
+  end
 
   def generate_spx
     unless test(?f, "test.spx")

metadata

@@ -4,16 +4,18 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 6
   - 5
-  version: "0.5"
+  version: 0.6.5
 platform: ruby
 authors: 
 - Guillaume Pierronnet
+- Grant Gardner
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-01-13 00:00:00 +01:00
+date: 2011-04-07 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -48,7 +50,9 @@ description: |-
   ruby-ogginfo gives you access to low level information on ogg files
   (bitrate, length, samplerate, encoder, etc... ), as well as tag.
   It is written in pure ruby.
-email: moumar@rubyforge.org
+email: 
+- moumar@rubyforge.org
+- grant@lastweekend.com.au
 executables: []
 
 extensions: []
@@ -61,13 +65,19 @@ files:
 - Manifest.txt
 - README.rdoc
 - Rakefile
-- setup.rb
+- lib/ogg/codecs/comments.rb
+- lib/ogg/codecs/speex.rb
+- lib/ogg/codecs/vorbis.rb
+- lib/ogg/page.rb
+- lib/ogg/reader.rb
+- lib/ogg/writer.rb
+- lib/ogg.rb
 - lib/ogginfo.rb
+- setup.rb
 - test/test_ruby-ogginfo.rb
+- test/test_ruby-spxinfo.rb
 has_rdoc: yard
-homepage: |
-  http://ruby-ogginfo.rubyforge.org/
-
+homepage: http://ruby-ogginfo.rubyforge.org/
 licenses: []
 
 post_install_message: 
@@ -97,7 +107,7 @@ rubyforge_project: ruby-ogginfo
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: ruby-ogginfo is a pure-ruby library that gives low level informations on ogg files
+summary: ruby-ogginfo gives you access to low level information on ogg files (bitrate, length, samplerate, encoder, etc..
 test_files: 
-- test/test_ruby-ogginfo.rb
 - test/test_ruby-spxinfo.rb
+- test/test_ruby-ogginfo.rb