media_processing_tool 1.0.0

data/bin/mig_http

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+if %w(start stop restart reload run zap status).include?((command = ARGV.first) ? command.downcase : command)
+  require 'daemons'
+  Daemons.run($0)
+  exit
+end
+
+lib_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift(lib_path) if !$:.include?(lib_path) and File.exists?(lib_path)
+require 'json'
+
+require 'cli'
+require 'mig'
+require 'mig/http'
+
+options[:binding] = '0.0.0.0'
+options[:local_port] = 4567
+options[:ffmpeg_cmd_path] = FFMPEG::DEFAULT_EXECUTABLE_PATH
+options[:mediainfo_cmd_path] = Mediainfo::DEFAULT_EXECUTABLE_PATH
+options[:exiftool_cmd_path] = ExifTool::DEFAULT_EXECUTABLE_PATH
+
+op = common_option_parser
+op.banner = "Usage:  #{File.basename(__FILE__)} [options] \n\t#{File.basename(__FILE__)} [start|stop|status] [daemon options] -- [application options]"
+op.on('--ffmpeg-bin-path PATH', 'The path to the FFMPEG executable.', "\tdefault: #{options[:ffmpeg_cmd_path]}") { |v| options[:ffmpeg_cmd_path] = v }
+op.on('--mediainfo-bin-path PATH', 'The path to the MediaInfo executable.', "\tdefault: #{options[:mediainfo_cmd_path]}") { |v| options[:mediainfo_cmd_path] = v }
+op.on('--exiftool-bin-path PATH', 'The path to the exiftool executable.', "\tdefault: #{options[:exiftool_cmd_path]}") { |v| options[:exiftool_cmd_path] = v }
+op.on('--binding BINDING', 'The address to bind the server to.',
+      "\tdefault: #{options[:binding]}") do |v|
+  options[:binding] = v
+end
+op.on('--port PORT', 'The port that the server should listen on.',
+      "\tdefault: #{options[:local_port]}") do |v|
+  options[:local_port] = v
+end
+op.on('--[no-]options-file [FILENAME]', "\tdefault: #{options[:options_file_path]}" ) { |v| options[:options_file_path] = v }
+add_common_options
+op.parse_common
+
+logger = Logger.new(options[:log_to] || STDERR)
+logger.level = Logger::DEBUG
+options[:logger] = logger
+
+mig = MediaInformationGatherer.new(options)
+
+app = MediaInformationGatherer::HTTP
+app.set(:logger, logger)
+app.set(:bind, options.delete(:binding))
+app.set(:port, options.delete(:local_port))
+app.set(:mig, mig)
+app.set(:initial_options, options)
+app.run!
+

data/bin/xml_processor

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+lib_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift(lib_path) if !$:.include?(lib_path) and File.exists?(lib_path)
+require 'optparse'
+require 'pp'
+
+require 'media_processing_tool/xml_processor'
+
+options_file_path = nil
+config_file_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'config', 'default', "#{File.basename(__FILE__, '.*')}_config"))
+options = { }
+ARGV << '--help' if ARGV.empty?
+op = OptionParser.new
+op.banner = "#{File.basename(__FILE__)} [options] file"
+options[:config_file_path] = config_file_path
+op.on('--config-file-path PATH', 'The path to the configuration file containing the @publish_map variable definition.', "default: #{config_file_path}") { |v| options[:config_file_path] = v }
+op.on('--[no-]output-results', 'Outputs the Result as a JSON object.') { |v| options[:output_results] = v }
+op.on('--[no-]pretty-print', 'Pretty Prints the Results.') { |v| options[:pretty_print] = v }
+#op.on('--path-to-mig PATH', '') { |v| options[:path_to_mig] = v }
+options[:log_level] = Logger::WARN
+op.on('--log-level LEVEL', [:debug, :DEBUG, :info, :INFO, :warn, :WARN, :error, :ERROR, :fatal, :FATAL], 'The logging level.', 'default: WARN') do |v|
+  v = v.upcase # Symbol doesn't support upcase!
+  options[:log_level] = Logger.const_defined?(v) ? Logger.const_get(v) : Logger::WARN
+end
+options[:log_to] = STDERR
+op.on('--log-to PATH', 'Log output location (ex: stderr, stdout, device path, file path)', "\tdefault: STDERR") do |v|
+  options[:log_to] = case v.downcase
+                     when 'stderr'; STDERR
+                     when 'stdout'; STDOUT
+                     else; v
+                     end
+end
+op.on('--help', 'Display this menu.') { puts op; exit }
+op.load(options_file_path)
+op.parse!
+
+xp = MediaProcessingTool::XMLProcessor.new(options)
+
+file_paths = ARGV
+results = file_paths.map { |file_path| { file: file_path, results: xp.process(file_path) } }
+results = results.pop[:results] if file_paths.length == 1
+
+if options[:output_results]
+  json_options = { allow_nan: true }
+
+  if options[:pretty_print]
+    puts JSON.pretty_generate(results, json_options)
+  else
+    puts JSON.fast_generate(results, json_options)
+  end
+end

