storyboard 0.2.3

data/.gitignore

@@ -0,0 +1,3 @@
+*.avi
+*.mkv
+.DS_Store

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vendor/suby"]
+	path = vendor/suby
+	url = http://github.com/markolson/suby

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create use 1.9.3@storyboard

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+gemspec
+
+gem 'nokogiri'
+gem 'suby', :path => 'vendor/suby', :require => 'suby'
+gem 'rmagick'
+gem 'prawn'
+gem 'ruby-progressbar'
+gem 'rubyzip'

data/Gemfile.lock

@@ -0,0 +1,55 @@
+GIT
+  remote: http://github.com/markolson/suby
+  revision: f44e9821f0f6ff07d2729a3a0b3abc386861b9e9
+  specs:
+    suby (0.4.0)
+      mime-types (>= 1.19)
+      nokogiri
+      path (>= 1.3.0)
+      rubyzip
+      term-ansicolor
+
+PATH
+  remote: .
+  specs:
+    Storyboard (0.1.1)
+      nokogiri
+      prawn
+      rmagick
+      ruby-progressbar
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    Ascii85 (1.0.2)
+    afm (0.2.0)
+    hashery (2.1.0)
+    mime-types (1.19)
+    nokogiri (1.5.6)
+    path (1.3.1)
+    pdf-reader (1.3.0)
+      Ascii85 (~> 1.0.0)
+      afm (~> 0.2.0)
+      hashery (~> 2.0)
+      ruby-rc4
+      ttfunk
+    prawn (0.12.0)
+      pdf-reader (>= 0.9.0)
+      ttfunk (~> 1.0.2)
+    rmagick (2.13.1)
+    ruby-progressbar (1.0.2)
+    ruby-rc4 (0.1.5)
+    rubyzip (0.9.9)
+    term-ansicolor (1.0.7)
+    ttfunk (1.0.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  Storyboard!
+  nokogiri
+  prawn
+  rmagick
+  ruby-progressbar
+  suby!

data/README.md

@@ -0,0 +1,40 @@
+# Storyboard
+
+Read the TV and Movies you don't have time to watch.
+
+## Storyboard
+
+Storyboard is _very much_ a work in progress, and only works (most of) some of the time. Using it is simple:
+
+    storyboard /path/to/video-file.mkv
+
+Storyboard will try to generate a file at `/path/to/video-file.pdf` containing the final product. ePub and Mobi support will come later.
+
+You can see available commands by running the program without any options
+
+    Usage: storyboard [options] videofile [output_directory]
+      -v, --[no-]verbose               Run verbosely
+          --[no-]scenes                Detect scene changes. This increases the time it takes to generate a file.
+      -ct FLOAT                        Scene detection threshold. 0.2 is too low, 0.8 is too high. Play with it!
+      -s, --subs FILE                  SRT subtitle file to use. Will skip extracting/downloading one.
+          --make x,y,z                 Filetypes to output
+                                       (pdf, mobi, epub)
+      -h, --help                       Show this message
+
+## Requirements
+
+Storyboard requires a recent version of *ffmpeg*. This gem includes a build of *ffprobe* that will only work on OS X 1.8, 64 bit. It's probably best not to use this on any different system for now. It's also best to run it on something with at least 8 cores.
+
+## Known Issues
+
+* If there is a scene change followed by dialog in the next frame or two, the dialog may not be shown.
+* Subtitles are always downloaded, never extracted from video files. Because the subtitles are searched for based on the filename it's best that you have then named in a standard format, e.g., `The X-Files - 1x21 - Tooms.avi`.
+* Sometimes the wrong subtitle file will be returned from the site. In those cases, download it manually and use the `-s` option to pass in the path to an SRT formatted subtitle file.
+* Some subtitles are encoded in UTF-16, and I haven't care quite enough yet to get them to work.
+* The subtitles are uuuuuugly.
+* Hardcoding 8 for the number of threads is a bad idea
+* Almost definitely some path-escaping issues, so avoid files with apostrophes and slashes
+
+## Help
+
+For now, best to email me theothermarkolson@gmail.com

data/TODO

@@ -0,0 +1,6 @@
+epub/mobi geenerators - since mobi is generated from epub, should I just always make both?
+passing in a directory instead of a file
+error messages
+extract subtitles from the files
+imdb subtitles
+#{filename}.srt and #{File.basename(filename,".*")}.srt checks

data/bin/storyboard

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'shellwords'
+require 'optparse'
+require 'logger'
+require 'open3'
+require 'bundler'
+ENV['BUNDLE_GEMFILE'] = File.join(File.dirname(__FILE__), '../Gemfile')
+Bundler.require(:default)
+
+require 'nokogiri'
+require 'suby'
+require 'rmagick'
+require 'prawn'
+require 'ruby-progressbar'
+
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'storyboard'
+
+options = {:scenes => true, :verbose => true, :types => ['pdf'], :scene_threshold => 0.4}
+
+# think about them
+options[:consolidate_frame_threshold] = 0.4
+options[:max_width] = 600
+
+LOG = Logger.new(STDOUT)
+LOG.level = Logger::INFO
+
+opts = OptionParser.new
+opts.banner = "Usage: storyboard [options] videofile [output_directory]"
+
+opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+  options[:version] = v
+  LOG.level = Logger::DEBUG if v
+end
+
+opts.on("-c", "--[no-]scenes", "Detect scene changes. This increases the time it takes to generate a file.") do |v|
+  options[:scenes] = v
+end
+
+opts.on("-ct", Float, "Scene detection threshold. 0.2 is too low, 0.8 is too high. Play with it!") do |f|
+  options[:scene_threshold] = f
+end
+
+opts.on("-s", "--subs FILE", "SRT subtitle file to use. Will skip extracting/downloading one.") do |s|
+  options[:subs] = s
+end
+
+opts.on("--make x,y,z", Array, "Filetypes to output", '(pdf, mobi, epub)') do |types|
+  options[:types] = types
+end
+
+opts.on_tail("-h", "--help", "Show this message") do
+  puts opts
+  exit
+end
+
+begin opts.parse! ARGV
+rescue OptionParser::InvalidOption, OptionParser::InvalidArgument => e
+  puts e
+  puts opts
+  exit 1
+end
+
+if ARGV.size < 1
+  puts "videofile required"
+  puts opts.to_s
+  exit 1
+end
+
+options[:file] = File.realdirpath(ARGV.shift)
+
+output_dir = ARGV.shift || Dir.pwd
+options[:basename] = File.basename(options[:file], ".*")
+
+options[:write_to] = output_dir #File.join(output_dir,options[:basename])
+options[:work_dir] = Dir.mktmpdir
+Dir.mkdir(options[:write_to]) unless File.directory?(options[:write_to])
+LOG.debug(options)
+
+Storyboard.new(options)

data/lib/storyboard/generators/pdf.rb

@@ -0,0 +1,46 @@
+require 'prawn'
+
+require 'rmagick'
+include Magick
+
+class Storyboard
+  class PDFRenderer < Storyboard::Renderer
+
+    attr_accessor :pdf, :storyboard, :dimensions
+    def initialize(parent)
+      @dimensions = []
+      @storyboard = parent
+    end
+
+    def set_dimensions(w,h)
+      @dimensions = [w,h]
+      @pdf = Prawn::Document.new(:page_size => [w, h], :margin => 0)
+    end
+
+    def write
+      @pdf.render_file "#{@storyboard.options[:write_to]}/#{@storyboard.options[:basename]}.pdf"
+      LOG.info("Wrote #{@storyboard.options[:write_to]}/#{@storyboard.options[:basename]}.pdf")
+    end
+
+    def render_frame(frame_name, subtitle = nil)
+      image_output = File.join(@storyboard.options[:save_directory], "sub-#{File.basename(frame_name)}")
+      img = ImageList.new(frame_name)
+
+      if(@dimensions.empty?)
+        resize_height = (img.rows * (@storyboard.options[:max_width].to_f/img.columns)).ceil
+        set_dimensions(storyboard.options[:max_width], resize_height)
+      end
+
+      img.resize_to_fit!(@dimensions[0], @dimensions[1])
+
+      self.add_subtitle(img, subtitle) if subtitle
+
+      img.format = 'jpeg'
+      img.write(image_output) { self.quality = 60 }
+      img.destroy!
+
+      @pdf.image image_output, :width => @dimensions[0], :height => @dimensions[1]
+    end
+
+  end
+end

data/lib/storyboard/generators/sub.rb

@@ -0,0 +1,32 @@
+class Storyboard
+  class Renderer
+    def add_subtitle(img, subtitle)
+      text = subtitle.lines.join("\n")
+      txt = nil
+      txtwidth = img.columns + 1
+      txtsize = 29
+      while(txtwidth > (img.columns * 0.8))
+        txtsize -= 1
+        txt = Draw.new
+        txt.pointsize = txtsize
+        o = txt.get_multiline_type_metrics(img, text)
+        txtwidth = o.width
+      end
+
+      txt.gravity = Magick::SouthGravity
+      txt.stroke_width = 1
+      txt.stroke = 'transparent'
+      txt.font_weight = Magick::BoldWeight
+
+      img.annotate(txt, 0,0,-2,-2, text) {
+        txt.fill = '#333333'
+      }
+
+      img.annotate(txt, 0,0,0,0, text){
+        txt.fill = "#ffffff"
+        txt.stroke = "#000000"
+      }
+      txt = nil
+    end
+  end
+end

data/lib/storyboard/subtitles.rb

@@ -0,0 +1,96 @@
+class Storyboard
+  def get_subtitles
+    if false == "the file has subtitles embedded"
+
+    else
+      LOG.debug("No subtitles embeded. Using suby.")
+      # suby includes a giant util library the guy also wrote
+      # that it uses to call file.basename instead of File.basename(file),
+      #but "file" has to be a "Path", so, whatever.
+      suby_file = Path(options[:file])
+      downloader = Suby::Downloader::OpenSubtitles.new(suby_file, 'en')
+      LOG.debug("Found #{downloader.download_url}")
+      downloader.extract(downloader.download_url)
+    end
+  end
+
+
+  class SRT
+    Page = Struct.new(:index, :start_time, :end_time, :lines)
+
+    TIME_REGEX = /\d{2}:\d{2}:\d{2}[,\.]\d{1,4}/
+    attr_accessor :text, :pages, :options
+
+    def initialize(contents, parent_options)
+      @options = parent_options
+      @text = contents
+      @pages = []
+      parse
+      clean_promos
+      LOG.info("Parsed subtitle file. #{count} entries found.")
+    end
+
+    #There are some horrid files, so I want to be able to have more than just a single regex
+    #to parse the srt file. Eventually, handling these errors will be a thing to do.
+    def parse
+      phase = :line_no
+      page = nil
+      @text.each_line {|l|
+        l = l.strip
+        # Some files have BOM markers. Why? Why would you add a BOM marker.
+        l.gsub!("\xEF\xBB\xBF".force_encoding("UTF-8"), '') if page.nil?
+        case phase
+        when :line_no
+          if l =~ /^\d+$/
+            page = Page.new(@pages.count + 1, nil, nil, [])
+            phase = :time
+          elsif !l.empty?
+            raise "Bad SRT File: Should have a block number but got '#{l}' [#{l.bytes.to_a.join(',')}]"
+          end
+        when :time
+          if l =~ /^(#{TIME_REGEX}) --> (#{TIME_REGEX})$/
+            page[:start_time] = STRTime.parse($1)
+            page[:end_time] = STRTime.parse($2)
+            phase = :text
+          else
+            raise "Bad SRT File: Should have time range but got '#{l}'"
+          end
+        when :text
+          if l.empty?
+            phase = :line_no
+            @pages << page
+          else
+            page[:lines] << l.gsub(%r{</?[^>]+?>}, '')
+          end
+        end
+      }
+    end
+
+    # Strip out obnoxious "CREATED BY L33T DUD3" or "DOWNLOADED FROM ____" text
+    def clean_promos
+      @pages.delete_if {|page|
+        !page[:lines].grep(/Subtitles downloaded/).empty? ||
+        !page[:lines].grep(/addic7ed/).empty? ||
+        !page[:lines].grep(/OpenSubtitles/).empty? ||
+        !page[:lines].grep(/sync, corrected by/).empty? ||
+        false
+      }
+    end
+
+    def save
+      File.open(File.join(options[:work_dir], options[:basename] + '.srt'), 'w') {|f|
+        f.write(self.to_s)
+      }
+      self
+    end
+
+    def to_s
+       text
+    end
+
+    def count
+      @pages.count
+    end
+  end
+
+end

data/lib/storyboard/thread-util.rb

@@ -0,0 +1,308 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'thread'
+class Thread::Pool
+  class Task
+    Timeout = Class.new(Exception)
+    Asked   = Class.new(Exception)
+
+    attr_reader :pool, :timeout, :exception, :thread, :started_at
+
+    def initialize (pool, *args, &block)
+      @pool      = pool
+      @arguments = args
+      @block     = block
+    end
+
+    def running?;    @running;   end
+    def finished?;   @finished;   end
+    def timeout?;    @timedout;   end
+    def terminated?; @terminated; end
+
+    def execute (thread)
+      return if terminated? || running? || finished?
+
+      @thread     = thread
+      @running    = true
+      @started_at = Time.now
+
+      pool.wake_up_timeout
+
+      begin
+        @block.call(*@arguments)
+      rescue Exception => reason
+        if reason.is_a? Timeout
+          @timedout = true
+        elsif reason.is_a? Asked
+          return
+        else
+          @exception = reason
+        end
+      end
+
+      @running  = false
+      @finished = true
+      @thread   = nil
+    end
+
+    def terminate! (exception = Asked)
+      return if terminated? || finished? || timeout?
+
+      @terminated = true
+
+      return unless running?
+
+      @thread.raise exception
+    end
+
+    def timeout!
+      terminate! Timeout
+    end
+
+    def timeout_after (time)
+      @timeout = time
+
+      pool.timeout_for self, time
+
+      self
+    end
+  end
+
+  attr_reader :min, :max, :spawned
+
+  def initialize (min, max = nil, &block)
+    @min   = min
+    @max   = max || min
+    @block = block
+
+    @cond  = ConditionVariable.new
+    @mutex = Mutex.new
+
+    @todo     = []
+    @workers  = []
+    @timeouts = {}
+
+    @spawned       = 0
+    @waiting       = 0
+    @shutdown      = false
+    @trim_requests = 0
+    @auto_trim     = false
+
+    @mutex.synchronize {
+      min.times {
+        spawn_thread
+      }
+    }
+  end
+
+  def shutdown?; !!@shutdown; end
+
+  def auto_trim?;    @auto_trim;         end
+  def auto_trim!;    @auto_trim = true;  end
+  def no_auto_trim!; @auto_trim = false; end
+
+  def resize (min, max = nil)
+    @min = min
+    @max = max || min
+
+    trim!
+  end
+
+  def backlog
+    @mutex.synchronize {
+      @todo.length
+    }
+  end
+
+  def process (*args, &block)
+    unless block || @block
+      raise ArgumentError, 'you must pass a block'
+    end
+
+    task = Task.new(self, *args, &(block || @block))
+
+    @mutex.synchronize {
+      raise 'unable to add work while shutting down' if shutdown?
+
+      @todo << task
+
+      if @waiting == 0 && @spawned < @max
+        spawn_thread
+      end
+
+      @cond.signal
+    }
+
+    task
+  end
+
+  alias << process
+
+  def trim (force = false)
+    @mutex.synchronize {
+      if (force || @waiting > 0) && @spawned - @trim_requests > @min
+        @trim_requests -= 1
+        @cond.signal
+      end
+    }
+
+    self
+  end
+
+  def trim!
+    trim true
+  end
+
+  def shutdown!
+    @mutex.synchronize {
+      @shutdown = :now
+      @cond.broadcast
+    }
+
+    wake_up_timeout
+
+    self
+  end
+
+  def shutdown
+    @mutex.synchronize {
+      @shutdown = :nicely
+      @cond.broadcast
+    }
+
+    join
+
+    if @timeout
+      @shutdown = :now
+
+      wake_up_timeout
+
+      @timeout.join
+    end
+
+    self
+  end
+
+  def join
+    @workers.first.join until @workers.empty?
+
+    self
+  end
+
+  def timeout_for (task, timeout)
+    unless @timeout
+      spawn_timeout_thread
+    end
+
+    @mutex.synchronize {
+      @timeouts[task] = timeout
+
+      wake_up_timeout
+    }
+  end
+
+  def shutdown_after (timeout)
+    Thread.new {
+      sleep timeout
+
+      shutdown
+    }
+
+    self
+  end
+
+  def wake_up_timeout
+    if @pipes
+      @pipes.last.write_nonblock 'x' rescue nil
+    end
+  end
+
+private
+  def spawn_thread
+    @spawned += 1
+
+    thread = Thread.new {
+      loop do
+        task = @mutex.synchronize {
+          if @todo.empty?
+            while @todo.empty?
+              if @trim_requests > 0
+                @trim_requests -= 1
+
+                break
+              end
+
+              break if shutdown?
+
+              @waiting += 1
+              @cond.wait @mutex
+              @waiting -= 1
+
+              break !shutdown?
+            end or break
+          end
+
+          @todo.shift
+        } or break
+
+        task.execute(thread)
+
+        break if @shutdown == :now
+
+        trim if auto_trim? && @spawned > @min
+      end
+
+      @mutex.synchronize {
+        @spawned -= 1
+        @workers.delete thread
+      }
+    }
+
+    @workers << thread
+
+    thread
+  end
+
+  def spawn_timeout_thread
+    @pipes   = IO.pipe
+    @timeout = Thread.new {
+      loop do
+        now     = Time.now
+        timeout = @timeouts.map {|task, timeout|
+          next unless task.started_at
+
+          now - task.started_at + task.timeout
+        }.compact.min unless @timeouts.empty?
+
+        readable, = IO.select([@pipes.first], nil, nil, timeout)
+
+        break if @shutdown == :now
+
+        if readable && !readable.empty?
+          readable.first.read_nonblock 1024
+        end
+
+        now = Time.now
+        @timeouts.each {|task, time|
+          next if !task.started_at || task.terminated? || task.finished?
+
+          if now > task.started_at + task.timeout
+            task.timeout!
+          end
+        }
+
+        @timeouts.reject! { |task, _| task.terminated? || task.finished? }
+
+        break if @shutdown == :now
+      end
+    }
+  end
+end