ruby-ogg 0.0.1

data/lib/ogg.rb

@@ -0,0 +1,157 @@
+require 'rubygems'
+require 'bindata'
+
+require 'stringio'
+
+module Ogg
+  # This is a superclass for all custom defined Ogg decoding errors
+  class DecodingError < StandardError
+  end
+  
+  # This error is raised when the file format is not valid Ogg
+  class MalformedFileError < DecodingError
+  end
+  
+  # Ogg::Decoder is used to decode Ogg bitstreams. The easiest way of properly
+  # parsing an Ogg file is to read consecutive packets with the read_packet
+  # method. For example:
+  #
+  #  require 'ogg'
+  #  
+  #  open("file.ogg", "rb") do |file|
+  #    dec = Ogg::Decoder.new(file)
+  #    packet = dec.read_packet
+  #    # Do something with the packet...
+  #  end
+  #
+  # The terms "page" and "packet" have special meanings when dealing with Ogg. A
+  # packet is a section of data which is encoded in the Ogg container. A page
+  # is a section of the Ogg container used as a means of storing packets.
+  # Since packets are what contain the "juicy bits" of the file, Ogg::Decoder
+  # provides sufficient abstraction to make handling of individual pages
+  # unnecessary. However, if you do need to read pages, that functionality is 
+  # available via the read_page method.
+  class Decoder
+    # Create a new Decoder from an IO which should be open for binary reading.
+    def initialize io
+      @io = io
+      @packets = []
+    end
+    
+    # Moves the file cursor forward to the next potential page. You probably
+    # wish to use the read_page method, which does some validation and actually
+    # returns the parsed page.
+    def seek_to_page(capture='OggS')
+      buffer = @io.read(capture.size)
+      page = nil
+      while not @io.eof?
+        if buffer == capture
+          @io.pos -= capture.size
+          return @io.pos
+        end
+        (buffer = buffer[1..-1] << @io.read(1)) rescue Exception
+      end
+      
+      raise EOFError
+    end
+
+    # Seek to and read the next page from the bitstream. Returns a Page or
+    # nil if there are no pages left.
+    def read_page
+      page = nil
+      while not @io.eof?
+        begin
+          seek_to_page
+          page = Page.read @io
+          page = nil unless page.verify_checksum
+          break
+        rescue Exception => ex
+          # False alarm, keep looking...
+        end
+      end
+      return page
+    end
+    
+    # Seek to and read the last page in the bitstream.
+    def read_last_page
+      raise 'Last page can only be read from a file stream' unless @io.is_a? File
+			buffer_size = 1024
+			pos = @io.stat.size - buffer_size
+			while pos > 0
+				@io.seek pos, IO::SEEK_SET
+				sio = StringIO.new @io.read(buffer_size)
+				
+				dec = Decoder.new(sio)
+				sub_pos = nil
+				
+				# Find last page in buffer
+        loop do
+          begin
+            sub_pos = dec.seek_to_page
+            sio.pos += 1
+          rescue
+            break
+          end
+        end
+
+        if sub_pos
+          @io.seek(pos + sub_pos, IO::SEEK_SET)
+          page = read_page
+          return page
+        end
+        
+				pos -= buffer_size * 2 - ('OggS'.size - 1)
+			end
+			
+			# This means that the Ogg file contains no pages
+			raise MalformedFileError
+    end
+    
+    # Seek to and read the next packet in the bitstream. Returns a string
+    # containing the packet's binary data or nil if there are no packets
+    # left.
+    def read_packet
+      return @packets.pop unless @packets.empty?
+      
+      while @packets.empty?
+        page = read_page
+        raise EOFError.new("End of file reached") if page.nil?
+        input = StringIO.new(page.data)
+        
+        page.segment_table.each do |seg|
+          @partial ||= ""
+          
+          @partial << input.read(seg)
+          if seg != 255
+            @packets.insert(0, @partial)
+            @partial = nil
+          end
+        end
+      end
+      
+      return @packets.pop
+    end
+  end
+  
+  # A BinData::Record which represents an Ogg page.
+  class Page < BinData::Record
+    endian   :little
+    string   :capture, :value => 'OggS', :read_length => 4
+    uint8    :version, :value => 0
+    uint8    :page_type
+    uint64   :granule_position
+    uint32   :bitstream_serial_number
+    uint32   :page_sequence_number
+    uint32   :checksum
+    uint8    :page_segments
+    array    :segment_table, :type => :uint8, :initial_length => :page_segments
+    string   :data, :read_length => lambda {segment_table.inject(0){|t,e| t+e}}
+    
+    def verify_checksum
+      poly = 0x04c11db7
+      # TODO: Implement CRC
+      return true
+    end
+  end
+end
+