data/config/default/xml_processor_config

@@ -0,0 +1,49 @@
+# The Following Instance Variables are Available During Evaluation
+#
+# @object The Hash that is being Processed
+# @full_file_path_field_name defaults to :path_on_file_system
+# @full_file_path = object[@full_file_path_field_name]
+#
+# @metadata_sources = object.fetch(:metadata_sources, { })
+# @exiftool = @metadata_sources[:exiftool] ||= { }
+# @mediainfo = @metadata_sources[:mediainfo] ||= { }
+# @ffmpeg = @metadata_sources[:ffmpeg] ||= { }
+# @filemagic = @metadata_sources[:filemagic] ||= { }
+# @media = @metadata_sources[:filemagic] ||= { }
+# @common_media_info = @metadata_sources[:common] ||= { }
+#
+# @media = entity.fetch('media', { })
+# @media_type = @media[:type] || @media['type']
+# @media_subtype = @media[:subtype] || @media['subtype']
+@publish_maps = [
+  {
+    type: :glob,
+    map: {
+      '*.*' => {
+        publish_executable: 'echo',
+        eval_publish_executable: false,
+        publish_arguments: %q("#{@full_file_path} #{@media_type}/#{@media_subtype} >> /tmp/mpt_xml_processor_test"),
+        eval_publish_arguments: true,
+        #workflow: {
+        #  name: 'WORKFLOW_ONLY',
+        #  parameters: {
+        #
+        #  } # parameters
+        #} # workflow
+      }
+    } # map
+  },
+  {
+    type: :eval,
+    map: {
+      'true' => {
+        workflow: {
+          name: 'WORKFLOW_ONLY',
+          parameters: {
+
+          } # parameters
+        } # workflow
+      }
+    } # map
+  },
+] # @publish_maps

data/lib/axml.rb

