marcandre-flvedit 0.6.1

data/lib/flv/edit.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'backports'
+require_relative '../flv'
+require_relative 'edit/version'
+require_relative 'edit/options'
+require_relative 'edit/processor'
+require_relative 'edit/runner'
+
+#todo Change bin/flvedit
+#todo Auto write to files
+#todo Command Save no|false
+#todo add & nearest keyframe & overwrite
+#todo fix timestamps
+#todo cut & nearest keyframe?
+#todo print & xml/yaml & multiple files
+#todo onLastSecond
+#todo in|out pipe
+#todo recursive?
+#todo fix offset, both 24bit issue & apparent skips
+#todo bug join & time for audio vs video

data/lib/flv/edit/options.rb

@@ -0,0 +1,162 @@
+# encoding: utf-8
+require 'optparse'
+
+module FLV
+  module Edit
+    class Options
+      attr_reader :commands, :options
+      def initialize(argv)
+        @commands, @options = parse(argv)
+      end
+      
+      def to_a
+        [@commands, @options]
+      end
+      
+    private
+      def parse(argv)
+        commands = []
+        options = {}
+        parser = OptionParser.new do |parser|
+          parser.banner = banner
+          parser.separator ""
+          parser.separator "Commands:"
+          Processor::Base.registry.sort_by(&:to_s).
+            each do |command, desc, cmd_opt|
+              name = command.name.split('::').last.downcase
+              option = name.downcase.to_sym
+              shortcut = cmd_opt[:shortcut] || name[0..0]
+              if param = cmd_opt[:param]
+                name << " " << (param[:name] || param[:class].to_s.upcase)
+                desc = [param[:class], *desc]  if param[:class]
+              end
+              parser.on("-#{shortcut}", "--#{name}", *desc) do |v|
+                options[option] = v
+                commands << command
+              end
+            end
+           
+          parser.separator ""
+          parser.separator "Switches:"
+          [
+            [:keyframe_mode,      "Keyframe mode slides on_cue_point(navigation) tags added by the",
+                                  "add command to nearest keyframe position"]
+          ].each do |switch, *desc|
+            shortcut = desc.first.is_a?(Symbol) ? desc.shift.to_s : switch.to_s[0..0]
+            full = desc.first.is_a?(Class) ? "--#{switch.to_s} N" : "--#{switch.to_s}"
+            parser.on("-#{shortcut}", full, *desc) { |v| options[switch] = v }
+          end
+              
+          parser.separator "Common:"
+          parser.on("-h", "--help", "Show this message") {}
+          parser.on("--version", "Show version") do
+            puts "Current version: #{FLV::Edit.version}"
+            exit
+          end
+          
+          parser.separator ""
+          parser.separator "flvedit (#{FLV::Edit.version}), copyright (c) 2009 Marc-André Lafortune"
+          parser.separator "This program is published under the BSD license."
+        end
+        options[:files] = parser.parse!(argv)
+        if commands.empty?
+          puts parser
+          exit
+        end
+        return commands, options
+      end
+      
+      def banner
+        <<-EOS
+Usage: flvedit#{(RUBY_PLATFORM =~ /win32/) ? '.exe' : ''} [--input] files --processing --more_processing ... [--save [PATH]]
+******
+*NOTE*: THIS IS NOT A STABLE RELEASE. API WILL CHANGE!
+******
+flvedit will apply the given processing to the input files. 
+
+Examples:
+  # Printout of the first 42 tags:
+    flvedit example.flv --debug 42
+
+  # Extract the first 2 seconds of a.flv and b.flv, join them and update the meta data.
+    flvedit a.flv b.flv --cut 0-2 --join --update --save out.flv
+
+Option formats:
+  TIMESTAMP:  Given in seconds with decimals for fractions of seconds.
+              Use 'h' and 'm' or ':' for hours and minutes separators.
+  Examples:   1:00:01 (for 1 hour and 1 second), 1h1 (same),
+              2m3.004 (2 minutes, 3 seconds and 4 milliseconds), 123.004 (same)
+  RANGE:      Expressed as BEGIN-END, where BEGIN or END are timestamps
+              that can be let empty for no limit
+  Examples:   1m-2m (second minute), 1m- (all but first minute), -1m (first minute)
+  RANGE/TS:   RANGE or TIMESTAMP.
+        EOS
+        #s.split("\n").collect!(&:strip).join("\n")
+      end
+    end
+  end
+end
+
+#todo: explicit Input command
+#todo: conditions for implicit Save
+  
+        # options[:metadatacreator] = "inlet media FLVTool2 v#{PROGRAMM_VERSION.join('.')} - http://www.inlet-media.de/flvtool2"
+        # options[:metadata] = {}
+
+          # when /^-([a-zA-Z0-9]+?):(.+)$/
+          #   options[:metadata][$1] = $2
+          # when /^-([a-zA-Z0-9]+?)#([0-9]+)$/
+          #   options[:metadata][$1] = $2.to_f
+          # when /^-([a-zA-Z0-9]+?)@(\d{4,})-(\d{2,})-(\d{2,}) (\d{2,}):(\d{2,}):(\d{2,})$/
+          #   options[:metadata][$1] = Time.local($2, $3, $4, $5, $6, $7)
+        #   when /^([^-].*)$/
+        #     if options[:in_path].nil? 
+        #       options[:in_path] = $1
+        #       if options[:in_path].downcase =~ /stdin|pipe/
+        #         options[:in_pipe] = true
+        #         options[:in_path] = 'pipe'
+        #       else
+        #         options[:in_path] = File.expand_path( options[:in_path] )
+        #       end
+        #     else
+        #       options[:out_path] = $1
+        #       if options[:out_path].downcase =~ /stdout|pipe/
+        #         options[:out_pipe] = true
+        #         options[:out_path] = 'pipe'
+        #       else
+        #         options[:out_path] = File.expand_path( options[:out_path] )
+        #       end
+        #     end
+        #   end
+        # end
+    
+  
+      # def self.validate_options( options )
+      #    if options[:commands].empty?
+      #      show_usage
+      #      exit 0
+      #    end
+      #    
+      #    options[:commands].each do |command|  
+      #      case command
+      #      when :print
+      #        if options[:out_pipe]
+      #          throw_error "Could not use print command in conjunction with output piping or redirection"
+      #          exit 1
+      #        end
+      #      when :debug
+      #        if options[:out_pipe]
+      #          throw_error "Could not use debug command in conjunction with output piping or redirection"
+      #          exit 1
+      #        end
+      #      when :help
+      #        show_usage
+      #        exit 0
+      #      when :version
+      #        show_version
+      #        exit 0
+      #      end
+      #    end
+      #    options
+      #  end
+      #  

