ffmpeg_wrapper 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5a4bfe1a276bbee90d906cf305d6d650c9e15b3b
+  data.tar.gz: 8e8bb0c17f3a4c9353c2af6cbc5fc91005724d38
+SHA512:
+  metadata.gz: a06e520d53ea7485a11ed1dca162002700151976561f68ccc9e3c0f2bc7fc6ad896d74e07a1bea091668f4b4a5ccbbed438f42a48cdddf7e8fe6d4094ec0d07f
+  data.tar.gz: f59b4818b62a19566955661e50c4a23e3159737aee9f3f2c003e85eec2482e9234bdb48c3b6de0de3a7655ea11ea96fe468282e2843fd50c264b111b07d33809

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+tags

data/.rspec

@@ -0,0 +1,3 @@
+--color
+-f doc
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ffmpeg_wrapper.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 slowness pc
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,62 @@
+# FfmpegWrapper
+
+Ruby gem wrapping cli utility FFmpeg.
+Now it lacks lots of features, but
+this will change in time as I need new
+functions myself or just feel like 
+enhancing it.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ffmpeg_wrapper'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ffmpeg_wrapper
+
+## Usage
+
+### FFmpeg
+
+```ruby
+require 'ffmpeg_wrapper'
+
+FFmpeg.run do
+  media 'somefile.mp4'
+  map(0,1).applying acodec: 'libmp3lame',
+  ac: 2, ar: '44.1k'
+    # .applying is a dynamic method of a
+    # String returned from #map
+  output 'out.mp3'
+end
+```
+
+
+### FFprobe
+
+``ruby
+info = FFprobe.run('video.mp4') do
+  show_streams
+  show_format
+  end
+info #=> { "format" => ..., "streams"=>... }
+info['format']['codec_type'] #=> 'video'
+``
+
+Look in the documentation for details.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/ffmpeg_wrapper/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/gem_tasks'
+
+namespace :test do
+  task :prepare do
+    mkdir 'spec/output'
+  end
+
+  task :cleanup do
+    `rm -rf spec/output`
+  end
+end

data/ffmpeg_wrapper.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ffmpeg_wrapper/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ffmpeg_wrapper"
+  spec.version       = FfmpegWrapper::VERSION
+  spec.authors       = ['slowness']
+  spec.email         = ['slma0x02@gmail.com']
+  spec.summary       = 'Wrapper for FFmpeg.'
+  spec.description   = 'FFmpeg is a powerful video, audio or image editing tool \
+  with tons of useful (and not so) functions.'
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec-its'
+end

data/lib/ffmpeg_wrapper.rb

@@ -0,0 +1,22 @@
+require 'ffmpeg_wrapper/version'
+
+module FfmpegWrapper
+  # Check if ffmpeg is present in the system
+  def self.method_missing(meth, *_args, &_blk)
+    case meth.to_s
+    when /has_(?<cmd>.*)\?/ then system "which #{$1} &>/dev/null"
+    end
+  end
+
+  fail 'No ffmpeg found in $PATH' unless has_ffmpeg?
+end
+
+require 'ostruct'
+require 'logger'
+
+require 'ffmpeg_wrapper/hash.rb'
+require 'ffmpeg_wrapper/ffmpeg.rb'
+require 'ffmpeg_wrapper/ffprobe.rb'
+require 'ffmpeg_wrapper/format.rb'
+require 'ffmpeg_wrapper/stream.rb'
+require 'ffmpeg_wrapper/version.rb'

data/lib/ffmpeg_wrapper/ffmpeg.rb

