active_encode 0.4.1 → 0.8.0

data/lib/active_encode/engine_adapters/media_convert_output.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+module ActiveEncode
+  module EngineAdapters
+    module MediaConvertOutput
+      class << self
+        AUDIO_SETTINGS = {
+          "AAC" => :aac_settings,
+          "AC3" => :ac3_settings,
+          "AIFF" => :aiff_settings,
+          "EAC3_ATMOS" => :eac_3_atmos_settings,
+          "EAC3" => :eac_3_settings,
+          "MP2" => :mp_2_settings,
+          "MP3" => :mp_3_settings,
+          "OPUS" => :opus_settings,
+          "VORBIS" => :vorbis_settings,
+          "WAV" => :wav_settings
+        }.freeze
+
+        VIDEO_SETTINGS = {
+          "AV1" => :av_1_settings,
+          "AVC_INTRA" => :avc_intra_settings,
+          "FRAME_CAPTURE" => :frame_capture_settings,
+          "H_264" => :h264_settings,
+          "H_265" => :h265_settings,
+          "MPEG2" => :mpeg_2_settings,
+          "PRORES" => :prores_settings,
+          "VC3" => :vc_3_settings,
+          "VP8" => :vp_8_settings,
+          "VP9" => :vp_9_settings,
+          "XAVC" => :xavc_settings
+        }.freeze
+
+        def tech_metadata(settings, output)
+          url = output.dig('outputFilePaths', 0)
+          {
+            width: output.dig('videoDetails', 'widthInPx'),
+            height: output.dig('videoDetails', 'heightInPx'),
+            frame_rate: extract_video_frame_rate(settings),
+            duration: output['durationInMs'],
+            audio_codec: extract_audio_codec(settings),
+            video_codec: extract_video_codec(settings),
+            audio_bitrate: extract_audio_bitrate(settings),
+            video_bitrate: extract_video_bitrate(settings),
+            url: url,
+            label: File.basename(url),
+            suffix: settings.name_modifier
+          }
+        end
+
+        def extract_audio_codec(settings)
+          settings.audio_descriptions.first.codec_settings.codec
+        rescue
+          nil
+        end
+
+        def extract_audio_codec_settings(settings)
+          codec_key = AUDIO_SETTINGS[extract_audio_codec(settings)]
+          settings.audio_descriptions.first.codec_settings[codec_key]
+        end
+
+        def extract_video_codec(settings)
+          settings.video_description.codec_settings.codec
+        rescue
+          nil
+        end
+
+        def extract_video_codec_settings(settings)
+          codec_key = VIDEO_SETTINGS[extract_video_codec(settings)]
+          settings.video_description.codec_settings[codec_key]
+        rescue
+          nil
+        end
+
+        def extract_audio_bitrate(settings)
+          codec_settings = extract_audio_codec_settings(settings)
+          return nil if codec_settings.nil?
+          try(codec_settings, :bitrate)
+        end
+
+        def extract_video_bitrate(settings)
+          codec_settings = extract_video_codec_settings(settings)
+          return nil if codec_settings.nil?
+          try(codec_settings, :bitrate) || try(codec_settings, :max_bitrate)
+        end
+
+        def extract_video_frame_rate(settings)
+          codec_settings = extract_video_codec_settings(settings)
+          return nil if codec_settings.nil?
+          (codec_settings.framerate_numerator.to_f / codec_settings.framerate_denominator.to_f).round(2)
+        rescue
+          nil
+        end
+
+        private
+
+        def try(struct, key)
+          struct[key]
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/active_encode/engine_adapters/pass_through_adapter.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+require 'fileutils'
+require 'nokogiri'
+require 'shellwords'
+require 'file_locator'
+
+# PassThroughAdapter accepts an input file url and a number of derivative urls in the options
+# E.g. `create(input, outputs: [{ label: 'low',  url: 'file:///derivatives/low.mp4' }, { label: 'high', url: 'file:///derivatives/high.mp4' }])`
+# This adapter mirrors the ffmpeg adapter but differs in a few ways:
+#    1. It starts by copying the derivative files to the work directory
+#    2. It runs Mediainfo on the input and output files and skips ffmpeg
+#    3. All work is done in the create method so it's status is always completed or failed
+module ActiveEncode
+  module EngineAdapters
+    class PassThroughAdapter
+      WORK_DIR = ENV["ENCODE_WORK_DIR"] || "encodes" # Should read from config
+      MEDIAINFO_PATH = ENV["MEDIAINFO_PATH"] || "mediainfo"
+
+      def create(input_url, options = {})
+        # Decode file uris for ffmpeg (mediainfo works either way)
+        input_url = URI.decode(input_url) if input_url.starts_with? "file:///"
+
+        new_encode = ActiveEncode::Base.new(input_url, options)
+        new_encode.id = SecureRandom.uuid
+        new_encode.current_operations = []
+        new_encode.output = []
+
+        # Create a working directory that holds all output files related to the encode
+        FileUtils.mkdir_p working_path("", new_encode.id)
+        FileUtils.mkdir_p working_path("outputs", new_encode.id)
+
+        # Extract technical metadata from input file
+        `#{MEDIAINFO_PATH} --Output=XML --LogFile=#{working_path("input_metadata", new_encode.id)} #{input_url.shellescape}`
+        new_encode.input = build_input new_encode
+        new_encode.input.id = new_encode.id
+        new_encode.created_at, new_encode.updated_at = get_times new_encode.id
+
+        if new_encode.input.duration.blank?
+          new_encode.state = :failed
+          new_encode.percent_complete = 1
+
+          new_encode.errors = if new_encode.input.file_size.blank?
+                                ["#{input_url} does not exist or is not accessible"]
+                              else
+                                ["Error inspecting input: #{input_url}"]
+                              end
+
+          write_errors new_encode
+          return new_encode
+        end
+
+        # For saving filename to label map used to find the label when building outputs
+        filename_label_hash = {}
+
+        # Copy derivatives to work directory
+        options[:outputs].each do |opt|
+          url = opt[:url]
+          output_path = working_path("outputs/#{sanitize_base opt[:url]}#{File.extname opt[:url]}", new_encode.id)
+          FileUtils.cp FileLocator.new(url).location, output_path
+          filename_label_hash[output_path] = opt[:label]
+        end
+
+        # Write filename-to-label map so we can retrieve them on build_output
+        File.write working_path("filename_label.yml", new_encode.id), filename_label_hash.to_yaml
+
+        new_encode.percent_complete = 1
+        new_encode.state = :running
+        new_encode.errors = []
+
+        new_encode
+      rescue StandardError => e
+        new_encode.state = :failed
+        new_encode.percent_complete = 1
+        new_encode.errors = [e.full_message]
+        write_errors new_encode
+        return new_encode
+      end
+
+      # Return encode object from file system
+      def find(id, opts = {})
+        encode_class = opts[:cast]
+        encode_class ||= ActiveEncode::Base
+        encode = encode_class.new(nil, opts)
+        encode.id = id
+        encode.created_at, encode.updated_at = get_times encode.id
+        encode.input = build_input encode
+        encode.input.id = encode.id
+        encode.output = []
+        encode.current_operations = []
+
+        encode.errors = read_errors(id)
+        if encode.errors.present?
+          encode.state = :failed
+          encode.percent_complete = 1
+        elsif cancelled?(id)
+          encode.state = :cancelled
+          encode.percent_complete = 1
+        elsif completed?(id)
+          encode.state = :completed
+          encode.percent_complete = 100
+        else
+          encode.output = build_outputs encode
+          encode.state = :completed
+          encode.percent_complete = 100
+        end
+
+        encode
+      rescue StandardError => e
+        encode.state = :failed
+        encode.percent_complete = 1
+        encode.errors = [e.full_message]
+        write_errors encode
+        return encode
+      end
+
+      # Cancel ongoing encode using pid file
+      def cancel(id)
+        # Check for errors and if not then create cancelled file else raise CancelError?
+        if running?(id)
+          File.write(working_path("cancelled", id), "")
+          find id
+        else
+          raise CancelError
+        end
+      end
+
+    private
+
+      def running?(id)
+        !cancelled?(id) || !failed?(id) || !completed?(id)
+      end
+
+      def cancelled?(id)
+        File.exist? working_path("cancelled", id)
+      end
+
+      def failed?(id)
+        read_errors(id).present?
+      end
+
+      def completed?(id)
+        File.exist? working_path("completed", id)
+      end
+
+      def get_times(id)
+        updated_at = if File.file? working_path("completed", id)
+                       File.mtime(working_path("completed", id))
+                     elsif File.file? working_path("cancelled", id)
+                       File.mtime(working_path("cancelled", id))
+                     elsif File.file? working_path("error.log", id)
+                       File.mtime(working_path("error.log", id))
+                     else
+                       File.mtime(working_path("input_metadata", id))
+                     end
+
+        [File.mtime(working_path("input_metadata", id)), updated_at]
+      end
+
+      def write_errors(encode)
+        File.write(working_path("error.log", encode.id), encode.errors.join("\n"))
+      end
+
+      def read_errors(id)
+        err_path = working_path("error.log", id)
+        error = File.read(err_path) if File.file? err_path
+        if error.present?
+          [error]
+        else
+          []
+        end
+      end
+
+      def build_input(encode)
+        input = ActiveEncode::Input.new
+        metadata = get_tech_metadata(working_path("input_metadata", encode.id))
+        input.url = metadata[:url]
+        input.assign_tech_metadata(metadata)
+        created_at = File.mtime(working_path("input_metadata", encode.id))
+        input.created_at = created_at
+        input.updated_at = created_at
+
+        input
+      end
+
+      def build_outputs(encode)
+        id = encode.id
+        outputs = []
+        filename_label_hash = YAML.safe_load(File.read(working_path("filename_label.yml", id))) if File.exist?(working_path("filename_label.yml", id))
+        Dir["#{File.absolute_path(working_path('outputs', id))}/*"].each do |file_path|
+          output = ActiveEncode::Output.new
+          output.url = "file://#{file_path}"
+          output.label = filename_label_hash[file_path] if filename_label_hash
+          output.id = "#{encode.input.id}-#{output.label}"
+          output.created_at = encode.created_at
+          output.updated_at = File.mtime file_path
+
+          # Extract technical metadata from output file
+          metadata_path = working_path("output_metadata-#{output.label}", id)
+          `#{MEDIAINFO_PATH} --Output=XML --LogFile=#{metadata_path} #{output.url}` unless File.file? metadata_path
+          output.assign_tech_metadata(get_tech_metadata(metadata_path))
+
+          outputs << output
+        end
+        File.write(working_path("completed", id), "")
+
+        outputs
+      end
+
+      def sanitize_base(input_url)
+        File.basename(input_url, File.extname(input_url)).gsub(/[^0-9A-Za-z.\-]/, '_')
+      end
+
+      def working_path(path, id)
+        File.join(WORK_DIR, id, path)
+      end
+
+      def get_tech_metadata(file_path)
+        doc = Nokogiri::XML File.read(file_path)
+        doc.remove_namespaces!
+        duration = get_xpath_text(doc, '//Duration/text()', :to_f)
+        duration *= 1000 unless duration.nil? # Convert to milliseconds
+        { url: get_xpath_text(doc, '//media/@ref', :to_s),
+          width: get_xpath_text(doc, '//Width/text()', :to_f),
+          height: get_xpath_text(doc, '//Height/text()', :to_f),
+          frame_rate: get_xpath_text(doc, '//FrameRate/text()', :to_f),
+          duration: duration,
+          file_size: get_xpath_text(doc, '//FileSize/text()', :to_i),
+          audio_codec: get_xpath_text(doc, '//track[@type="Audio"]/CodecID/text()', :to_s),
+          audio_bitrate: get_xpath_text(doc, '//track[@type="Audio"]/BitRate/text()', :to_i),
+          video_codec: get_xpath_text(doc, '//track[@type="Video"]/CodecID/text()', :to_s),
+          video_bitrate: get_xpath_text(doc, '//track[@type="Video"]/BitRate/text()', :to_i) }
+      end
+
+      def get_xpath_text(doc, xpath, cast_method)
+        doc.xpath(xpath).first&.text&.send(cast_method)
+      end
+    end
+  end
+end

