media_processing_tool 1.0.0

data/lib/media_processing_tool/publisher.rb

@@ -0,0 +1,52 @@
+# THIS CLASS IS CURRENTLY JUST A PASSTHROUGH TO THE GENERIC PUBLISH MAP PROCESSOR
+
+require 'logger'
+require 'udam_utils/publish_map_processor'
+module MediaProcessingTool
+
+  class Publisher
+
+    attr_accessor :logger, :object, :publisher
+
+    # @param [Hash] params
+    # @option params [Object|nil] :logger
+    # @Option params [String] :config_file_path
+    def initialize(params = {})
+      @logger = params[:logger] ||= Logger.new(STDOUT)
+
+      @interrupted = false
+      Signal.trap 'INT' do stop end
+      Signal.trap 'TERM' do stop end
+      Signal.trap 'SIGINT' do stop end
+
+      #@config_file_path = params[:config_file_path]
+      #raise ArgumentError, 'Missing required parameter :config_file_path' unless @config_file_path
+      #load_configuration_from_file(@config_file_path)
+
+
+      publisher_options = params
+      @publisher = UDAMUtils::GenericPublishMapProcessor.new(publisher_options)
+
+    end # initialize
+
+    def stop
+      @interrupted = true
+      puts 'Quitting on interrupt signal.'
+      while true
+        puts 'Exiting...'
+        exit
+      end
+    end # stop
+
+    def process(object, params = { })
+      publisher.process_object(params.merge(:object => object))
+    end
+
+    def publish(object, params = {})
+      #@object = object
+      #publisher.process_object(object)
+    end # publish
+
+  end # Publisher
+
+end # MediaProcessingTool

data/lib/media_processing_tool/xml_parser.rb

@@ -0,0 +1,30 @@
+require 'media_processing_tool/xml_parser/identifier'
+require 'final_cut_pro/xml_parser'
+require 'itunes/xml_parser'
+module MediaProcessingTool
+
+  class XMLParser
+
+    # Gives access to the last document returned by the Identifier
+    # This gives access to the identifiers instance parameters (such determined type) for use later
+    def self.identifier_document
+      @identifier_document
+    end # self.identifier_document
+
+    def self.parse(xml, args = { })
+      @identifier_document = Identifier.load(xml, args)
+
+      case @identifier_document.type
+      when :final_cut_pro
+        doc = FinalCutPro::XMLParser.parse(@identifier_document.xml_document, args)
+      when :itunes
+        doc = ITunes::XMLParser.parse(xml, args)
+      else
+        doc = @identifier_document
+      end
+      doc
+    end # self.parse
+
+  end # XMLParser
+
+end # MediaProcessingTool

data/lib/media_processing_tool/xml_parser/document.rb

@@ -0,0 +1,38 @@
+require 'axml'
+
+module MediaProcessingTool
+
+  class XMLParser
+
+    class Document
+
+      def self.xml_as_document(xml, params = {})
+        AXML.xml_as_document(xml)
+      end # self.xml_as_document
+
+      def self.load(xml, params = { })
+        new(xml, params)
+      end # self.load
+
+      def initialize(xml, params = { })
+        @xml_document = self.class.xml_as_document(xml, params)
+      end # initialize
+
+      def xml_document
+        @xml_document
+      end # xml_document
+
+      def root
+        xml_document.root
+      end # root
+
+      # Gets the
+      def root_type
+        @root_type ||= root.name
+      end # type
+
+    end # Document
+
+  end # XMLParser
+
+end # MediaProcessingTool

data/lib/media_processing_tool/xml_parser/identifier.rb

