marcandre-flvedit 0.6.1

data/lib/flv/event.rb

@@ -0,0 +1,40 @@
+module FLV
+  # The body of a tag containing meta data, cue points or last second information
+  # These behave like a Hash. The keys should be symbols
+  # while the values can be about any type, including arrays and hashes.
+  class Event < Hash
+    include Packable
+    include Body
+    TYPICAL_EVENTS = [:onMetaData, :onCuePoint, :onCaption, :onCaptionInfo, :onLastSecond, :onEvent]
+    attr_accessor :event
+
+    def initialize(event = :onMetaData, h = {})
+      self.replace h
+      self.event = event.to_sym
+    end
+
+    def read_packed(io,options) #:nodoc:
+      len = io.pos_change do
+        evt, h = io >>:flv_value >>:flv_value
+        self.event = evt.to_sym
+        replace h
+      end
+      FLV::Util.double_check :size, options[:bytes], len
+    end
+    
+    def write_packed(io,*) #:nodoc:
+      io << [event.to_s, :flv_value] << [self, :flv_value]
+    end
+
+    def debug(format, *)
+      format.values(:event => event)
+      format.values(self)
+    end
+    
+    def is?(what)
+      event.to_s == what.to_s || super
+    end
+    
+    alias_method :similar_to?, :==
+  end
+end

data/lib/flv/file.rb

@@ -0,0 +1,41 @@
+module FLV
+  module File
+    def each(*arg, &block)
+      return super unless arg.empty?
+      return to_enum unless block_given?
+      h= read(Header)
+      yield h
+      super(Tag, &block)
+    end
+
+    def self.open(*arg)
+      file = ::File.open(*arg)
+      begin
+        file = return_value = file.packed.extend(File)
+      rescue Exception
+        file.close
+        raise
+      end
+      begin 
+        return_value = yield(file) 
+      ensure 
+        file.close 
+      end if block_given? 
+      return_value 
+    end
+
+    def self.read(portname, *arg)
+      open(portname) do |f|
+        return f.to_a if arg.empty?
+        n, offset = arg.first, arg[1] || 0
+        f.each.first(n+offset)[offset, offset+n-1]
+      end
+    end
+    
+    def self.foreach(portname, *, &block)
+      open(portname) do |f|
+        f.each(&block)
+      end
+    end
+  end
+end

data/lib/flv/header.rb

@@ -0,0 +1,37 @@
+module FLV
+  # Represents the header chunk present at the very beginning of any FLV file.
+  class Header
+    include Base
+    attr_accessor :version, :has_audio, :has_video, :extra, :path
+
+    FLV_SIGNATURE = [String, {:bytes => 3}].freeze
+    SIGNATURE = 'FLV'
+    MIN_OFFSET = 9
+    FLAGS = { :has_video => 1, :has_audio => 4 }.freeze
+
+    def read_packed(io, *) #:nodoc:
+          signature,        self.version, type_flags, offset  = \
+      io  >> FLV_SIGNATURE  >> :char      >> :char    >> :unsigned_long 
+
+      raise RuntimeError.new("typeflags is #{signature}, #{version}, #{type_flags}, #{offset}") unless Fixnum === type_flags
+      
+      FLAGS.each {|flag,mask| send("#{flag}=", type_flags & mask > 0) }
+      self.extra = io.read(offset - MIN_OFFSET)
+      ignore_PreviousTagSize0 = io.read :unsigned_long
+      self.path = io.try :path
+      raise IOError("Wrong Signature (#{signature} instead of #{SIGNATURE})") unless SIGNATURE == signature
+    end
+
+    def write_packed(io, *) #:nodoc:
+      self.extra ||= ""
+      type_flags = FLAGS.sum{|flag, mask | send(flag) ? mask : 0}
+      io << SIGNATURE << [self.version || 1, :char] << [type_flags, :char] <<
+            [MIN_OFFSET + self.extra.length, :unsigned_long] << self.extra << [0, :unsigned_long]
+    end
+    
+    def debug(format, *)
+      format.header("Header", path)
+      format.values(to_h.tap{|h| h.delete(:path)})
+    end
+  end
+end

