active_encode 1.3.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a55a4e3f05065b6f69afc4a7d097f9c5c15926aada0fdb5915c3b19e09d024a2
-  data.tar.gz: 6c3e3b9f78fb430ed77f658a6f2be986dee227b642ce92a0c156998a1d35663c
+  metadata.gz: 4f90e9c3cedb039d22d5576047ff97f27007e1ab0a4a42be49a8af6332152237
+  data.tar.gz: cd525b293617c059017568d2bd9d70817213f4b81e9331cf08b330412c8f35c7
 SHA512:
-  metadata.gz: 1124cbecacf61ec7fa05a5eaf109599d4957e6865c0bc7e8938dc0a5d09f1912c5c93d49764c60301b7d1de0917b6d1af923b3e322812a7cc7f4b1dacf571257
-  data.tar.gz: 69695a33b2af42d9b19f101e2030209c2483d8bed919fc76542593f599a603bcba720341f0826fdd350154ac4feb62733a7a8453e11b935a28016889dc41e79a
+  metadata.gz: 7cdfba6f2f6f5712ecb9c54f8f7fd61c679559ca07930c43430cc26a85d96e7469d6b1d33061922dc05abf2a287b92676a7c4cf9bc66f4216607cafdc7fa86b3
+  data.tar.gz: 9c7ce5b39d81c746eda7bf54e023c6893300aa6a5bd4743f5afefe430189e62cd7419ff065d86bd3be4368b44bf4005ba18241472d1374f74744700905272ed5

data/.circleci/config.yml

@@ -46,6 +46,16 @@ jobs:
 
       - samvera/cached_checkout
 
+      - run:
+          name: Check for a branch named 'master'
+          command: |
+            git fetch --all --quiet --prune --prune-tags
+            if [[ -n "$(git branch --all --list master */master)" ]]; then
+              echo "A branch named 'master' was found. Please remove it."
+              echo "$(git branch --all --list master */master)"
+            fi
+            [[ -z "$(git branch --all --list master */master)" ]]
+
       - samvera/bundle:
           ruby_version: << parameters.ruby_version >>
           bundler_version: << parameters.bundler_version >>

data/.rubocop_todo.yml

@@ -8,6 +8,7 @@ Metrics/AbcSize:
 Metrics/BlockLength:
   Exclude:
     - 'lib/active_encode/spec/shared_specs/*'
+    - 'lib/active_encode/engine_adapters/media_convert_adapter.rb'
     - 'spec/**/*'
 
 Metrics/BlockNesting:
@@ -26,12 +27,11 @@ Metrics/CyclomaticComplexity:
   Exclude:
     - 'lib/active_encode/engine_adapters/elastic_transcoder_adapter.rb'
     - 'lib/active_encode/engine_adapters/ffmpeg_adapter.rb'
-    - 'lib/active_encode/engine_adapters/zencoder_adapter.rb'
     - 'lib/active_encode/engine_adapters/media_convert_adapter.rb'
+    - 'lib/active_encode/engine_adapters/media_convert_output.rb'
 
 Layout/LineLength:
   Exclude:
-    - 'lib/active_encode/engine_adapters/matterhorn_adapter.rb'
     - 'spec/**/*'
 
 Metrics/MethodLength:
@@ -44,6 +44,7 @@ Metrics/PerceivedComplexity:
   Exclude:
     - 'lib/active_encode/engine_adapters/ffmpeg_adapter.rb'
     - 'lib/active_encode/engine_adapters/media_convert_adapter.rb'
+    - 'lib/active_encode/engine_adapters/media_convert_output.rb'
     - 'lib/file_locator.rb'
 
 RSpec/AnyInstance:
@@ -61,7 +62,6 @@ RSpec/InstanceVariable:
 
 RSpec/MessageSpies:
   Exclude:
-    - 'spec/integration/matterhorn_adapter_spec.rb'
     - 'spec/integration/ffmpeg_adapter_spec.rb'
 
 RSpec/NamedSubject:

data/CONTRIBUTING.md

@@ -68,7 +68,7 @@ further details.
 * Fork the repository on GitHub
 * Create a topic branch from where you want to base your work.
   * This is usually the `main` branch.
-  * To quickly create a topic branch based on `main`; `git branch fix/master/my_contribution main`
+  * To quickly create a topic branch based on `main`; `git branch fix/main/my_contribution main`
   * Then checkout the new branch with `git checkout fix/main/my_contribution`.
   * Please avoid working directly on the `main` branch.
   * Please do not create a branch called `master`. (See note below.)

data/Gemfile

@@ -1,15 +1,12 @@
 # frozen_string_literal: true
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in hydra-transcoder.gemspec
+# Specify your gem's dependencies in active_encode.gemspec
 gemspec
 
 gem 'aws-sdk-elastictranscoder'
 gem 'aws-sdk-s3'
 gem 'byebug'
-gem 'rubyhorn', git: "https://github.com/avalonmediasystem/rubyhorn.git"
-gem 'shingoncoder'
-gem 'zencoder'
 
 # BEGIN ENGINE_CART BLOCK
 # engine_cart: 2.4.0
@@ -33,18 +30,6 @@ else
     else
       gem 'rails', ENV['RAILS_VERSION']
     end
-
-    case ENV['RAILS_VERSION']
-    when /^[56]/, /^7.0/
-      gem 'concurrent-ruby', '1.3.4'
-    when /^6.0/
-      gem 'sass-rails', '>= 6'
-      gem 'webpacker', '~> 4.0'
-    when /^5.[12]/
-      gem 'sass-rails', '~> 5.0'
-      gem 'sprockets', '~> 3.7'
-      gem 'thor', '~> 0.20'
-    end
   end
 end
 # END ENGINE_CART BLOCK

data/README.md