@@ -0,0 +1,59 @@
+# Abstracted XML Module
+module AXML
+
+  begin
+    require 'libxml'
+    XML_PARSER = :libxml unless defined?(XML_PARSER)
+  rescue LoadError
+    require 'rexml/document'
+    XML_PARSER = :rexml unless defined?(XML_PARSER)
+  end
+
+  module REXMLAbstraction
+    class << self
+      def self.xml_as_document(xml)
+        if xml.is_a?(String)
+          xml_clean = xml.chomp.strip.chomp
+          unless xml_clean.start_with?('<')
+            file_name = File.expand_path(xml)
+            xml_document = REXML::Document.new(File.new(file_name)) if !file_name.start_with?('<') and File.exists?(file_name)
+          end
+          xml_document ||= REXML::Document.new(xml)
+        else
+          xml_document = xml
+        end
+        xml_document
+      end # xml_as_document
+    end # self
+  end
+
+  module LibXMLAbstraction
+
+    def self.xml_as_document(xml)
+      if xml.is_a?(String)
+        xml_clean = xml.chomp.strip.chomp
+        unless xml_clean.start_with?('<')
+          file_name = File.expand_path(xml)
+          xml_document = LibXML::XML::Document.file(file_name) if File.exists?(file_name)
+        end
+        xml_document ||= LibXML::XML::Document.string(xml)
+      else
+        xml_document = xml
+      end
+      xml_document
+    end
+
+  end
+
+  # if XML_PARSER == :libxml
+  #   #puts 'Including LibXML'
+  #   include LibXMLAbstraction
+  # else
+  #   #puts 'Including REXML'
+  #   include REXMLAbstraction
+  # end
+
+  # Force LibXML Usage
+  def self.xml_as_document(xml); LibXMLAbstraction.xml_as_document(xml); end # self.xml_as_document
+
+end # AXML

data/lib/cli.rb

@@ -0,0 +1,88 @@
+require 'logger'
+require 'optparse'
+module CLI
+
+  LOGGING_LEVELS = {
+      :debug => Logger::DEBUG,
+      :info => Logger::INFO,
+      :warn => Logger::WARN,
+      :error => Logger::ERROR,
+      :fatal => Logger::FATAL
+  }
+
+  class <<self
+
+    attr_accessor :options
+
+  end
+
+  class CommonOptionParser < ::OptionParser
+
+    attr_accessor :options
+
+    #def options=(value)
+    #  #puts "Setting #{self.class.name}[#{self.object_id}] options => (#{value.class.name}[#{value.object_id}]) #{value}"
+    #  @options = value
+    #end
+    #
+    #def options
+    #  #puts "Getting #{self.class.name}[#{self.object_id}] options. #{@options}"
+    #  @options
+    #end
+
+    def parse_common
+      #puts "Parsing #{self.class.name}[#{self.object_id}] options. #{@options}"
+      parse!(ARGV.dup)
+
+      options_file_path = options[:options_file_path]
+      # Make sure that options from the command line override those from the options file
+      parse!(ARGV.dup) if options_file_path and load(options_file_path)
+
+      check_required_arguments
+    end
+
+    def required_arguments; @required_arguments ||= [ ] end
+    def add_required_argument(*args)  [*args].each { |arg| required_arguments << arg } end
+    alias :add_required_arguments :add_required_argument
+
+    def missing_required_arguments
+      puts "Options #{options}"
+      required_arguments.dup.delete_if { |a| options.has_key?(a.is_a?(Hash) ? a.keys.first : a) }
+    end
+
+    def check_required_arguments
+      _missing_arguments = missing_required_arguments
+      unless _missing_arguments.empty?
+        abort "Missing Required Arguments: #{_missing_arguments.map { |v| (v.is_a?(Hash) ? v.values.first : v).to_s.sub('_', '-')}.join(', ')}\n#{self.to_s}"
+      end
+    end
+  end # CommonOptionParser
+
+  def self.new_common_option_parser(*args)
+    op = CommonOptionParser.new(*args)
+    op.options = options
+    op
+  end
+
+end
+
+@options = options ||= { } #HashTap.new
+def options; @options end
+def common_option_parser
+  @common_option_parser ||= begin
+    CLI.options ||= options
+    CLI.new_common_option_parser
+  end
+end
+def add_common_options
+  options[:log_level] ||= 1
+  common_option_parser.on('--[no-]options-file [FILENAME]', "\tdefault: #{options[:options_file_path]}" ) { |v| options[:options_file_path] = v }
+  common_option_parser.on('--log-to FILENAME', 'Log file location.', "\tdefault: STDERR") { |v| options[:log_to] = v }
+  common_option_parser.on('--log-level LEVEL', CLI::LOGGING_LEVELS.keys, "Logging level. Available Options: #{CLI::LOGGING_LEVELS.keys.join(', ')}",
+                          "\tdefault: #{CLI::LOGGING_LEVELS.invert[options[:log_level]]}") { |v| options[:log_level] = CLI::LOGGING_LEVELS[v] }
+  common_option_parser.on('-h', '--help', 'Show this message.') { puts common_option_parser; exit }
+end
+
+default_options_file_path = File.join(File.expand_path('.'), "#{File.basename($0, '.rb')}_options")
+options[:options_file_path] = default_options_file_path if File.exists?(default_options_file_path)
+options[:options_file_path] ||= File.expand_path(File.basename($0, '.*'), '~/.options')