data/lib/flv/packing.rb

@@ -0,0 +1,140 @@
+require 'singleton'
+
+module FLV
+  class Event < Hash ; end
+  # FLV files can contain structured data. This modules makes it easy to (un)pack that data.
+  # The packing option +flv_value+ can (un)pack any kind of variable.
+  # It corresponds to +SCRIPTDATAVALUE+ in the official FLV file format spec.
+  # Implementation Note:
+  # +flv_value+ is actually simply a wrapper that will (un)pack the type of variable;
+  # the actual data is (un)packed with the format +flv+, which is independently defined for each type
+  module Packing
+    
+    # A special kind of value used to signify the end of a list (implemented at the end)
+    class EndOfList  # :nodoc:
+    end
+
+  #=== Top-level :flv_value filter:
+  
+    TYPE_TO_CLASS = Hash.new do |h, type|
+      #EndOfList
+      raise IOError, "Invalid type for a flash variable. #{type.inspect} is not in #{h.keys.sort.inspect}" #todo: handle error for corrupted da
+    end.merge!(
+       0 => Numeric   ,
+       1 => TrueClass , # There really should be a Boolean class!
+       2 => String    ,
+       3 => Hash      ,
+       8 => [Hash, :flv_with_size],
+       9 => EndOfList ,
+      10 => Array     ,
+      11 => Time
+    ).freeze
+    
+    CLASS_TO_TYPE = Hash.new do |h, klass|
+      h[klass] = h[klass.superclass] # Makes it such that CLASS_TO_TYPE[Fixnum] = CLASS_TO_TYPE[Integer]
+    end.merge!(TYPE_TO_CLASS.invert).merge!(
+      Event => TYPE_TO_CLASS.key([Hash, :flv_with_size]), # Write Events as hashes with size
+      FalseClass => TYPE_TO_CLASS.key(TrueClass)
+    )
+
+    # Read/write the type and (un)pack the actual data with :flv
+    Object.packers.set(:flv_value) do |packer|
+      packer.write do |io|
+        type_nb = CLASS_TO_TYPE[self.class]
+        klass, format = TYPE_TO_CLASS[type_nb]
+        io << [type_nb, :char] << [self, format || :flv]
+      end
+      packer.read  do |io|
+        klass, format = TYPE_TO_CLASS[io.read(:char)]
+        io.read([klass, format || :flv])
+      end
+    end
+
+  #=== For each basic type, the :flv filter (un)packs the actual data:
+
+    Numeric.packers.set(:flv) do |packer|
+      # Both Integers and Floats are packed as doubles
+      packer.write {|io| io << [to_f, :double] }
+      packer.read  do |io|
+        n = io.read(:double)
+        n.to_i == n ? n.to_i : n
+      end
+    end
+
+    [TrueClass, FalseClass].each do |klass|
+      klass.packers.set(:flv) do |packer|
+        packer.write {|io| io << [self ? 1 : 0, :char] }
+        packer.read  {|io| io.read(:char) != 0 }
+      end
+    end
+
+    String.packers.set(:flv) do |packer|
+      packer.write {|io| io << [length, :unsigned_short] << self }
+      packer.read  {|io| io.read(io.read(:unsigned_short)) }
+    end
+    
+    Array.packers.set(:flv) do |packer|
+      packer.write do |io|
+        io << [length, :unsigned_long]
+        each do |value|
+          io << [value, :flv_value]
+        end
+      end
+      packer.read do |io|
+        nb = io.read(:unsigned_long)
+        io.each(:flv_value).take(nb)
+      end
+    end
+
+    # The default format for hashes has a useless hint for the size
+    # This filter simply acts as a wrapper for the :flv_without_size filter
+    Hash.packers.set(:flv_with_size) do |packer|
+      packer.write do |io|
+        io << [length, :unsigned_long] << [self, :flv]
+      end
+      packer.read  do |io|
+        ignore_length_hint = io >> :unsigned_long
+        io.read [Hash, :flv]
+      end
+    end
+
+    Hash.packers.set(:flv) do |packer|
+      packer.write do |io|
+        each do |key, value|
+          io << [key.to_s, :flv] << [value, :flv_value]
+        end
+        io << ["", :flv] << [EndOfList.instance, :flv_value]
+      end
+      packer.read  do |io|
+        Hash[
+          io.each([String, :flv], :flv_value).
+            take_while {|str, val|  val != EndOfList.instance }.
+            map{|k,v| [k.to_sym, v]}
+        ]
+      end
+    end
+
+    Time.packers.set(:flv) do |packer|
+      packer.write {|io| io << [to_f * 1000, :double] << [Time.now.gmtoff / 60, :short] }
+      packer.read do |io|
+        seconds, zone = io >> :double >> :short
+        Time.at((seconds / 1000).to_i) + (zone * 60) - Time.now.gmtoff
+      end
+    end
+    
+    class EndOfList # :nodoc:
+      include Singleton, Packable
+      packers.set :flv, {}
+
+      def write_packed(*)
+        # no data to write
+      end
+
+      def self.read_packed(*)
+        self.instance
+      end
+    end
+    
+    Integer.packers.set :unsigned_24bits,  :bytes => 3, :signed => false, :endian => :big
+  end #module Packing
+end #module FLV

