videoinfo 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2d9f23008adc1a077641356b4fde1287788ab376
+  data.tar.gz: 511ba79416ab3b21e1a953c03d0f608574a156b5
+SHA512:
+  metadata.gz: d2c7f16d606e4518facbd133a9692e0b6bde23011e13014ec04ec987dba5c95d15f0f0309bc954b2d53aa20ec363fe41711c0283af1c4e5eac13d25ea1c212ce
+  data.tar.gz: bada7f288cacddc5db52c5cdb51bd97b9588944ae83f6fbcbb0baffcd41310da006db0f25fef50e9817cce437c4ccb7bd038fad55d89ca75fd837d86e4b065ee

data/.gitignore

@@ -0,0 +1,5 @@
+.ruby-version
+.ruby-gemset
+Gemfile.lock
+/tmp
+*.gem

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+## CHANGELOG
+
+#### Version 0.2.0 (August 8, 2014)
+ * Initial release

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,115 @@
+## Videoinfo
+
+Videoinfo is a simple tool for aggregating video metadata and capturing/uploading screenshots.
+
+## Installation
+
+First, you'll want to install the prerequisite binaries and make sure they are in your PATH.
+
+ * [mediainfo](http://mediaarea.net/en-us/MediaInfo/Download)
+ * [ffmpeg](https://www.ffmpeg.org/download.html)
+
+Add this line to your application's Gemfile:
+
+    gem 'videoinfo'
+
+And then execute:
+
+    bundle install
+
+Or install it yourself with:
+
+    $ gem install videoinfo
+
+## Configuration
+
+There are only a few configuration options:
+
+```ruby
+Videoinfo.mediainfo_binary = '/path/to/mediainfo'  # defaults to 'mediainfo'
+Videoinfo.ffmpeg_binary    = '/path/to/ffmpeg'     # defaults to 'ffmpeg'
+Videoinfo.image_host       = ImageHosts::Imgur.new # can be any object that responds to upload(File)
+Videoinfo.interactive      = true                  # defaults to true when using the command line, false otherwise
+```
+
+## Usage
+
+#### Command Line
+
+```
+$ videoinfo -h
+Usage: videoinfo [options] "MOVIENAME" file
+    -i, --image-host=IMAGEHOST       The ImageHost to use for uploading screenshots. Default: Imgur
+    -s, --screenshots=SCREENSHOTS    The number of screenshots to create, max 7. Default: 2
+    -n, --no-prompt                  Disable interactive mode
+    -h, --help                       Show this message
+
+$ videoinfo -s 5 -i Imgur 'Hackers' Hackers.1995.mkv > hackers.txt
+Is your movie "Hackers (1995)" (tt0113243)? [Y/n] y
+```
+
+#### In scripts
+
+The simpliest way to analyze a movie is with `Videoinfo.analyze_movie()`:
+
+```ruby
+result = Videoinfo.analyze_movie('hackers', 'Hackers.1995.mkv', 0) # => #<Videoinfo::Results::MovieResult>
+result.imdb_id         # => "0113243"
+result.title           # => "Hackers"
+result.plot_summary    # => "A young boy is arrested..."
+result.release_date    # => "15 September 1995 (USA)"
+result.rating          # => 6.2
+result.rating_over_ten # => "6.2 / 10"
+result.genres          # => ["Action", "Crime", "Drama", "Thriller"]
+result.director        # => "Iain Softley"
+result.writers         # => ["Rafael Moreu"]
+result.runtime         # => 107
+result.imdb_url        # => "http://www.imdb.com/title/tt0113243"
+result.wiki_url        # => "https://en.wikipedia.org/wiki/Hackers_(film)"
+result.trailer_url     # => "https://www.youtube.com/watch?v=vCobCU9FfzI"
+result.screenshot_urls # => ["https://i.imgur.com/SoBhWfQ.png", ...]
+result.mediainfo       # => "General..."
+```
+
+Or, you can be more explicit:
+
+```ruby
+movie = Videoinfo::Videos::Movie.new('hackers', 'Hackers.1995.mkv', 5)
+movie.populate_result!            # => #<Videoinfo::Results::MovieResult>
+movie.result                      # => #<Videoinfo::Results::MovieResult>
+movie.search_imdb                 # => [#<Imdb::Movie>, ...]
+movie.search_wiki                 # => "https://en.wikipedia.org/wiki/Hackers_(film)"
+movie.search_youtube              # => "https://www.youtube.com/watch?v=vCobCU9FfzI"
+movie.read_mediainfo              # => "General..."
+movie.capture_screenshots         # => [#<Tempfile:/var/folders/l1/qf5v1rlj6n99n20_rhwrp_5r0000gn/T/ss_20.20140803-67537-ur85vi.png>, ...]
+Videoinfo.upload_screenshot(file) # => "https://i.imgur.com/SoBhWfQ.png"
+```
+
+## Contributing
+
+You are welcome to submit patches with bug fixes or feature additions. Please
+make sure to test your changes throughly and keep to the style you see throughout
+the rest of the code base. Indent with 2 spaces and no trailing spaces at the end
+of lines. Just follow the steps below.
+
+1. Fork and clone the repository
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a Pull Request
+
+## Links
+
+* Code: `git clone git@github.com:ryanjohns/videoinfo.git`
+* Home: <https://github.com/ryanjohns/videoinfo>
+* Bugs: <https://github.com/ryanjohns/videoinfo/issues>
+* mediainfo: <http://mediaarea.net/en-us/MediaInfo/Download>
+* ffmpeg: <https://www.ffmpeg.org/download.html>
+
+## Author/Maintainter
+
+ * [Ryan Johns](https://github.com/ryanjohns)
+
+## License
+
+Videoinfo is released under the [MIT License](http://www.opensource.org/licenses/MIT).

data/bin/videoinfo

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'videoinfo'
+require 'videoinfo/cli'
+
+trap('TERM') { puts ''; exit 1 }
+trap('INT')  { puts ''; exit 1 }
+
+Videoinfo::CLI.run(ARGV)

data/lib/videoinfo.rb

@@ -0,0 +1,82 @@
+require 'tempfile'
+require 'shellwords'
+require 'cgi'
+require 'uri'
+require 'net/https'
+require 'json'
+require 'securerandom'
+require 'imdb'
+require 'videoinfo/errors'
+require 'videoinfo/image_host'
+require 'videoinfo/image_hosts/imgur'
+require 'videoinfo/result'
+require 'videoinfo/results/movie_result'
+require 'videoinfo/version'
+require 'videoinfo/video'
+require 'videoinfo/videos/movie'
+
+module Videoinfo
+
+  # Helper method to analyze a movie.
+  def self.analyze_movie(name, file, screenshots = 0)
+    Videos::Movie.new(name, file, screenshots).populate_result!
+  end
+
+  # Performs a google search and returns the top 10 results.
+  def self.google(term)
+    uri = URI("https://www.google.com/search?hl=en&q=#{CGI.escape(term)}")
+    begin
+      response = Net::HTTP.get_response(uri)
+      document = Nokogiri::HTML(response.body.encode('UTF-8', 'binary', :invalid => :replace, :undef => :replace, :replace => ''))
+      document.css('cite').map { |node| node.inner_text }
+    rescue => e
+      raise Error, "could not search google for '#{term}'. #{e.message}"
+    end
+  end
+
+  # Uploads a screenshot to the currently configured image_host and returns a URL to the image.
+  def self.upload_screenshot(image)
+    image_host.upload(image)
+  end
+
+  # Set the path of the mediainfo binary.
+  def self.mediainfo_binary=(mediainfo)
+    @mediainfo_binary = mediainfo.to_s.shellescape
+  end
+
+  # Get the path to the mediainfo binary, defaulting to 'mediainfo'.
+  def self.mediainfo_binary
+    @mediainfo_binary ||= 'mediainfo'
+  end
+
+  # Set the path of the ffmpeg binary.
+  def self.ffmpeg_binary=(ffmpeg)
+    @ffmpeg_binary = ffmpeg.to_s.shellescape
+  end
+
+  # Get the path to the ffmpeg binary, defaulting to 'ffmpeg'.
+  def self.ffmpeg_binary
+    @ffmpeg_binary ||= 'ffmpeg'
+  end
+
+  # Set the image host class. Must be an object that responds to upload(File) and returns a URL.
+  def self.image_host=(host)
+    @image_host = host
+  end
+
+  # Get the image host class, defaulting to ImageHosts::Imgur.new.
+  def self.image_host
+    @image_host ||= ImageHosts::Imgur.new
+  end
+
+  # Set interactive mode to true or false.
+  def self.interactive=(value)
+    @interactive = value
+  end
+
+  # True if interactive mode is enabled, defaulting to false.
+  def self.interactive?
+    @interactive ||= false
+  end
+
+end

data/lib/videoinfo/cli.rb

@@ -0,0 +1,53 @@
+require 'optparse'
+
+module Videoinfo
+  class CLI
+
+    # Analyze a video from command line arguments and print the result to STDOUT.
+    def self.run(args)
+      Videoinfo.interactive = true
+      screenshots           = 2
+      option_parser         = OptionParser.new do |opts|
+        opts.banner = 'Usage: videoinfo [options] "MOVIENAME" file'
+        opts.on('-i', '--image-host=IMAGEHOST', "The ImageHost to use for uploading screenshots. Default: #{Videoinfo.image_host.class.to_s.split('::').last}") do |host|
+          begin
+            Videoinfo.image_host = Videoinfo::ImageHosts.const_get(host).new
+          rescue
+            hosts = Videoinfo::ImageHosts.constants.map(&:to_s).join(', ')
+            STDERR.puts "ERROR: '#{host}' is an unknown image host. Available hosts: #{hosts}"
+            exit 1
+          end
+        end
+        opts.on('-s', '--screenshots=SCREENSHOTS', "The number of screenshots to create, max 7. Default: #{screenshots}") do |ss|
+          screenshots = ss.to_i
+          if screenshots > 7
+            STDERR.puts opts
+            exit 1
+          end
+        end
+        opts.on('-n', '--no-prompt', 'Disable interactive mode') do
+          Videoinfo.interactive = false
+        end
+        opts.on('-h', '--help', 'Show this message') do
+          puts opts
+          exit
+        end
+      end
+
+      name, file = option_parser.parse!(args)
+      if name.to_s == '' || file.to_s == ''
+        STDERR.puts option_parser
+        exit 1
+      end
+
+      begin
+        result = Videoinfo.analyze_movie(name, file, screenshots)
+        puts result.to_s
+      rescue Error => e
+        STDERR.puts "ERROR: #{e.message}"
+        exit 1
+      end
+    end
+
+  end
+end

data/lib/videoinfo/errors.rb

@@ -0,0 +1,4 @@
+module Videoinfo
+  class Error < StandardError
+  end
+end

data/lib/videoinfo/image_host.rb

@@ -0,0 +1,9 @@
+module Videoinfo
+  class ImageHost
+
+    def upload(image)
+      raise NotImplementedError
+    end
+
+  end
+end

data/lib/videoinfo/image_hosts/imgur.rb

@@ -0,0 +1,37 @@
+module Videoinfo
+  module ImageHosts
+    class Imgur < ImageHost
+
+      def initialize
+        @boundary     = SecureRandom.hex(6)
+        @header       = { 'Content-Type' => "multipart/form-data, boundary=#{@boundary}" }
+        @uri          = URI.parse('https://imgur.com/upload')
+        @http         = Net::HTTP.new(@uri.host, @uri.port)
+        @http.use_ssl = true
+      end
+
+      def upload(image)
+        begin
+          request      = Net::HTTP::Post.new(@uri.request_uri, @header)
+          request.body = post_body(image)
+          response     = @http.request(request)
+          img_name     = JSON.parse(response.body)['data']['hash']
+          "https://i.imgur.com/#{img_name}.png"
+        rescue => e
+          raise Error, "could not upload image #{File.basename(image.path)}. #{e.message}"
+        end
+      end
+
+      private
+
+      def post_body(image)
+        body  = "--#{@boundary}\r\n"
+        body << "Content-Disposition: form-data; name=\"Filedata\"; filename=\"#{File.basename(image.path)}\"\r\n"
+        body << "Content-Type: image/png\r\n\r\n"
+        body << image.read
+        body << "\r\n\r\n--#{@boundary}--\r\n"
+      end
+
+    end
+  end
+end

data/lib/videoinfo/result.rb

@@ -0,0 +1,21 @@
+module Videoinfo
+  class Result
+
+    attr_accessor :mediainfo, :screenshot_urls
+
+    def to_s
+      output = []
+
+      if screenshot_urls && screenshot_urls.size > 0
+        output += ['[b]Screenshots:[/b]', '[quote][align=center]']
+        output += screenshot_urls.map { |url| "[img=#{url}]" }
+        output += ['[/align][/quote]', '']
+      end
+
+      output += ['[mediainfo]', mediainfo, '[/mediainfo]']
+
+      output.join("\n")
+    end
+
+  end
+end

data/lib/videoinfo/results/movie_result.rb

@@ -0,0 +1,47 @@
+module Videoinfo
+  module Results
+    class MovieResult < Result
+
+      attr_accessor :imdb_id, :title, :plot_summary, :release_date, :rating, :genres, :director, :writers, :runtime, :wiki_url, :trailer_url
+
+      def rating_over_ten
+        rating ? "#{rating} / 10" : nil
+      end
+
+      def imdb_url
+        imdb_id ? "http://www.imdb.com/title/tt#{imdb_id}" : nil
+      end
+
+      def to_s
+        output = ['[b]Description:[/b]', '[quote]', plot_summary, '[/quote]', '']
+        output << '[b]Information:[/b]'
+        output << '[quote]'
+        output << "Title: #{title}"
+        output << "Rating: #{rating_over_ten}"
+        output << "Release Date: #{release_date}"
+        output << "Genres: #{(genres || []).join(' | ')}"
+        output << "Director: #{director}"          if director
+        output << "Writers: #{writers.join(', ')}" if writers && writers.size > 0
+        output << "Runtime: #{runtime} minutes"    if runtime
+        output << "Wikipedia url: #{wiki_url}"     if wiki_url
+        output << "IDMB url: #{imdb_url}"
+        output << '[/quote]'
+
+        if trailer_url
+          output += ['', '[b]Trailer:[/b]', '[quote]', "[center][youtube]#{trailer_url}[/youtube][/center]", '[/quote]']
+        end
+
+        if screenshot_urls && screenshot_urls.size > 0
+          output += ['', '[b]Screenshots:[/b]', '[quote][align=center]']
+          output += screenshot_urls.map { |url| "[img=#{url}]" }
+          output += ['[/align][/quote]']
+        end
+
+        output += ['', '[mediainfo]', mediainfo, '[/mediainfo]']
+
+        output.join("\n")
+      end
+
+    end
+  end
+end

data/lib/videoinfo/version.rb

@@ -0,0 +1,3 @@
+module Videoinfo
+  VERSION = '0.2.0'
+end

data/lib/videoinfo/video.rb

@@ -0,0 +1,59 @@
+module Videoinfo
+  class Video
+
+    attr_accessor :name, :file, :screenshots, :result
+
+    def initialize(name, file, screenshots = 0)
+      self.name        = name
+      self.file        = file
+      self.screenshots = screenshots
+    end
+
+    def file=(f)
+      @file = File.expand_path(f)
+    end
+
+    def result
+      @result ||= Result.new
+    end
+
+    def populate_result!
+      result.mediainfo       = read_mediainfo
+      result.screenshot_urls = capture_screenshots.map { |ss| Videoinfo.upload_screenshot(ss) }
+
+      result
+    end
+
+    def read_mediainfo
+      raise Error, "#{file}: file not found" unless File.file?(file)
+
+      info = Dir.chdir(File.dirname(file)) { %x(#{Videoinfo.mediainfo_binary} #{File.basename(file).shellescape}) }
+      raise Error, 'unable to read mediainfo' unless $?.success?
+
+      info
+    end
+
+    def capture_screenshots
+      return [] unless screenshots > 0
+      raise Error, "#{file}: file not found" unless File.file?(file)
+
+      duration = %x(#{Videoinfo.mediainfo_binary} --Inform="General;%Duration%" #{file.shellescape}).strip.to_f / 1000
+      raise Error, 'unable to determine video duration' unless $?.success? && duration > 0
+
+      images   = []
+      stepsize = screenshots == 1 ? 100 : 60 / (screenshots - 1)
+      (20..80).step(stepsize) do |percent|
+        image = Tempfile.new(["ss_#{percent}.", '.png'])
+        %x(#{Videoinfo.ffmpeg_binary} -y -ss #{duration * percent / 100} -i #{file.shellescape} -vframes 1 -f image2 #{image.path} -v quiet)
+        if $?.success?
+          images << image
+        else
+          raise Error, "ERROR: unable to capture screenshot at #{percent}% into the video"
+        end
+      end
+
+      images
+    end
+
+  end
+end

data/lib/videoinfo/videos/movie.rb

@@ -0,0 +1,62 @@
+module Videoinfo
+  module Videos
+    class Movie < Video
+
+      def result
+        @result ||= Results::MovieResult.new
+      end
+
+      def populate_result!
+        result.mediainfo = read_mediainfo
+
+        movie = search_imdb.first
+        if movie
+          result.imdb_id      = movie.id
+          result.title        = movie.title.sub(/\(\d{4}\)/, '').strip
+          result.plot_summary = movie.plot_summary
+          result.release_date = movie.release_date
+          result.rating       = movie.rating
+          result.genres       = movie.genres
+          result.director     = movie.director.first
+          result.writers      = movie.writers.compact
+          result.runtime      = movie.length
+          result.wiki_url     = search_wiki
+          result.trailer_url  = search_youtube
+        end
+
+        result.screenshot_urls = capture_screenshots.map { |ss| Videoinfo.upload_screenshot(ss) }
+
+        result
+      end
+
+      def search_imdb
+        movies = []
+        begin
+          movies = Imdb::Search.new(name).movies
+        rescue => e
+          raise Error, "could not search IMDB. #{e.message}"
+        end
+
+        return movies unless Videoinfo.interactive?
+
+        movies.each do |m|
+          STDERR.print "Is your movie \"#{m.title}\" (tt#{m.id})? [Y/n] "
+          return [m] if STDIN.gets.strip !~ /^(n|no)$/i
+        end
+
+        []
+      end
+
+      def search_wiki
+        wiki_url = Videoinfo.google("site:wikipedia.org #{result.title || name} film").first
+        wiki_url ? "https://#{wiki_url}" : nil
+      end
+
+      def search_youtube
+        youtube_url = Videoinfo.google("site:youtube.com #{result.title || name} trailer").first
+        youtube_url ? "https://#{youtube_url}" : nil
+      end
+
+    end
+  end
+end

data/videoinfo.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/videoinfo/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'videoinfo'
+  s.version     = Videoinfo::VERSION
+  s.summary     = 'Simple tool for aggregating video metadata and capturing screenshots'
+  s.description = 'Combines metadata from a variety of sources with codec details from mediainfo to produce a marked-up summary for a video file. Also captures screenshots using ffmpeg and uploads them to a configurable image host.'
+  s.authors     = ['Ryan Johns']
+  s.email       = 'ryanjohns@gmail.com'
+  s.homepage    = 'https://github.com/ryanjohns/videoinfo'
+  s.license     = 'MIT'
+
+  s.files         = `git ls-files`.split("\n")
+  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_runtime_dependency 'imdb', '~> 0.8'
+
+  s.requirements << 'mediainfo'
+  s.requirements << 'ffmpeg'
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: videoinfo
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Ryan Johns
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: imdb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: Combines metadata from a variety of sources with codec details from mediainfo
+  to produce a marked-up summary for a video file. Also captures screenshots using
+  ffmpeg and uploads them to a configurable image host.
+email: ryanjohns@gmail.com
+executables:
+- videoinfo
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- README.md
+- bin/videoinfo
+- lib/videoinfo.rb
+- lib/videoinfo/cli.rb
+- lib/videoinfo/errors.rb
+- lib/videoinfo/image_host.rb
+- lib/videoinfo/image_hosts/imgur.rb
+- lib/videoinfo/result.rb
+- lib/videoinfo/results/movie_result.rb
+- lib/videoinfo/version.rb
+- lib/videoinfo/video.rb
+- lib/videoinfo/videos/movie.rb
+- videoinfo.gemspec
+homepage: https://github.com/ryanjohns/videoinfo
+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:
+- mediainfo
+- ffmpeg
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simple tool for aggregating video metadata and capturing screenshots
+test_files: []