mediakit 0.0.12 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee3e85010075e5c0cc67eb59f16716b958a69d72
-  data.tar.gz: 51f35a2e74284eff387a63e51970626d8b56272b
+  metadata.gz: 00fe5dc8bf1a3f9d14614c1ae42ccdccf3f7941b
+  data.tar.gz: 660ba4fe4cae816c0c30e05e340dbdd8a299dd4f
 SHA512:
-  metadata.gz: 40389b44e91057cba2e806a69aa4b361c7b8d7758b9d4217cb985c6047d4b2db0eaf6acaa0e3ae84971a15f4d926a7623beb1a034f2d0556b452aa8a5d119682
-  data.tar.gz: 21c2f0a2a669050440b07a83cfef0aef310b3d520e2b5e5315bf9f91bebd402d18062cc3a74e651233c6c103bf82cf62fc887cb8b108dd7ddf33da7a174460d5
+  metadata.gz: 19923e14f8f23410b9b6a202c53287f8ad6dbd70d93f695ddd74e5f612382d8353a15a0c8ec0bab49665367213ef502ab5ef32d59eeec7849357ea0d265ae4cd
+  data.tar.gz: 4779b3998cac878a698f9d3885df1e9ff00aef8de93c7fbd37f7ba7a40f37c26ece71059d22ca464b01409ee8ac6c7a177fe9367009d2767ffda1c770a967306

data/.codeclimate.yml

@@ -0,0 +1,8 @@
+# Save as .codeclimate.yml (note leading .) in project root directory
+languages:
+  Ruby: true
+  JavaScript: true
+  PHP: true
+  Python: true
+# exclude_paths:
+# - "foo/bar.rb"

data/.gitignore

@@ -8,4 +8,4 @@
 /spec/reports/
 /tmp/
 /.idea
-out.mp4
+out.*

data/README.md

@@ -1,6 +1,6 @@
 # Mediakit
 
