streamio-ffmpeg 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b2f7f026d79edbb50b3cc2a727970b24ddc14e35
-  data.tar.gz: 1eb3016af722ac698e9ffa27515b515f7683bf7a
+  metadata.gz: 6f7d05b3e4d5f1e43f04cea131e8f5f7e3772dec
+  data.tar.gz: 645f8fcfd8691bb62c27e4182374316512b78de9
 SHA512:
-  metadata.gz: bd2bde719ec750a394f4a9143d117355e615d7302d9da8c02d58300b59fed78c7e7e85c2d8b4821221cc21fc402c6bc94982596db37df85f121915aa3b889265
-  data.tar.gz: 448a6304a0c99eb13a1540bf8a99f45db9d8a08f12d7430a08a6f4b7a6a0a12746f9b1211587ff226a5c37184d81438ab3fd18780a393ba7439c9e30a44a472b
+  metadata.gz: 5ec0c612684983472f87288d1f8216c1762969ab4271f53a092d5e34141d975ec3121e9f54667467fc5e11364517d54fef17a9d858c04b1c042c8494b0b727b6
+  data.tar.gz: f362e03fcc8c05558e46cda6b6f4ab62ab3b9aadb5f67e030806403a29f6ffca3a0d5e58dc6f1dea175005e42094f20e2a1a7fc4fcfde136d1ecc17b7ac332b9

data/CHANGELOG

@@ -1,3 +1,19 @@
+== Master
+
+Current with 2.0.0
+
+== 2.0.0 2016-01-14
+
+New:
+* Support watermarking (thanks smoothdvd)
+* Bumped target ffmpeg version to 2.8
+
+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)
+
 == 1.0.0 2013-07-08
 
 New:

data/README.md

@@ -23,7 +23,9 @@ Will not work in jruby until they fix: http://goo.gl/Z4UcX (should work in the u
 
 ### ffmpeg
 
-The current gem is tested against ffmpeg 1.2.1. So no guarantees with earlier (or much later) versions. Output and input standards have inconveniently changed rather a lot between versions of ffmpeg. My goal is to keep this library in sync with new versions of ffmpeg as they come along.
+The current gem is tested against ffmpeg 2.8.4. So no guarantees with earlier (or much later) 
+versions. Output and input standards have inconveniently changed rather a lot between versions 
+of ffmpeg. My goal is to keep this library in sync with new versions of ffmpeg as they come along.
 
 Usage
 -----
@@ -85,7 +87,7 @@ Use the EncodingOptions parser for humanly readable transcoding options. Below y
 ``` ruby
 options = {video_codec: "libx264", frame_rate: 10, resolution: "320x240", video_bitrate: 300, video_bitrate_tolerance: 100,
            aspect: 1.333333, keyframe_interval: 90,
-           x264_profile: "high", x264_preset: "slow",
+           x264_vprofile: "high", x264_preset: "slow",
            audio_codec: "libfaac", audio_bitrate: 32, audio_sample_rate: 22050, audio_channels: 1,
            threads: 2,
            custom: "-vf crop=60:60:10:10"}
@@ -128,6 +130,16 @@ options = {video_min_bitrate: 600, video_max_bitrate: 600, buffer_size: 2000}
 movie.transcode("movie.flv", options)
 ```
 
+Add watermark image on the video.
+
+For example, you want to add a watermark on the video at right top corner with 10px padding.
+
+``` ruby
+options = { watermark: "full_path_of_watermark.png", resolution: "640x360", watermark_filter: { position: "RT", padding_x: 10, padding_y: 10 } }
+```
+
+Position can be "LT" (Left Top Corner), "RT" (Right Top Corner), "LB" (Left Bottom Corner), "RB" (Right Bottom Corner).
+
 ### Taking Screenshots
 
 You can use the screenshot method to make taking screenshots a bit simpler.
@@ -142,6 +154,20 @@ 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:
+
+``` ruby
+movie.screenshot("screenshot.jpg", vframes: 20, frame_rate: '1/6')
+```
+
+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)
+```
+
 You can preserve aspect ratio the same way as when using transcode.
 
 ``` ruby