@@ -0,0 +1,43 @@
+require 'media_processing_tool/xml_parser/document'
+module MediaProcessingTool
+
+  class XMLParser
+
+    class Identifier < Document
+
+      def initialize(xml, params = { })
+        super(xml, params)
+      end # initialize
+
+      def is_fcpxml?
+        root_type == 'fcpxml'
+      end # is_fcpxml?
+
+      def is_xmeml?
+        root_type == 'xmeml'
+      end # is_xmeml?
+
+      def is_plist?
+        root_type == 'plist'
+      end # is_plist?
+
+      def is_final_cut_pro?
+        is_xmeml? || is_fcpxml?
+      end # is_final_cut_pro?
+
+      def is_itunes?
+        is_plist? and !xml_document.find('/plist/dict/key[text()="Tracks"]').empty?
+      end # is_itunes?
+
+      def type
+        return :final_cut_pro if is_final_cut_pro?
+        return :itunes if is_itunes?
+        return :plist if is_plist?
+        return :unknown
+      end # source_application
+
+    end # Identifier
+
+  end # XMLParser
+
+end # MediaProcessingTool

data/lib/media_processing_tool/xml_processor.rb

@@ -0,0 +1,132 @@
+require 'media_processing_tool/xml_parser'
+require 'media_processing_tool/publisher'
+require 'mig'
+module MediaProcessingTool
+
+  class XMLProcessor
+
+    def self.process(xml, params = { })
+
+    end # self.process
+
+    DEFAULT_FILE_PATH_FIELD_NAME = :path_on_file_system
+
+    attr_accessor :logger
+
+    # @return [Boolean] determines if the files parsed from the XML should be sent to a publisher
+    attr_accessor :publish
+
+    def initialize(params = { })
+      initialize_logger(params)
+
+      @publish = params.fetch(:publish, true)
+      @default_file_path_field_name = params[:@default_file_path_field_name] || DEFAULT_FILE_PATH_FIELD_NAME
+
+      initialize_mig(params.dup)
+      initialize_default_publisher(params.dup)
+    end # initialize
+
+    def initialize_logger(params = { })
+      @logger = params[:logger] ||= Logger.new(params[:log_to] || STDOUT)
+      logger.level = params[:log_level] if params[:log_level]
+      params[:logger] = logger unless params[:logger]
+    end # initialize_logger
+
+    def initialize_mig(params = {})
+      logger.debug { "Initializing Media Processing Tool. #{params}" }
+      @mig = MediaInformationGatherer.new(params)
+    end # initialize_mig
+
+    def initialize_default_publisher(params = {})
+      logger.debug { "Initializing Default Publisher. #{params}" }
+      params[:file_path_field_name] = @default_file_path_field_name
+      @default_publisher = MediaProcessingTool::Publisher.new(params)
+    end # initialize_publisher
+
+    def document
+     @document
+    end # document
+    alias :doc :document
+
+    def document_type
+      @identifier_document.type
+    end # document_type
+
+    def publisher(params = {})
+      @publisher
+    end # publisher
+
+    def process(xml, params = {})
+      @xml_file_path = File.exists?(xml) ? xml : nil
+
+      @document = XMLParser.parse(xml)
+      @identifier_document = XMLParser.identifier_document
+      @params = params
+
+      @files = document.respond_to?(:files) ? document.files : [ ]
+      @results = { }
+
+      #force_default_publisher = params[:force_default_publisher]
+      force_default_publisher = params.fetch(:force_default_publisher, true)
+
+      if force_default_publisher
+        @publisher = @default_publisher.dup
+        @results[:files] = process_document_files(@files, :publisher => @publisher) if @files
+      else
+        # TODO PUT IN DYNAMIC PUBLISHER HANDLING
+        doc_type = document_type
+      end
+
+      #{ :files => files, :sequences => sequences }
+
+      @results
+    end # process
+
+    def process_document_files(_files, params = {})
+      publisher = params[:publisher]
+
+      run_mig = params.fetch(:run_mig, true)
+
+      _results = [ ]
+      total_files = _files.length
+      current_file_counter = 0
+      _files.each do |file|
+        current_file_counter += 1
+        full_file_path = file[@default_file_path_field_name]
+
+        logger.debug { "Processing Document File #{current_file_counter} of #{total_files}. File Path: #{full_file_path}" }
+        if run_mig
+          _mig = run_mig_on_file(full_file_path)
+          file[:metadata_sources] = _mig ? _mig.metadata_sources : { }
+        else
+          logger.debug { 'Media Information Gathering SKIPPED. run_mig set to false.' }
+        end
+        file[:xml_file_path] = @xml_file_path
+        file_result = { file: file }
+        file_result[:publish_result] = publisher.process(file) if publish and publisher
+
+        _results << file_result
+      end
+      _results
+    end # process_files
+
+    def process_document_sequences(params = {})
+      sequences = doc.respond_to?(:sequences) ? doc.sequences : [ ]
+    end # process_sequences
+
+    def process_document_tracks(params = {})
+      tracks = doc.respond_to?(:tracks) ? doc.tracks : [ ]
+    end # process_tracks
+
+    def run_mig_on_file(full_file_path, params = {})
+      if File.exists?(full_file_path)
+        @mig.run(full_file_path)
+        return @mig
+      else
+        logger.debug { "Media Information Gathering SKIPPED. File Not Found. #{full_file_path}" }
+        return false
+      end
+    end # run_mig_on_file
+
+  end # XMLProcessor
+end # MediaProcessingTool