@@ -0,0 +1,128 @@
+module FfmpegWrapper
+  class FFmpeg
+    def initialize
+      @command = 'ffmpeg -y -hide_banner'
+      @inputs = []
+      @audios = []
+      @videos = []
+      @mappings = []
+      @filters = []
+      @n = 0
+      @result = {}
+      @post_exec_hooks = []
+    end
+    # Construct ffmpeg command using that
+    # function, then execute. All opts hashe's
+    # option meant to be axactly the same as according
+    # ffmpeg flags. That is <tt>-pix_fmt => :pix_fmt</tt>
+    # @return [FFmpeg]
+    # @example
+    #         FFmpeg.run do
+    #           media 'somefile.mp4'
+    #           map(0,1).applying acodec: 'libmp3lame',
+    #                                ac: 2, ar: '44.1k'
+    #           # .applying is a dynamic method of a
+    #           # String returned from #map
+    #           output 'out.mp3'
+    #         end
+    def self.run(*flags, &block)
+      lo = Logger.new(STDOUT) if flags.include?(:debug)
+      ff = FFmpeg.new
+      ff.instance_eval do
+        instance_eval(&block)
+        @command << ' ' << @inputs.join(' ')
+        @command << ' ' << @filters.join(' ') if @filters.any?
+        @command << ' ' << @mappings.join(' ') if @mappings.any?
+        @command << ' ' << @output if @output
+        lo.info @command if lo
+        @out = IO.popen(@command, err: [:child, :out]) do |io|
+          io.read
+        end
+        @post_exec_hooks.each { |h| instance_eval(&h) }
+        fail @out.to_s unless $?.success?
+      end
+      ff.instance_variable_get(:@result)
+    end
+
+    # Adds input file, containing audio and video.
+    # @param filename [String]
+    # @param opts [Hash] options for this input file. See list
+    # of options below.  If input file is a media container,
+    # e. g. mpeg4 or avi you don't need to explicitly specify any.
+    # If file is raw video or audio, specify _V_ for video
+    # and _A_ for audio
+    # @option opts [String] :f _V_ format 'rawvideo'
+    # @option opts [String] :s _V_ geometry WxH(+X,Y)
+    # @option opts [String] :pix_fmt _V_ pixel format bgr8, rgba, etc...
+    # @option opts [Int]    :r _V_ fps
+    # @option opts [String] :f _A_ format 'alaw', etc...
+    # @option opts [String] :ar _A_ sample rate, e.g. '44.1k'
+    # @option opts [Int] :ac _A_ channels
+    # @see FFmpeg.map .run method example for call sequence
+    # @return id [Integer] input file id
+    def media(filename, opts = {})
+      n = input(filename, opts)
+      @videos << n
+      @audios << n
+      n
+    end
+
+    # Adds input video file (no audio will be extracted anyway)
+    # @param filename [String]
+    # @param opts [Hash] options for this input file
+    # @return id [Integer] input file id
+    def video(filename, opts = {})
+      n = input(filename, opts)
+      @videos << n
+      n
+    end
+
+    # Adds input audio file (no video will be extracted anyway)
+    # @param filename [String]
+    # @param opts [Hash] options for this input file
+    # @return id [Integer] input file id
+    def audio(filename, opts = {})
+      n = input(filename, opts)
+      @audios << n
+      n
+    end
+
+    # Specify filename for output file
+    # @param filename [String]
+    def output(filename)
+      @output = " #{filename}"
+    end
+
+    # Specify mapping: what input stream or alias (from format, e. g. \[a\])
+    # @param file [String, Int] file number or alias
+    # @param index [Int] stream specifier
+    # @see FFmpeg#map #map method example for call sequence
+    # @see https://trac.ffmpeg.org/wiki/How%20to%20use%20-map%20option ffmpeg
+    #   map option guide
+    # @return [String]
+    def map(file, index = nil)
+      line =  "-map #{file}#{':' + index.to_s if index}"
+      @mappings << line
+      def line.applying(opts = {})
+        opts.each do |k, v|
+          self << " -#{k} #{v}"
+        end
+      end
+      line
+    end
+
+    private
+
+    def input(filename, opts = {})
+      line = ''
+      opts.each do |k, v|
+        line << " -#{k} #{v}"
+      end
+      line << " -i #{filename}"
+      @inputs << line
+      @n += 1
+      @n - 1
+    end
+
+  end
+end