@@ -151,7 +177,7 @@ movie.screenshot("screenshot.png", { seek_time: 2, resolution: '200x120' }, pres
 Specify the path to ffmpeg
 --------------------------
 
-By default, streamio assumes that the ffmpeg binary is available in the execution path and named ffmpeg and so will run commands that look something like "ffmpeg -i /path/to/input.file ...". Use the FFMPEG.ffmpeg_binary setter to specify the full path to the binary if necessary:
+By default, the gem assumes that the ffmpeg binary is available in the execution path and named ffmpeg and so will run commands that look something like "ffmpeg -i /path/to/input.file ...". Use the FFMPEG.ffmpeg_binary setter to specify the full path to the binary if necessary:
 
 ``` ruby
 FFMPEG.ffmpeg_binary = '/usr/local/bin/ffmpeg'
@@ -163,7 +189,7 @@ This will cause the same command to run as "/usr/local/bin/ffmpeg -i /path/to/in
 Automatically kill hung processes
 ---------------------------------
 
-By default, streamio will wait for 30 seconds between IO feedback from the FFMPEG process. After which an error is logged and the process killed.
+By default, the gem will wait for 30 seconds between IO feedback from the FFMPEG process. After which an error is logged and the process killed.
 It is possible to modify this behaviour by setting a new default:
 
 ``` ruby

data/lib/ffmpeg/encoding_options.rb

@@ -13,8 +13,9 @@ module FFMPEG
       # 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/ }
-      other = params - codecs - presets
-      params = codecs + presets + other
+      watermarkoptions = params.select { |p| p =~ /i / || p=~ /filter_complex/ }  
+      other = params - codecs - presets - watermarkoptions
+      params = watermarkoptions + codecs + presets + other
 
       params_string = params.join(" ")
       params_string << " #{convert_aspect(calculate_aspect)}" if calculate_aspect?
@@ -100,6 +101,10 @@ module FFMPEG
       "-threads #{value}"
     end
 
+    def convert_target(value)
+      "-target #{value}"
+    end
+
     def convert_duration(value)
       "-t #{value}"
     end
@@ -125,7 +130,16 @@ module FFMPEG
     end
 
     def convert_screenshot(value)
-      value ? "-vframes 1 -f image2" : ""
+      vframes = '-vframes 1 ' unless self[:vframes]
+      value ? "#{vframes}-f image2" : ""
+    end
+
+    def convert_quality(value)
+      "-q:v #{value}"
+    end
+
+    def convert_vframes(value)
+      "-vframes #{value}"
     end
 
     def convert_x264_vprofile(value)
@@ -136,6 +150,23 @@ module FFMPEG
       "-preset #{value}"
     end
 
+    def convert_watermark(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  
+    end
+
     def convert_custom(value)
       value
     end

data/lib/ffmpeg/movie.rb

@@ -1,63 +1,98 @@
 require 'time'
+require 'multi_json'
 
 module FFMPEG
   class Movie
     attr_reader :path, :duration, :time, :bitrate, :rotation, :creation_time
-    attr_reader :video_stream, :video_codec, :video_bitrate, :colorspace, :resolution, :dar
-    attr_reader :audio_stream, :audio_codec, :audio_bitrate, :audio_sample_rate
+    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
 
     def initialize(path)
-      raise Errno::ENOENT, "the file '#{path}' does not exist" unless File.exists?(path)
+      raise Errno::ENOENT, "the file '#{path}' does not exist" unless File.exist?(path)
 
       @path = path
 
       # ffmpeg will output to stderr
-      command = "#{FFMPEG.ffmpeg_binary} -i #{Shellwords.escape(path)}"
-      output = Open3.popen3(command) { |stdin, stdout, stderr| stderr.read }
+      command = "#{FFMPEG.ffprobe_binary} -i #{Shellwords.escape(path)} -print_format json -show_format -show_streams -show_error"
+      std_output = ''
+      std_error = ''
 
-      fix_encoding(output)
+      Open3.popen3(command) do |stdin, stdout, stderr|
+        std_output = stdout.read unless stdout.nil?
+        std_error = stderr.read unless stderr.nil?
+      end
 
-      output[/Input \#\d+\,\s*(\S+),\s*from/]
-      @container = $1
+      fix_encoding(std_output)
 
-      output[/Duration: (\d{2}):(\d{2}):(\d{2}\.\d{2})/]
-      @duration = ($1.to_i*60*60) + ($2.to_i*60) + $3.to_f
+      metadata = MultiJson.load(std_output, symbolize_keys: true)
 
-      output[/start: (\d*\.\d*)/]
-      @time = $1 ? $1.to_f : 0.0
+      if metadata.key?(:error)
 
-      output[/creation_time {1,}: {1,}(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})/]
-      @creation_time = $1 ? Time.parse("#{$1}") : nil
+        @duration = 0
 
-      output[/bitrate: (\d*)/]
-      @bitrate = $1 ? $1.to_i : nil
+      else
 
-      output[/rotate\ {1,}:\ {1,}(\d*)/]
-      @rotation = $1 ? $1.to_i : nil
+        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' }
 
-      output[/Video:\ (.*)/]
-      @video_stream = $1
+        @container = metadata[:format][:format_name]
 
-      output[/Audio:\ (.*)/]
-      @audio_stream = $1
+        @duration = metadata[:format][:duration].to_f
 
-      if video_stream
-        @video_codec, @colorspace, resolution, video_bitrate = video_stream.split(/\s?,\s?/)
-        @video_bitrate = video_bitrate =~ %r(\A(\d+) kb/s\Z) ? $1.to_i : nil
-        @resolution = resolution.split(" ").first rescue nil # get rid of [PAR 1:1 DAR 16:9]
-        @dar = $1 if video_stream[/DAR (\d+:\d+)/]
-      end
+        @time = metadata[:format][:start_time].to_f
+
+        @creation_time = if metadata[:format].key?(:tags) and metadata[:format][:tags].key?(:creation_time)
+                           Time.parse(metadata[:format][:tags][:creation_time])
+                         else
+                           nil
+                         end
+
+        @bitrate = metadata[:format][:bit_rate].to_i
+
+        unless video_streams.empty?
+          # TODO: Handle multiple video codecs (is that possible?)
+          video_stream = video_streams.first
+          @video_codec = video_stream[:codec_name]
+          @colorspace = video_stream[:pix_fmt]
+          @width = video_stream[:width]
+          @height = video_stream[:height]
+          @video_bitrate = video_stream[:bit_rate].to_i
+          @sar = video_stream[:sample_aspect_ratio]
+          @dar = video_stream[:display_aspect_ratio]
+
+          @frame_rate = unless video_stream[:avg_frame_rate] == '0/0'
+                          Rational(video_stream[:avg_frame_rate])
+                        else
+                          nil
+                        end
+
+          @video_stream = "#{video_stream[:codec_name]} (#{video_stream[:profile]}) (#{video_stream[:codec_tag_string]} / #{video_stream[:codec_tag]}), #{colorspace}, #{resolution} [SAR #{sar} DAR #{dar}]"
+
+          @rotation = if video_stream.key?(:tags) and video_stream[:tags].key?(:rotate)
+                        video_stream[:tags][:rotate].to_i
+                      else
+                        nil
+                      end
+        end
+
+        unless audio_streams.empty?
+          # TODO: Handle multiple audio codecs
+          audio_stream = audio_streams.first
+          @audio_channels = audio_stream[:channels].to_i
+          @audio_codec = audio_stream[:codec_name]
+          @audio_sample_rate = audio_stream[:sample_rate].to_i
+          @audio_bitrate = audio_stream[:bit_rate].to_i
+          @audio_channel_layout = audio_stream[:channel_layout]
+          @audio_stream = "#{audio_codec} (#{audio_stream[:codec_tag_string]} / #{audio_stream[:codec_tag]}), #{audio_sample_rate} Hz, #{audio_channel_layout}, #{audio_stream[:sample_fmt]}, #{audio_bitrate} bit/s"
+        end
 
-      if audio_stream
-        @audio_codec, audio_sample_rate, @audio_channels, unused, audio_bitrate = audio_stream.split(/\s?,\s?/)
-        @audio_bitrate = audio_bitrate =~ %r(\A(\d+) kb/s\Z) ? $1.to_i : nil
-        @audio_sample_rate = audio_sample_rate[/\d*/].to_i
       end
 
-      @invalid = true if @video_stream.to_s.empty? && @audio_stream.to_s.empty?
-      @invalid = true if output.include?("is not supported")
-      @invalid = true if output.include?("could not find codec parameters")
+      @invalid = true if metadata.key?(:error)
+      @invalid = true if std_error.include?("Unsupported codec")
+      @invalid = true if std_error.include?("is not supported")
+      @invalid = true if std_error.include?("could not find codec parameters")
     end
 
     def valid?
@@ -65,32 +100,43 @@ module FFMPEG
     end
 
     def width
-      resolution.split("x")[0].to_i rescue nil
+      rotation.nil? || rotation == 180 ? @width : @height;
     end
 
     def height
-      resolution.split("x")[1].to_i rescue nil
+      rotation.nil? || rotation == 180 ? @height : @width;
+    end
+
+    def resolution
+      unless width.nil? or height.nil?
+        "#{width}x#{height}"
+      end
     end
 
     def calculated_aspect_ratio
       aspect_from_dar || aspect_from_dimensions
     end
 
-    def size
-      File.size(@path)
+    def calculated_pixel_aspect_ratio
+      aspect_from_sar || 1
     end
 
-    def audio_channels
-      return nil unless @audio_channels
-      return @audio_channels[/\d*/].to_i if @audio_channels["channels"]
-      return 1 if @audio_channels["mono"]
-      return 2 if @audio_channels["stereo"]
-      return 6 if @audio_channels["5.1"]
+    def size
+      File.size(@path)
     end
 
-    def frame_rate
-      return nil unless video_stream
-      video_stream[/(\d*\.?\d*)\s?fps/] ? $1.to_f : nil
+    def audio_channel_layout
+      # TODO Whenever support for ffmpeg/ffprobe 1.2.1 is dropped this is no longer needed
+      @audio_channel_layout || case(audio_channels)
+                                 when 1
+                                   'stereo'
+                                 when 2
+                                   'stereo'
+                                 when 6
+                                   '5.1'
+                                 else
+                                   'unknown'
+                               end
     end
 
     def transcode(output_file, options = EncodingOptions.new, transcoder_options = {}, &block)
@@ -109,6 +155,13 @@ module FFMPEG
       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.zero? ? nil : aspect
+    end
+
     def aspect_from_dimensions
       aspect = width.to_f / height.to_f
       aspect.nan? ? nil : aspect

data/lib/ffmpeg/transcoder.rb

@@ -42,7 +42,7 @@ module FFMPEG
     end
 
     def encoding_succeeded?
-      @errors << "no output file created" and return false unless File.exists?(@output_file)
+      @errors << "no output file created" and return false unless File.exist?(@output_file)
       @errors << "encoded file is invalid" and return false unless encoded.valid?
       true
     end
@@ -58,7 +58,7 @@ module FFMPEG
       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|

data/lib/ffmpeg/version.rb

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

data/lib/streamio-ffmpeg.rb

@@ -35,14 +35,56 @@ module FFMPEG
   #
   # @param [String] path to the ffmpeg binary
   # @return [String] the path you set
+  # @raise Errno::ENOENT if the ffmpeg binary cannot be found
   def self.ffmpeg_binary=(bin)
+    if bin.is_a?(String) && !File.executable?(bin)
+      raise Errno::ENOENT, "the ffmpeg binary, \'#{bin}\', is not executable"
+    end
     @ffmpeg_binary = bin
   end
 
   # Get the path to the ffmpeg binary, defaulting to 'ffmpeg'
   #
   # @return [String] the path to the ffmpeg binary
+  # @raise Errno::ENOENT if the ffmpeg binary cannot be found
   def self.ffmpeg_binary
-    @ffmpeg_binary || 'ffmpeg'
+    @ffmpeg_binary || which('ffmpeg')
   end
+
+  # Get the path to the ffprobe binary, defaulting to what is on ENV['PATH']
+  #
+  # @return [String] the path to the ffprobe binary
+  # @raise Errno::ENOENT if the ffprobe binary cannot be found
+  def self.ffprobe_binary
+    @ffprobe_binary || which('ffprobe')
+  end
+
+  # Set the path of the ffprobe binary.
+  # Can be useful if you need to specify a path such as /usr/local/bin/ffprobe
+  #
+  # @param [String] path to the ffprobe binary
+  # @return [String] the path you set
+  # @raise Errno::ENOENT if the ffprobe binary cannot be found
+  def self.ffprobe_binary=(bin)
+    if bin.is_a?(String) && !File.executable?(bin)
+      raise Errno::ENOENT, "the ffprobe binary, \'#{bin}\', is not executable"
+    end
+    @ffprobe_binary = bin
+  end
+
+  # Cross-platform way of finding an executable in the $PATH.
+  #
+  #   which('ruby') #=> /usr/bin/ruby
+  # see: http://stackoverflow.com/questions/2108727/which-in-ruby-checking-if-program-exists-in-path-from-ruby
+  def self.which(cmd)
+    exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+    ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+      exts.each { |ext|
+        exe = File.join(path, "#{cmd}#{ext}")
+        return exe if File.executable? exe
+      }
+    end
+    raise Errno::ENOENT, "the #{cmd} binary could not be found in #{ENV['PATH']}"
+  end
+
 end

metadata

@@ -1,50 +1,68 @@
 --- !ruby/object:Gem::Specification
 name: streamio-ffmpeg
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
-- David Backeus
+- Rackfish AB
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-08 00:00:00.000000000 Z
+date: 2016-01-19 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.14'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.1'
 description: 
 email:
-- david@streamio.com
+- support@rackfish.com
+- bikeath1337.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG
+- LICENSE
+- README.md
 - lib/ffmpeg/encoding_options.rb
 - lib/ffmpeg/errors.rb
 - lib/ffmpeg/io_monkey.rb
@@ -52,9 +70,6 @@ files:
 - lib/ffmpeg/transcoder.rb
 - lib/ffmpeg/version.rb
 - lib/streamio-ffmpeg.rb
-- README.md
-- LICENSE
-- CHANGELOG
 homepage: http://github.com/streamio/streamio-ffmpeg
 licenses: []
 metadata: {}
@@ -64,17 +79,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: Wraps ffmpeg to read metadata and transcodes videos.