web_video 1.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Brainberry
+
+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.rdoc

@@ -0,0 +1,107 @@
+=WebVideo
+
+WebVideo allows you to inspect and process video files.
+
+==Installation
+You need install 'ffmpeg' liblary ant it's dependent's...
+
+===Mac OS
+  sudo port install ffmpeg +lame +libogg +vorbis +faac +faad +xvid +x264 +a52
+
+===Linux (Ubuntu)
+  sudo apt-get install ffmpeg
+  sudo apt-get install libfaac-dev libxvidcore4-dev liba52-0.7.4 liba52-0.7.4-dev libx264-dev
+  sudo apt-get install libavutil49 libavutil-dev libavcodec-dev
+  sudo apt-get install libavcodec-unstripped-52
+
+===Install "WebVideo" via plugin
+  rails plugin install http://github.com/galetahub/web_video.git
+
+===Install "WebVideo" via gem
+Directly from repository:
+  sudo gem install web_video
+Or in your application "Gemfile":
+  gem "web_video"
+
+==Logger
+You can put it in "config/initializers/web_video.rb".
+
+  logfile = File.open(Rails.root.join('log', 'video.log'), 'w')
+  logfile.sync = true
+
+  WebVideo.logger = Logger.new(logfile)
+
+==Example
+
+Read video information
+  video = WebVideo::Adapters::FfmpegAdapter.new('demo.avi')
+  
+  video.filename # => "demo.avi"
+  
+  video.duration # => "00:03:39.90"
+  
+  video.bitrate  # => "2624 kb/s"
+  
+  video.duration_in_seconds # => 219
+  
+  video.streams  # => Array of streams
+    # [ #<WebVideo::Stream @codec="mpeg4", @type="Video", @details="yuv420p, 640x480 [PAR 1:1 DAR 4:3], 30 tbr, 30 tbn, 30 tbc">, 
+    #   #<WebVideo::Stream @codec="mp3", @type="Audio", @details="44100 Hz, stereo, s16, 128 kb/s">]
+
+Video Convertation
+  transcoder = WebVideo::Transcoder.new("demo.avi")
+or
+  transcoder = WebVideo::Transcoder.new(video)
+
+Transcoder attributes
+  transcoder.adapter # => :ffmpeg
+  
+  transcoder.source  # => return WebVideo::Adapters::FfmpegAdapter instance (video)
+
+Generate flv file. Next example will generate "demo.flv" from "demo.avi".
+
+  options = {:resolution => "480x360"}
+      
+  begin
+    transcoder.convert("demo.flv", options) do |command|
+      command << "-ar 22050"
+      command << "-ab 128k"
+      command << "-acodec libmp3lame"
+      command << "-vcodec flv"
+      command << "-r 25"
+      command << "-y"
+    end
+  rescue WebVideo::CommandLineError => e
+    WebVideo.logger.error("Unable to transcode video: #{e.class} - #{e.message}")
+  end
+
+
+Generate images from video
+By default screenshot starts at '00:00:01', to change it pass option :at => '00:05:00' (at five minutes)
+
+  transcoder.screenshot("demo.jpg", :resolution => "480x360")
+  
+Next code will generate five images: demo_01.jpg, demo_02.jpg, demo_03.jpg ...
+  
+  image_files = 'demo_%2d.jpg'
+  options = {:resolution => "480x360", :count => 5 }
+
+  begin
+    transcoder.screenshot(image_files, options) do |command|
+      command << "-vcodec mjpeg"
+      # The duration for which image extraction will take place
+      #command << "-t 4"
+      command << "-y"
+    end
+  rescue WebVideo::CommandLineError => e
+    WebVideo.logger.error("Unable to transcode video: #{e.class} - #{e.message}")
+  end
+
+==TODO
+1. Add adapter for support 'mencoder' tool
+2. More information about video file (class Stream must parse details)
+3. Add support for 'flvtool2'
+4. Write more documentation
+5. Write tests
+
+Copyright (c) 2010 Brainberry, released under the MIT license