-[![Circle CI](https://circleci.com/gh/ainame/mediakit/tree/master.svg?style=svg)](https://circleci.com/gh/ainame/mediakit/tree/master)
+[![Circle CI](https://circleci.com/gh/ainame/mediakit/tree/master.svg?style=svg)](https://circleci.com/gh/ainame/mediakit/tree/master) [![Code Climate](https://codeclimate.com/github/ainame/mediakit/badges/gpa.svg)](https://codeclimate.com/github/ainame/mediakit)
 
 mediakit is the libraries for ffmpeg and sox backed media manipulation something.
 I've design this library for following purpose.
@@ -13,13 +13,14 @@ I've design this library for following purpose.
 Currently you can use low-level inteface of mediakit!
 
 * [x] low-level interface
-  * [x] execute command for ffmpeg
+  * [x] execute command for ffmpeg as a code
   * [x] unit testing supports (fake driver)
   * [x] nice command setting
   * [x] read timeout setting
   * [x] shell escape for security
   * [x] ffmpeg instropection (retrive supported formats, codecs, encoders and decoders)
   * [x] logger support
+  * [x] formats, codecs, encoders and decoders representation as a code
 * [ ] low-level ffprobe interface
 * [ ] high-level interface for ffmpeg
 * [ ] low-level interface for sox
@@ -124,7 +125,25 @@ assert_equal(exit_status, true)
 fake_driver.reset
 ```
 
+### Formats/Codecs/Decoders/Encoders
 
+FFmpeg has so many formats, codecs, decoders and encoders.
+So, mediakit provide constant values for presenting those resources as a code.
+
+```rb
+ffmpeg = Mediakit::FFmpeg.create
+ffmpeg.init
+
+# can use after call Mediakit::FFmpeg#init
+Mediakit::FFmpeg::AudioCodec::CODEC_MP3 #=> #<Mediakit::FFmpeg::AudioCodec:0x007fb514040ad0>
+Mediakit::FFmpeg::AudioCodec::CODEC_MP3.name #=> "mp3"
+Mediakit::FFmpeg::AudioCodec::CODEC_MP3.desc #=> "MP3 (MPEG audio layer 3)"
+...
+
+```
+
+These values reflect your ffmpeg binary build conditions by automate.
+`Mediakit::FFmpeg::AudioCodec::CODEC_MP3` is just a instance of Mediakit::FFmpeg::AudioCodec class.
 ### High Level Interface
 
 TBD

data/bin/console

@@ -10,5 +10,7 @@ require "mediakit"
 # require "pry"
 # Pry.start
 
+ffmpeg = Mediakit::FFmpeg.create
+ffmpeg.init
 require "pry"
 Pry.start

data/lib/mediakit/drivers.rb

@@ -1,5 +1,4 @@
-require 'shellwords'
-require 'mediakit/utils/process_runner'
+require 'mediakit/process/runner'
 
 module Mediakit
   module Drivers
@@ -34,12 +33,12 @@ module Mediakit
       # @return [String] stdout output
       def run(*args)
         options, rest_args = parse_options(args.dup)
-        runner = Mediakit::Utils::ProcessRunner.new(options)
+        runner = Mediakit::Process::Runner.new(options)
         begin
           stdout, stderr, exit_status = runner.run(bin, *rest_args)
           raise(FailError, stderr) unless exit_status
           stdout
-        rescue Mediakit::Utils::ProcessRunner::CommandNotFoundError => e
+        rescue Mediakit::Process::Runner::CommandNotFoundError => e
           raise(ConfigurationError, "cant' find bin in #{bin}.")
         end
       end
@@ -53,7 +52,7 @@ module Mediakit
       # @return [String] command
       def command(*args)
         options, rest_args = parse_options(args.dup)
-        runner = Mediakit::Utils::ProcessRunner.new(options)
+        runner = Mediakit::Process::Runner.new(options)
         runner.build_command(bin, *rest_args)
       end
 

data/lib/mediakit/ffmpeg/options.rb

@@ -24,10 +24,12 @@ module Mediakit
         return if option.nil?
         case option
         when GlobalOption
+          raise(ArgumentError, 'you can give only a GlobalOption.') if @global
           set_global(option)
         when InputFileOption
           add_input(option)
         when OutputFileOption
+          raise(ArgumentError, 'you can give only a OutputFileOption.') if @output
           set_output(option)
         else
           raise(ArgumentError)
@@ -96,6 +98,12 @@ module Mediakit
       end
 
       class GlobalOption < OrderedHash
+        def initialize(options = {})
+          if options.values.any? { |x| x.kind_of?(Hash) }
+            raise(ArgumentError, 'you can\'t give nested Hash in GlobalOption')
+          end
+          super
+        end
       end
 
       class OptionPathPair

data/lib/mediakit/ffmpeg.rb

@@ -1,17 +1,27 @@
 require 'mediakit/drivers'
 require 'mediakit/ffmpeg/options'
+require 'mediakit/utils/constant_factory'
 
 module Mediakit
   class FFmpeg
-    class FFmpegError < StandardError; end
+    class FFmpegError < StandardError;
+    end
+
+    attr_reader(:codecs, :formats, :decoders, :encoders)
 
-    attr_accessor(:codecs, :formats, :decoders, :encoders)
+    def self.create(driver = Mediakit::Drivers::FFmpeg.new)
+      @ffmpeg ||= new(driver)
+    end
 
     def initialize(driver)
-      @driver = driver
+      @driver                                 = driver
       @codecs, @formats, @decoders, @encoders = [], [], [], []
     end
 
+    def init
+      Mediakit::Initializers::FFmpeg.setup(self)
+    end
+
     # execute runners with options object
     #
     # @param [Mediakit::Runners::FFmpeg::Options] options options to create CLI argument
@@ -25,20 +35,74 @@ module Mediakit
       @driver.command(args, driver_options)
     end
 
-    Codec = Struct.new(:name, :desc, :type, :decode, :encode, :decoders, :encoders, :intra_frame, :lossy, :lossless) do |klass|
-      def to_s; name; end
+    module BaseTypeMatcher
+      def self.included(included_class)
+        define_method(:===) do |other|
+          return true if included_class::Base >= other
+          false
+        end
+
+        included_class.send(:module_function, :===)
+      end
+    end
+
+    class Format
+      def self.using_attributes
+        [:name, :desc, :demuxing, :muxing]
+      end
+
+      include Utils::ConstantFactory
+    end
+
+    class Codec
+      def self.using_attributes
+        [:name, :desc, :type, :decode, :encode, :decoders, :encoders, :intra_frame, :lossy, :lossless]
+      end
+
+      include Utils::ConstantFactory
+    end
+
+    class AudioCodec < Codec
+    end
+
+    class VideoCodec < Codec
+    end
+
+    class SubtitleCodec < Codec
+    end
+
+    class Encoder
+      def self.using_attributes
+        [:name, :desc, :type, :frame_level, :slice_level, :experimental, :horizon_band, :direct_rendering_method]
+      end
+
+      include Utils::ConstantFactory
+    end
+
+    class AudioEncoder < Encoder
+    end
+
+    class VideoEncoder < Encoder
+    end
+
+    class SubtitleEncoder < Encoder
+    end
+
+    class Decoder
+      def self.using_attributes
+        [:name, :desc, :type, :frame_level, :slice_level, :experimental, :horizon_band, :direct_rendering_method]
+      end
+
+      include Utils::ConstantFactory
     end
 
-    Format = Struct.new(:name, :desc, :demuxing, :muxing) do |klass|
-      def to_s; name; end
+    class AudioDecoder < Decoder
     end
 
-    Encoder = Struct.new(:name, :desc, :type, :frame_level, :slice_level, :experimental, :horizon_band, :direct_rendering_method) do |klass|
-      def to_s; name; end
+    class VideoDecoder < Decoder
     end
 
-    Decoder = Struct.new(:name, :desc, :type, :frame_level, :slice_level, :experimental, :horizon_band, :direct_rendering_method) do |klass|
-      def to_s; name; end
+    class SubtitleDecoder < Decoder
     end
   end
 end

data/lib/mediakit/initializers/ffmpeg.rb

@@ -3,6 +3,16 @@ require 'active_support/core_ext/string/inflections'
 module Mediakit
   module Initializers
     class FFmpeg
+      def self.setup(ffmpeg)
+        Mediakit::Initializers::FFmpeg::FormatInitializer.new(ffmpeg).call
+        Mediakit::Initializers::FFmpeg::DecoderInitializer.new(ffmpeg).call
+        Mediakit::Initializers::FFmpeg::EncoderInitializer.new(ffmpeg).call
+        Mediakit::Initializers::FFmpeg::CodecInitializer.new(ffmpeg).call
+      end
+
+      class UnknownTypeError < StandardError
+      end
+
       class Base
         attr_reader :items
 
@@ -12,6 +22,7 @@ module Mediakit
 
         def call
           @command.send(item_type).concat(parse_items)
+          @command.send(item_type).freeze
         end
 
         def item_type
@@ -37,49 +48,6 @@ module Mediakit
         end
       end
 
-      class CodecInitializer < Base
-        DELIMITER_FOR_CODECS = "\n -------\n".freeze
-        SUPPORT_PATTERN = /(?<support>(?<decode>[D.])(?<encode>[E.])(?<type>[VAS.])(?<intra_frame>[I.])(?<lossy>[L.])(?<lossless>[S.]))/.freeze
-        DESCRIPTION_PATTERN = /.*?( \(decoders: (?<decoders>.+?) \)| \(encoders: (?<encoders>.+?) \))*/.freeze
-        PATTERN = /\A\s*#{SUPPORT_PATTERN}\s+(?<name>\w+)\s+(?<desc>(#{DESCRIPTION_PATTERN}))\z/.freeze
-
-        def item_type
-          'codecs'
-        end
-
-        def raw_items
-          options = Mediakit::FFmpeg::Options.new(Mediakit::FFmpeg::Options::GlobalOption.new('codecs' => true))
-          output, _, _ = @command.run(options)
-          return [] if output.nil? || output.empty?
-          output.split(DELIMITER_FOR_CODECS)[1].each_line.to_a
-        end
-
-        def create_item(line)
-          match = line.match(PATTERN)
-          if match
-            type = case match[:type]
-                   when "A"
-                     :audio
-                   when "V"
-                     :video
-                   when "S"
-                     :subtitle
-                   else
-                     :unknown
-                   end
-            decode = match[:decode] != '.'
-            encode = match[:encode] != '.'
-            decoders = match[:decoders] ? match[:decoders].split(' ') : (decode ? [match[:name]] : nil)
-            encoders = match[:encoders] ? match[:encoders].split(' ') : (encode ? [match[:name]] : nil)
-            intra_frame = match[:intra_frame] != '.'
-            lossy = match[:lossy] != '.'
-            lossless = match[:lossless] != '.'
-
-            Mediakit::FFmpeg::Codec.new(match[:name], match[:desc], type, decode, encode, decoders, encoders, intra_frame, lossy, lossless)
-          end
-        end
-      end
-
       class FormatInitializer < Base
         DELIMITER_FOR_FORMATS = "\n --\n".freeze
         SUPPORT_PATTERN = /(?<support>(?<demuxing>[D.\s])(?<muxing>[E.\s]))/.freeze
@@ -91,7 +59,7 @@ module Mediakit
 
         def raw_items
           options = Mediakit::FFmpeg::Options.new(Mediakit::FFmpeg::Options::GlobalOption.new('formats' => true))
-          output, _, _ = @command.run(options)
+          output, _, _ = @command.run(options, logger: nil)
           return [] if output.nil? || output.empty?
           output.split(DELIMITER_FOR_FORMATS)[1].each_line.to_a
         end
@@ -99,10 +67,15 @@ module Mediakit
         def create_item(line)
           match = line.match(PATTERN)
           if match
-            demuxing = match[:demuxing] == 'D'
-            muxing = match[:muxing] == 'E'
-
-            Mediakit::FFmpeg::Format.new(match[:name], match[:desc], demuxing, muxing)
+            attributes = {
+              name: match[:name],
+              desc: match[:desc],
+              demuxing: match[:demuxing] == 'D',
+              muxing: match[:muxing] == 'E'
+            }
+            Mediakit::FFmpeg::Format.create_constant(
+              "FORMAT_#{attributes[:name].underscore.upcase}", attributes
+            )
           end
         end
       end
@@ -128,7 +101,7 @@ module Mediakit
 
         def raw_items
           options = Mediakit::FFmpeg::Options.new(Mediakit::FFmpeg::Options::GlobalOption.new('decoders' => true))
-          output, _, _ = @command.run(options)
+          output, _, _ = @command.run(options, logger: nil)
           return [] if output.nil? || output.empty?
           output.split(DELIMITER_FOR_CODER)[1].each_line.to_a
         end
@@ -136,23 +109,31 @@ module Mediakit
         def create_item(line)
           match =  line.match(PATTERN)
           if match
-            type =  case match[:type]
-                    when 'V'
-                      :video
-                    when 'A'
-                      :audio
-                    when 'S'
-                      :subtitle
-                    else
-                      :unknown
-                    end
-            frame_leval =  match[:frame_level] !=  '.'
-            slice_leval =  match[:slice_level] !=  '.'
-            experimental =  match[:experimental] !=  '.'
-            horizon_band =  match[:horizon_band] !=  '.'
-            direct_rendering_method =  match[:direct_rendering_method] !=  '.'
-
-            Mediakit::FFmpeg::Decoder.new(match[:name], match[:desc], type, frame_leval, slice_leval, experimental, horizon_band, direct_rendering_method)
+            attributes = {
+              name: match[:name],
+              desc: match[:desc],
+              frame_level: match[:frame_level] != '.',
+              slice_level: match[:slice_level] != '.',
+              experimental: match[:experimental] != '.',
+              horizon_band: match[:horizon_band] != '.',
+              direct_rendering_method: match[:direct_rendering_method] != '.'
+            }
+            case match[:type]
+            when 'V'
+              Mediakit::FFmpeg::VideoDecoder.create_constant(
+                "DECODER_#{attributes[:name].underscore.upcase}", attributes.merge(type: :video)
+              )
+            when 'A'
+              Mediakit::FFmpeg::AudioDecoder.create_constant(
+                "DECODER_#{attributes[:name].underscore.upcase}", attributes.merge(type: :audio)
+              )
+            when 'S'
+              Mediakit::FFmpeg::SubtitleDecoder.create_constant(
+                "DECODER_#{attributes[:name].underscore.upcase}", attributes.merge(type: :subtitle)
+              )
+            else
+              raise(UnknownTypeError)
+            end
           end
         end
       end
@@ -178,7 +159,7 @@ module Mediakit
 
         def raw_items
           options = Mediakit::FFmpeg::Options.new(Mediakit::FFmpeg::Options::GlobalOption.new('encoders' => true))
-          output, _, _ = @command.run(options)
+          output, _, _ = @command.run(options, logger: nil)
           return [] if output.nil? || output.empty?
           output.split(DELIMITER_FOR_CODER)[1].each_line.to_a
         end
@@ -186,23 +167,95 @@ module Mediakit
         def create_item(line)
           match =  line.match(PATTERN)
           if match
-            type =  case match[:type]
-                    when 'V'
-                      :video
-                    when 'A'
-                      :audio
-                    when 'S'
-                      :subtitle
-                    else
-                      :unknown
-                    end
-            frame_level =  match[:frame_level] !=  '.'
-            slice_level =  match[:slice_level] !=  '.'
-            experimental =  match[:experimental] !=  '.'
-            horizon_band =  match[:horizon_band] !=  '.'
-            direct_rendering_method =  match[:direct_rendering_method] !=  '.'
-
-            Mediakit::FFmpeg::Encoder.new(match[:name], match[:desc], type, frame_level, slice_level, experimental, horizon_band, direct_rendering_method)
+            attributes = {
+              name: match[:name],
+              desc: match[:desc],
+              frame_level: match[:frame_level] != '.',
+              slice_level: match[:slice_level] != '.',
+              experimental: match[:experimental] != '.',
+              horizon_band: match[:horizon_band] != '.',
+              direct_rendering_method: match[:direct_rendering_method] != '.'
+            }
+
+            case match[:type]
+            when 'V'
+              Mediakit::FFmpeg::VideoEncoder.create_constant(
+                "ENCODER_#{attributes[:name].underscore.upcase}", attributes.merge(type: :video)
+              )
+            when 'A'
+              Mediakit::FFmpeg::AudioEncoder.create_constant(
+                "ENCODER_#{attributes[:name].underscore.upcase}", attributes.merge(type: :audio)
+              )
+            when 'S'
+              Mediakit::FFmpeg::SubtitleEncoder.create_constant(
+                "ENCODER_#{attributes[:name].underscore.upcase}", attributes.merge(type: :subtitle)
+              )
+            else
+              raise(UnknownTypeError)
+            end
+          end
+        end
+      end
+
+      class CodecInitializer < Base
+        DELIMITER_FOR_CODECS = "\n -------\n".freeze
+        SUPPORT_PATTERN = /(?<support>(?<decode>[D.])(?<encode>[E.])(?<type>[VAS.])(?<intra_frame>[I.])(?<lossy>[L.])(?<lossless>[S.]))/.freeze
+        DESCRIPTION_PATTERN = /.*?( \(decoders: (?<decoders>.+?) \)| \(encoders: (?<encoders>.+?) \))*/.freeze
+        PATTERN = /\A\s*#{SUPPORT_PATTERN}\s+(?<name>\w+)\s+(?<desc>(#{DESCRIPTION_PATTERN}))\z/.freeze
+
+        def item_type
+          'codecs'
+        end
+
+        def raw_items
+          options = Mediakit::FFmpeg::Options.new(Mediakit::FFmpeg::Options::GlobalOption.new('codecs' => true))
+          output, _, _ = @command.run(options, logger: nil)
+          return [] if output.nil? || output.empty?
+          output.split(DELIMITER_FOR_CODECS)[1].each_line.to_a
+        end
+
+        def find_decoders(decoders)
+          return unless decoders
+          decoders.map { |name| @command.decoders.find { |decoder| decoder.name == name } }
+        end
+
+        def find_encoders(encoders)
+          return unless encoders
+          encoders.map { |name| @command.encoders.find { |encoder| encoder.name == name } }
+        end
+
+        def create_item(line)
+          match = line.match(PATTERN)
+          if match
+            decode = match[:decode] != '.'
+            encode = match[:encode] != '.'
+            attributes = {
+              name: match[:name],
+              desc: match[:desc],
+              decode: decode,
+              encode: encode,
+              decoders: find_decoders(match[:decoders] ? match[:decoders].split(' ') : (decode ? [match[:name]] : nil)),
+              encoders: find_encoders(match[:encoders] ? match[:encoders].split(' ') : (encode ? [match[:name]] : nil)),
+              intra_frame: match[:intra_frame] != '.',
+              lossy: match[:lossy] != '.',
+              lossless: match[:lossless] != '.'
+            }
+            case match[:type]
+            when 'V'
+              Mediakit::FFmpeg::VideoCodec.create_constant(
+                "CODEC_#{attributes[:name].underscore.upcase}", attributes.merge(type: :video)
+              )
+            when 'A'
+              Mediakit::FFmpeg::AudioCodec.create_constant(
+                "CODEC_#{attributes[:name].underscore.upcase}", attributes.merge(type: :audio)
+              )
+            when 'S'
+              Mediakit::FFmpeg::SubtitleCodec.create_constant(
+                "CODEC_#{attributes[:name].underscore.upcase}", attributes.merge(type: :subtitle)
+              )
+            else
+              raise(UnknownTypeError)
+            end
           end
         end
       end

data/lib/mediakit/{utils/process_runner.rb → process/runner.rb}

@@ -1,13 +1,13 @@
 require 'open3'
-require 'thread'
 require 'timeout'
 require 'cool.io'
 require 'logger'
-require 'mediakit/utils/shell_escape'
+require 'mediakit/process/shell_escape'
+require 'mediakit/utils/null_logger'
 
 module Mediakit
-  module Utils
-    class ProcessRunner
+  module Process
+    class Runner
       class CommandNotFoundError < StandardError;
       end
       class TimeoutError < StandardError;
@@ -17,10 +17,10 @@ module Mediakit
 
       attr_reader(:logger)
 
-      def initialize(timeout: nil, nice: 0, logger: nil)
+      def initialize(timeout: nil, nice: 0, logger: Logger.new(STDOUT))
         @timeout = timeout
         @nice = nice
-        @logger = logger || Logger.new(STDOUT)
+        @logger = logger || Mediakit::Utils::NullLogger.new
       end
 
       # @overload run(command, *args)
@@ -37,11 +37,7 @@ module Mediakit
         begin
           stdin, stdout, stderr, wait_thread = Open3.popen3(command)
           stdin.close
-          output, error_output, exit_status = if @timeout
-                                                wait_with_timeout(stdout, stderr, wait_thread)
-                                              else
-                                                wait_without_timeout(stdout, stderr, wait_thread)
-                                              end
+          output, error_output, exit_status = wait(stdout, stderr, wait_thread)
         rescue Errno::ENOENT => e
           raise(CommandNotFoundError, "Can't find command - #{command}, #{e.meessage}")
         end
@@ -49,13 +45,7 @@ module Mediakit
         [output, error_output, exit_status]
       end
 
-      def wait_without_timeout(stdout, stderr, wait_thread)
-        wait_thread.join
-        exit_status = (wait_thread.value.exitstatus == 0)
-        [stdout.read, stderr.read, exit_status]
-      end
-
-      def wait_with_timeout(stdout, stderr, wait_thread)
+      def wait(stdout, stderr, wait_thread)
         begin
           setup_watchers(stdout, stderr)
           loop_thread = Thread.new { run_loop }
@@ -87,13 +77,13 @@ module Mediakit
       end
 
       def setup_watchers(stdout, stderr)
-        @timer = TimeoutTimer.new(@timeout, Thread.current)
-        @out_watcher = IOWatcher.new(stdout) { |data| @timer.update; logger.info(data) }
-        @err_watcher = IOWatcher.new(stderr) { |data| @timer.update; logger.error(data) }
+        @timer = @timeout ? TimeoutTimer.new(@timeout, Thread.current) : nil
+        @out_watcher = IOWatcher.new(stdout) { |data| @timer.update if @timer; logger.info(data) }
+        @err_watcher = IOWatcher.new(stderr) { |data| @timer.update if @timer; logger.error(data) }
         @loop = Coolio::Loop.new
         @out_watcher.attach(@loop)
         @err_watcher.attach(@loop)
-        @timer.attach(@loop)
+        @timer.attach(@loop) if @timer
       end
 
       def run_loop
@@ -116,7 +106,7 @@ module Mediakit
       end
 
       def force_kill_process(pid)
-        Process.kill('SIGKILL', pid)
+        ::Process.kill('SIGKILL', pid)
       rescue Errno::ESRCH => e
         logger.warn("fail SIGKILL pid=#{pid} - #{e.message}, #{e.backtrace.join("\n")}")
       end
@@ -131,8 +121,8 @@ module Mediakit
         end
 
         def on_read(data)
-          @data << data
           @block.call(data)
+          @data << data
         end
 
         def on_close
@@ -144,7 +134,6 @@ module Mediakit
         DEFAULT_CHECK_INTERVAL = 0.1
 
         def initialize(duration, current_thread)
-          @mutex = Mutex.new
           @duration = duration
           @watched_at = Time.now
           @current_thread = current_thread
@@ -158,9 +147,7 @@ module Mediakit
         end
 
         def update
-          @mutex.synchronize do
-            @watched_at = Time.now
-          end
+          @watched_at = Time.now
         end
 
         private

data/lib/mediakit/{utils → process}/shell_escape.rb

@@ -1,7 +1,7 @@
 require 'shellwords'
 
 module Mediakit
-  module Utils
+  module Process
     module ShellEscape
       def escape(*args)
         case args.size

data/lib/mediakit/railtie.rb

@@ -0,0 +1,8 @@
+module Mediakit
+  module Railtie < ::Rails::Railtie
+    initializer('mediakit.initialize_ffmpeg') do
+      ffmpeg = Mediakit::FFmpeg.create
+      Mediakit::Initializers.setup(ffmpeg)
+    end
+  end
+end

data/lib/mediakit/utils/constant_factory.rb

@@ -0,0 +1,35 @@
+module Mediakit
+  module Utils
+    module ConstantFactory
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.class_eval do
+          attr_reader(*(base.using_attributes))
+
+          def initialize(attributes)
+            self.class.using_attributes.each do |key|
+              instance_variable_set("@#{key}", attributes[key])
+            end
+          end
+        end
+      end
+
+      module ClassMethods
+        def using_attributes
+          raise(NotImplementedError)
+        end
+
+        def create_constant(name, attributes)
+          raise(
+            ArgumentError,
+            <<EOS
+you can give attribute keys which only defined by `using_attributes` and that is satisfied all keys.'
+EOS
+          ) unless Set.new(using_attributes) == Set.new(attributes.keys)
+          return self.const_get(name) if self.const_defined?(name)
+          self.const_set(name, new(attributes).freeze)
+        end
+      end
+    end
+  end
+end

data/lib/mediakit/utils/null_logger.rb

@@ -0,0 +1,13 @@
+module Mediakit
+  module Utils
+    class NullLogger
+      attr_accessor(:formatter, :level)
+
+      def debug(*); end
+      def info(*); end
+      def warn(*); end
+      def error(*); end
+      def fatal(*); end
+    end
+  end
+end

data/lib/mediakit/version.rb

@@ -1,3 +1,3 @@
 module Mediakit
-  VERSION = "0.0.12"
+  VERSION = '0.1.1'
 end

data/lib/mediakit.rb

@@ -5,4 +5,6 @@ module Mediakit
   require 'mediakit/ffmpeg'
   require 'mediakit/ffprobe'
   require 'mediakit/initializers'
+
+  require 'mediakit/railtie' if defined?(Rails)
 end

data/mediakit.gemspec

@@ -29,4 +29,5 @@ EOS
   spec.add_development_dependency "ruby-debug-ide", "~> 0.4"
   spec.add_development_dependency "yard", "> 0.8"
   spec.add_development_dependency "rubocop", ">= 0.31"
+  spec.add_development_dependency "minitest-power_assert", ">= 0.2"
 end

data/sample/encode.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mediakit"
+require 'pry'
+
+input_file = ARGV[0]
+exit(1) unless input_file
+
+output_file = ARGV[1] || 'out.mov'
+
+def transcode_option(input, output)
+  options = Mediakit::FFmpeg::Options.new(
+    Mediakit::FFmpeg::Options::GlobalOption.new(
+      'y' => true,
+      'threads' => 4,
+      't' => 10
+    ),
+    Mediakit::FFmpeg::Options::InputFileOption.new(
+      options: nil,
+      path:    input,
+    ),
+    Mediakit::FFmpeg::Options::OutputFileOption.new(
+      options: {
+        'acodec' => 'mp3',
+        'vcodec' => 'libx264',
+        #'vf' => 'crop=240:240:0:0',
+        'ar' => '44100',
+        'ab' => '128k',
+      },
+      path:    output,
+    ),
+  )
+end
+
+root        = File.expand_path(File.join(File.dirname(__FILE__), '../'))
+input_path  = File.expand_path(input_file)
+output_path = File.expand_path(File.join(root, 'out.mov'))
+ffmpeg      = Mediakit::FFmpeg.create
+options     = transcode_option(input_path, output_path)
+puts "$ #{ffmpeg.command(options, nice: 10)}"
+puts ffmpeg.run(options, nice: 10, timeout: 30)

data/sample/instropections.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mediakit"
+require 'pry'
+
+ffmpeg = Mediakit::FFmpeg.new(Mediakit::Drivers::FFmpeg.new)
+Mediakit::Initializers.setup(ffmpeg)
+
+binding.pry
+
+# ffmpeg.codecs.select {|c| c.name =~ /264/ } ...

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mediakit
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.1.1
 platform: ruby
 authors:
 - ainame
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-05-27 00:00:00.000000000 Z
+date: 2015-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -108,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0.31'
+- !ruby/object:Gem::Dependency
+  name: minitest-power_assert
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
 description: |
   mediakit is the libraries for ffmpeg and sox backed media manipulation something.
   you can create complex manipulation for media as a ruby code.
@@ -117,6 +131,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
 - Gemfile
 - README.md
@@ -131,12 +146,17 @@ files:
 - lib/mediakit/ffprobe.rb
 - lib/mediakit/initializers.rb
 - lib/mediakit/initializers/ffmpeg.rb
-- lib/mediakit/utils/process_runner.rb
-- lib/mediakit/utils/shell_escape.rb
+- lib/mediakit/process/runner.rb
+- lib/mediakit/process/shell_escape.rb
+- lib/mediakit/railtie.rb
+- lib/mediakit/utils/constant_factory.rb
+- lib/mediakit/utils/null_logger.rb
 - lib/mediakit/version.rb
 - mediakit.gemspec
 - sample/configure.rb
-- sample/raw_crop.rb
+- sample/crop.rb
+- sample/encode.rb
+- sample/instropections.rb
 homepage: https://github.com/ainame/mediakit
 licenses: []
 metadata: {}