streamio-ffmpeg 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f7d05b3e4d5f1e43f04cea131e8f5f7e3772dec
-  data.tar.gz: 645f8fcfd8691bb62c27e4182374316512b78de9
+  metadata.gz: 7a9cde12ae96942f93cff233ac586afa9dcb804d
+  data.tar.gz: 9fc3c59bbd8ebdcf0aa00dac17a0314c8490e877
 SHA512:
-  metadata.gz: 5ec0c612684983472f87288d1f8216c1762969ab4271f53a092d5e34141d975ec3121e9f54667467fc5e11364517d54fef17a9d858c04b1c042c8494b0b727b6
-  data.tar.gz: f362e03fcc8c05558e46cda6b6f4ab62ab3b9aadb5f67e030806403a29f6ffca3a0d5e58dc6f1dea175005e42094f20e2a1a7fc4fcfde136d1ecc17b7ac332b9
+  metadata.gz: 02226d4978a610a81cf08c154a99aeb18782a85e0e1071d836e9da1c57e0920780758f210490e7003ece9e551c2f2fc0247648be8ce8f0a4abebeb3a6ce61969
+  data.tar.gz: c31ab9b785ea8f1b58e009c2770c91caf9a4071bab81cadac187bb74dfa34e049f30269b7514800e7c1578169537949ce33551523f7226c34e8d4122fdd364e5

data/CHANGELOG

@@ -2,6 +2,27 @@
 
 Current with 2.0.0
 