data/Rakefile

@@ -0,0 +1,42 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the web_video plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the web_video plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'WebVideo'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "web_video"
+    gemspec.version = '1.0.0'
+    gemspec.summary = "WebVideo allows you to inspect and process video files"
+    gemspec.description = "WebVideo allows you to inspect, convert and take screenshots from video files"
+    gemspec.email = "galeta.igor@gmail.com"
+    gemspec.homepage = "http://github.com/galetahub/web_video"
+    gemspec.authors = ["Igor Galeta"]
+    gemspec.files = FileList["[A-Z]*", "{lib}/**/*"]
+    gemspec.rubyforge_project = "web_video"
+  end
+  
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/lib/web_video/adapters/abstract_adapter.rb

@@ -0,0 +1,62 @@
+module WebVideo
+  module Adapters
+    class AbstractAdapter
+      attr_accessor :filepath, :filename, :path
+      
+      def initialize(filepath, options = {})
+        @filepath = filepath
+        
+        @filename = File.basename(@filepath)
+        @path = File.dirname(@filepath)
+        
+        @options = options.symbolize_keys
+        @metadata = parse
+      end
+      
+      def file_exists?
+        File.exist?(@filepath)
+      end
+      
+      def size
+        File.size(@filepath)
+      end
+      
+      def duration
+        @metadata[:duration]
+      end
+      
+      def bitrate
+        @metadata[:bitrate]
+      end
+      
+      def streams
+        @metadata[:streams]
+      end
+      
+      def command_name
+        ''
+      end
+      
+      def convert_command
+        []
+      end
+      
+      def screenshot_command
+        []
+      end
+      
+      def installed?
+        !WebVideo::Tools.run("which", command_name).blank?
+      end
+      
+      def run(command, options = {})
+        WebVideo::Tools.run_with_option(command_name, command, options)
+      end
+      
+      private
+        def parse
+          return {}
+        end
+    end
+  end
+end

data/lib/web_video/adapters/ffmpeg_adapter.rb

@@ -0,0 +1,71 @@
+module WebVideo
+  module Adapters
+    class FfmpegAdapter < AbstractAdapter
+      
+      # 00:21:41.18
+      def duration_in_seconds
+        if @metadata[:duration] =~ /([0-9][0-9])\:([0-9][0-9])\:([0-9][0-9])\.([0-9][0-9])/
+          ( $1.to_i * 60 * 60 ) + ( $2.to_i * 60 ) + ( $3.to_i ) + ( ($4.to_i/100) * 60 )
+        end
+      end
+      
+      def command_name
+        'ffmpeg'
+      end
+      
+      def convert_command
+        command = []
+        command << "-i $input_file$"
+        command << "-s $resolution$"
+        
+        command.dup
+      end
+      
+      def screenshot_command
+        command = []
+        command << "-i $input_file$"
+    
+        # Specifies the frame size of the output (Default is the size of the original video.)
+        command << "-s $resolution$"
+        
+        # Frame rate of video. i.e. no. of frames to be extracted into images per second
+        # The default value is 25
+        command << "-r 1"
+        
+        # Disable audio recording.
+        command << "-an"
+        
+        # Number of video frames to record
+        command << "-vframes $count$"
+        
+        # Force format (image2|rawvideo)
+        command << "-f $format$"
+        
+        # Start the extraction from particular point
+        command << "-ss $at$"
+        
+        command.dup
+      end
+      
+      private
+        def parse
+          if installed?
+            metadata = {}
+            
+            ffmpeg_output = WebVideo::Tools.run(command_name, "-i #{@filepath}", [0,1])
+            
+            metadata[:duration] = $1 if ffmpeg_output =~ /Duration\: ([0-9][0-9]\:[0-9][0-9]\:[0-9][0-9]\.[0-9][0-9])\,/
+            metadata[:bitrate] = $1 if ffmpeg_output =~ /\, bitrate\: (.*)$/
+            
+            metadata[:streams] = []
+            
+            ffmpeg_output.scan(/stream #0.([0-9])(\[.+\])?:\s(.*):\s([^,]*),\s(.*)/i).each do |match|
+              metadata[:streams] << WebVideo::Stream.new(:type => match[2], :codec => match[3], :details => match[4])
+            end
+            
+            return metadata
+          end
+        end
+    end
+  end
+end

data/lib/web_video/stream.rb

@@ -0,0 +1,26 @@
+module WebVideo
+  class Stream
+    attr_accessor :type, :codec, :details
+    
+    #
+    # stream = Stream.new :type => 'Video', :codec => 'mpeg4', :details => 'yuv420p, 640x480 [PAR 1:1 DAR 4:3], 30 tbr, 30 tbn, 30 tbc'
+    # stream.video? # => true
+    # stream.audio? # => false 
+    #
+    def initialize(options = {})
+      options.symbolize_keys!
+      
+      @type = options[:type].to_s.downcase
+      @codec = options[:codec]
+      @details = options[:details]
+    end
+    
+    def video?
+      @type == 'video'
+    end
+    
+    def audio?
+      @type == 'audio'
+    end
+  end
+end

data/lib/web_video/tools.rb

@@ -0,0 +1,39 @@
+module WebVideo
+  module Tools
+    
+    def self.run_with_option(command_name, params, options = {})
+      run(command_name, apply_options(params, options))
+    end
+
+    #
+    # Execute command with params and return output if exit status equal expected_outcodes
+    #
+    def self.run(cmd, params = "", expected_outcodes = 0)
+      command = %Q[#{cmd} #{params}].gsub(/\s+/, " ")
+      command = "#{command} 2>&1"
+      
+      WebVideo.logger.info(command)
+      
+      output = `#{command}`
+      
+      WebVideo.logger.info(output)
+      
+      unless [expected_outcodes].flatten.include?($?.exitstatus)
+        raise WebVideo::CommandLineError, "Error while running #{cmd}"
+      end
+      
+      output
+    end
+    
+    def self.apply_options(command, options)
+      str = command.dup
+      
+      options.each do |key, value|
+        param = value.is_a?(String) ? value.inspect : value
+        str.gsub!("$#{key}$", param.to_s)
+      end
+      
+      str
+    end
+  end
+end

data/lib/web_video/transcoder.rb

@@ -0,0 +1,112 @@
+module WebVideo
+  class Transcoder
+    attr_accessor :source
+    attr_reader :adapter
+
+    # Video Convertation
+    # 
+    # transcoder = WebVideo::Transcoder.new("demo.avi")
+    # transcoder.source # WebVideo::Adapters::AbstractAdapter instance
+    #
+    # Or
+    #
+    # video = WebVideo::Adapters::FfmpegAdapter.new('demo.avi')
+    # transcoder = WebVideo::Transcoder.new(video)
+    # transcoder.source # WebVideo::Adapters::FfmpegAdapter instance (video)
+    #
+    def initialize(filepath, options = {}, adapter = :ffmpeg)
+      @adapter = adapter
+      
+      if filepath.is_a?(WebVideo::Adapters::AbstractAdapter)
+        @source = filepath
+      else
+        args = [filepath, options]
+        
+        @source = case @adapter
+          when String, Symbol then
+            load_adapter(@adapter.to_s).new(*args)
+          when Class then
+            @adapter.new(*args)
+          else
+            @adapter
+          end
+        end
+    end
+
+    # Create screenshots
+    #
+    # transcoder = WebVideo::Transcoder.new("demo.avi")
+    # transcoder.screenshot("demo.jpg", :resolution => "480x360")
+    #
+    # options:
+    #   :count  - count images to generate
+    #   :format - image decoder
+    #   :at     - time to start make screenshots from
+    #   :resolution - image resolution
+    def screenshot(destination, options = {}, &block)
+      options.symbolize_keys!
+      
+      options[:count] ||= 1
+      options[:format] ||= "image2"
+      options[:at] ||= "00:00:01"
+      
+      process(destination, @source.screenshot_command, options, &block)
+    end
+
+    # Generate new video file
+    #
+    # transcoder = WebVideo::Transcoder.new("demo.avi")
+    #
+    # begin
+    #   transcoder.convert("demo.flv", :resolution => "480x360") do |command|
+    #     command << "-ar 22050"
+    #     command << "-ab 128k"
+    #     command << "-acodec libmp3lame"
+    #     command << "-vcodec flv"
+    #     command << "-r 25"
+    #     command << "-y"
+    #   end
+    #  rescue WebVideo::CommandLineError => e
+    #    WebVideo.logger.error("Unable to transcode video: #{e.class} - #{e.message}")
+    # end
+    #
+    # options:
+    #   :resolution - video resolution
+    #
+    def convert(destination, options = {}, &block)
+      options.symbolize_keys!
+     
+      process(destination, @source.convert_command, options, &block)
+    end
+
+    # Execute command
+    #
+    def execute(command, options = {})
+      @source.run(command, options)
+    end
+    
+    private
+    
+      def load_adapter(adapter_name)        
+        class_name = "#{adapter_name}_adapter".classify
+        "WebVideo::Adapters::#{class_name}".constantize
+      end
+      
+      def process(destination, command, options = {}, &block)
+        options[:input_file] = @source.filepath
+        options[:output_file] = destination
+        
+        if block_given?
+          begin
+            yield command
+          rescue Exception => e
+            raise WebVideo::Error, "Error take screenshot #{destination}: #{e.class} => #{e.message}"
+          end
+        end
+        
+        command << "$output_file$"
+      
+        execute(command.join(' '), options)
+      end
+  end
+end

data/lib/web_video.rb

@@ -0,0 +1,36 @@
+require 'logger'
+
+module WebVideo
+  autoload :Tools, 'web_video/tools'
+  autoload :Stream, 'web_video/stream'
+  autoload :Transcoder, 'web_video/transcoder'
+  
+  module Adapters
+    autoload :AbstractAdapter, 'web_video/adapters/abstract_adapter'
+    autoload :FfmpegAdapter, 'web_video/adapters/ffmpeg_adapter'
+  end
+
+  #
+  # WebVideo.logger.info 'Demo convert'
+  #
+  def self.logger
+    @logger ||= Logger.new('/dev/null')      
+    @logger
+  end
+  
+  #
+  # Configure logging. Pass a valid Ruby logger object.
+  #
+  #   logger = Logger.new(STDOUT)
+  #   WebVideo.logger = logger
+  #
+  def self.logger=(value)
+    @logger = value
+  end
+  
+  class Error < StandardError #:nodoc:
+  end
+
+  class CommandLineError < StandardError #:nodoc:
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'test/unit'
+require 'active_support'

data/test/web_video_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class WebVideoTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  test "the truth" do
+    assert true
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: web_video
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Igor Galeta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-07 00:00:00 +03:00
+default_executable: 
+dependencies: []
+
+description: WebVideo allows you to inspect, convert and take screenshots from video files
+email: galeta.igor@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- lib/web_video.rb
+- lib/web_video/adapters/abstract_adapter.rb
+- lib/web_video/adapters/ffmpeg_adapter.rb
+- lib/web_video/stream.rb
+- lib/web_video/tools.rb
+- lib/web_video/transcoder.rb
+has_rdoc: true
+homepage: http://github.com/galetahub/web_video
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: web_video
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: WebVideo allows you to inspect and process video files
+test_files: 
+- test/web_video_test.rb
+- test/test_helper.rb