data/lib/flv/tag.rb

@@ -0,0 +1,62 @@
+module FLV  
+  # FLV files consists of a single header and a collection of Tags.
+  # Tags all have a timestamp and a body; this body can be Audio, Video, or Event.
+  class Tag
+    include Base
+    attr_accessor :body, :timestamp
+
+    def timestamp=(t)
+      @timestamp = Timestamp.try_convert(t)
+    end
+    
+    def initialize(timestamp = 0, body = nil)
+      self.body = body.instance_of?(Hash) ? Event.new(:onMetaData, body) : body
+      self.timestamp = timestamp
+    end
+    
+    CLASS_CODE = {
+      8 => Audio,
+      9 => Video,
+      18 => Event
+    }.freeze
+
+    def write_packed(io, *) #:nodoc
+      packed_body = @body.pack
+      len = io.pos_change do
+        io  << [CLASS_CODE.key(self.body.class), :char] \
+            << [packed_body.length, :unsigned_24bits]     \
+            << [@timestamp.in_milliseconds, :unsigned_24bits]       \
+            << [@timestamp.in_milliseconds >>24, :char]              \
+            << [streamid=0, :unsigned_24bits]             \
+            << packed_body
+      end
+      io << [len, :unsigned_long]
+    end
+    
+    def read_packed(io, options) #:nodoc
+      len = io.pos_change do 
+           code,    body_len,           timestamp_in_ms,   timestamp_in_ms_ext,  streamid =
+        io >>:char  >>:unsigned_24bits  >>:unsigned_24bits  >>:char               >>:unsigned_24bits
+        @timestamp = Timestamp.in_milliseconds(timestamp_in_ms + (timestamp_in_ms_ext << 24))
+        @body = io.read CLASS_CODE[code] || Body, :bytes => body_len
+      end
+      FLV::Util.double_check :size, len, io.read(:unsigned_long) #todo
+    end
+
+    def debug(format, compared_with = nil) #:nodoc
+      format.header("#{timestamp} ", @body.title)
+      @body.debug(format) unless compared_with && @body.similar_to?(compared_with.body)
+    end
+
+    def is?(what) #:nodoc
+      super || body.is?(what)
+    end
+    
+    def method_missing(*arg, &block)
+      super
+    rescue NoMethodError
+      body.send(*arg, &block)
+    end
+    
+  end
+end

data/lib/flv/timestamp.rb