data/lib/mig.rb

@@ -0,0 +1,158 @@
+require 'logger'
+require 'mig/modules/exiftool'
+require 'mig/modules/ffmpeg'
+require 'mig/modules/mediainfo'
+require 'mig/modules/media_type'
+require 'mig/modules/common'
+
+class MediaInformationGatherer
+
+  File::Stat.class_eval do
+
+    TO_HASH_METHODS = [
+      :atime, :blksize, :blockdev?, :blocks, :chardev?, :ctime, :dev, :dev_major, :dev_minor, :directory?,
+      :executable?, :executable_real?, :file?, :ftype, :gid, :grpowned?, :ino, :mode, :mtime, :nlink, :owned?,
+      :pipe?, :rdev, :rdev_major, :rdev_minor, :readable?, :readable_real?,
+      :setgid?, :setuid?, :size, :size?, :socket?, :sticky?, :symlink?, :uid,
+      :world_readable?, :world_writable?, :writable?, :writable_real?, :zero?
+    ]
+
+    def to_hash
+      if defined?(__callee__)
+        return (self.methods - Object.methods - [__callee__]).each_with_object({}) { |meth, acc| acc[meth] = self.send(meth) if self.method(meth).arity == 0 }
+      else
+        #(self.methods - Object.methods).each({}) { |meth, acc| acc[meth] = self.send(meth) if self.method(meth).arity == 0 }
+        hash_out = { }
+        TO_HASH_METHODS.each do |meth|
+          hash_out[meth] = self.send(meth) if self.methods.include?(meth.to_s) and self.method(meth).arity == 0
+        end
+        return hash_out
+      end
+    end
+
+  end
+
+  attr_reader :log, :options
+
+  # @param [Hash] _options
+  # @option options [String] :exiftool_cmd_path
+  # @option options [String] :ffmpeg_cmd_path
+  # @option options [String] :mediainfo_cmd_path
+  def initialize(_options = { })
+    @options = { }
+    @options.merge!(_options)
+
+    @log = options[:logger] || $log || Logger.new(STDOUT)
+    log.debug { "#{self.class.name} - Options loaded. #{options}" }
+
+    options[:logger] ||= log
+
+    params = options.dup
+
+    @exiftool = ExifTool.new( params )
+    @ffmpeg = FFMPEG.new( params )
+    @mediainfo = Mediainfo.new( params )
+
+    @media_typer = MediaType.new
+
+    @default_run_file_stat = options.fetch(:run_file_stat, true)
+    @default_run_file_magic = options.fetch(:run_filemagic, true)
+    @default_run_mediainfo = options.fetch(:run_mediainfo, true)
+    @default_run_ffmpeg = options.fetch(:run_ffmpeg, true)
+    @default_run_exiftool = options.fetch(:run_exiftool, true)
+    @default_run_common = options.fetch(:run_common, true)
+  end # initialize
+
+  def media_type; @media_type ||= { } end
+  def metadata_sources; @metadata_sources ||= { } end
+
+  # @param [String] file_path The path to the file to gather information about
+  def run(file_path, options = { })
+    @media_type = { }
+    @metadata_sources = { }
+
+    raise Errno::ENOENT, "File Not Found. File Path: '#{file_path}'" unless File.exist?(file_path)
+
+
+    gathering_start = Time.now
+    log.debug { "Gathering metadata for file: #{file_path}"}
+    @metadata_sources = run_modules(file_path, options)
+    log.debug { "Metadata gathering completed. Took: #{Time.now - gathering_start} seconds" }
+
+    metadata_sources
+  end # run
+
+  # @param [String] file_path The path of the file to gather information about
+  # @return [Hash]
+  def run_modules(file_path, options = { })
+    run_file_stat = options.fetch(:run_file_stat, @default_run_file_stat)
+    run_filemagic = options.fetch(:run_filemagic, @default_run_filemagic)
+    run_mediainfo = options.fetch(:run_mediainfo, @default_run_mediainfo)
+    run_ffmpeg = options.fetch(:run_ffmpeg, @default_run_ffmpeg)
+    run_exiftool = options.fetch(:run_exiftool, @default_run_exiftool)
+    run_common = options.fetch(:run_common, @default_run_common)
+
+    if run_file_stat
+      log.debug { 'Running File Stat.' }
+      start = Time.now and metadata_sources[:stat] = File.stat(file_path).to_hash rescue { :error => { :message => $!.message, :backtrace => $!.backtrace } }
+      log.debug { "File Stat took #{Time.now - start}" }
+    end
+
+    if run_filemagic
+      log.debug { 'Running Filemagic.' }
+      start = Time.now and metadata_sources[:filemagic] = @media_typer.run(file_path, options) rescue { :error => { :message => $!.message, :backtrace => $!.backtrace } }
+      log.debug { "Filemagic took #{Time.now - start}" }
+    end
+
+    if run_mediainfo
+      log.debug { 'Running MediaInfo.' }
+      start = Time.now and metadata_sources[:mediainfo] = @mediainfo.run(file_path, options) rescue { :error => { :message => $!.message, :backtrace => $!.backtrace } }
+      log.debug { "MediaInfo took #{Time.now - start}" }
+    end
+
+    if run_ffmpeg
+      log.debug { 'Running FFMPEG.' }
+      start = Time.now and metadata_sources[:ffmpeg] = @ffmpeg.run(file_path, options) rescue { :error => { :message => $!.message, :backtrace => $!.backtrace } }
+      log.debug { "FFMpeg took #{Time.now - start}" }
+    end
+
+    if run_exiftool
+      log.debug { 'Running ExifTool.' }
+      start = Time.now and metadata_sources[:exiftool] = @exiftool.run(file_path) rescue { :error => { :message => $!.message, :backtrace => $!.backtrace } }
+      log.debug { "ExifTool took #{Time.now - start}" }
+    end
+
+    set_media_type
+    metadata_sources[:media_type] = media_type
+
+    metadata_sources[:common] = Common.common_variables(metadata_sources) if run_common
+
+    metadata_sources
+  end # run_modules
+
+  def get_media_type_using_exiftool
+    exiftool_md = metadata_sources[:exiftool]
+    return unless exiftool_md.is_a?(Hash)
+
+    mime_type = exiftool_md['MIMEType']
+    return unless mime_type.is_a?(String)
+
+    type, sub_type = mime_type.split('/')
+    return unless type
+
+    { :type => type, :subtype => sub_type }
+  end
+
+  def get_media_type_using_filemagic
+    filemagic_md = metadata_sources[:filemagic]
+    return unless filemagic_md.is_a?(Hash)
+    return unless filemagic_md[:type]
+
+    filemagic_md
+  end
+
+  def set_media_type
+    @media_type = get_media_type_using_filemagic || get_media_type_using_exiftool
+  end
+
+end # MediaInformationGatherer