data/lib/final_cut_pro.rb

@@ -0,0 +1,31 @@
+require 'logger'
+module FinalCutPro
+
+  attr_writer :logger
+
+  # @param [Hash] options
+  # @option options [Object|nil] :logger (Logger)
+  # @option options [String|Object] :log_to (STDERR)
+  # @option options [Fixnum] :log_level (3)
+  def self.process_options_for_logger(options = { })
+    _logger = options[:logger]
+    unless _logger
+      if options[:log_to] or options[:log_level]
+        _logger = Logger.new(options[:log_to] || STDERR)
+        _logger.level = options[:log_level] if options[:log_level]
+      else
+        _logger = logger
+      end
+    end
+    @logger ||= _logger
+    _logger
+  end # process_options_for_logger
+
+  def self.logger
+    return @logger if @logger
+    @logger = Logger.new(STDERR)
+    @logger.level = Logger::ERROR
+    @logger
+  end # self.logger
+
+end # FinalCutPro

data/lib/final_cut_pro/sequence_processor.rb

@@ -0,0 +1,135 @@
+require 'logger'
+require 'uri'
+require 'timecode_methods'
+
+module FinalCutPro
+  class SequenceProcessor
+
+    class << self
+      include TimecodeMethods
+
+      attr_writer :logger
+      def logger; @logger ||= Logger.new(STDOUT) end
+
+      def parse_xml(xml)
+        doc = FinalCutPro::XMLParser.load(xml)
+        sequences = doc.parse_sequences(xml)
+        process(sequences)
+      end
+
+      def process(sequences)
+        files = { }
+        clips = [ ]
+        _sequences = { }
+        [*sequences].each do |sequence|
+          sequence_id = sequence[:id]
+          clip_items = sequence[:clip_items]
+          next unless clip_items
+          clip_item_counter = 0
+          clip_items_count = clip_items.count
+          clip_items.each do |clip_item|
+            clip_item_counter += 1
+            #logger.debug { "Clip Item #{clip_item_counter} of #{clip_items_count}"}
+
+            clip_rate = clip_item[:rate]
+            clip_time_base = clip_rate[:timebase].to_f
+            clip_rate_ntsc = clip_rate[:ntsc] == 'TRUE' ? true : false
+            clip_frame_rate = convert_time_base(clip_time_base, clip_rate_ntsc)
+
+            clip_duration_frames = clip_item[:duration].to_i
+            clip_duration_seconds = clip_duration_frames / clip_frame_rate
+
+            clip_start_frame = clip_item[:start].to_i
+            clip_end_frame = clip_item[:end].to_i
+
+            clip_in_frame = clip_item[:in].to_i
+            clip_out_frame = clip_item[:out].to_i
+
+
+            # File tags may just be a reference to an earlier file tag. A reference only includes an id attribute which we
+            # can use to lookup the file from previous parsing.
+            file = clip_item[:file] || { }
+            file_id = file[:id]
+            if file.keys.count == 1
+              # We only got the id with this file tag so look it up in our file cache
+              file = files[file_id]
+            else
+              # This file has more than just an ID so it's not a reference to a previous file. Store it in the file cache
+              files[file_id] = file
+            end
+            next unless file
+
+            file_timecode = file[:timecode] || { }
+            #file_timecode_value = file_timecode[:string] || '00:00:00:00'
+            file_timecode_frame = file_timecode[:frame].to_i
+
+            file_rate = file[:rate] || { }
+            file_time_base = file_rate[:timebase]
+            file_rate_ntsc = (file_rate[:ntsc] == 'TRUE') ? true : false
+            file_frame_rate = convert_time_base(file_time_base, file_rate_ntsc)
+            #puts "TB: #{file_time_base} NTSC: #{file_rate_ntsc} FPS: #{file_frame_rate}"
+            file_in_frame = clip_in_frame # + file_timecode_frame
+            file_out_frame = clip_out_frame # + file_timecode_frame
+
+            # Use the time base and not the frame rate
+            file_to_clip_rate_ratio = (file_time_base.to_f / clip_time_base.to_f)
+
+            #file_in_frame_at_clip_frame_rate = clip_in_frame * file_to_clip_rate_ratio
+            #file_out_frame_at_clip_frame_rate = clip_out_frame * file_to_clip_rate_ratio
+
+            file_in_timecode = frames_to_timecode(file_in_frame, clip_frame_rate, clip_rate_ntsc, ':')
+            file_out_timecode = frames_to_timecode(file_out_frame, clip_frame_rate, clip_rate_ntsc, ':')
+
+            #file_in_timecode_with_offset = TimecodeHelper.timecode_calculator(file_in_timecode, file_out_timecode, file_timecode_value, file_frame_rate)
+            file_in_seconds = (file_in_frame/clip_frame_rate) # TimecodeHelper.convert_frames_to_seconds(file_frame_rate, file_in_frame)
+            file_out_seconds = (file_out_frame/clip_frame_rate) # TimecodeHelper.convert_frames_to_seconds(file_frame_rate, file_out_frame)
+
+            file_path_url = file[:pathurl] || ''
+            file_path = URI.unescape(file_path_url).scan(/.*:\/\/\w*(\/.*)/).flatten.first
+
+
+            file_in_frame_with_offset = file_timecode_frame + (file_in_frame * file_to_clip_rate_ratio)
+            file_out_frame_with_offset = file_timecode_frame + (file_out_frame * file_to_clip_rate_ratio)
+            file_in_timecode_with_offset = frames_to_timecode(file_in_frame_with_offset, file_frame_rate, file_rate_ntsc, ';')
+            file_out_timecode_with_offset = frames_to_timecode(file_out_frame_with_offset, file_frame_rate, file_rate_ntsc, ';')
+
+            clips << {
+              :start_frame => clip_start_frame,
+              :end_frame => clip_end_frame,
+              :timebase => clip_time_base,
+              :ntsc => clip_rate[:ntsc],
+              :frame_rate => clip_frame_rate,
+              :sequence => { :id => sequence_id },
+              :duration_in_seconds => clip_duration_seconds,
+              :duration_in_frames => clip_duration_frames,
+              :file => {
+                :id => file_id,
+                :pathurl => file_path_url,
+                :path => file_path,
+                :timecode => file_timecode,
+                :timebase => file_time_base,
+                :ntsc => file_rate_ntsc,
+                :frame_rate => file_frame_rate,
+
+                :in_frame => file_in_frame,
+                :out_frame => file_out_frame,
+                :in_seconds => file_in_seconds,
+                :out_seconds => file_out_seconds,
+                :in_timecode => file_in_timecode,
+                :out_timecode => file_out_timecode,
+                :in_frame_with_offset => file_in_frame_with_offset,
+                :out_frame_with_offset => file_out_frame_with_offset,
+                :in_timecode_with_offset => file_in_timecode_with_offset,
+                :out_timecode_with_offset => file_out_timecode_with_offset,
+              },
+            }
+            _sequences[sequence_id] = clips
+          end
+        end
+        _sequences
+      end # process
+
+    end # << self
+
+  end # SequenceProcessor
+end # FinalCutPro