data/lib/vorbis.rb

@@ -0,0 +1,143 @@
+require 'rubygems'
+require 'bindata'
+
+module Vorbis
+  # This class reads metadata (such as comments/tags and bitrate) from Vorbis 
+  # audio files. Here's an example of usage:
+  #
+  #  require 'vorbis'
+  #  
+  #  Vorbis::Info.open('echoplex.ogg') do |info|
+  #    info.comments[:artist].first #=> "Nine Inch Nails"
+  #    info.comments[:title].first  #=> "Echoplex"
+  #    info.sample_rate             #=> 44100
+  #  end
+  #
+  # You may notice that for each comment field an array of values is
+  # available. This is because it is perfectly valid for a Vorbis file
+  # to have multiple artists, titles, or anything else.
+  class Info
+    attr_reader :identification_header, :comment_header
+    attr_reader :comments
+    attr_reader :duration, :sample_rate, :nominal_bitrate, :channels, :bitrate
+    
+    # Create a new Vorbis::Info object for reading metadata.
+    def initialize(path, container=:ogg)
+      if path.is_a? IO
+        @io = path
+      else
+        @io = open(path, 'rb')
+      end
+      
+      case container
+      when :ogg
+        init_ogg
+      else
+        raise "#{container.to_s} is not a supported container format"
+      end
+      
+      @io.close
+      
+      yield self if block_given?
+    end
+    
+    def self.open(*args, &block)
+      return self.new(*args, &block)
+    end
+    
+    # Read Vorbis metadata from within an Ogg container.
+    private
+    def init_ogg
+      require 'ogg'
+      
+      parser = Ogg::Decoder.new @io
+      
+      @identification_header = IdentificationHeader.read(parser.read_packet)
+      @sample_rate = @identification_header.audio_sample_rate
+      @nominal_bitrate = @identification_header.bitrate_nominal
+      @channels = @identification_header.audio_channels
+      
+      @comment_header = CommentHeader.read(parser.read_packet)
+      @comments = @comment_header.comments
+      
+      pos_after_headers = @io.pos
+      
+      begin
+        # Duration is last granule position divided by sample rate
+        pos = parser.read_last_page.granule_position.to_f
+        @duration = pos / @sample_rate
+      rescue Exception
+        @duration = 0
+      end
+      
+      begin
+        @bitrate = (file.stat.size - pos_after_headers).to_f * 8 / @duration
+      rescue Exception
+        @bitrate = 0
+      end
+    end
+  end
+  
+  # A BinData::Record which represents a Vorbis identification header.
+  class IdentificationHeader < BinData::Record
+    endian   :little
+    uint8    :packet_type, :value => 1
+    string   :codec, :value => 'vorbis', :read_length => 6
+    uint32   :vorbis_version
+    uint8    :audio_channels
+    uint32   :audio_sample_rate
+    int32    :bitrate_maximum
+    int32    :bitrate_nominal
+    int32    :bitrate_minimum
+    bit4     :blocksize_0
+    bit4     :blocksize_1
+  end
+  
+  # A simple subclass of Hash which converts keys to uppercase strings.
+  class InsensitiveHash < Hash
+    def [](key)
+      super(key.to_s.upcase)
+    end
+    
+    def []=(key, value)
+      super(key.to_s.upcase, value)
+    end
+  end
+  
+  # A BinData::BasePrimitive which represents a list of comments as per 
+  # the Vorbis I comment header specification.
+  class Comments < BinData::BasePrimitive
+    register(self.name, self)
+    
+    def read_and_return_value(io)
+      n_comments = read_uint32le(io)
+      comments = InsensitiveHash.new
+      n_comments.times do
+        length = read_uint32le(io)
+        comment = io.readbytes(length)
+        key, value = comment.split('=', 2)
+        (comments[key] ||= []) << value
+      end
+      return comments
+    end
+    
+    def sensible_default
+      return {}
+    end
+
+    def read_uint32le(io)
+      return BinData::Uint32le.read(io)
+    end
+  end
+  
+  # A BinData::Record which represents a Vorbis comment header.
+  class CommentHeader < BinData::Record
+    endian   :little
+    uint8    :packet_type, :value => 3
+    string   :codec, :value => 'vorbis', :read_length => 6
+    uint32   :vendor_length
+    string   :vendor_string, :read_length => :vendor_length
+    comments :comments
+  end
+end
+

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-ogg
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Aiden Nibali
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-24 00:00:00 +11:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bindata
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: 
+description: 
+email: dismal.denizen@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/vorbis.rb
+- lib/ogg.rb
+has_rdoc: true
+homepage: http://rubyforge.org/projects/ruby-ogg/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: ruby-ogg
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A library for reading Ogg bitstreams
+test_files: []
+