data/lib/flv/edit/processor.rb

@@ -0,0 +1,3 @@
+%w(base add command_line cut debug head join print reader save update).each do |proc|
+  require_relative "processor/#{proc}"
+end

data/lib/flv/edit/processor/add.rb

@@ -0,0 +1,67 @@
+require 'yaml'
+require 'rexml/document'
+require 'optparse'
+
+module FLV
+  module Edit
+    module Processor
+
+      class Add < Base
+        desc "Adds tags from the xml or yaml file PATH (default: tags.yaml/xml)", :param => {:name => "[PATH]"}
+        
+        def initialize(*)
+          super
+          @add = (options[:add_tags] || read_tag_file).sort_by(&:timestamp)
+        end
+        
+        def on_tag(tag)
+          insert_before tag, @add
+        end
+        
+        # def on_keyframe(tag)
+        #   insert_before tag, @add_before_key_frame
+        # end
+        
+      private
+        def insert_before(tag, list_to_insert)
+          stop_at = list_to_insert.find_index{|i| i.timestamp > tag.timestamp} || list_to_insert.length
+          dispatch_instead(*(list_to_insert.slice!(0...stop_at) << tag))   if stop_at > 0
+        end
+      
+        DEFAULT = ["tags.yaml", "tags.xml"]
+        #todo: overwrite, navigation
+        #todo: default event
+        def read_tag_file
+          filename = options[:add]
+          DEFAULT.each{|fn| filename ||= fn if ::File.exists?(fn)}
+          raise "You must either specify a tag file or have a file named #{DEFAULT.join(' or ')}" unless filename
+          ::File.open(filename) {|f| read_tags(f)}
+        end
+        
+        def read_tags(file)
+          tags =
+            unless file.path.downcase.end_with? ".xml"
+              YAML.load(file)
+            else
+              xml = REXML::Document.new(file, :ignore_whitespace_nodes => :all) 
+              xml.root.elements.to_a("metatag").map do |tag|
+                {
+                  :event => tag.attributes['event'],
+                  :overwrite => tag.attributes['overwrite'],
+                  :timestamp => (tag.elements['timestamp'].text rescue 0),
+                  :navigation => (tag.elements['type'].text == "navigation" rescue false),
+                  :arguments => Hash[tag.elements['parameters'].map{|param| [param.name, param.text]}]
+                }
+              end
+            end
+          tags = [tags] unless tags.is_a? Array
+          tags.map do |info|
+            info.symbolize_keys!
+            Tag.new(info[:timestamp], Event.new(info[:event], info[:arguments]))
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/flv/edit/processor/base.rb