data/lib/ffmpeg_wrapper/ffprobe.rb

@@ -0,0 +1,73 @@
+require 'json'
+
+module FfmpegWrapper
+  class FFprobe
+    class << self
+      # Execute ffprobe command.
+      # @param [String] filename
+      # @return [Hash]
+      # @example
+      #        info = FFprobe.run('video.mp4') do
+      #          show_streams
+      #          show_format
+      #        end
+      #        info                         #=> { "format" => ..., "streams"=>... }
+      #        info['format']['codec_type'] #=> 'video'
+      def run(filename, &block)
+        ff = FFprobe.new filename
+        ff.instance_eval do
+          @command << ' -v quiet -of json'
+          instance_eval &block if block
+          @command << @show_specifiers.reduce(' ') do |acc, v|
+            acc << " -#{v}"
+            acc
+          end
+          @command << ' ' << @options.to_shellflags
+          @command << ' ' << @input
+          out = `#{@command} 2>/dev/null`
+          begin
+            @result = JSON.parse out
+            fail if @result.keys.empty?
+          rescue
+            @result = { 'errors' => error }
+          # FIXME: Do not return from ensure
+          ensure
+            return @result
+          end
+        end
+      end
+    end
+
+    # @param [String] filename
+    def initialize(filename)
+      @input = filename || fail(ArgumentError 'No input specified')
+      @command = 'ffprobe '
+      @show_specifiers = []
+      @options = {}
+    end
+
+    # Specify input file options
+    # @param [Hash] options
+    def options(hash)
+      @options.merge! hash
+    end
+    alias_method :option, :options
+
+    private
+
+    def method_missing(meth, *args, &blk)
+      case meth
+      when /show_(\w+)/ then
+        @show_specifiers << meth
+      else
+        super
+      end
+    end
+
+    def error
+      @command.gsub!('-v quiet', '-v error')
+      @command.gsub!('-of json', '')
+      `#{@command} 2>&1`
+    end
+  end
+end

data/lib/ffmpeg_wrapper/filters/blackdetect.rb

@@ -0,0 +1,50 @@
+require 'ostruct'
+
+module FfmpegWrapper
+  class FFmpeg
+    # Find intervals of blackness in a video file.
+    # This info then can be found in a hash, returned
+    # from FFmpeg.run by key :blacks.
+    # TODO: add argument support
+    # @param opts [Hash]
+    # @return FFmpeg self. Chainable, see example.
+    # @example
+    #         FFmpeg.run do
+    #           media 'video.mp4'
+    #           detect_black.and_write_to 'black_intervals.txt'
+    #         end # => { ... :blacks => [ { :start => x, :end => y, :duration => z}, ... ] }
+    def filter_blackdetect(opts = {})
+      @filters << '-vf blackdetect'
+      @output = ' -f null /dev/null '
+      @redirection = [:child, :out]
+      @result[:blacks] = []
+
+      # Singleton method defined on FFmpeg
+      # after calling #filter_blackdetect.
+      # Writes info about black intervals as a plain text to
+      # a file.
+      # @param (String) filename
+      def self.and_write_to(filename)
+        @post_exec_hooks << proc do
+          File.open(filename, 'w') do |f|
+            @result[:blacks].each do |black|
+              f.puts 'black_interval start: %f end: %f duration: %f' % [black[:start], black[:end], black[:duration]]
+            end
+          end
+        end
+      end
+      @post_exec_hooks << proc do
+        bdlines = @out.lines.grep(/blackdetect/)
+        bdlines.map do |l|
+          /black_start:(?<st>\S+).*
+            black_end:(?<en>\S+).*
+            black_duration:(?<du>\S+)/x =~ l
+          @result[:blacks] << { start: st.to_f, end: en.to_f, duration: du.to_f }
+        end
+      end
+      self
+    end
+
+    alias_method :detect_black, :filter_blackdetect
+  end
+end

