active_encode 0.8.0 → 1.0.0

data/guides/media_convert_adapter.md

@@ -0,0 +1,208 @@
+# MediaConvertAdapter
+
+
+To use active_encode with MediaConvert, you will need:
+
+* An AWS account that has access to create MediaConvert jobs
+* An AWS [IAM service role that has access to necessary AWS resources](https://docs.aws.amazon.com/mediaconvert/latest/ug/iam-role.html).
+* An S3 bucket to store source files
+* An S3 bucket to store derivatives (recommended to be separate)
+* Existing [MediaConvert Output presets](https://docs.aws.amazon.com/mediaconvert/latest/ug/creating-preset-from-scratch.html) to define your outputs (eg desired HLS adaptive variants)
+* EventBridge/Cloudfront setup to store output (can be automatically created by code we include here)
+* You have to add these gems to your project Gemfile, that are required for
+ the mediaconvert adapter but not included as active_encode dependencies:
+  * aws-sdk-cloudwatchevents
+  * aws-sdk-cloudwatchlogs
+  * aws-sdk-mediaconvert
+  * aws-sdk-s3
+
+You may find this tutorial helpful to create the AWS resources you need, or debug the process: https://github.com/aws-samples/aws-media-services-simple-vod-workflow (mainly the firsst two modules).
+
+## Note: No Technical Metadata
+
+This adapter does _not_ perform input characterization or fill out technical metadata in the encoding job `input` object. technical metadata in `encode.input` such as `width`, `duration`,
+or `video_codec` will be nil.
+
+## CloudWatch and EventBridge setup, optionally with setup!
+
+[AWS Elemental MediaConvert](https://aws.amazon.com/mediaconvert/) makes it difficult to acesss
+detailed output information in the job description that can be pulled directly from the service. One way to work around this is capture the MediaConvert job status notification
+when the job status changes to `COMPLETE`, via an
+[Amazon Eventbridge](https://aws.amazon.com/eventbridge/) rule that forwards the status change
+notification to another service for capture and/or handling -- for instance a CloudWatch Logs]
+(https://aws.amazon.com/cloudwatch/) log group.
+
+`ActiveEncode::EngineAdapters::MediaConvert` is written to get detailed output information from just such a setup, a CloudWatch log group that has been set up to receive MediaConvert job status `COMPLETE` notifications via an EventBridge rule.
+
+We proide a method to create this CloudWatch and EventBridge infrastructure for you, the `#setup!` method.
+
+
+```ruby
+ActiveEncode::Base.engine_adapter = :media_convert
+ActiveEncode::Base.engine_adapter.setup!
+```
+
+The active AWS user/role when calling the `#setup!` method will require permissions to create the
+necessary CloudWatch and EventBridge resources.
+
+The `setup!` task will create an EventBridge rule name and CloudWatch log group name based on the MediaConvert queue setting, by default `"Default"`. So:
+* EventBridge rule: `active-encode-mediaconvert-Default`
+* Log group name: `/aws/events/active-encode/mediaconvert/Default`
+
+The names chosen will respect the `log_group` and `queue` config though, if set.
+
+
+**Alternately**, we have an experimental flag to get and derive what output information 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, try:
+
+    ActiveEncode::Base.engine_adapter.direct_output_lookup = true
+
+
+## Configuration
+
+Some parameters are set as (typically global) configuration, while others are passed in as parameters to `create`. Here we'll discuss the configuration.
+
+
+* `role`. Required. An IAM role that the MediaConvert job will run under. This is [required by MediaConvert](https://docs.aws.amazon.com/mediaconvert/latest/ug/iam-role.html), it can't just use your current AWS credentials.
+
+* `output_bucket`. Required.  An S3 bucket name, all output will be written to this bucket, at a path prefix specified in the `create` call.
+
+* `log_group`. Optional, unusual. Specify the name of the CloudWatch log group to use for logging. By default, will be constructed automatically from the MediaConvert queue to use.
+
+* `queue`. Optional, unusual. Specify the name of the [MediaConvert queue](https://docs.aws.amazon.com/mediaconvert/latest/ug/working-with-queues.html) to use. By default it will use the MediaConvert default, called `"Default"`. Ordinarily there is no reason to set this.
+
+```ruby
+ActiveEncode::Base.engine_adapter = :media_convert
+
+ActiveEncode::Base.engine_adapter.role = 'arn:aws:iam::11111111111111:role/my-role-name'
+ActiveEncode::Base.engine_adapter.output_bucket = 'my-bucket-name'
+```
+
+
+## Input and output options, and the masterfile_bucket
+
+The adapter can take a local file as argument (via `file://` URL or any other standard way for ActiveEncode), _or_ an `s3://` URL.
+
+The input, whether local file _or_ remote S3 file, is normally _copied_ to a random-string-path location on the `masterfile_bucket`, and then that copy is used as input for the MediaConvert process.  Unless the input is already an `s3://` URL located in the `masterfile_bucket`, then it is just used.
+
+
+```ruby
+ActiveEncode::Base.create(
+  "file://path/to/file.mp4",
+  {
+    masterfile_bucket: "my-masterfile-bucket"
+    output_prefix: "path/to/output/base_name_of_outputs",
+    outputs: [
+      { preset: "my-hls-preset-high", modifier: "_high" },
+      { preset: "my-hls-preset-medium", modifier: "_medium" },
+      { preset: "my-hls-preset-low", modifier: "_low" }
+    ]
+  }
+)
+# your input will be COPIED to my-masterfile-bucket and that copy passed
+# as an input to the MediaConvert operation.
+```
+
+However, if you pass the `use_original_url` bucket, then an `s3://` input URL you pass in will _not_ be copied to `masterfile_bucket`, but passed direct as input to the MediaConvert process.
+
+```ruby
+ActiveEncode::Base.create(
+  "s3://some-other-bucket/path/to/file.mp4",
+  {
+    masterfile_bucket: "my-masterfile-bucket"
+    use_original_url: true,
+    output_prefix: "path/to/output/base_name_of_outputs",
+    outputs: [
+      { preset: "my-hls-preset-high", modifier: "_high" },
+      { preset: "my-hls-preset-medium", modifier: "_medium" },
+    ]
+  }
+)
+# the S3 input will be used directly as input to the MediaConvert process,
+# it will not be copied to the masterfile_bucket first.
+```
+
+Only in this case of `use_original_url` and an `s3://` input source, the `masterfile_bucket` argument can be ommitted, since it will be used.
+
+You can also use `destination` instead of `output_prefix`, to supply a complete `s3://` url,
+ignoring `output_bucket` config. With `use_original_url` you can now supply inputs and
+outputs as simple s3 urls.
+
+```ruby
+ActiveEncode::Base.create(
+  "s3://some-other-bucket/path/to/file.mp4",
+  {
+    use_original_url: true,
+    destination: "s3://my-output-bucket/path/to/output/base_name_of_outputs",
+    outputs: [
+      { preset: "my-hls-preset-high", modifier: "_high" },
+      { preset: "my-hls-preset-medium", modifier: "_medium" },
+    ]
+  }
+)
+```
+
+## AWS Auth Credentials
+
+The adapter, when interacting with AWS services, will interact with AWS using the [current AWS credentials looked up from environment](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/setup-config.html#aws-ruby-sdk-setting-credentials) in the standard way, such as the `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` [environmental variables](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html), or [on disk at in a credentials file](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html).
+
+The IAM identity, in order to issue MediaConvert jobs and get output information from CloudWatch, will need the following permissions, such as in this example policy:
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Sid": "mediaconvertActions",
+      "Effect": "Allow",
+      "Action": "mediaconvert:*",
+      "Resource": "*"
+    },
+    {
+      "Sid": "iamPassRole",
+      "Effect": "Allow",
+      "Action": "iam:PassRole",
+      "Resource": "arn:aws:iam::111122223333:role/MediaConvertRole"
+    },
+    {
+      "Sid": "logsStartQuery",
+      "Effect": "Allow",
+      "Action": "logs:StartQuery",
+      "Resource": "*"
+    },
+    {
+      "Sid": "logsGetQuery",
+      "Effect": "Allow",
+      "Action": "logs:GetQueryResult",
+      "Resource": "*"
+    },
+  ]
+}
+```
+
+Where the `iamPassRole` resource is the role you will pass in the `role` configuration. The `logsStartQuery` and `logsGetQuery` permissions could probably additionally be limited to the specific CloudWatch log group.
+
+MediaConvert necessarily [requires you to pass a separate IAM role](https://docs.aws.amazon.com/mediaconvert/latest/ug/iam-role.html) that will be used by the actual MediaConvert operation -- the `role` config for this adapter. That role will need this permission:
+
+```json
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Effect": "Allow",
+            "Action": [
+                "execute-api:Invoke",
+                "execute-api:ManageConnections"
+            ],
+            "Resource": "arn:aws:execute-api:*:*:*"
+        }
+    ]
+}
+```
+
+In addition to read/write access to the relevant S3 buckets.
+
+Also see [this tutorial](https://github.com/aws-samples/aws-media-services-simple-vod-workflow/blob/master/1-IAMandS3/README.md#1-create-an-iam-role-to-use-with-aws-elemental-mediaconvert)
+
+

data/lib/active_encode/base.rb

@@ -11,7 +11,7 @@ require 'active_encode/global_id'
 require 'active_encode/persistence'
 require 'active_encode/polling'
 
-module ActiveEncode #:nodoc:
+module ActiveEncode # :nodoc:
   class Base
     include Core
     include Status

data/lib/active_encode/core.rb

@@ -73,19 +73,19 @@ module ActiveEncode
 
     protected
 
-      def merge!(encode)
-        @id = encode.id
-        @input = encode.input
-        @output = encode.output
-        @options = encode.options
-        @state = encode.state
-        @errors = encode.errors
-        @created_at = encode.created_at
-        @updated_at = encode.updated_at
-        @current_operations = encode.current_operations
-        @percent_complete = encode.percent_complete
-
-        self
-      end
+    def merge!(encode)
+      @id = encode.id
+      @input = encode.input
+      @output = encode.output
+      @options = encode.options
+      @state = encode.state
+      @errors = encode.errors
+      @created_at = encode.created_at
+      @updated_at = encode.updated_at
+      @current_operations = encode.current_operations
+      @percent_complete = encode.percent_complete
+
+      self
+    end
   end
 end

data/lib/active_encode/engine_adapter.rb

@@ -6,7 +6,7 @@ require 'active_support/core_ext/string/inflections'
 module ActiveEncode
   # The <tt>ActiveEncode::EngineAdapter</tt> module is used to load the
   # correct adapter. The default engine adapter is the :active_job engine.
-  module EngineAdapter #:nodoc:
+  module EngineAdapter # :nodoc:
     extend ActiveSupport::Concern
 
     included do
@@ -29,21 +29,21 @@ module ActiveEncode
 
       private
 
-        def interpret_adapter(name_or_adapter_or_class)
-          case name_or_adapter_or_class
-          when Symbol, String
-            ActiveEncode::EngineAdapters.lookup(name_or_adapter_or_class).new
-          else
-            name_or_adapter_or_class if engine_adapter?(name_or_adapter_or_class)
-            raise ArgumentError unless engine_adapter?(name_or_adapter_or_class)
-          end
+      def interpret_adapter(name_or_adapter_or_class)
+        case name_or_adapter_or_class
+        when Symbol, String
+          ActiveEncode::EngineAdapters.lookup(name_or_adapter_or_class).new
+        else
+          name_or_adapter_or_class if engine_adapter?(name_or_adapter_or_class)
+          raise ArgumentError unless engine_adapter?(name_or_adapter_or_class)
         end
+      end
 
-        ENGINE_ADAPTER_METHODS = %i[create find cancel].freeze
+      ENGINE_ADAPTER_METHODS = %i[create find cancel].freeze
 
-        def engine_adapter?(object)
-          ENGINE_ADAPTER_METHODS.all? { |meth| object.respond_to?(meth) }
-        end
+      def engine_adapter?(object)
+        ENGINE_ADAPTER_METHODS.all? { |meth| object.respond_to?(meth) }
+      end
     end
   end
 end

data/lib/active_encode/engine_adapters/elastic_transcoder_adapter.rb

@@ -41,194 +41,194 @@ module ActiveEncode
 
       private
 
-        # Needs region and credentials setup per http://docs.aws.amazon.com/sdkforruby/api/Aws/ElasticTranscoder/Client.html
-        def client
-          @client ||= Aws::ElasticTranscoder::Client.new
-        end
+      # Needs region and credentials setup per http://docs.aws.amazon.com/sdkforruby/api/Aws/ElasticTranscoder/Client.html
+      def client
+        @client ||= Aws::ElasticTranscoder::Client.new
+      end
 
-        def s3client
-          Aws::S3::Client.new
-        end
+      def s3client
+        Aws::S3::Client.new
+      end
 
-        def get_job_details(job_id)
-          client.read_job(id: job_id)&.job
-        end
+      def get_job_details(job_id)
+        client.read_job(id: job_id)&.job
+      end
 
-        def build_encode(job)
-          return nil if job.nil?
-          encode = ActiveEncode::Base.new(convert_input(job), {})
-          encode.id = job.id
-          encode.state = JOB_STATES[job.status]
-          encode.current_operations = []
-          encode.percent_complete = convert_percent_complete(job)
-          encode.created_at = convert_time(job.timing["submit_time_millis"])
-          encode.updated_at = convert_time(job.timing["finish_time_millis"]) || convert_time(job.timing["start_time_millis"]) || encode.created_at
-
-          encode.output = convert_output(job)
-          encode.errors = job.outputs.select { |o| o.status == "Error" }.collect(&:status_detail).compact
-
-          tech_md = convert_tech_metadata(job.input.detected_properties)
-          [:width, :height, :frame_rate, :duration, :file_size].each do |field|
-            encode.input.send("#{field}=", tech_md[field])
-          end
+      def build_encode(job)
+        return nil if job.nil?
+        encode = ActiveEncode::Base.new(convert_input(job), {})
+        encode.id = job.id
+        encode.state = JOB_STATES[job.status]
+        encode.current_operations = []
+        encode.percent_complete = convert_percent_complete(job)
+        encode.created_at = convert_time(job.timing["submit_time_millis"])
+        encode.updated_at = convert_time(job.timing["finish_time_millis"]) || convert_time(job.timing["start_time_millis"]) || encode.created_at
 
-          encode.input.id = job.id
-          encode.input.state = encode.state
-          encode.input.created_at = encode.created_at
-          encode.input.updated_at = encode.updated_at
+        encode.output = convert_output(job)
+        encode.errors = job.outputs.select { |o| o.status == "Error" }.collect(&:status_detail).compact
 
-          encode
+        tech_md = convert_tech_metadata(job.input.detected_properties)
+        [:width, :height, :frame_rate, :duration, :file_size].each do |field|
+          encode.input.send("#{field}=", tech_md[field])
         end
 
-        def convert_time(time_millis)
-          return nil if time_millis.nil?
-          Time.at(time_millis / 1000).utc
-        end
+        encode.input.id = job.id
+        encode.input.state = encode.state
+        encode.input.created_at = encode.created_at
+        encode.input.updated_at = encode.updated_at
 
-        def convert_bitrate(rate)
-          return nil if rate.nil?
-          (rate.to_f * 1024).to_s
-        end
+        encode
+      end
 
-        def convert_state(job)
-          case job.status
-          when "Submitted", "Progressing" # Should there be a queued state?
-            :running
-          when "Canceled"
-            :cancelled
-          when "Error"
-            :failed
-          when "Complete"
-            :completed
-          end
-        end
+      def convert_time(time_millis)
+        return nil if time_millis.nil?
+        Time.at(time_millis / 1000).utc
+      end
 
-        def convert_percent_complete(job)
-          job.outputs.inject(0) { |sum, output| sum + output_percentage(output) } / job.outputs.length
-        end
+      def convert_bitrate(rate)
+        return nil if rate.nil?
+        (rate.to_f * 1024).to_s
+      end
 
-        def output_percentage(output)
-          case output.status
-          when "Submitted"
-            10
-          when "Progressing", "Canceled", "Error"
-            50
-          when "Complete"
-            100
-          else
-            0
-          end
+      def convert_state(job)
+        case job.status
+        when "Submitted", "Progressing" # Should there be a queued state?
+          :running
+        when "Canceled"
+          :cancelled
+        when "Error"
+          :failed
+        when "Complete"
+          :completed
         end
+      end
 
-        def convert_input(job)
-          job.input.key
-        end
+      def convert_percent_complete(job)
+        job.outputs.inject(0) { |sum, output| sum + output_percentage(output) } / job.outputs.length
+      end
 
-        def copy_to_input_bucket(input_url, bucket)
-          case Addressable::URI.parse(input_url).scheme
-          when nil, 'file'
-            upload_to_s3 input_url, bucket
-          when 's3'
-            check_s3_bucket input_url, bucket
-          end
+      def output_percentage(output)
+        case output.status
+        when "Submitted"
+          10
+        when "Progressing", "Canceled", "Error"
+          50
+        when "Complete"
+          100
+        else
+          0
         end
+      end
 
-        def check_s3_bucket(input_url, source_bucket)
-          # logger.info("Checking `#{input_url}'")
-          s3_object = FileLocator::S3File.new(input_url).object
-          if s3_object.bucket_name == source_bucket
-            # logger.info("Already in bucket `#{source_bucket}'")
-            s3_object.key
-          else
-            s3_key = File.join(SecureRandom.uuid, s3_object.key)
-            # logger.info("Copying to `#{source_bucket}/#{input_url}'")
-            target = Aws::S3::Object.new(bucket_name: source_bucket, key: input_url)
-            target.copy_from(s3_object, multipart_copy: s3_object.size > 15_728_640) # 15.megabytes
-            s3_key
-          end
-        end
+      def convert_input(job)
+        job.input.key
+      end
 
-        def upload_to_s3(input_url, source_bucket)
-          # original_input = input_url
-          bucket = Aws::S3::Resource.new(client: s3client).bucket(source_bucket)
-          filename = FileLocator.new(input_url).location
-          s3_key = File.join(SecureRandom.uuid, File.basename(filename))
-          # logger.info("Copying `#{original_input}' to `#{source_bucket}/#{input_url}'")
-          obj = bucket.object(s3_key)
-          obj.upload_file filename
+      def copy_to_input_bucket(input_url, bucket)
+        case Addressable::URI.parse(input_url).scheme
+        when nil, 'file'
+          upload_to_s3 input_url, bucket
+        when 's3'
+          check_s3_bucket input_url, bucket
+        end
+      end
 
+      def check_s3_bucket(input_url, source_bucket)
+        # logger.info("Checking `#{input_url}'")
+        s3_object = FileLocator::S3File.new(input_url).object
+        if s3_object.bucket_name == source_bucket
+          # logger.info("Already in bucket `#{source_bucket}'")
+          s3_object.key
+        else
+          s3_key = File.join(SecureRandom.uuid, s3_object.key)
+          # logger.info("Copying to `#{source_bucket}/#{input_url}'")
+          target = Aws::S3::Object.new(bucket_name: source_bucket, key: input_url)
+          target.copy_from(s3_object, multipart_copy: s3_object.size > 15_728_640) # 15.megabytes
           s3_key
         end
+      end
 
-        def read_preset(id)
-          @presets ||= {}
-          @presets[id] ||= client.read_preset(id: id).preset
-        end
+      def upload_to_s3(input_url, source_bucket)
+        # original_input = input_url
+        bucket = Aws::S3::Resource.new(client: s3client).bucket(source_bucket)
+        filename = FileLocator.new(input_url).location
+        s3_key = File.join(SecureRandom.uuid, File.basename(filename))
+        # logger.info("Copying `#{original_input}' to `#{source_bucket}/#{input_url}'")
+        obj = bucket.object(s3_key)
+        obj.upload_file filename
 
-        def convert_output(job)
-          @pipeline ||= client.read_pipeline(id: job.pipeline_id).pipeline
-          job.outputs.collect do |joutput|
-            preset = read_preset(joutput.preset_id)
-            extension = preset.container == 'ts' ? '.m3u8' : ''
-            additional_metadata = {
-              managed: false,
-              id: joutput.id,
-              label: joutput.key.split("/", 2).first,
-              url: "s3://#{@pipeline.output_bucket}/#{job.output_key_prefix}#{joutput.key}#{extension}"
-            }
-            tech_md = convert_tech_metadata(joutput, preset).merge(additional_metadata)
-
-            output = ActiveEncode::Output.new
-            output.state = convert_state(joutput)
-            output.created_at = convert_time(job.timing["submit_time_millis"])
-            output.updated_at = convert_time(job.timing["finish_time_millis"] || job.timing["start_time_millis"]) || 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
-          end
-        end
+        s3_key
+      end
 
-        def convert_errors(job)
-          job.outputs.select { |o| o.status == "Error" }.collect(&:status_detail).compact
-        end
+      def read_preset(id)
+        @presets ||= {}
+        @presets[id] ||= client.read_preset(id: id).preset
+      end
 
-        def convert_tech_metadata(props, preset = nil)
-          return {} if props.nil? || props.empty?
-          metadata_fields = {
-            file_size: { key: :file_size, method: :itself },
-            duration_millis: { key: :duration, method: :to_i },
-            frame_rate: { key: :frame_rate, method: :to_i },
-            segment_duration: { key: :segment_duration, method: :itself },
-            width: { key: :width, method: :itself },
-            height: { key: :height, method: :itself }
+      def convert_output(job)
+        @pipeline ||= client.read_pipeline(id: job.pipeline_id).pipeline
+        job.outputs.collect do |joutput|
+          preset = read_preset(joutput.preset_id)
+          extension = preset.container == 'ts' ? '.m3u8' : ''
+          additional_metadata = {
+            managed: false,
+            id: joutput.id,
+            label: joutput.key.split("/", 2).first,
+            url: "s3://#{@pipeline.output_bucket}/#{job.output_key_prefix}#{joutput.key}#{extension}"
           }
+          tech_md = convert_tech_metadata(joutput, preset).merge(additional_metadata)
 
-          metadata = {}
-          props.each_pair do |key, value|
-            next if value.nil?
-            conversion = metadata_fields[key.to_sym]
-            next if conversion.nil?
-            metadata[conversion[:key]] = value.send(conversion[:method])
-          end
+          output = ActiveEncode::Output.new
+          output.state = convert_state(joutput)
+          output.created_at = convert_time(job.timing["submit_time_millis"])
+          output.updated_at = convert_time(job.timing["finish_time_millis"] || job.timing["start_time_millis"]) || output.created_at
 
-          unless preset.nil?
-            audio = preset.audio
-            video = preset.video
-            metadata.merge!(
-              audio_codec: audio&.codec,
-              audio_channels: audio&.channels,
-              audio_bitrate: convert_bitrate(audio&.bit_rate),
-              video_codec: video&.codec,
-              video_bitrate: convert_bitrate(video&.bit_rate)
-            )
+          [: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
 
-          metadata
+          output
         end
+      end
+
+      def convert_errors(job)
+        job.outputs.select { |o| o.status == "Error" }.collect(&:status_detail).compact
+      end
+
+      def convert_tech_metadata(props, preset = nil)
+        return {} if props.blank?
+        metadata_fields = {
+          file_size: { key: :file_size, method: :itself },
+          duration_millis: { key: :duration, method: :to_i },
+          frame_rate: { key: :frame_rate, method: :to_i },
+          segment_duration: { key: :segment_duration, method: :itself },
+          width: { key: :width, method: :itself },
+          height: { key: :height, method: :itself }
+        }
+
+        metadata = {}
+        props.each_pair do |key, value|
+          next if value.nil?
+          conversion = metadata_fields[key.to_sym]
+          next if conversion.nil?
+          metadata[conversion[:key]] = value.send(conversion[:method])
+        end
+
+        unless preset.nil?
+          audio = preset.audio
+          video = preset.video
+          metadata.merge!(
+            audio_codec: audio&.codec,
+            audio_channels: audio&.channels,
+            audio_bitrate: convert_bitrate(audio&.bit_rate),
+            video_codec: video&.codec,
+            video_bitrate: convert_bitrate(video&.bit_rate)
+          )
+        end
+
+        metadata
+      end
     end
   end
 end