@@ -1,8 +1,8 @@
 # ActiveEncode
 
 Code: [![Version](https://badge.fury.io/rb/active_encode.png)](http://badge.fury.io/rb/active_encode)
-[![Build Status](https://travis-ci.org/samvera-labs/active_encode.png?branch=master)](https://travis-ci.org/samvera-labs/active_encode)
-[![Coverage Status](https://coveralls.io/repos/github/samvera-labs/active_encode/badge.svg?branch=master)](https://coveralls.io/github/samvera-labs/active_encode?branch=master)
+[![CircleCI](https://dl.circleci.com/status-badge/img/gh/samvera-labs/active_encode/tree/main.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/samvera-labs/active_encode/tree/main)
+[![Coverage Status](https://coveralls.io/repos/github/samvera-labs/active_encode/badge.svg?branch=main)](https://coveralls.io/github/samvera-labs/active_encode?branch=main)
 
 Docs: [![Contribution Guidelines](http://img.shields.io/badge/CONTRIBUTING-Guidelines-blue.svg)](./CONTRIBUTING.md)
 [![Apache 2.0 License](http://img.shields.io/badge/APACHE2-license-blue.svg)](./LICENSE)
@@ -11,7 +11,7 @@ Jump in: [![Slack Status](http://slack.samvera.org/badge.svg)](http://slack.samv
 
 # What is ActiveEncode?
 
-ActiveEncode serves as the basis for the interface between a Ruby (Rails) application and a provider of encoding services such as [FFmpeg](https://www.ffmpeg.org/), [Amazon Elastic Transcoder](http://aws.amazon.com/elastictranscoder/), [AWS Elemental MediaConvert](https://aws.amazon.com/mediaconvert/), and [Zencoder](http://zencoder.com).
+ActiveEncode serves as the basis for the interface between a Ruby (Rails) application and a provider of encoding services such as [FFmpeg](https://www.ffmpeg.org/), [Amazon Elastic Transcoder](http://aws.amazon.com/elastictranscoder/), and [AWS Elemental MediaConvert](https://aws.amazon.com/mediaconvert/).
 
 # Help
 
@@ -247,6 +247,12 @@ RSpec.describe MyCustomAdapter do
 end
 ```
 
+## Contributing 
+
+If you're working on PR for this project, create a feature branch off of `main`. 
+
+This repository follows the [Samvera Community Code of Conduct](https://samvera.atlassian.net/wiki/spaces/samvera/pages/405212316/Code+of+Conduct) and [language recommendations](https://github.com/samvera/maintenance/blob/main/templates/CONTRIBUTING.md#language).  Please ***do not*** create a branch called `master` for this repository or as part of your pull request; the branch will either need to be removed or renamed before it can be considered for inclusion in the code base and history of this repository.
+
 # Acknowledgments
 
 This software has been developed by and is brought to you by the Samvera community.  Learn more at the

data/active_encode.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Michael Klein, Chris Colvard, Phuong Dinh"]
   spec.email         = ["mbklein@gmail.com, chris.colvard@gmail.com, phuongdh@gmail.com"]
   spec.summary       = 'Declare encode job classes that can be run by a variety of encoding services'
-  spec.description   = 'This gem provides an interface to transcoding services such as Ffmpeg, Amazon Elastic Transcoder, or Zencoder.'
+  spec.description   = 'This gem provides an interface to transcoding services such as Ffmpeg, Amazon Elastic Transcoder, or Amazon Elemental MediaConvert.'
   spec.homepage      = "https://github.com/samvera-labs/active_encode"
   spec.license       = "Apache-2.0"
 
@@ -22,12 +22,13 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "rails"
   spec.add_dependency "addressable", "~> 2.8"
+  spec.add_dependency "retriable"
 
   spec.add_development_dependency "aws-sdk-cloudwatchevents"
   spec.add_development_dependency "aws-sdk-cloudwatchlogs"
   spec.add_development_dependency "aws-sdk-core", "<= 3.220.0"
   spec.add_development_dependency "aws-sdk-elastictranscoder"
-  spec.add_development_dependency "aws-sdk-mediaconvert"
+  spec.add_development_dependency "aws-sdk-mediaconvert", ">= 1.157.0"
   spec.add_development_dependency "aws-sdk-s3"
   spec.add_development_dependency "bixby", '~> 5.0', '>= 5.0.2'
   spec.add_development_dependency "bundler"

data/lib/active_encode/engine_adapters/ffmpeg_adapter.rb

@@ -202,6 +202,7 @@ module ActiveEncode
 
       def write_errors(encode)
         File.write(working_path("error.log", encode.id), encode.errors.join("\n"))
+        File.write(working_path("exit_status.code", encode.id), "1") unless File.exist?(working_path("exit_status.code", encode.id))
       end
 
       def read_errors(id)
@@ -311,6 +312,8 @@ module ActiveEncode
       end
 
       def running?(pid)
+        return false if pid.nil?
+
         Process.getpgid pid.to_i
         true
       rescue Errno::ESRCH
@@ -352,13 +355,19 @@ module ActiveEncode
         doc.remove_namespaces!
         duration = get_xpath_text(doc, '//Duration/text()', :to_f)
         duration *= 1000 unless duration.nil? # Convert to milliseconds
+        audio_codec = get_xpath_text(doc, '//track[@type="Audio"]/CodecID/text()', :to_s)
+        if get_xpath_text(doc, '//track[@type="Audio"]/Format/text()', :to_s) == "MPEG Audio" &&
+           get_xpath_text(doc, '//track[@type="Audio"]/Format_Profile/text()', :to_s) == "Layer 3"
+          audio_codec ||= "mp3"
+        end
+
         { 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_codec: audio_codec,
           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),

data/lib/active_encode/engine_adapters/media_convert_adapter.rb

@@ -6,6 +6,7 @@ require 'aws-sdk-cloudwatchevents'
 require 'aws-sdk-cloudwatchlogs'
 require 'aws-sdk-mediaconvert'
 require 'file_locator'
+require 'retriable'
 
 require 'active_support/json'
 require 'active_support/time'
@@ -46,12 +47,16 @@ module ActiveEncode
     #
     #      ActiveEncode::Base.engine_adapter.setup!
     #
-    # **OR**, there is experimental functionality to get what we can directly from the job without
-    # requiring a CloudWatch log -- this is expected to be complete only for  HLS output at present.
-    # It seems to work well for HLS output. To opt-in, and not require CloudWatch logs:
+    # **OR** There is functionality to get what we can directly from the job without requiring
+    # a CloudWatch log -- this only works for HLS and file outputs at present.
+    # To opt-in, and not require CloudWatch logs:
     #
     #     ActiveEncode::Base.engine_adapter.direct_output_lookup = true
     #
+    # MediaConvert also provides a probe endpoint to extract technical metadata about a file stored
+    # in s3.  This can be used to gather output metadata when using direct_output_lookup instead of
+    # having to look in the CloudWatch logs.
+    #
     # ## Example
     #
     #     ActiveEncode::Base.engine_adapter = :media_convert
@@ -102,16 +107,42 @@ module ActiveEncode
         end
       end
 
+      class RetriableClient
+        def initialize
+          @retry_params = { on: Aws::MediaConvert::Errors::ServiceError, base_interval: 1 }
+          endpoint = Retriable.retriable(@retry_params) { Aws::MediaConvert::Client.new.describe_endpoints.endpoints.first.url }
+          @client = Aws::MediaConvert::Client.new(endpoint: endpoint)
+        end
+
+        def method_missing(method, *args, &block)
+          if @client.respond_to?(method)
+            Retriable.retriable(@retry_params) { @client.send(method, *args, &block) }
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          @client.respond_to?(method_name) || super
+        end
+      end
+
       # @!attribute [rw] role simple name of AWS role to pass to MediaConvert, eg `my-role-name`
       # @!attribute [rw] output_bucket simple bucket name to write output to
       # @!attribute [rw] direct_output_lookup if true, do NOT get output information from cloudwatch,
       #                  instead retrieve and construct it only from job itself. Currently
-      #                  working only for HLS output. default false.
-      attr_accessor :role, :output_bucket, :direct_output_lookup
+      #                  working only for HLS output. (default: false)
+      # @!attribute [rw] use_probe if true use probe endpoint to get technical metadata about input and outputs (default: false)
+      attr_accessor :role, :output_bucket, :direct_output_lookup, :use_probe
 
       # @!attribute [w] log_group log_group_name that is being used to capture output
       # @!attribute [w] queue name of MediaConvert queue to use.
-      attr_writer :log_group, :queue
+      # @!attribute [w] output_id_format sprintf format for output ids (default: "%{job_id}-output%{suffix}")
+      #                  Available string variables are job_id and the keys in the MediaConvertOutput tech meatdata hash
+      # @!attribute [w] output_label_format sprintf format for output ids (default: "%{basename}" if output_url is preset
+      #                  otherwise "%{suffix}")
+      #                  Available string variables are job_id, basename, and the keys in the MediaConvertOutput tech metadata hash
+      attr_writer :log_group, :queue, :output_id_format, :output_label_format
 
       # Creates a [CloudWatch Logs]
       # (https://aws.amazon.com/cloudwatch/) log group and an EventBridge rule to forward status
@@ -274,6 +305,10 @@ module ActiveEncode
 
         encode.input.created_at = encode.created_at
         encode.input.updated_at = encode.updated_at
+        if use_probe
+          tech_md = MediaConvertOutput.tech_metadata_from_probe(url: encode.input.url, probe_response: probe(encode.input.url))
+          encode.input.assign_tech_metadata(tech_md)
+        end
 
         encode = complete_encode(encode, job) if encode.state == :completed
         encode
@@ -338,35 +373,42 @@ module ActiveEncode
 
         output_group_details  = job.dig("output_group_details", 0, "output_details")
         file_input_url        = job.dig("settings", "inputs", 0, "file_input")
+        output_group_type     = output_group_settings.type.downcase.to_sym
+        output_destination    = output_group_settings[output_group_type].destination
 
         outputs = output_group_details.map.with_index do |output_group_detail, index|
-          # Right now we only know how to get a URL for hls output, although
-          # the others should be possible and very analagous, just not familiar with them.
-          if output_group_settings.type == "HLS_GROUP_SETTINGS"
+          # Only HLS and file output groups have been tested with this approach
+          if [:hls_group_settings, :file_group_settings].include? output_group_type
             output_url = MediaConvertOutput.construct_output_url(
-              destination: output_group_settings.hls_group_settings.destination,
+              destination: output_destination,
               file_input_url: file_input_url,
               name_modifier: output_settings[index].name_modifier,
-              file_suffix: "m3u8"
+              file_suffix: output_settings[index].container_settings.container.downcase
             )
           end
 
-          tech_md = MediaConvertOutput.tech_metadata_from_settings(
-            output_url: output_url,
-            output_settings: output_settings[index],
-            output_detail_settings: output_group_detail
-          )
+          tech_md = if use_probe
+                      MediaConvertOutput.tech_metadata_from_probe(
+                        url: output_url,
+                        output_settings: output_settings[index],
+                        probe_response: probe(output_url)
+                      )
+                    else
+                      MediaConvertOutput.tech_metadata_from_settings(
+                        output_url: output_url,
+                        output_settings: output_settings[index],
+                        output_detail_settings: output_group_detail
+                      )
+                    end
 
           output = ActiveEncode::Output.new
-
+          output.url = output_url
           output.created_at = job.timing.submit_time
           output.updated_at = job.timing.finish_time || job.timing.start_time || output.created_at
-
-          [:width, :height, :frame_rate, :duration, :checksum, :audio_codec, :video_codec,
-           :audio_bitrate, :video_bitrate, :file_size, :label, :url, :id].each do |field|
-            output.send("#{field}=", tech_md[field])
-          end
-          output.id ||= "#{job.id}-output#{tech_md[:suffix]}"
+          output.assign_tech_metadata(tech_md)
+          file_basename = File.basename(output.url)
+          output.id = format(output_id_format, tech_md.merge(job_id: job.id))
+          output.label = format(output_label_format(file_basename), tech_md.merge(job_id: job.id, basename: file_basename))
           output
         end
 
@@ -382,15 +424,13 @@ module ActiveEncode
           )
 
           output = ActiveEncode::Output.new
+          output.url = adaptive_playlist_url
           output.created_at = job.timing.submit_time
           output.updated_at = job.timing.finish_time || job.timing.start_time || output.created_at
-          output.id = "#{job.id}-output-auto"
-
-          [:duration, :audio_codec, :video_codec].each do |field|
-            output.send("#{field}=", outputs.first.send(field))
-          end
-          output.label = File.basename(adaptive_playlist_url)
-          output.url = adaptive_playlist_url
+          output.assign_tech_metadata(outputs.first.tech_metadata)
+          file_basename = File.basename(output.url)
+          output.id = format(output_id_format, output.tech_metadata.merge(job_id: job.id, suffix: '-auto'))
+          output.label = format(output_label_format(file_basename), output.tech_metadata.merge(job_id: job.id, suffix: '-auto', basename: file_basename))
           outputs << output
         end
 
@@ -411,30 +451,26 @@ module ActiveEncode
         outputs = logged_results.dig('detail', 'outputGroupDetails', 0, 'outputDetails').map.with_index do |logged_detail, index|
           tech_md = MediaConvertOutput.tech_metadata_from_logged(output_settings[index], logged_detail)
           output = ActiveEncode::Output.new
-
+          output.url = tech_md[:url]
           output.created_at = job.timing.submit_time
           output.updated_at = job.timing.finish_time || job.timing.start_time || output.created_at
-
-          [:width, :height, :frame_rate, :duration, :checksum, :audio_codec, :video_codec,
-           :audio_bitrate, :video_bitrate, :file_size, :label, :url, :id].each do |field|
-            output.send("#{field}=", tech_md[field])
-          end
-          output.id ||= "#{job.id}-output#{tech_md[:suffix]}"
+          output.assign_tech_metadata(tech_md)
+          file_basename = File.basename(output.url)
+          output.id = format(output_id_format, tech_md.merge(job_id: job.id))
+          output.label = format(output_label_format(file_basename), tech_md.merge(job_id: job.id, basename: file_basename))
           output
         end
 
         adaptive_playlist = logged_results.dig('detail', 'outputGroupDetails', 0, 'playlistFilePaths', 0)
         unless adaptive_playlist.nil?
           output = ActiveEncode::Output.new
+          output.url = adaptive_playlist
           output.created_at = job.timing.submit_time
           output.updated_at = job.timing.finish_time || job.timing.start_time || output.created_at
-          output.id = "#{job.id}-output-auto"
-
-          [:duration, :audio_codec, :video_codec].each do |field|
-            output.send("#{field}=", outputs.first.send(field))
-          end
-          output.label = File.basename(adaptive_playlist)
-          output.url = adaptive_playlist
+          output.assign_tech_metadata(outputs.first.tech_metadata)
+          file_basename = File.basename(output.url)
+          output.id = format(output_id_format, output.tech_metadata.merge(job_id: job.id, suffix: '-auto'))
+          output.label = format(output_label_format(file_basename), output.tech_metadata.merge(job_id: job.id, suffix: '-auto', basename: file_basename))
           outputs << output
         end
         outputs
@@ -476,10 +512,21 @@ module ActiveEncode
       end
 
       def mediaconvert
-        @mediaconvert ||= begin
-          endpoint = Aws::MediaConvert::Client.new.describe_endpoints.endpoints.first.url
-          Aws::MediaConvert::Client.new(endpoint: endpoint)
-        end
+        @mediaconvert ||= RetriableClient.new
+      end
+
+      def probe(url)
+        # NOTE: certain audio files don't return any track information
+        @probe_cache ||= {}
+        @probe_cache[url] ||= mediaconvert.probe({ input_files: [{ file_url: url }] })&.probe_results&.first
+      end
+
+      def output_id_format
+        @output_id_format || "%{job_id}-output%{suffix}"
+      end
+
+      def output_label_format(file_basename)
+        @output_label_format || (file_basename.present? ? "%{basename}" : "%{suffix}")
       end
 
       def s3client

data/lib/active_encode/engine_adapters/media_convert_output.rb

@@ -35,8 +35,8 @@ module ActiveEncode
         # @param output_detail_settings [Aws::MediaConvert::Types::OutputDetail]
         def tech_metadata_from_settings(output_url:, output_settings:, output_detail_settings:)
           {
-            width: output_detail_settings.video_details.width_in_px,
-            height: output_detail_settings.video_details.height_in_px,
+            width: output_detail_settings.video_details&.width_in_px,
+            height: output_detail_settings.video_details&.height_in_px,
             frame_rate: extract_video_frame_rate(output_settings),
             duration: output_detail_settings.duration_in_ms,
             audio_codec: extract_audio_codec(output_settings),
@@ -44,7 +44,6 @@ module ActiveEncode
             audio_bitrate: extract_audio_bitrate(output_settings),
             video_bitrate: extract_video_bitrate(output_settings),
             url: output_url,
-            label: (output_url ? File.basename(output_url) : output_settings.name_modifier),
             suffix: output_settings.name_modifier
           }
         end
@@ -61,11 +60,33 @@ module ActiveEncode
             audio_bitrate: extract_audio_bitrate(settings),
             video_bitrate: extract_video_bitrate(settings),
             url: url,
-            label: File.basename(url),
             suffix: settings.name_modifier
           }
         end
 
+        def tech_metadata_from_probe(url:, probe_response:, output_settings: nil)
+          tech_md = { url: url, suffix: output_settings&.name_modifier }
+          return tech_md unless probe_response
+
+          # Need to determine which track has video/audio
+          video_track = probe_response.container.tracks&.find { |track| track.track_type == "video" }
+          audio_track = probe_response.container.tracks&.find { |track| track.track_type == "audio" }
+          frame_rate = (video_track.video_properties.frame_rate.numerator / video_track.video_properties.frame_rate.denominator.to_f).round(2) if video_track
+          duration = probe_response.container.duration * 1000 if probe_response.container.duration.present?
+
+          tech_md.merge({
+                          width: video_track&.video_properties&.width,
+                          height: video_track&.video_properties&.height,
+                          frame_rate: frame_rate,
+                          duration: duration, # milliseconds
+                          audio_codec: audio_track&.codec,
+                          video_codec: video_track&.codec,
+                          audio_bitrate: audio_track&.audio_properties&.bit_rate,
+                          video_bitrate: video_track&.video_properties&.bit_rate,
+                          file_size: probe_response.metadata.file_size
+                        })
+        end
+
         # constructs an `s3:` output URL  from the MediaConvert job params, the same
         # way MediaConvert will.
         #
@@ -110,27 +131,27 @@ module ActiveEncode
         end
 
         def extract_audio_codec(settings)
-          settings.audio_descriptions.first.codec_settings.codec
-        rescue
-          nil
+          settings.audio_descriptions&.first&.codec_settings&.codec
         end
 
         def extract_audio_codec_settings(settings)
-          codec_key = AUDIO_SETTINGS[extract_audio_codec(settings)]
+          codec = extract_audio_codec(settings)
+          return nil if codec.nil?
+
+          codec_key = AUDIO_SETTINGS[codec]
           settings.audio_descriptions.first.codec_settings[codec_key]
         end
 
         def extract_video_codec(settings)
-          settings.video_description.codec_settings.codec
-        rescue
-          nil
+          settings.video_description&.codec_settings&.codec
         end
 
         def extract_video_codec_settings(settings)
-          codec_key = VIDEO_SETTINGS[extract_video_codec(settings)]
+          codec = extract_video_codec(settings)
+          return nil if codec.nil?
+
+          codec_key = VIDEO_SETTINGS[codec]
           settings.video_description.codec_settings[codec_key]
-        rescue
-          nil
         end
 
         def extract_audio_bitrate(settings)

data/lib/active_encode/engine_adapters/pass_through_adapter.rb

@@ -234,13 +234,18 @@ module ActiveEncode
         doc.remove_namespaces!
         duration = get_xpath_text(doc, '//Duration/text()', :to_f)
         duration *= 1000 unless duration.nil? # Convert to milliseconds
+        audio_codec = get_xpath_text(doc, '//track[@type="Audio"]/CodecID/text()', :to_s)
+        if get_xpath_text(doc, '//track[@type="Audio"]/Format/text()', :to_s) == "MPEG Audio" &&
+           get_xpath_text(doc, '//track[@type="Audio"]/Format_Profile/text()', :to_s) == "Layer 3"
+          audio_codec ||= "mp3"
+        end
         { 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_codec: audio_codec,
           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) }

data/lib/active_encode/engine_adapters.rb

@@ -9,8 +9,6 @@ module ActiveEncode
   module EngineAdapters
     extend ActiveSupport::Autoload
 
-    autoload :MatterhornAdapter
-    autoload :ZencoderAdapter
     autoload :ElasticTranscoderAdapter
     autoload :TestAdapter
     autoload :FfmpegAdapter

data/lib/active_encode/technical_metadata.rb

@@ -36,5 +36,11 @@ module ActiveEncode
         send("#{field}=", metadata[field]) if metadata.key?(field)
       end
     end
+
+    def tech_metadata
+      [:width, :height, :frame_rate, :duration, :file_size, :checksum,
+       :audio_codec, :video_codec, :audio_bitrate, :video_bitrate, :subtitles,
+       :format, :language].index_with { |field| send(field) }
+    end
   end
 end

data/lib/active_encode/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module ActiveEncode
-  VERSION = '1.3.0'
+  VERSION = '2.0.0'
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: active_encode
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Michael Klein, Chris Colvard, Phuong Dinh
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-30 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -38,6 +37,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: retriable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: aws-sdk-cloudwatchevents
   requirement: !ruby/object:Gem::Requirement
@@ -100,14 +113,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.157.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.157.0
 - !ruby/object:Gem::Dependency
   name: aws-sdk-s3
   requirement: !ruby/object:Gem::Requirement
@@ -255,7 +268,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: This gem provides an interface to transcoding services such as Ffmpeg,
-  Amazon Elastic Transcoder, or Zencoder.
+  Amazon Elastic Transcoder, or Amazon Elemental MediaConvert.
 email:
 - mbklein@gmail.com, chris.colvard@gmail.com, phuongdh@gmail.com
 executables: []
@@ -293,12 +306,10 @@ files:
 - lib/active_encode/engine_adapters/elastic_transcoder_adapter.rb
 - lib/active_encode/engine_adapters/ffmpeg_adapter.rb
 - lib/active_encode/engine_adapters/ffmpeg_adapter/cleaner.rb
-- lib/active_encode/engine_adapters/matterhorn_adapter.rb
 - lib/active_encode/engine_adapters/media_convert_adapter.rb
 - lib/active_encode/engine_adapters/media_convert_output.rb
 - lib/active_encode/engine_adapters/pass_through_adapter.rb
 - lib/active_encode/engine_adapters/test_adapter.rb
-- lib/active_encode/engine_adapters/zencoder_adapter.rb
 - lib/active_encode/errors.rb
 - lib/active_encode/filename_sanitizer.rb
 - lib/active_encode/global_id.rb
@@ -317,7 +328,6 @@ licenses:
 - Apache-2.0
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -332,8 +342,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Declare encode job classes that can be run by a variety of encoding services
 test_files: []

data/lib/active_encode/engine_adapters/matterhorn_adapter.rb

@@ -1,300 +0,0 @@
-# frozen_string_literal: true
-require 'rubyhorn'
-
-module ActiveEncode
-  module EngineAdapters
-    class MatterhornAdapter
-      DEFAULT_ARGS = { 'flavor' => 'presenter/source' }.freeze
-
-      def create(input_url, options = {})
-        workflow_id = options[:preset] || "full"
-        workflow_om = Rubyhorn.client.addMediaPackageWithUrl(DEFAULT_ARGS.merge('workflow' => workflow_id, 'url' => input_url, 'filename' => File.basename(input_url), 'title' => File.basename(input_url)))
-        build_encode(get_workflow(workflow_om))
-      end
-
-      def find(id, _opts = {})
-        build_encode(fetch_workflow(id))
-      end
-
-      def cancel(id)
-        workflow_om = Rubyhorn.client.stop(id)
-        build_encode(get_workflow(workflow_om))
-      end
-
-      private
-
-      def fetch_workflow(id)
-        workflow_om = begin
-          Rubyhorn.client.instance_xml(id)
-                      rescue Rubyhorn::RestClient::Exceptions::HTTPNotFound
-                        nil
-        end
-
-        workflow_om ||= begin
-          Rubyhorn.client.get_stopped_workflow(id)
-                        rescue
-                          nil
-        end
-
-        get_workflow(workflow_om)
-      end
-
-      def get_workflow(workflow_om)
-        return nil if workflow_om.nil?
-        if workflow_om.ng_xml.is_a? Nokogiri::XML::Document
-          workflow_om.ng_xml.remove_namespaces!.root
-        else
-          workflow_om.ng_xml
-        end
-      end
-
-      def build_encode(workflow)
-        return nil if workflow.nil?
-        input_url = convert_input(workflow)
-        input_url = get_workflow_title(workflow) if input_url.blank?
-        encode = ActiveEncode::Base.new(input_url, convert_options(workflow))
-        encode.id = convert_id(workflow)
-        encode.state = convert_state(workflow)
-        encode.current_operations = convert_current_operations(workflow)
-        encode.percent_complete = calculate_percent_complete(workflow)
-        encode.created_at = convert_created_at(workflow)
-        encode.updated_at = convert_updated_at(workflow) || encode.created_at
-        encode.output = convert_output(workflow, encode.options)
-        encode.errors = convert_errors(workflow)
-
-        encode.input.id = "presenter/source"
-        encode.input.state = encode.state
-        encode.input.created_at = encode.created_at
-        encode.input.updated_at = encode.updated_at
-        tech_md = convert_tech_metadata(workflow)
-        [:width, :height, :duration, :frame_rate, :checksum, :audio_codec, :video_codec,
-         :audio_bitrate, :video_bitrate].each do |field|
-          encode.input.send("#{field}=", tech_md[field])
-        end
-
-        encode
-      end
-
-      def convert_id(workflow)
-        workflow.attribute('id').to_s
-      end
-
-      def get_workflow_state(workflow)
-        workflow.attribute('state').to_s
-      end
-
-      def convert_state(workflow)
-        case get_workflow_state(workflow)
-        when "INSTANTIATED", "RUNNING" # Should there be a queued state?
-          :running
-        when "STOPPED"
-          :cancelled
-        when "FAILED"
-          workflow.xpath('//operation[@state="FAILED"]').empty? ? :cancelled : :failed
-        when "SUCCEEDED", "SKIPPED" # Should there be a errored state?
-          :completed
-        end
-      end
-
-      def convert_input(workflow)
-        # Need to do anything else since this is a MH url? and this disappears when a workflow is cleaned up
-        workflow.xpath('mediapackage/media/track[@type="presenter/source"]/url/text()').to_s.strip
-      end
-
-      def get_workflow_title(workflow)
-        workflow.xpath('mediapackage/title/text()').to_s.strip
-      end
-
-      def convert_tech_metadata(workflow)
-        convert_track_metadata(workflow.xpath('//track[@type="presenter/source"]').first)
-      end
-
-      def convert_output(workflow, options)
-        outputs = []
-        workflow.xpath('//track[@type="presenter/delivery" and tags/tag[text()="streaming"]]').each do |track|
-          output = ActiveEncode::Output.new
-          output.label = track.xpath('tags/tag[starts-with(text(),"quality")]/text()').to_s
-          output.url = track.at("url/text()").to_s
-          if output.url.start_with? "rtmp"
-            output.url = File.join(options[:stream_base], MatterhornRtmpUrl.parse(output.url).to_path) if options[:stream_base]
-          end
-          output.id = track.at("@id").to_s
-
-          tech_md = convert_track_metadata(track)
-          [:width, :height, :frame_rate, :duration, :checksum, :audio_codec, :video_codec,
-           :audio_bitrate, :video_bitrate, :file_size].each do |field|
-            output.send("#{field}=", tech_md[field])
-          end
-
-          output.state = :completed
-          output.created_at = convert_output_created_at(track, workflow)
-          output.updated_at = convert_output_updated_at(track, workflow)
-
-          outputs << output
-        end
-        outputs
-      end
-
-      def convert_current_operations(workflow)
-        current_op = workflow.xpath('//operation[@state!="INSTANTIATED"]/@description').last.to_s
-        current_op.present? ? [current_op] : []
-      end
-
-      def convert_errors(workflow)
-        workflow.xpath('//errors/error/text()').map(&:to_s)
-      end
-
-      def convert_created_at(workflow)
-        created_at = workflow.xpath('mediapackage/@start').last.to_s
-        created_at.present? ? Time.parse(created_at).utc : nil
-      end
-
-      def convert_updated_at(workflow)
-        updated_at = workflow.xpath('//operation[@state!="INSTANTIATED"]/completed/text()').last.to_s
-        updated_at.present? ? Time.strptime(updated_at, "%Q") : nil
-      end
-
-      def convert_output_created_at(track, workflow)
-        quality = track.xpath('tags/tag[starts-with(text(),"quality")]/text()').to_s
-        created_at = workflow.xpath("//operation[@id=\"compose\"][configurations/configuration[@key=\"target-tags\" and contains(text(), \"#{quality}\")]]/started/text()").to_s
-        created_at.present? ? Time.at(created_at.to_i / 1000.0).utc : nil
-      end
-
-      def convert_output_updated_at(track, workflow)
-        quality = track.xpath('tags/tag[starts-with(text(),"quality")]/text()').to_s
-        updated_at = workflow.xpath("//operation[@id=\"compose\"][configurations/configuration[@key=\"target-tags\" and contains(text(), \"#{quality}\")]]/completed/text()").to_s
-        updated_at.present? ? Time.at(updated_at.to_i / 1000.0).utc : nil
-      end
-
-      def convert_options(workflow)
-        options = {}
-        options[:preset] = workflow.xpath('template/text()').to_s
-        if workflow.xpath('//properties/property[@key="avalon.stream_base"]/text()').present?
-          options[:stream_base] = workflow.xpath('//properties/property[@key="avalon.stream_base"]/text()').to_s
-        end # this is avalon-felix specific
-        options
-      end
-
-      def convert_track_metadata(track)
-        return {} if track.nil?
-        metadata = {}
-        # metadata[:mime_type] = track.at("mimetype/text()").to_s if track.at('mimetype')
-        metadata[:checksum] = track.at("checksum/text()").to_s.strip if track.at('checksum')
-        metadata[:duration] = track.at("duration/text()").to_s.to_i if track.at('duration')
-        if track.at('audio')
-          metadata[:audio_codec] = track.at("audio/encoder/@type").to_s
-          metadata[:audio_channels] = track.at("audio/channels/text()").to_s
-          metadata[:audio_bitrate] = track.at("audio/bitrate/text()").to_s.to_f
-        end
-        if track.at('video')
-          metadata[:video_codec] = track.at("video/encoder/@type").to_s
-          metadata[:video_bitrate] = track.at("video/bitrate/text()").to_s.to_f
-          metadata[:frame_rate] = track.at("video/framerate/text()").to_s.to_f
-          metadata[:width] = track.at("video/resolution/text()").to_s.split('x')[0].to_i
-          metadata[:height] = track.at("video/resolution/text()").to_s.split('x')[1].to_i
-        end
-        metadata
-      end
-
-      def get_media_package(workflow)
-        mp = workflow.xpath('//mediapackage')
-        first_node = mp.first
-        first_node['xmlns'] = 'http://mediapackage.opencastproject.org'
-        mp
-      end
-
-      def calculate_percent_complete(workflow)
-        totals = {
-          transcode: 70,
-          distribution: 20,
-          other: 10
-        }
-
-        completed_transcode_operations = workflow.xpath('//operation[@id="compose" and (@state="SUCCEEDED" or @state="SKIPPED")]').size
-        total_transcode_operations = workflow.xpath('//operation[@id="compose"]').size
-        total_transcode_operations = 1 if total_transcode_operations.zero?
-        completed_distribution_operations = workflow.xpath('//operation[starts-with(@id,"distribute") and (@state="SUCCEEDED" or @state="SKIPPED")]').size
-        total_distribution_operations = workflow.xpath('//operation[starts-with(@id,"distribute")]').size
-        total_distribution_operations = 1 if total_distribution_operations.zero?
-        completed_other_operations = workflow.xpath('//operation[@id!="compose" and not(starts-with(@id,"distribute")) and (@state="SUCCEEDED" or @state="SKIPPED")]').size
-        total_other_operations = workflow.xpath('//operation[@id!="compose" and not(starts-with(@id,"distribute"))]').size
-        total_other_operations = 1 if total_other_operations.zero?
-
-        ((totals[:transcode].to_f / total_transcode_operations) * completed_transcode_operations) +
-          ((totals[:distribution].to_f / total_distribution_operations) * completed_distribution_operations) +
-          ((totals[:other].to_f / total_other_operations) * completed_other_operations)
-      end
-
-      def create_multiple_files(input, workflow_id)
-        # Create empty media package xml document
-        mp = Rubyhorn.client.createMediaPackage
-
-        # Next line associates workflow title to avalon via masterfile pid
-        title = File.basename(input.values.first)
-        dc = Nokogiri::XML('<dublincore xmlns="http://www.opencastproject.org/xsd/1.0/dublincore/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><dcterms:title>' + title + '</dcterms:title></dublincore>')
-        mp = Rubyhorn.client.addDCCatalog('mediaPackage' => mp.to_xml, 'dublinCore' => dc.to_xml, 'flavor' => 'dublincore/episode')
-
-        # Add quality levels - repeated for each supplied file url
-        input.each_pair do |quality, url|
-          mp = Rubyhorn.client.addTrack('mediaPackage' => mp.to_xml, 'url' => url, 'flavor' => DEFAULT_ARGS['flavor'])
-          # Rewrite track to include quality tag
-          # Get the empty tags element under the newly added track
-          tags = mp.xpath('//xmlns:track/xmlns:tags[not(node())]', 'xmlns' => 'http://mediapackage.opencastproject.org').first
-          quality_tag = Nokogiri::XML::Node.new 'tag', mp
-          quality_tag.content = quality
-          tags.add_child quality_tag
-        end
-        # Finally ingest the media package
-        begin
-                Rubyhorn.client.start("definitionId" => workflow_id, "mediapackage" => mp.to_xml)
-        rescue Rubyhorn::RestClient::Exceptions::HTTPBadRequest
-          # make this two calls...one to get the workflow definition xml and then the second to submit it along with the mediapackage to start...due to unsolved issue with some MH installs
-          begin
-                  workflow_definition_xml = Rubyhorn.client.definition_xml(workflow_id)
-                  Rubyhorn.client.start("definition" => workflow_definition_xml, "mediapackage" => mp.to_xml)
-          rescue Rubyhorn::RestClient::Exceptions::HTTPNotFound
-            raise StandardError, "Unable to start workflow"
-                end
-              end
-      end
-    end
-
-    class MatterhornRtmpUrl
-      class_attribute :members
-      self.members = %i[application prefix media_id stream_id filename extension]
-      attr_accessor(*members)
-      REGEX = %r{^
-  /(?<application>.+)        # application (avalon)
-  /(?:(?<prefix>.+):)?       # prefix      (mp4:)
-  (?<media_id>[^\/]+)        # media_id    (98285a5b-603a-4a14-acc0-20e37a3514bb)
-  /(?<stream_id>[^\/]+)      # stream_id   (b3d5663d-53f1-4f7d-b7be-b52fd5ca50a3)
-  /(?<filename>.+?)          # filename    (MVI_0057)
-  (?:\.(?<extension>.+))?$   # extension   (mp4)
-      }x.freeze
-
-      # @param [MatchData] match_data
-      def initialize(match_data)
-        self.class.members.each do |key|
-          send("#{key}=", match_data[key])
-        end
-      end
-
-      def self.parse(url_string)
-        # Example input: /avalon/mp4:98285a5b-603a-4a14-acc0-20e37a3514bb/b3d5663d-53f1-4f7d-b7be-b52fd5ca50a3/MVI_0057.mp4
-
-        uri = URI.parse(url_string)
-        match_data = REGEX.match(uri.path)
-        MatterhornRtmpUrl.new match_data
-      end
-
-      alias _binding binding
-      def binding
-        _binding
-      end
-
-      def to_path
-        File.join(media_id, stream_id, "#{filename}.#{extension || prefix}")
-      end
-    end
-  end
-end

data/lib/active_encode/engine_adapters/zencoder_adapter.rb

@@ -1,156 +0,0 @@
-# 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 = {})
-        response = Zencoder::Job.create(input: input_url.to_s)
-        build_encode(get_job_details(response.body["id"]))
-      end
-
-      def find(id, _opts = {})
-        build_encode(get_job_details(id))
-      end
-
-      def cancel(id)
-        response = Zencoder::Job.cancel(id)
-        build_encode(get_job_details(id)) if response.success?
-      end
-
-      private
-
-      def get_job_details(job_id)
-        Zencoder::Job.details(job_id)
-      end
-
-      def get_job_progress(job_id)
-        Zencoder::Job.progress(job_id)
-      end
-
-      def build_encode(job_details)
-        return nil if job_details.nil?
-        encode = ActiveEncode::Base.new(convert_input(job_details), convert_options(job_details))
-        encode.id = job_details.body["job"]["id"].to_s
-        encode.state = convert_state(get_job_state(job_details))
-        job_progress = get_job_progress(encode.id)
-        encode.current_operations = convert_current_operations(job_progress)
-        encode.percent_complete = convert_percent_complete(job_progress, job_details)
-        encode.created_at = job_details.body["job"]["created_at"]
-        encode.updated_at = job_details.body["job"]["updated_at"]
-        encode.errors = []
-
-        encode.output = convert_output(job_details, job_progress)
-
-        encode.input.id = job_details.body["job"]["input_media_file"]["id"].to_s
-        encode.input.errors = convert_input_errors(job_details)
-        tech_md = convert_tech_metadata(job_details.body["job"]["input_media_file"])
-        [:width, :height, :frame_rate, :duration, :checksum, :audio_codec, :video_codec,
-         :audio_bitrate, :video_bitrate, :file_size].each do |field|
-          encode.input.send("#{field}=", tech_md[field])
-        end
-        encode.input.state = convert_state(job_details.body["job"]["input_media_file"]["state"])
-        encode.input.created_at = job_details.body["job"]["input_media_file"]["created_at"]
-        encode.input.updated_at = job_details.body["job"]["input_media_file"]["updated_at"]
-
-        encode
-      end
-
-      def convert_state(state)
-        case state
-        when "assigning", "pending", "waiting", "processing" # Should there be a queued state?
-          :running
-        when "cancelled"
-          :cancelled
-        when "failed", "no_input"
-          :failed
-        when "finished"
-          :completed
-        end
-      end
-
-      def get_job_state(job_details)
-        job_details.body["job"]["state"]
-      end
-
-      def convert_current_operations(job_progress)
-        current_ops = []
-        job_progress.body["outputs"].each { |output| current_ops << output["current_event"] unless output["current_event"].nil? }
-        current_ops
-      end
-
-      def convert_percent_complete(job_progress, job_details)
-        percent = job_progress.body["progress"]
-        percent ||= 100 if convert_state(get_job_state(job_details)) == :completed
-        percent ||= 0
-        percent
-      end
-
-      def convert_input(job_details)
-        job_details.body["job"]["input_media_file"]["url"]
-      end
-
-      def convert_options(_job_details)
-        {}
-      end
-
-      def convert_output(job_details, job_progress)
-        job_details.body["job"]["output_media_files"].collect do |o|
-          output = ActiveEncode::Output.new
-          output.id = o["id"].to_s
-          output.label = o["label"]
-          output.url = o["url"]
-          output.errors = Array(o["error_message"])
-
-          tech_md = convert_tech_metadata(o)
-          [:width, :height, :frame_rate, :duration, :checksum, :audio_codec, :video_codec,
-           :audio_bitrate, :video_bitrate, :file_size].each do |field|
-            output.send("#{field}=", tech_md[field])
-          end
-          output_progress = job_progress.body["outputs"].find { |out_prog| out_prog["id"] = output.id }
-          output.state = convert_state(output_progress["state"])
-          output.created_at = o["created_at"]
-          output.updated_at = o["updated_at"]
-          output
-        end
-      end
-
-      def convert_input_errors(job_details)
-        Array(job_details.body["job"]["input_media_file"]["error_message"])
-      end
-
-      def convert_tech_metadata(media_file)
-        return {} if media_file.nil?
-
-        metadata = {}
-        media_file.each_pair do |key, value|
-          next if value.blank?
-          case key
-          when "md5_checksum"
-            metadata[:checksum] = value
-          when "format"
-            metadata[:mime_type] = value
-          when "duration_in_ms"
-            metadata[:duration] = value
-          when "audio_codec"
-            metadata[:audio_codec] = value
-          when "channels"
-            metadata[:audio_channels] = value
-          when "audio_bitrate_in_kbps"
-            metadata[:audio_bitrate] = value
-          when "video_codec"
-            metadata[:video_codec] = value
-          when "frame_rate"
-            metadata[:frame_rate] = value
-          when "video_bitrate_in_kbps"
-            metadata[:video_bitrate] = value
-          when "width"
-            metadata[:width] = value
-          when "height"
-            metadata[:height] = value
-          end
-        end
-        metadata
-      end
-    end
-  end
-end