data/lib/active_encode/engine_adapters/test_adapter.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveEncode
   module EngineAdapters
     class TestAdapter
@@ -9,8 +10,8 @@ module ActiveEncode
         new_encode = ActiveEncode::Base.new(input_url, options)
         new_encode.id = SecureRandom.uuid
         new_encode.state = :running
-        new_encode.created_at = Time.now
-        new_encode.updated_at = Time.now
+        new_encode.created_at = Time.now.utc
+        new_encode.updated_at = Time.now.utc
         @encodes[new_encode.id] = new_encode
         new_encode
       end
@@ -18,14 +19,14 @@ module ActiveEncode
       def find(id, _opts = {})
         new_encode = @encodes[id]
         # Update the updated_at time to simulate changes
-        new_encode.updated_at = Time.now
+        new_encode.updated_at = Time.now.utc
         new_encode
       end
 
       def cancel(id)
         new_encode = @encodes[id]
         new_encode.state = :cancelled
-        new_encode.updated_at = Time.now
+        new_encode.updated_at = Time.now.utc
         new_encode
       end
     end

data/lib/active_encode/engine_adapters/zencoder_adapter.rb

@@ -1,13 +1,14 @@
+# frozen_string_literal: true
 module ActiveEncode
   module EngineAdapters
     class ZencoderAdapter
       # TODO: add a stub for an input helper (supplied by an initializer) that transforms encode.input.url into a zencoder accepted url