@@ -0,0 +1,124 @@
+require 'delegate'
+require 'optparse'
+
+module FLV
+  class Timestamp < DelegateClass(Float)
+    def initialize(ms=0)
+      raise ArgumentError unless ms.is_a? Numeric
+      super
+    end
+    
+    # Returns [hours, minutes, seconds, milliseconds]
+    def to_a
+      n = in_milliseconds
+      [1000,60,60].map do |div|
+        val = n % div
+        n /= div
+        val
+      end.reverse.unshift(n)
+    end
+    
+    # Returns "HH:MM:SS.MMMM" like "1:23:45.678" or "1:00.000" for 1 minute.
+    def to_s
+      return "" if self == INFINITY
+      nbs = to_a.drop_while(&:zero?)
+      ms = nbs.pop || 0
+      first = nbs.shift || 0
+      sprintf("%d%s.%03d", first, nbs.map{|n| sprintf(":%02d",n)}.join, ms)
+    end
+
+    def in_seconds
+      to_f
+    end
+    
+    def in_milliseconds
+      (self * 1000).round
+    end
+    
+    def widen(amount)
+      TimestampRange.new(self,self).widen(amount)
+    end
+    
+    def self.in_milliseconds(ms)
+      Timestamp.new(ms/1000.0)
+    end
+    
+    def self.in_seconds(s)
+      new s
+    end
+
+    def self.try_convert(s, if_empty_string = 0)
+      case s
+      when Timestamp
+        s
+      when Numeric
+        new s
+      when ""
+        new if_empty_string
+      when REGEXP
+        h, m, s, ms = Regexp.last_match.captures
+        ms &&= ms.ljust(3,'0')[0,3] # e.g. 1.23 => 1.230
+        h, m = m, h if h and h.end_with?(":") and m.nil?
+        h, m, s, ms = [h, m, s, ms].map{|n| (n || 0).to_i}
+        in_seconds ((h*60+m)*60+s)+ms/1000.0
+      end
+    end
+    
+    REGEXP = /^(\d*[h:])?(\d*[m:])?(\d*)\.?(\d*)$/.freeze
+  end # Timestamp
+  
+  INFINITY = 1/0.0
+  class TimestampRange < Range
+    core = Timestamp::REGEXP.source.gsub(/[\$\^\(\)]/,"")
+    REGEXP = Regexp.new("^(#{core})-(#{core})$").freeze
+    
+    def to_s
+      "#{self.begin}-#{self.end}"
+    end
+    
+    def initialize(from, to, exclusive=false)
+      super(Timestamp.try_convert(from), Timestamp.try_convert(to, INFINITY), exclusive)
+    end
+    
+    def in_seconds
+      Range.new(self.begin.in_seconds, self.end.in_seconds, self.exclude_end?)      
+    end
+
+    def in_milliseconds
+      Range.new(self.begin.in_milliseconds, self.end.in_milliseconds, self.exclude_end?)
+    end
+    
+    def self.try_convert(s)
+      case s
+      when Range
+        new s.begin, s.end
+      when TimestampRange
+        s
+      when REGEXP
+        new *Regexp.last_match.captures
+      else
+        p "Can't convert #{s}"
+      end
+    end
+    
+    def widen(amount)
+      TimestampRange.new [self.begin - amount, 0].max, self.end + amount, self.exclude_end?
+    end
+  end # TimestampRange
+  OptionParser.accept(TimestampRange, TimestampRange::REGEXP) {|str,from,to| TimestampRange.try_convert(str)}
+  
+  
+  class TimestampOrTimestampRange  # :nodoc:
+    core = Timestamp::REGEXP.source.gsub(/[\$\^\(\)]/,"")
+    REGEXP = Regexp.new("^(#{core})-(#{core})|(#{core})$").freeze
+  end # TimestampOrTimestampRange
+  OptionParser.accept(TimestampOrTimestampRange, TimestampOrTimestampRange::REGEXP) do |str,from, to, from_to|
+    (from_to ? Timestamp : TimestampRange).try_convert(str)
+  end
+end
+
+class Range # :nodoc:
+  def ==(r) # Override built-in == because of bug in Ruby 1.8 & 1.9, see http://redmine.ruby-lang.org/issues/show/1165
+    self.begin == r.begin && self.end == r.end && self.exclude_end? == r.exclude_end?
+  end
+end