sensible-cinema 0.6.0

data/FAQ

@@ -0,0 +1,12 @@
+FAQ
+
+Q. How can I easily watch this on my TV, not on my computer, silly!
+
+A. Currently you'll either need to attach your computer to your TV (buy some long cables, or a new graphics card
+   or an adapter cable and some long cords, or get a laptop somehow (ex: buy a used older one) and plug that into your TV.
+
+  There is also some work working toward getting the stuff playing on your computer to stream live to your wii/ps3/xbox:
+    http://betterlogic.com/roger/?p=3023 has the beginnings of said work, though it doesn't work yet, as I have no demo hardware to 
+    test it out with.
+    
+A history of thoughts leading up to this can be found here: http://betterlogic.com/roger/?p=2618

data/LICENSE

@@ -0,0 +1,5 @@
+All files released under the GPLv3 license [1] unless otherwise specified.  Ping me if you want this changed.
+
+May contains 3rd party libraries under their own license.
+
+[1] http://www.gnu.org/licenses/gpl.html

data/README

@@ -0,0 +1,7 @@
+This projects aims to allow users to "skip scenes" on media playback.  It aims to be be an EDL (http://en.wikipedia.org/wiki/Edit_decision_list) player for any arbitrary player.
+
+(VLC and online players, for example hulu/netflix).
+
+Trouble Shooting:
+
+If you have poor performance, possibly set the process priority to low on the DVD player program.  Also report back.

data/Rakefile

@@ -0,0 +1,30 @@
+require 'jeweler'
+require 'os'
+Jeweler::Tasks.new do |s|
+    s.name = "sensible-cinema"
+    s.summary = "an EDL scene-selector/bleeper that works with online players like hulu"
+    s.email = "rogerdpack@gmail.com"
+    s.homepage = "http://github.com/rdp"
+    s.authors = ["Roger Pack"]
+    s.add_development_dependency 'rspec' # prefer rspec 2 I guess...
+    s.add_development_dependency 'jeweler'
+    s.add_development_dependency 'rdp-rmagick'
+    s.add_dependency 'mini_magick' # ocr
+    s.add_development_dependency 'hitimes' # now jruby compat. yea!
+    s.add_dependency 'sane', '>= 0.22.0'
+    s.add_dependency 'rdp-win32screenshot', '>= 0.0.6.2'
+    s.extensions = ["ext/mkrf_conf.rb"]
+end
+
+desc 'run all specs'
+task 'spec' do
+  success = true
+  for file in Dir['spec/*spec*.rb'] do
+    p file
+    if !system('cd spec & ' + OS.ruby_bin + " ../" + file)
+      success = false
+      break
+    end
+  end
+  p 'all specs passed!' if success
+end

data/TODO

@@ -0,0 +1,106 @@
+== medium ==
+
+make work with VLC and hulu with hours...
+
+== low but actually want to do eventually (me) low prio: just do these...==
+
+  release ruby-y-y why not, it's interesting
+    release it "Linux compat anyone?"
+
+  just local files for my own edits...
+
+== raw backlog ... based on user request.. ==
+
+netflix
+  
+add my own stuff to imdb...
+
+imdb parser
+
+make it into a real live full functional app...like fully fully functional and good (for use, not editing), mostly with the drop down lists uh guess.
+
+GUI: paste edit list, choose player
+
+PISH
+
+can overlay with a "fuzzer-outer" for specific coordinates somehow or other...
+
+advertise like to lay men
+
+with VLC non full screen, it does the annoying mouse thing needlessly.
+
+hire out scene lists
+
+youtube non full screened...hmmm
+
+bleeper name
+
+yank old gem versions (?) :)
+
+overlay with wav file (would work for VLC, could also "click to mute" for the others...)
+
+fix pending tests...
+
+can black out certain coords to keep things pretty...
+
+allow x2,y2 for player descriptions...
+
+Linux port (call that good enough for usability on TV's...) between that and a VLC version...
+
+a web runnable? Why not?
+  click here to watch your favorite film edited!
+
+blank out with a user specifiable color (?)
+
+Auto mute commercials?
+
+rruby.net rubyy.net
+
+new github username
+
+replay parts
+
+overlay/replace with some url of audio or video
+
+control volume programmatically (using mouse) on the player itself.
+control mute programmatically (using mouse) on the player itself.
+
+overlay alpha transparent pic
+
+Have a "list of all known movies (url's)" and be able to open (IE et al) to the correct part, and start playing them, and they work...
+
+magnify video parts (?)
+overlay with transparent gif?
+
+OCR
+  pop it up only every so often (?)
+    after commercials?
+
+user customizable levels...
+  maybe even "I don't like ones that are x, y, z", or "boring level x"
+
+user-assignable "confidence" (how much time to 'wrap' surround the mutes, etc. to accomodate for slow computers/laggy internet/different players/poor input)
+
+auto-assignment of EDL's to media:
+  DVD's
+    VLC
+    directory of scene-lists
+  web plugin?
+
+Programmatically do all of the above, by driving a player with its real API.
+  VLC
+    Allow it to make mp4's somewhere.
+    See if burnable to DVD.
+    web interface?
+  auto start on DVD insertion (?)
+    and show appropriate scene-lists available based on title/md5 of something?
+    
+could have an easy 
+    
+never do unless paid:
+
+super easy streamer windows -> {XBOX360, wii, etc..} basically like playon, which appears to have no free equivalent, I guess, though you can 
+  save the files somewhere and stream them (and stream DVD's [?]) using tversity...maybe some other things...hmm...but no netflix!
+  so currently they basically need to run a cable from laptop to PC, for me.  windows laptop, for netflix, though a dedicated box could run things like boxee.
+  so I could create something that's basically windows -> ??? (ushare).  
+  For now it's either a cable, a computer (with its cable), or pay.

data/VERSION

@@ -0,0 +1 @@
+0.6.0

data/bin/scene-skipper

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'sane'
+Thread.abort_on_exception=true
+for file in ['overlayer', 'keyboard_input', 'screen_tracker', 'mouse']
+  require_relative '../lib/' + file
+end
+
+$VERBOSE = 1 if ARGV.delete('-v')
+$TEST = 1 if ARGV.delete('-t')  
+
+$stderr.puts 'warning: windows only for crucial parts currently' unless  ENV['OS'] == 'Windows_NT'
+
+first = ARGV[0]
+
+if ARGV.length >= 1 && (File.exist?(first) || first == 'test')
+
+  if File.exist? first
+    overlay = OverLayer.new(first, ARGV[2])  
+    overlay.start_thread true
+  else
+    puts 'warning--only doing screen dump in 4s...'
+    overlay = nil
+    $VERBOSE = 1 # that's what they wanted...
+    sleep 4
+  end
+  
+  if ARGV[1] && File.exist?(ARGV[1])
+    # this one doesn't use file updates, so pass it the string
+    screen_tracker = ScreenTracker.new_from_yaml File.binread(ARGV[1]), overlay
+    screen_tracker.dump_bmp if $VERBOSE
+    exit 1 unless overlay
+    screen_tracker.process_forever_in_thread
+    Mouse.jitter_forever_in_own_thread
+  else
+    puts 'warning--not using any screen tracking...'
+  end
+
+  key_input = KeyboardInput.new overlay
+  key_input.start_thread # status thread
+  key_input.handle_keystrokes_forever # when this method exits, we want to exit fully...
+
+else
+  puts <<-END
+
+  syntax: mute_lists.yml [player_description.yml] [-v (verbose [chatty] mode)] [-t (test mode)]
+    See the #{File.expand_path(File.dirname(__FILE__), "..")}/zamples for more info on creating files.
+  END
+    
+  for file in Dir[__dir__ + '../zamples/mute*/*']
+     puts "\n", "Example file:", file + "\n\n", File.read(file)
+  end
+  
+  puts '', 'Available files:'
+  for file in Dir[__dir__ + '../zamples/*/*']
+    puts File.expand_path(file) unless File.directory?(file)
+  end
+  exit 1
+end 

data/ext/mkrf_conf.rb

@@ -0,0 +1,5 @@
+raise 'must be using jruby to be able to run this...at least for now' unless RUBY_PLATFORM =~ /java/
+
+f = File.open(File.join(File.dirname(__FILE__), "Rakefile"), "w") # create dummy rakefile to indicate success
+f.write("task :default\n")
+f.close

data/lib/blanker.rb

@@ -0,0 +1,54 @@
+
+
+class Blanker 
+  
+  if RUBY_PLATFORM =~ /java/
+    require 'java'
+    JFrame = javax.swing.JFrame
+    JPanel = javax.swing.JPanel
+  
+    def self.blank_full_screen!
+      # a new screen each time as other jruby doesn't terminate as gracefully as we would like...
+        frame = JFrame.new("Edited!") # ltodo take out...
+        frame.default_close_operation = JFrame::EXIT_ON_CLOSE
+        frame.set_location(0,0)
+        frame.set_size(2000, 2000) # ltodo better coords...
+        frame.show
+        # lodo on top?
+        
+        fr = frame
+        fr.set_resizable(false)
+        
+        fr.set_undecorated(true) unless fr.is_displayable
+        
+        # probably unnecessary
+        panel = JPanel.new
+        frame.add(panel)
+        # frame.set_background()
+        panel.repaint
+        panel.revalidate
+        # too heavy!
+        # gd = java.awt.GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice()
+        # gd.set_full_screen_window(fr)
+        @fr = fr
+        @fr.set_visible(true)
+    end
+  else
+    
+    def self.blank_full_screen!
+      puts 'the screen is now...blank!'      
+    end
+  
+  end
+  
+  def self.unblank_full_screen!
+    if RUBY_PLATFORM =~ /java/
+      if @fr
+        @fr.dispose
+      end
+    else
+      puts 'the screen is now...visible!'
+    end
+  end
+  
+end

data/lib/keyboard_input.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'sane'
+require 'Win32API'
+
+# does the jruby check inline
+
+class KeyboardInput
+
+ def initialize fella
+  @fella = fella
+ end
+
+ def start_thread
+  Thread.new { loop { 
+    print get_line_printout
+    sleep 0.1
+   } }
+ end
+
+ def get_line_printout
+    status  = @fella.status
+    # scary hard coded values here...
+    " " * 20 + "\b"*150 + status
+ end
+
+ def getch
+  @getch ||= Win32API.new('crtdll', '_getch', [], 'L')
+  @getch.call
+ end
+
+ def handle_keystrokes_forever
+   raise 'only jruby supported, as it looks just too messy in normal ruby' unless OS.java?
+   while(ch = getch)
+     return if ch.in? [3, 113] # ctrl+c, q -> exit
+     # lodo handle arrow keys, too, which is a bit more complicated...
+     handle_keystroke ch
+   end
+ end
+
+ def handle_keystroke ch
+   string = "" << ch
+   @fella.keyboard_input(string)
+ end
+
+end

data/lib/mouse.rb

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'ffi'
+
+module Mouse
+  extend FFI::Library
+
+  ffi_lib 'user32'
+  ffi_convention :stdcall
+  
+  MOUSEEVENTF_MOVE = 1
+  INPUT_MOUSE = 0
+  MOUSEEVENTF_ABSOLUTE = 0x8000
+  
+  class MouseInput < FFI::Struct
+    layout :dx, :long,
+           :dy, :long,
+           :mouse_data, :ulong,
+           :flags, :ulong,
+           :time, :ulong,
+           :extra, :ulong
+  end
+  class InputEvent < FFI::Union
+    layout :mi, MouseInput
+  end 
+  class Input < FFI::Struct
+    layout :type, :ulong,
+           :evt, InputEvent
+  end
+  
+  # UINT SendInput(UINT nInputs, LPINPUT pInputs, int cbSize);
+  attach_function :SendInput, [ :uint, :pointer, :int ], :uint
+  
+  def self.jitter_forever_in_own_thread
+    
+    myinput = Mouse::Input.new
+    myinput[:type] = Mouse::INPUT_MOUSE
+
+    in_evt = myinput[:evt][:mi]
+
+    in_evt[:mouse_data] = 0
+    in_evt[:flags] = Mouse::MOUSEEVENTF_MOVE # | Mouse::MOUSEEVENTF_ABSOLUTE
+    in_evt[:time] = 0
+    in_evt[:extra] = 0
+    in_evt[:dx] = 0
+    in_evt[:dy] = 8 # just enough for VLC full screen...
+
+    Thread.new {
+      loop {
+        in_evt[:dy] *= -1
+        Mouse.SendInput(1, myinput, Mouse::Input.size)
+        in_evt[:dy] *= -1
+        sleep 0.05
+        Mouse.SendInput(1, myinput, Mouse::Input.size)
+        sleep 0.75
+      }
+    }
+    
+  end
+    
+end

data/lib/muter.rb

@@ -0,0 +1,48 @@
+require 'rubygems' # ugh
+require 'ffi'
+
+module Muter
+  # from msdn on keybd_event ...
+  
+  VK_VOLUME_DOWN = 0xAE
+  VK_VOLUME_UP = 0xAF
+  VK_VOLUME_MUTE = 0xAD
+  KEYEVENTF_KEYUP = 2
+  
+  extend FFI::Library
+  ffi_lib 'user32'
+  ffi_convention :stdcall
+
+  attach_function :keybd_event, [ :uchar, :uchar, :int, :pointer ], :void
+  
+  def hit_mute_key
+    # simulate pressing the mute key
+    keybd_event(VK_VOLUME_MUTE, 0, 0, nil)
+    keybd_event(VK_VOLUME_MUTE, 0, KEYEVENTF_KEYUP, nil)
+  end
+  
+  def hit_volume_up_key
+    keybd_event(VK_VOLUME_UP, 0, 0, nil)
+    keybd_event(VK_VOLUME_UP, 0, KEYEVENTF_KEYUP, nil)
+  end
+  
+  def hit_volume_down_key
+    keybd_event(VK_VOLUME_DOWN, 0, 0, nil)
+    keybd_event(VK_VOLUME_DOWN, 0, KEYEVENTF_KEYUP, nil)
+  end
+  
+  def mute!
+    #unmute! # just in case
+    hit_mute_key
+  end
+  # TODO better for 7...
+  def unmute!
+    hit_mute_key # Windows XP...
+    hit_volume_down_key
+    hit_volume_up_key
+  end
+      
+  # allow for Muter.xxx
+  extend self
+  
+end

data/lib/ocr.rb

@@ -0,0 +1,57 @@
+require 'mini_magick'
+require 'open3'
+
+# helper for OCR'ing single digits that were screen captured
+module OCR
+  
+  GOCR = File.expand_path(File.dirname(__FILE__) + "/../vendor/gocr048.exe -C 0-9:/ ")
+  
+  CACHE = {}
+  
+  # options are :might_be_colon, :should_invert
+  def identify_digit memory_bitmap, options = {}
+    if CACHE[memory_bitmap]
+      print 'h' if $DEBUG
+      return CACHE[memory_bitmap]
+    else
+      p 'ocr cache miss' if $DEBUG
+    end
+    might_be_colon = options[:might_be_colon]
+    should_invert = options[:should_invert]
+    if might_be_colon
+      # do processing in-line <sigh>
+      total = (memory_bitmap.scan /\x00{5}+/).length
+      if total >= 3 # really should be 4 for VLC
+        # it had some dots...must have been a colon!
+      end
+      CACHE[memory_bitmap] = ":"
+      return ":"
+    end
+    image = MiniMagick::Image.from_blob(memory_bitmap)
+    image.format(:pnm) # expensive, requires convert.exe in path...
+    if should_invert # mogrify calls it negate...
+      image.negate 
+    end
+    for level in [130, 100] # 100 for hulu...
+      input, output, error, thread_if_on_19 = Open3.popen3 GOCR + " -l #{level} -"
+      input.write image.to_blob
+      input.close
+      a = output.read
+      output.close
+      a.strip!
+      if a =~ /[0-9]/
+        a = a.to_i
+        CACHE[memory_bitmap] = a
+        return a
+      end
+    end
+    nil
+  end
+  
+  def version
+    `#{GOCR} -h 2>&1`
+  end
+  
+  extend self
+  
+end