data/lib/ffmpeg_wrapper/filters/concat.rb

@@ -0,0 +1,56 @@
+module FfmpegWrapper
+  class FFmpeg
+    # This function extends basic {FFmpeg} functionality
+    # providing filter command.
+    # TODO: non-trivial mappings(i.e. multi-streamed inputs)
+    def filter_concat(_mappings = {})
+      line = ''
+      line << filter_complex(:audio)
+      line << filter_complex(:video)
+      @filters << line
+      mappings = []
+      mappings << (@videos.size > 1 ? '[v]' : @videos.first)
+      mappings << (@audios.size > 1 ? '[a]' : @audios.first)
+      mappings
+    end
+
+    private
+
+    def stream_map_for_video
+      return if @videos.empty?
+      line = ''
+      @videos.each do |file|
+        line << " [#{file}:0] "
+      end
+      line
+    end
+
+    def stream_map_for_audio
+      return if @audios.empty?
+      line = ''
+      @audios.each do |file|
+        line << " [#{file}:0] "
+      end
+      line
+    end
+
+    def concat_for_video
+      "concat=n=#{@videos.size}:v=1:a=0 [v]"
+    end
+
+    def concat_for_audio
+      "concat=n=#{@audios.size}:v=0:a=1 [a]"
+    end
+
+    def filter_complex(str)
+      fail ArgumentError unless [:audio, :video].include?(str)
+      str = str.to_s
+      return '' if instance_variable_get('@' + str + 's').count < 2
+      line = ' -filter_complex '
+      line << "'"
+      line << send("stream_map_for_#{str}")
+      line << send("concat_for_#{str}")
+      line << "'"
+    end
+  end
+end

data/lib/ffmpeg_wrapper/format.rb

@@ -0,0 +1,15 @@
+module FfmpegWrapper
+  class Format < ::OpenStruct
+    CMDLINE_NAMES = {
+      format_name: 'f'
+    }
+    def to_cmdline
+      cmd = ''
+      each_pair do |field, value|
+        field_for_cmd = CMDLINE_NAMES[field]
+        cmd << " #{field_for_cmd} #{value}" if field_for_cmd
+      end
+      cmd
+    end
+  end
+end

data/lib/ffmpeg_wrapper/hash.rb

@@ -0,0 +1,9 @@
+class Hash
+  def to_shellflags
+    line = ''
+    each do |k, v|
+      line << "-#{k} #{v}"
+    end
+    line
+  end
+end

data/lib/ffmpeg_wrapper/stream.rb

@@ -0,0 +1,11 @@
+module FfmpegWrapper
+  class Stream < OpenStruct
+    def video?
+      codec_type == 'video' if codec_type
+    end
+
+    def audio?
+      codec_type == 'audio' if codec_type
+    end
+  end
+end

data/lib/ffmpeg_wrapper/version.rb

@@ -0,0 +1,3 @@
+module FfmpegWrapper
+  VERSION = "0.0.2"
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: ffmpeg_wrapper
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- slowness
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  FFmpeg is a powerful video, audio or image editing tool \
+    with tons of useful (and not so) functions.
+email:
+- slma0x02@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ffmpeg_wrapper.gemspec
+- lib/ffmpeg_wrapper.rb
+- lib/ffmpeg_wrapper/ffmpeg.rb
+- lib/ffmpeg_wrapper/ffprobe.rb
+- lib/ffmpeg_wrapper/filters/blackdetect.rb
+- lib/ffmpeg_wrapper/filters/concat.rb
+- lib/ffmpeg_wrapper/format.rb
+- lib/ffmpeg_wrapper/hash.rb
+- lib/ffmpeg_wrapper/stream.rb
+- lib/ffmpeg_wrapper/version.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.14
+signing_key: 
+specification_version: 4
+summary: Wrapper for FFmpeg.
+test_files: []
+has_rdoc: