vcs_ruby 1.0.1 → 1.1.0

data/lib/{thumbnail.rb → frame.rb}

@@ -1,59 +1,76 @@
 #
-# Thumbnails from video
+# Frame from video
 #
 
 require 'mini_magick'
 
 module VCSRuby
-  class Thumbnail
+  class Frame
     attr_accessor :width, :height, :aspect
-    attr_accessor :image_path
-    attr_accessor :time
-    attr_reader :filters
+    attr_reader :filters, :time
 
-    def initialize capper, video, configuration
-      @capper = capper
+    def initialize video, capturer, time
       @video = video
-      @configuration = configuration
+      @capturer = capturer
+      @time = time
       @filters = []
     end
 
+    def filename= file_path
+      @out_path = File.dirname(file_path)
+      @out_filename = File.basename(file_path,'.*')
+    end
+
+    def filename
+      File.join(@out_path, "#{@out_filename}.#{@capturer.format_extension}")
+    end
+
+    def format= fmt
+      @capturer.format = fmt
+    end
+
+    def format
+      @capturer.format
+    end
+
     def capture
-      @capper.grab @time, @image_path
+      @capturer.grab @time, filename
     end
 
-    def capture_and_evade interval
-      times = [TimeIndex.new] + @configuration.blank_alternatives
-      times.select! { |t| (t < interval / 2) and (t > interval / -2) }
+    def capture_and_evade interval = nil
+      times = [TimeIndex.new] + Configuration.instance.blank_alternatives
+      if interval
+        times.select! { |t| (t < interval / 2) and (t > interval / -2) }
+      end
       times.map! { |t| @time + t }
 
       times.each do |time|
         @time = time
         capture
         break unless blank?
-        puts "Blank frame detected. => #{@time}" unless Tools::quiet?
-        puts "Giving up!" if time == times.last && !Tools::quiet?
+        puts "Blank frame detected. => #{@time}" unless Configuration.instance.quiet?
+        puts "Giving up!" if time == times.last && !Configuration.instance.quiet?
       end
     end
 
     def blank?
-      image = MiniMagick::Image.open @image_path
+      image = MiniMagick::Image.open filename
       image.colorspace 'Gray'
       mean = image['%[fx:image.mean]'].to_f
-      return mean < @configuration.blank_threshold
+      return mean < Configuration.instance.blank_threshold
     end
 
     def apply_filters
       MiniMagick::Tool::Convert.new do |convert|
         convert.background 'Transparent'
         convert.fill 'Transparent'
-        convert << @image_path
+        convert << filename
 
         sorted_filters.each do |filter|
           call_filter filter, convert
         end
 
-        convert << @image_path
+        convert << filename
       end
     end
 
@@ -76,12 +93,12 @@ private
 
     def timestamp_filter convert
       convert.stack do |box|
-        box.box @configuration.timestamp_background
-        box.fill  @configuration.timestamp_color
-        box.pointsize @configuration.timestamp_font.size
+        box.box Configuration.instance.timestamp_background
+        box.fill Configuration.instance.timestamp_color
+        box.pointsize Configuration.instance.timestamp_font.size
         box.gravity 'SouthEast'
-        if @configuration.timestamp_font.exists?
-          box.font @configuration.timestamp_font.path 
+        if Configuration.instance.timestamp_font.exists?
+          box.font Configuration.instance.timestamp_font.path
         end
         box.annotate('+10+10', " #{@time.to_timestamp} ")
       end
@@ -115,7 +132,11 @@ private
         a.fill 'White'
         a.background 'White'
         a.bordercolor 'White'
-        a.mattecolor 'White'
+        if Tools.magick_version.major > 6
+          a.alpha_color 'White'
+        else
+          a.mattecolor 'White'
+        end
         a.frame "#{border}x#{border}"
         a.stack do |b|
           b.flip

data/lib/libAV/libav.rb

@@ -0,0 +1,143 @@
+#
+# libAV Abstraction
+#
+
+require 'capturer'
+require 'command'
+
+module VCSRuby
+  class LibAV < Capturer
+
+    HEADER = 10
+
+    ENCODING_SUPPORT = 2
+    VIDEO_CODEC = 3
+    NAME = 8
+
+    attr_reader :info, :video_streams, :audio_streams
+
+    def initialize video
+      @video = video
+      @avconv = Command.new :libav, 'avconv'
+      @avprobe = Command.new :libav, 'avprobe'
+
+      detect_version if available?
+    end
+
+    def file_valid?
+      return probe_meta_information
+    end
+
+    def name
+      :libav
+    end
+
+    def available?
+      @avconv.available? && @avprobe.available?
+    end
+
+
+    def detect_version
+      info = @avconv.execute('-version')
+      match = /avconv ([\d|.|-|:]*)/.match(info)
+      if match
+        @version = match[1]
+      end
+    end
+
+
+
+    def grab time, image_path
+      @avconv.execute "-y -ss #{time.total_seconds} -i \"#{@video.full_path}\" -an -dframes 1 -vframes 1 -vcodec #{format} -f rawvideo \"#{image_path}\""
+    end
+
+    def available_formats
+      # Ordered by priority
+      image_formats = ['png', 'tiff', 'bmp', 'mjpeg']
+      formats = []
+
+      list = @avprobe.execute "-codecs"
+      list.lines.drop(HEADER).each do |codec|
+        name, e, v = format_split(codec)
+        formats << name if image_formats.include?(name) && e && v
+      end
+
+      image_formats.select{ |format| formats.include?(format) }.map(&:to_sym)
+    end
+
+    def to_s
+      "LibAV #{@version}"
+    end
+
+private
+    def format_split line
+      correction = 0
+      unless line[0] == ' '
+        correction = 1
+      end
+      e = line[ENCODING_SUPPORT - correction] == 'E'
+      v = line[VIDEO_CODEC - correction] == 'V'
+
+      name = line[NAME-correction..-1].split(' ', 2).first
+      return name, e, v
+    rescue
+      return nil, false, false
+    end
+
+    def probe_meta_information
+      check_cache
+      parse_meta_info
+      return true
+    rescue Exception => e
+      puts e
+      return false
+    end
+
+    def check_cache
+      unless @cache
+        @cache = @avprobe.execute("\"#{@video.full_path}\"  -show_format -show_streams", "2>&1")
+      end
+    end
+
+    def get_hash defines
+      result = {}
+      defines.lines.each do |line|
+        kv = line.split("=")
+        result[kv[0].strip] = kv[1].strip if kv.count == 2
+      end
+      result
+    end
+
+    def parse_meta_info
+      parse_format
+      parse_audio_streams
+      parse_video_streams
+    end
+
+    def parse_format
+      @cache.scan(/\[FORMAT\](.*?)\[\/FORMAT\]/m) do |format|
+        @info = LibAVMetaInfo.new(get_hash(format[0]))
+      end
+    end
+
+    def parse_audio_streams
+      @audio_streams = []
+      @cache.scan(/\[STREAM\](.*?)\[\/STREAM\]/m) do |stream|
+        info = get_hash(stream[0])
+        if info['codec_type'] == 'audio'
+          @audio_streams << LibAVAudioStream.new(info)
+        end
+      end
+    end
+
+    def parse_video_streams
+      @video_streams = []
+      @cache.scan(/\[STREAM\](.*?)\[\/STREAM\]/m) do |stream|
+        info = get_hash(stream[0])
+        if info['codec_type'] == 'video'
+          @video_streams << LibAVVideoStream.new(info)
+        end
+      end
+    end
+  end
+end

data/lib/libAV/libav_audio_stream.rb

@@ -0,0 +1,38 @@
+#
+# Implementes AudioStream Interface for libAV
+#
+
+# AudioStream = Struct.new(:codec, :channels, :channel_layout, :sample_rate, :bit_rate, :raw)
+module VCSRuby
+  class LibAVAudioStream
+    attr_reader :raw
+
+    def initialize audio_stream
+      @raw = audio_stream
+    end
+
+    def codec short = false
+      if short
+        @raw['codec_name']
+      else
+        @raw['codec_long_name']
+      end
+    end
+
+    def channels
+      @raw['channels'].to_i
+    end
+
+    def channel_layout
+      @raw['channel_layout']
+    end
+
+    def sample_rate
+      @raw['sample_rate'].to_i
+    end
+
+    def bit_rate
+      @raw['bit_rate'].to_i
+    end
+  end
+end

data/lib/libAV/libav_meta_info.rb

@@ -0,0 +1,37 @@
+#
+# Implementes MetaInfo Interface for libAV
+#
+
+# MetaInformation = Struct.new(:duration, :bit_rate, :size, :format, :extension, :raw)
+
+require_relative '../time_index'
+
+module VCSRuby
+  class LibAVMetaInfo
+    attr_reader :raw
+
+    def initialize meta_info
+      @raw = meta_info
+    end
+
+    def duration
+      TimeIndex.new(@raw['duration'].to_f)
+    end
+
+    def bit_rate
+      @raw['bit_rate'].to_i
+    end
+
+    def size
+      @raw['size'].to_i
+    end
+
+    def format
+      @raw['format_long_name']
+    end
+
+    def extension
+      @raw['format_name']
+    end
+  end
+end

data/lib/libAV/libav_video_stream.rb

@@ -0,0 +1,52 @@
+#
+# Implementes VideoStream Interface for libAV
+#
+
+# VideoStream = Struct.new(:width, :height, :codec, :color_space, :bit_rate, :frame_rate, :aspect_ratio, :raw)
+
+module VCSRuby
+  class LibAVVideoStream
+    attr_reader :raw
+
+    def initialize video_stream
+      @raw = video_stream
+    end
+
+    def width
+      @raw['width'].to_i
+    end
+
+    def height
+      @raw['height'].to_i
+    end
+
+    def codec short = false
+      if short
+        @raw['codec_name']
+      else
+        @raw['codec_long_name']
+      end
+    end
+
+    def color_space
+      if ["unknown", "", nil].include? @raw['color_space']
+        @raw['pix_fmt']
+      else
+        @raw['color_space']
+      end
+    end
+
+    def bit_rate
+      @raw['bit_rate'].to_i
+    end
+
+
+    def frame_rate
+      Rational(@raw['r_frame_rate'])
+    end
+
+    def aspect_ratio
+      @raw['display_aspect_ratio']
+    end
+  end
+end

data/lib/stream.rb

@@ -0,0 +1,24 @@
+#
+# Represents a stream in a video
+#
+
+require 'vcs'
+
+module VCSRuby
+  class Stream
+    def initialize stream
+      @stream = stream
+      create_accessors
+    end
+
+    def create_accessors
+      @stream.each do |key, value|
+        self.class.send :define_method, key.to_sym do
+          return @stream[key]
+        end
+      end
+    end
+
+    private
+  end
+end

data/lib/tools.rb

@@ -3,6 +3,7 @@
 #
 
 module VCSRuby
+
   class Tools
     def self.windows?
       return ((RUBY_PLATFORM =~ /win32/ or RUBY_PLATFORM =~ /mingw32/) or (RbConfig::CONFIG['host_os'] =~ /mswin|windows/i))
@@ -12,24 +13,6 @@ module VCSRuby
       return ((RUBY_PLATFORM =~ /linux/) or (RbConfig::CONFIG['host_os'] =~ /linux/i))
     end
 
-    def self.verbose= verbose
-      @verbose = verbose
-      @quiet = false if @verbose
-    end
-
-    def self.verbose?
-      @verbose
-    end
-
-    def self.quiet= quiet
-      @quiet = quiet
-      @verbose = false if @quiet
-    end
-
-    def self.quiet?
-      @quiet
-    end
-
     def self.list_arguments arguments
       arguments.map{ |argument| argument.to_s }.join(', ')
     end
@@ -39,10 +22,20 @@ module VCSRuby
       exit 0
     end
 
+    MagickVersion = Struct.new(:major, :minor, :revision)
+    def self.magick_version
+      output = %x[convert -version]
+      m = output.match /(\d+)\.(\d+)\.(\d+)(-(\d+))?/
+      MagickVersion.new(m[1].to_i, m[2].to_i, m[3].to_i)
+    end
+
     def self.contact_sheet_with_options video, options
-      sheet = VCSRuby::ContactSheet.new video, options[:profile]
+      Configuration.instance.load_profile options[:profile] if options[:profile]
+      Configuration.instance.capturer = options[:capturer]
+
+      video = VCSRuby::Video.new video
+      sheet = video.contact_sheet
 
-      sheet.capturer = options[:capturer]
       sheet.format = options[:format] if options[:format]
       sheet.title = options[:title] if options[:title]
       sheet.signature = options[:signature] if options[:signature]

data/lib/vcs.rb

@@ -2,13 +2,25 @@
 # Video Contact Sheet Ruby
 #
 
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+
 require 'command'
 require 'configuration'
 require 'contact_sheet'
-require 'ffmpeg'
-require 'libav'
-require 'mplayer'
-require 'thumbnail'
+require 'video'
+require 'frame'
 require 'time_index'
 require 'tools'
 require 'version'
+require 'FFmpeg/ffmpeg'
+require 'FFmpeg/ffmpeg_audio_stream'
+require 'FFmpeg/ffmpeg_video_stream'
+require 'FFmpeg/ffmpeg_meta_info'
+require 'libAV/libav'
+require 'libAV/libav_audio_stream'
+require 'libAV/libav_video_stream'
+require 'libAV/libav_meta_info'
+require 'MPlayer/mplayer'
+require 'MPlayer/mplayer_audio_stream'
+require 'MPlayer/mplayer_video_stream'
+require 'MPlayer/mplayer_meta_info'

data/lib/version.info

@@ -1 +1 @@
-1.0.1
+1.1.1

data/lib/version.rb

@@ -12,11 +12,11 @@ module VCSRuby
   end
 
   def self.update_version
+    current_version = read_version
     parts = File.open(version_path, &:readline).split('.').map(&:strip)
     parts[2] = (parts[2].to_i + 1).to_s
     File.open(version_path, 'w') {|f| f.write(parts.join('.')) }
-
-    read_version
+    current_version    
   end
 end
 

data/lib/video.rb

@@ -0,0 +1,89 @@
+#
+# Represents the video file
+#
+
+require 'vcs'
+
+module VCSRuby
+  class Video
+    attr_reader :config
+
+    def initialize video
+      initialize_filename video
+      initialize_capturers
+    end
+
+    def valid?
+      capturer.file_valid?
+    end
+
+    def info
+      capturer.info
+    end
+
+    def video
+      capturer.video_streams.first
+    end
+
+    def video_streams
+      capturer.video_streams
+    end
+
+    def audio
+      capturer.audio_streams.first
+    end
+
+    def audio_streams
+      capturer.audio_streams
+    end
+
+    def full_path
+      File.join(@path, @filename)
+    end
+
+    def contact_sheet
+      @contact_sheet ||= ContactSheet.new self, capturer
+    end
+
+    def frame time_index
+      return Frame.new self, capturer, time_index
+    end
+
+private
+    def initialize_filename video
+      @path = File.dirname(File.absolute_path(video))
+      @filename = File.basename(video)
+    end
+
+    def initialize_capturers
+      @capturers = []
+
+      @capturers << LibAV.new(self)
+      @capturers << MPlayer.new(self)
+      @capturers << FFmpeg.new(self)
+
+      if Configuration.instance.verbose?
+        puts "Available capturers: #{available_capturers.map{ |c| c.to_s }.join(', ')}"
+      end
+    end
+
+    def available_capturers
+      @capturers.select{ |c| c.available? }
+    end
+
+    def capturer
+      result = nil
+      if Configuration.instance.capturer == :any
+        result = available_capturers.first
+      else
+        result = available_capturers.select{ |c| c.name == Configuration.instance.capturer }.first
+      end
+
+      unless result
+        raise "Selected Capturer (#{Configuration.instance.capturer}) not available. Install one of these: #{@capturers.map{ |c| c.name }.join(', ')}"
+      end
+
+      return result
+    end
+  end
+end