-      def create(input_url, options = {})
+      def create(input_url, _options = {})
         response = Zencoder::Job.create(input: input_url.to_s)
         build_encode(get_job_details(response.body["id"]))
       end
 
-      def find(id, opts = {})
+      def find(id, _opts = {})
         build_encode(get_job_details(id))
       end
 

data/lib/active_encode/errors.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module ActiveEncode #:nodoc:
+  class NotFound < RuntimeError; end
+  class NotRunningError < RuntimeError; end
+  class CancelError < RuntimeError; end
+end

data/lib/active_encode/global_id.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'globalid'
 
 module ActiveEncode
@@ -9,7 +10,7 @@ module ActiveEncode
       other.is_a?(ActiveEncode::Base) && to_global_id == other.to_global_id
     end
 
-    def to_global_id(options = {})
+    def to_global_id(_options = {})
       super(app: 'ActiveEncode')
     end
   end

data/lib/active_encode/input.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveEncode
   class Input
     include Status
@@ -8,8 +9,8 @@ module ActiveEncode
 
     def valid?
       id.present? && url.present? &&
-      created_at.is_a?(Time) && updated_at.is_a?(Time) &&
-      updated_at >= created_at
+        created_at.is_a?(Time) && updated_at.is_a?(Time) &&
+        updated_at >= created_at
     end
   end
 end

data/lib/active_encode/output.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveEncode
   class Output
     include Status
@@ -9,8 +10,8 @@ module ActiveEncode
 
     def valid?
       id.present? && url.present? && label.present? &&
-      created_at.is_a?(Time) && updated_at.is_a?(Time) &&
-      updated_at >= created_at
+        created_at.is_a?(Time) && updated_at.is_a?(Time) &&
+        updated_at >= created_at
     end
   end
 end