@@ -0,0 +1,209 @@
+module FLV
+  module Edit  
+    module Processor
+      # Processors are used to process FLV files. Processors form are chain and the data (header and tags) will 'flow'
+      # through the chain in sequence. Each processor can inspect the data and change the flow,
+      # either by modifying the data, inserting new data in the flow or stopping the propagation of data.
+      #
+      # A FLV file can be seen as a sequence of chunks, the first one being a Header and the following ones
+      # a series of Tags with different types of bodies: Audio, Video or Event. Events store all meta data
+      # related information: onMetaData, onCuePoint, ...
+      #
+      # To tap into the flow of chunks, a processor can define any of the following methods:
+      #   on_chunk
+      #     on_header
+      #     on_tag
+      #       on_audio
+      #       on_video
+      #         on_keyframe
+      #         on_interframe
+      #         on_disposable_interframe
+      #       on_event
+      #         on_meta_data
+      #         on_cue_point
+      #         on_other_event
+      #
+      # All of these methods will have one argument: the current chunk being processed.
+      # For example, if the current chunk is an 'onMetaData' event, then
+      # the following will be called (from the most specialized to the least).
+      #   processor.on_meta_data(chunk)
+      #   processor.on_event(chunk)
+      #   processor.on_chunk(chunk)
+      #   # later on, the next processor will handle it:
+      #   next_processor.on_meta_data(chunk)
+      #   #...
+      #
+      # The methods need not return anything. It is assumed that the chunk will continue to flow through the
+      # processing chain. When the chunk should not continue down the chain, call +absorb+.
+      # To insert other tags in the flow, call +dispatch_instead+.
+      # Finally, it's possible to +stop+ the processing of the file completely.
+      #
+      # It is possible to look back at already processed chunks (up to a certain limit) with +look_back+
+      # or even in the future with +look_ahead+
+      #
+      class Base
+        attr_reader :options
+
+        def initialize(source=nil, options={})
+          @options = options.freeze
+          @source = source
+          on_calls = self.class.instance_methods(false).select{|m| m.to_s.start_with?("on_")}.map(&:to_sym) #Note: to_s needed for ruby 1.9, to_sym for ruby 1.8
+          unless (potential_errors = on_calls - ALL_EVENTS).empty?
+            warn "The following are not events: #{potential_errors.join(',')} (class #{self.class})"
+          end
+        end
+
+        def has_next_file?
+          @source.has_next_file?
+        end
+
+        def rewind
+          @source.rewind
+        end
+
+        def absorb(*) # Note: the (*) is so that we can alias events like on_meta_data
+          throw :absorb
+        end
+      
+        def stop
+          throw :stop
+        end
+      
+        def process_all
+          each{} while has_next_file?
+        end
+
+        def each(&block)
+          return to_enum(:each_chunk) unless block_given?
+          @block = block
+          catch :stop do
+            process_next_file
+          end
+        end
+      
+        def process_next_file
+          dispatch_chunks(@source)
+        end
+        
+        def dispatch_chunks(enum)
+          enum.each do |chunk|
+            dispatch_chunk(chunk)
+          end
+        end
+
+        def dispatch_chunk(chunk)
+          evt = chunk.main_event
+          catch :absorb do
+            EVENT_TRIGGER_LIST[evt].each do |event|
+              send(event, chunk) if respond_to?(event)
+            end
+            @block.call chunk
+          end
+        end
+      
+        def dispatch_instead(*chunks)
+          chunks.each do |chunk|
+            @block.call chunk
+          end
+          absorb
+        end
+
+        def stdout
+          options[:out] || STDOUT
+        end
+
+        EVENT_TRIGGER = {
+          :on_header      => :on_chunk,
+          :on_tag         => :on_chunk,
+          :on_audio       => :on_tag,
+          :on_video       => :on_tag,
+          :on_event       => :on_tag,
+          :on_meta_data   => :on_event,
+          :on_cue_point   => :on_event,
+          :on_last_second => :on_event,
+          :on_other_event => :on_event,
+          :on_keyframe    => :on_video,
+          :on_interframe  => :on_video,
+          :on_disposable_interframe => :on_video
+        }.freeze
+      
+        ALL_EVENTS = (EVENT_TRIGGER.keys | EVENT_TRIGGER.values).freeze
+      
+        MAIN_EVENTS = ALL_EVENTS.reject{ |k| EVENT_TRIGGER.has_value?(k)}.freeze
+      
+        EVENT_TRIGGER_LIST = Hash.new{|h, k| h[k] = [k] + h[EVENT_TRIGGER[k]]}.tap{|h| h[nil] = []; h.values_at(*MAIN_EVENTS)}.freeze
+      
+      protected
+      
+        def self.desc(text, options = {})
+          registry << [self, text, options]
+        end
+    
+        def self.registry # :nodoc:
+          @@registry ||= []
+        end
+    
+        def self.absorb(*events)
+          events.each{|evt| alias_method evt, :absorb}
+        end
+        
+      end #class Base
+
+      def self.chain(chain_classes, options = {})
+        next_chain_class = chain_classes.pop
+        next_chain_class.new(chain(chain_classes, options), options) if next_chain_class
+      end
+
+      # Let's extend the different kinds of chunks so that any_chunk.main_event returns
+      # the desired trigger.
+
+      module MainEvent # :nodoc:
+        module Header
+          def main_event
+            :on_header
+          end
+        end
+
+        module Video
+          MAPPING = {
+            :keyframe => :on_keyframe,
+            :interframe => :on_interframe,
+            :disposable_interframe => :on_disposable_interframe
+          }.freeze
+
+          def main_event
+            MAPPING[frame_type]
+          end
+        end
+
+        module Audio
+          def main_event
+            :on_audio
+          end
+        end
+
+        module Event
+          MAPPING = Hash.new(:on_other_event).merge!(
+            :onMetaData => :on_meta_data,
+            :onCuePoint => :on_cue_point,
+            :onLastSecond => :on_last_second
+          ).freeze
+          def main_event
+            MAPPING[event]
+          end
+        end
+        
+        module Tag
+          def main_event
+            body.main_event
+          end
+        end
+      end #module MainEvent
+    end #module Processor
+  end #module Edit
+  
+  [Header, Tag, Audio, Video, Event].each do |klass|
+    klass.class_eval{ include Edit::Processor::MainEvent.const_get(klass.to_s.sub('FLV::', '')) }
+  end
+  
+end #module FLV