+== 2.1.0 2016-08-08
+
+New:
+* Issue #135, Support creating slideshows from stills
+* Issue #130, Adds support for a URL as an input
+* Support for specifying options to apply to the input file
+* Improved support for calling  FFMpeg with popen3, improving compatibility with various platforms, including windows
+* Issue #111. uses attr_accessor for the timeout attribute
+* Exposes the movie's entire meta data and format tags as movie attributes
+* Issue #122, adds encoding fix to stderr
+* All specs pass and brought current with Rspec V3
+* Issue #123, #131 improved stream validation, ignoring additional invalid streams if a valid stream is recognized
+* Issue #124, improved parsing for moving creation_time
+* SAR and DAR now adapt after rotation, DAR is ignored when calculating dimensions
+
+Improvements:
+* Allow parenthesis in colorspace (thanks walterdavis for initial code and rociiu for finding a bug with it)
+* Width and height now switched if video is filmed in portrait mode. ffmpeg 2.7 or later now automatically rotates output
+* Movie metadata now provided with ffprobe (#114). Thanks to Ryan Lovelett for the contributions!
+* Ability to create multiple screenshots at consistent intervals in one pass (#113)
+
 == 2.0.0 2016-01-14
 
 New:

data/README.md

@@ -130,6 +130,38 @@ options = {video_min_bitrate: 600, video_max_bitrate: 600, buffer_size: 2000}
 movie.transcode("movie.flv", options)
 ```
 
+### Specifying Input Options
+
+To specify which options apply the input, such as changing the input framerate, use `input_options` hash
+in the transcoder_options.
+
+``` ruby
+movie = FFMPEG::Movie.new("path/to/movie.mov")
+
+transcoder_options = { input_options: { framerate: '1/5' } }
+movie.transcode("movie.mp4", {}, transcoder_options)
+
+# FFMPEG Command will look like this:
+# ffmpeg -y -framerate 1/5 -i path/to/movie.mov movie.mp4
+```
+
+### Overriding the Input Path
+
+If FFMPEG's input path needs to specify a sequence of files, rather than a path to a single movie, transcoding_options
+`input` can be set. If this option is present, the path of the original movie will not be used.
+
+``` ruby
+movie = FFMPEG::Movie.new("path/to/movie.mov")
+
+transcoder_options = { input: 'img_%03d.png' }
+movie.transcode("movie.mp4", {}, transcoder_options)
+
+# FFMPEG Command will look like this:
+# ffmpeg -y -i img_%03d.png movie.mp4
+```
+
+### Watermarking
+
 Add watermark image on the video.
 
 For example, you want to add a watermark on the video at right top corner with 10px padding.
@@ -139,6 +171,8 @@ options = { watermark: "full_path_of_watermark.png", resolution: "640x360", wate
 ```
 
 Position can be "LT" (Left Top Corner), "RT" (Right Top Corner), "LB" (Left Bottom Corner), "RB" (Right Bottom Corner).
+The watermark will not appear unless `watermark_options` specifies the position. `padding_x` and `padding_y` default to
+`10`.
 
 ### Taking Screenshots
 
@@ -154,18 +188,18 @@ The screenshot method has the very same API as transcode so the same options wil
 movie.screenshot("screenshot.bmp", seek_time: 5, resolution: '320x240')
 ```
 
-To generate multiple screenshots in a single pass, specify `vframes`. The following code
-generates up to 20 screenshots every 10 seconds:
+To generate multiple screenshots in a single pass, specify `vframes` and a wildcard filename. Make
+sure to disable output file validation. The following code generates up to 20 screenshots every 10 seconds:
 
 ``` ruby
-movie.screenshot("screenshot.jpg", vframes: 20, frame_rate: '1/6')
+movie.screenshot("screenshot_%d.jpg", {vframes: 20, frame_rate: '1/6'}, validate: false)
 ```
 
 To specify the quality when generating compressed screenshots (.jpg), use `quality` which specifies
 ffmpeg `-v:q` option. Quality is an integer between 1 and 31, where lower is better quality:
 
 ``` ruby
-movie.screenshot("screenshot.jpg", quality: 3)
+movie.screenshot("screenshot_%d.jpg", quality: 3)
 ```
 
 You can preserve aspect ratio the same way as when using transcode.
@@ -174,6 +208,18 @@ You can preserve aspect ratio the same way as when using transcode.
 movie.screenshot("screenshot.png", { seek_time: 2, resolution: '200x120' }, preserve_aspect_ratio: :width)
 ```
 
+### Create a Slideshow from Stills
+Creating a slideshow from stills uses named sequences of files and stiches the result together in a slideshow
+video.
+
+Since there is not movie to transcode, the Transcoder class needs to be used. The input and input_options are
+provided through transcoder options.
+
+``` ruby
+slideshow_transcoder = FFMPEG::Transcoder.new('', 'slideshow.mp4', {resolution: "320x240"}, input: 'img_%03d.jpeg', input_options: {framerate: '1/5' })
+slideshow = slideshow_transcoder.run
+```
+
 Specify the path to ffmpeg
 --------------------------
 

data/lib/ffmpeg/encoding_options.rb

@@ -4,22 +4,34 @@ module FFMPEG
       merge!(options)
     end
 
-    def to_s
-      params = collect do |key, value|
-        send("convert_#{key}", value) if value && supports_option?(key)
+    def params_order(k)
+      if k =~ /watermark$/
+        0
+      elsif k =~ /watermark/
+        1
+      elsif k =~ /codec/
+        2
+      elsif k =~ /preset/
+        3
+      else
+        4
       end
+    end
+
+    def to_a
+      params = []
 
       # codecs should go before the presets so that the files will be matched successfully
       # all other parameters go after so that we can override whatever is in the preset
-      codecs = params.select { |p| p =~ /codec/ }
-      presets = params.select { |p| p =~ /\-.pre/ }
-      watermarkoptions = params.select { |p| p =~ /i / || p=~ /filter_complex/ }  
-      other = params - codecs - presets - watermarkoptions
-      params = watermarkoptions + codecs + presets + other
+      keys.sort_by{|k| params_order(k) }.each do |key|
+
+        value   = self[key]
+        a = send("convert_#{key}", value) if value && supports_option?(key)
+        params += a unless a.nil?
+      end
 
-      params_string = params.join(" ")
-      params_string << " #{convert_aspect(calculate_aspect)}" if calculate_aspect?
-      params_string
+      params += convert_aspect(calculate_aspect) if calculate_aspect?
+      params.map(&:to_s)
     end
 
     def width
@@ -37,7 +49,7 @@ module FFMPEG
     end
 
     def convert_aspect(value)
-      "-aspect #{value}"
+      ["-aspect", value]
     end
 
     def calculate_aspect
@@ -50,121 +62,130 @@ module FFMPEG
     end
 
     def convert_video_codec(value)
-      "-vcodec #{value}"
+      ["-vcodec", value]
     end
 
     def convert_frame_rate(value)
-      "-r #{value}"
+      ["-r", value]
     end
 
     def convert_resolution(value)
-      "-s #{value}"
+      ["-s", value]
     end
 
     def convert_video_bitrate(value)
-      "-b:v #{k_format(value)}"
+      ["-b:v", k_format(value)]
     end
 
     def convert_audio_codec(value)
-      "-acodec #{value}"
+      ["-acodec", value]
     end
 
     def convert_audio_bitrate(value)
-      "-b:a #{k_format(value)}"
+      ["-b:a", k_format(value)]
     end
 
     def convert_audio_sample_rate(value)
-      "-ar #{value}"
+      ["-ar", value]
     end
 
     def convert_audio_channels(value)
-      "-ac #{value}"
+      ["-ac", value]
     end
 
     def convert_video_max_bitrate(value)
-      "-maxrate #{k_format(value)}"
+      ["-maxrate", k_format(value)]
     end
 
     def convert_video_min_bitrate(value)
-      "-minrate #{k_format(value)}"
+      ["-minrate", k_format(value)]
     end
 
     def convert_buffer_size(value)
-      "-bufsize #{k_format(value)}"
+      ["-bufsize", k_format(value)]
     end
 
     def convert_video_bitrate_tolerance(value)
-      "-bt #{k_format(value)}"
+      ["-bt", k_format(value)]
     end
 
     def convert_threads(value)
-      "-threads #{value}"
+      ["-threads", value]
     end
 
     def convert_target(value)
-      "-target #{value}"
+      ['-target', value]
     end
 
     def convert_duration(value)
-      "-t #{value}"
+      ["-t", value]
     end
 
     def convert_video_preset(value)
-      "-vpre #{value}"
+      ["-vpre", value]
     end
 
     def convert_audio_preset(value)
-      "-apre #{value}"
+      ["-apre", value]
     end
 
     def convert_file_preset(value)
-      "-fpre #{value}"
+      ["-fpre", value]
     end
 
     def convert_keyframe_interval(value)
-      "-g #{value}"
+      ["-g", value]
     end
 
     def convert_seek_time(value)
-      "-ss #{value}"
+      ["-ss", value]
     end
 
     def convert_screenshot(value)
-      vframes = '-vframes 1 ' unless self[:vframes]
-      value ? "#{vframes}-f image2" : ""
+      result = []
+      unless self[:vframes]
+        result << '-vframes'
+        result << 1
+      end
+      result << '-f'
+      result << 'image2'
+      value ? result : []
     end
 
     def convert_quality(value)
-      "-q:v #{value}"
+      ['-q:v', value]
     end
 
     def convert_vframes(value)
-      "-vframes #{value}"
+      ['-vframes', value]
     end
 
     def convert_x264_vprofile(value)
-      "-vprofile #{value}"
+      ["-vprofile", value]
     end
 
     def convert_x264_preset(value)
-      "-preset #{value}"
+      ["-preset", value]
     end
 
     def convert_watermark(value)
-      "-i #{value}"
+      ["-i", value]
     end
 
     def convert_watermark_filter(value)
-      case value[:position].to_s
-      when "LT"
-        "-filter_complex 'scale=#{self[:resolution]},overlay=x=#{value[:padding_x]}:y=#{value[:padding_y]}'"
-      when "RT"
-        "-filter_complex 'scale=#{self[:resolution]},overlay=x=main_w-overlay_w-#{value[:padding_x]}:y=#{value[:padding_y]}'"
-      when "LB"
-        "-filter_complex 'scale=#{self[:resolution]},overlay=x=#{value[:padding_x]}:y=main_h-overlay_h-#{value[:padding_y]}'"
-      when "RB"
-        "-filter_complex 'scale=#{self[:resolution]},overlay=x=main_w-overlay_w-#{value[:padding_x]}:y=main_h-overlay_h-#{value[:padding_y]}'"
-      end  
+      position = value[:position]
+      padding_x = value[:padding_x] || 10
+      padding_y = value[:padding_y] || 10
+      case position.to_s
+        when "LT"
+          ["-filter_complex", "scale=#{self[:resolution]},overlay=x=#{padding_x}:y=#{padding_y}"]
+        when "RT"
+          ["-filter_complex", "scale=#{self[:resolution]},overlay=x=main_w-overlay_w-#{padding_x}:y=#{padding_y}"]
+        when "LB"
+          ["-filter_complex", "scale=#{self[:resolution]},overlay=x=#{padding_x}:y=main_h-overlay_h-#{padding_y}"]
+        when "RB"
+          ["-filter_complex", "scale=#{self[:resolution]},overlay=x=main_w-overlay_w-#{padding_x}:y=main_h-overlay_h-#{padding_y}"]
+      end
     end
 
     def convert_custom(value)

data/lib/ffmpeg/movie.rb

@@ -1,5 +1,6 @@
 require 'time'
 require 'multi_json'
+require 'uri'
 
 module FFMPEG
   class Movie
@@ -7,52 +8,72 @@ module FFMPEG
     attr_reader :video_stream, :video_codec, :video_bitrate, :colorspace, :width, :height, :sar, :dar, :frame_rate
     attr_reader :audio_stream, :audio_codec, :audio_bitrate, :audio_sample_rate, :audio_channels
     attr_reader :container
+    attr_reader :metadata, :format_tags
+
+    UNSUPPORTED_CODEC_PATTERN = /^Unsupported codec with id (\d+) for input stream (\d+)$/
 
     def initialize(path)
-      raise Errno::ENOENT, "the file '#{path}' does not exist" unless File.exist?(path)
+      @path = path
+
+      if remote?
+        @head = head
+        raise Errno::ENOENT, "the URL '#{path}' does not exist" if @head.nil? || @head.code.to_i != 200
+      else
+        raise Errno::ENOENT, "the file '#{path}' does not exist" unless File.exist?(path)
+      end
 
       @path = path
 
       # ffmpeg will output to stderr
-      command = "#{FFMPEG.ffprobe_binary} -i #{Shellwords.escape(path)} -print_format json -show_format -show_streams -show_error"
+      command = [FFMPEG.ffprobe_binary, '-i', path, *['-print_format', 'json', '-show_format', '-show_streams', '-show_error']]
       std_output = ''
       std_error = ''
 
-      Open3.popen3(command) do |stdin, stdout, stderr|
+      Open3.popen3(*command) do |stdin, stdout, stderr|
         std_output = stdout.read unless stdout.nil?
         std_error = stderr.read unless stderr.nil?
       end
 
       fix_encoding(std_output)
+      fix_encoding(std_error)
 
-      metadata = MultiJson.load(std_output, symbolize_keys: true)
+      begin
+        @metadata = MultiJson.load(std_output, symbolize_keys: true)
+      rescue MultiJson::ParseError
+        raise "Could not parse output from FFProbe:\n#{ std_output }"
+      end
 
-      if metadata.key?(:error)
+      if @metadata.key?(:error)
 
         @duration = 0
 
       else
+        video_streams = @metadata[:streams].select { |stream| stream.key?(:codec_type) and stream[:codec_type] === 'video' }
+        audio_streams = @metadata[:streams].select { |stream| stream.key?(:codec_type) and stream[:codec_type] === 'audio' }
 
-        video_streams = metadata[:streams].select { |stream| stream.key?(:codec_type) and stream[:codec_type] === 'video' }
-        audio_streams = metadata[:streams].select { |stream| stream.key?(:codec_type) and stream[:codec_type] === 'audio' }
+        @container = @metadata[:format][:format_name]
 
-        @container = metadata[:format][:format_name]
+        @duration = @metadata[:format][:duration].to_f
 
-        @duration = metadata[:format][:duration].to_f
+        @time = @metadata[:format][:start_time].to_f
 
-        @time = metadata[:format][:start_time].to_f
+        @format_tags = @metadata[:format][:tags]
 
-        @creation_time = if metadata[:format].key?(:tags) and metadata[:format][:tags].key?(:creation_time)
-                           Time.parse(metadata[:format][:tags][:creation_time])
+        @creation_time = if @format_tags and @format_tags.key?(:creation_time)
+                           begin
+                             Time.parse(@format_tags[:creation_time])
+                           rescue ArgumentError
+                             nil
+                           end
                          else
                            nil
                          end
 
-        @bitrate = metadata[:format][:bit_rate].to_i
+        @bitrate = @metadata[:format][:bit_rate].to_i
 
-        unless video_streams.empty?
-          # TODO: Handle multiple video codecs (is that possible?)
-          video_stream = video_streams.first
+        # TODO: Handle multiple video codecs (is that possible?)
+        video_stream = video_streams.first
+        unless video_stream.nil?
           @video_codec = video_stream[:codec_name]
           @colorspace = video_stream[:pix_fmt]
           @width = video_stream[:width]
@@ -76,9 +97,9 @@ module FFMPEG
                       end
         end
 
-        unless audio_streams.empty?
-          # TODO: Handle multiple audio codecs
-          audio_stream = audio_streams.first
+        # TODO: Handle multiple audio codecs
+        audio_stream = audio_streams.first
+        unless audio_stream.nil?
           @audio_channels = audio_stream[:channels].to_i
           @audio_codec = audio_stream[:codec_name]
           @audio_sample_rate = audio_stream[:sample_rate].to_i
@@ -89,16 +110,35 @@ module FFMPEG
 
       end
 
-      @invalid = true if metadata.key?(:error)
-      @invalid = true if std_error.include?("Unsupported codec")
-      @invalid = true if std_error.include?("is not supported")
+      unsupported_stream_ids = unsupported_streams(std_error)
+      nil_or_unsupported = -> (stream) { stream.nil? || unsupported_stream_ids.include?(stream[:index]) }
+
+      @invalid = true if nil_or_unsupported.(video_stream) && nil_or_unsupported.(audio_stream)
+      @invalid = true if @metadata.key?(:error)
       @invalid = true if std_error.include?("could not find codec parameters")
     end
 
+    def unsupported_streams(std_error)
+      [].tap do |stream_indices|
+        std_error.each_line do |line|
+          match = line.match(UNSUPPORTED_CODEC_PATTERN)
+          stream_indices << match[2].to_i if match
+        end
+      end
+    end
+
     def valid?
       not @invalid
     end
 
+    def remote?
+      @path =~ URI::regexp
+    end
+
+    def local?
+      not remote?
+    end
+
     def width
       rotation.nil? || rotation == 180 ? @width : @height;
     end
@@ -122,7 +162,11 @@ module FFMPEG
     end
 
     def size
-      File.size(@path)
+      if local?
+        File.size(@path)
+      else
+        @head.content_length
+      end
     end
 
     def audio_channel_layout
@@ -151,14 +195,14 @@ module FFMPEG
     def aspect_from_dar
       return nil unless dar
       w, h = dar.split(":")
-      aspect = w.to_f / h.to_f
+      aspect = (@rotation==nil) || (@rotation==180)? (w.to_f / h.to_f):(h.to_f / w.to_f)
       aspect.zero? ? nil : aspect
     end
 
     def aspect_from_sar
       return nil unless sar
       w, h = sar.split(":")
-      aspect = w.to_f / h.to_f
+      aspect = (@rotation==nil) || (@rotation==180)? (w.to_f / h.to_f):(h.to_f / w.to_f)
       aspect.zero? ? nil : aspect
     end
 
@@ -172,5 +216,16 @@ module FFMPEG
     rescue ArgumentError
       output.force_encoding("ISO-8859-1")
     end
+
+    def head
+      url = URI(@path)
+      return unless url.path
+
+      http = Net::HTTP.new(url.host, url.port)
+      http.use_ssl = url.port == 443
+      http.request_head(url.path)
+    rescue SocketError, Errno::ECONNREFUSED
+      nil
+    end
   end
 end

data/lib/ffmpeg/transcoder.rb

@@ -1,23 +1,23 @@
 require 'open3'
-require 'shellwords'
 
 module FFMPEG
   class Transcoder
-    @@timeout = 30
+    attr_reader :command, :input
 
-    def self.timeout=(time)
-      @@timeout = time
-    end
+    @@timeout = 30
 
-    def self.timeout
-      @@timeout
+    class << self
+      attr_accessor :timeout
     end
 
-    def initialize(movie, output_file, options = EncodingOptions.new, transcoder_options = {})
-      @movie = movie
+    def initialize(input, output_file, options = EncodingOptions.new, transcoder_options = {})
+      if input.is_a?(FFMPEG::Movie)
+        @movie = input
+        @input = input.path
+      end
       @output_file = output_file
 
-      if options.is_a?(String) || options.is_a?(EncodingOptions)
+      if options.is_a?(Array) || options.is_a?(EncodingOptions)
         @raw_options = options
       elsif options.is_a?(Hash)
         @raw_options = EncodingOptions.new(options)
@@ -29,6 +29,14 @@ module FFMPEG
       @errors = []
 
       apply_transcoder_options
+
+      @input = @transcoder_options[:input] unless @transcoder_options[:input].nil?
+
+      input_options = @transcoder_options[:input_options] || []
+      iopts = []
+      input_options.each { |k, v| iopts += ['-' + k.to_s, v] }
+
+      @command = [FFMPEG.ffmpeg_binary, '-y', *iopts, '-i', @input, *@raw_options.to_a, @output_file]
     end
 
     def run(&block)
@@ -51,14 +59,17 @@ module FFMPEG
       @encoded ||= Movie.new(@output_file)
     end
 
+    def timeout
+      self.class.timeout
+    end
+
     private
     # frame= 4855 fps= 46 q=31.0 size=   45306kB time=00:02:42.28 bitrate=2287.0kbits/
     def transcode_movie
-      @command = "#{FFMPEG.ffmpeg_binary} -y -i #{Shellwords.escape(@movie.path)} #{@raw_options} #{Shellwords.escape(@output_file)}"
-      FFMPEG.logger.info("Running transcoding...\n#{@command}\n")
+      FFMPEG.logger.info("Running transcoding...\n#{command}\n")
       @output = ""
 
-      Open3.popen3(@command) do |_stdin, _stdout, stderr, wait_thr|
+      Open3.popen3(*command) do |_stdin, _stdout, stderr, wait_thr|
         begin
           yield(0.0) if block_given?
           next_line = Proc.new do |line|
@@ -75,14 +86,14 @@ module FFMPEG
             end
           end
 
-          if @@timeout
-            stderr.each_with_timeout(wait_thr.pid, @@timeout, 'size=', &next_line)
+          if timeout
+            stderr.each_with_timeout(wait_thr.pid, timeout, 'size=', &next_line)
           else
             stderr.each('size=', &next_line)
           end
 
         rescue Timeout::Error => e
-          FFMPEG.logger.error "Process hung...\n@command\n#{@command}\nOutput\n#{@output}\n"
+          FFMPEG.logger.error "Process hung...\n@command\n#{command}\nOutput\n#{@output}\n"
           raise Error, "Process hung. Full output: #{@output}"
         end
       end
@@ -91,10 +102,10 @@ module FFMPEG
     def validate_output_file(&block)
       if encoding_succeeded?
         yield(1.0) if block_given?
-        FFMPEG.logger.info "Transcoding of #{@movie.path} to #{@output_file} succeeded\n"
+        FFMPEG.logger.info "Transcoding of #{input} to #{@output_file} succeeded\n"
       else
         errors = "Errors: #{@errors.join(", ")}. "
-        FFMPEG.logger.error "Failed encoding...\n#{@command}\n\n#{@output}\n#{errors}\n"
+        FFMPEG.logger.error "Failed encoding...\n#{command}\n\n#{@output}\n#{errors}\n"
         raise Error, "Failed encoding.#{errors}Full output: #{@output}"
       end
     end
@@ -103,7 +114,7 @@ module FFMPEG
        # if true runs #validate_output_file
       @transcoder_options[:validate] = @transcoder_options.fetch(:validate) { true }
 
-      return if @movie.calculated_aspect_ratio.nil?
+      return if @movie.nil? || @movie.calculated_aspect_ratio.nil?
       case @transcoder_options[:preserve_aspect_ratio].to_s
       when "width"
         new_height = @raw_options.width / @movie.calculated_aspect_ratio

data/lib/ffmpeg/version.rb

@@ -1,3 +1,3 @@
 module FFMPEG
-  VERSION = '2.0.0'
+  VERSION = '2.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: streamio-ffmpeg
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Rackfish AB
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-19 00:00:00.000000000 Z
+date: 2016-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -89,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.6.6
 signing_key: 
 specification_version: 4
 summary: Wraps ffmpeg to read metadata and transcodes videos.