sensible-cinema 0.6.0

data/lib/overlayer.rb

@@ -0,0 +1,341 @@
+require 'sane'
+require 'thread'
+require 'timeout'
+require 'yaml'
+require_relative 'muter'
+require_relative 'blanker'
+require 'pp' # pretty_inspect
+
+class Time
+  def self.now_f
+    now.to_f
+  end
+end
+
+class OverLayer
+  
+  def muted?
+    @am_muted
+  end
+  
+  def blank?
+    @am_blanked
+  end
+  
+  def mute!
+    @am_muted = true
+    puts 'muting!' if $VERBOSE
+    Muter.mute! unless $DEBUG
+  end
+  
+  def unmute!
+    @am_muted = false
+    puts 'unmuting!' if $VERBOSE
+    Muter.unmute! unless $DEBUG
+  end
+  
+  def blank!
+    @am_blanked = true
+    Blanker.blank_full_screen! unless $DEBUG
+  end
+  
+  def unblank!
+    @am_blanked = false
+    Blanker.unblank_full_screen! unless $DEBUG
+  end
+  
+  def reload_yaml!
+    if @file_mtime != (new_time = File.stat(@filename).mtime)
+      @all_sequences = OverLayer.translate_yaml(File.read(@filename))
+      # LTODO... @all_sequences = @all_sequences.map{|k, v| v.sort!} etc.
+      puts '(re) loaded mute sequences as', pretty_sequences.pretty_inspect, ""
+      pps 'because old time', @file_mtime.to_f, '!= new time', new_time.to_f if $VERBOSE
+      @file_mtime = new_time # save 0.0002!
+    else
+      p 'matching time:', new_time if $VERBOSE
+    end
+  end
+  
+  def pretty_sequences
+    new_sequences = {}
+    @all_sequences.each{|type, values|
+      if values.is_a? Array
+        new_sequences[type] = values.map{|s, f|
+          [translate_time_to_human_readable(s), translate_time_to_human_readable(f)]
+        }
+      else
+        new_sequences[type] = values
+      end
+    }
+    new_sequences
+  end
+  
+  def self.new_raw ruby_hash
+    File.write 'temp.yml', YAML.dump(ruby_hash)
+    OverLayer.new('temp.yml')
+  end
+  
+  def initialize filename, minutes = nil 
+    @filename = filename
+    @am_muted = false
+    @am_blanked = false
+    @mutex = Mutex.new
+    @cv = ConditionVariable.new
+    @file_mtime = nil
+    reload_yaml!
+    @start_time = Time.now_f # assume they want to start immediately...
+    if minutes
+      self.set_seconds self.class.translate_string_to_seconds(minutes)
+    end
+  end
+  
+  def self.translate_yaml raw_yaml
+    all = YAML.load(raw_yaml)
+    # now it's like {:mutes => {"1:02.0" => "1:3.0"}}
+    # translate to floats like 62.0 => 63.0
+    for type in [:mutes, :blank_outs]
+      maps = all[type] || all[type.to_s] || {}
+      new = {}
+      maps.each{|s,e|
+        # both are like 1:02.0
+        new[translate_string_to_seconds(s)] = translate_string_to_seconds(e)
+      }
+      all.delete(type.to_s)
+      all[type] = new.sort
+    end
+    all
+  end
+  
+  def translate_time_to_human_readable seconds
+    # 3600 => "1:00:00"
+    out = ''
+    hours = seconds.to_i / 3600
+    out << "%d" % hours 
+    out << ":"
+    seconds = seconds - hours*3600
+    minutes = seconds.to_i / 60
+    out << "%02d" % minutes
+    seconds = seconds - minutes * 60
+    out << ":"
+    out << "%04.1f" % seconds
+  end
+  
+  # make it optional...for now muhaha [lodo take out if never useful]
+  def timestamp_changed to_this_exact_string, delta
+    if to_this_exact_string
+      set_seconds OverLayer.translate_string_to_seconds(to_this_exact_string) + delta
+    else
+      round_current_time_to_nearest_second
+    end
+  end
+  
+  def round_current_time_to_nearest_second
+    current_time = cur_time
+    better_time = current_time.round
+    set_seconds better_time
+    puts 'screen snapshot diff with time we thought it was was:' + (current_time - better_time).to_s if $VERBOSE
+  end
+      
+  def self.translate_string_to_seconds s
+    # might actually already be a float...
+    if s.is_a? Float
+      return s
+    end
+    
+    # s is like 1:01:02.0
+    total = 0.0
+    seconds = s.split(":")[-1]
+    total += seconds.to_f
+    minutes = s.split(":")[-2] || "0"
+    total += 60 * minutes.to_i
+    hours = s.split(":")[-3] || "0"
+    total += 60* 60 * hours.to_i
+    total
+  end
+  
+  # returns seconds it's at currently...
+  def cur_time
+    return Time.now_f - @start_time
+  end
+  
+  def status
+    time = "Current time: " + translate_time_to_human_readable(cur_time)
+    begin
+      mute, blank, next_sig = get_current_state
+      if next_sig == :done
+        state = " no more actions after this point..."
+      else
+        state = " next action at #{translate_time_to_human_readable next_sig}s (#{mute ? "muted" : '' } #{blank ? "blanked" : '' })"
+      end
+    end
+    time + state + " (HhMmSsTtdvq): "
+  end
+
+  def keyboard_input char
+    delta = case char
+      when 'h' then 60*60
+      when 'H' then -60*60
+      when 'm' then 60
+      when 'M' then -60
+      when 's' then 1
+      when 'S' then -1
+      when 't' then 0.1
+      when 'T' then -0.1
+      when 'v' then
+        $VERBOSE = !$VERBOSE
+        p 'set verbose to ', $VERBOSE
+        return
+      when 'd'
+        $DEBUG = !$DEBUG
+        p 'set debug to', $DEBUG
+        return
+      when ' ' then
+        puts cur_time
+        return
+      else nil
+    end
+    if delta
+      reload_yaml!
+      set_seconds(cur_time + delta)
+    else
+      puts 'invalid char: [' + char + ']'
+    end
+  end
+  
+  # sets it to a new set of seconds...
+  def set_seconds seconds
+    seconds = [seconds, 0].max
+    @mutex.synchronize {
+      @start_time = Time.now_f - seconds
+      # tell the driver thread to continue onward. Cheery-o. We're not super thread friendly but good enough for having two contact each other...
+      @cv.signal
+    }
+  end
+
+  # we have a single scheduler thread, that is notified when the time may have changed
+  # like 
+  # def restart new_time
+  #  @current_time = xxx
+  #  broadcast # things have changed
+  # end
+
+  def start_thread continue_forever = false
+    Thread.new { continue_until_past_all continue_forever }
+  end
+  
+  # returns [start, end, active|:done]
+  def discover_state type, cur_time
+      for start, endy in @all_sequences[type]
+        if cur_time < endy
+          # first one that we haven't passed the *end* of yet
+          if(cur_time >= start)
+            return [start, endy, true]
+          else
+            return [start, endy, false]
+          end
+        end
+        
+      end
+      return [nil, nil, :done]
+  end
+  
+  # returns [true, false, next_moment_of_importance|:done]
+  def get_current_state
+    all = []
+    time = cur_time
+    for type in [:mutes, :blank_outs] do
+      all << discover_state(type, time)
+    end
+    output = []
+    # all is [[start, end, active]...] or [:done, :done]
+    # so create [true, false, next_moment]
+    earliest_moment = 1_000_000
+    all.each{|start, endy, active|
+      if active == :done
+        output << false
+        next
+      else
+        output << active
+      end
+      if active
+        earliest_moment = [earliest_moment, endy].min
+      else
+        earliest_moment = [earliest_moment, start].min
+      end
+    }
+    if earliest_moment == 1_000_000
+      output << :done
+    else
+      output << earliest_moment
+    end
+    output
+  end
+  
+  def continue_until_past_all continue_forever
+    if RUBY_VERSION < '1.9.2'
+      raise 'need 1.9.2+ for MRI' unless RUBY_PLATFORM =~ /java/
+    end
+
+    @mutex.synchronize {
+      loop {
+        muted, blanked, next_point = get_current_state
+        if next_point == :done
+          unless continue_forever
+            return # done!
+          else
+            time_till_next_mute_starts = 1_000_000
+          end
+        else
+          time_till_next_mute_starts = next_point - cur_time
+        end
+        
+        pps 'sleeping until next action (%s) begins in %fs (%f) %f' % [next_point, time_till_next_mute_starts, Time.now_f, cur_time] if $VERBOSE
+        
+        @cv.wait(@mutex, time_till_next_mute_starts) if time_till_next_mute_starts > 0
+        pps 'just woke up from pre-mute wait at', Time.now_f if $VERBOSE
+        something_has_possibly_changed
+      }
+    }
+  end  
+  
+  def set_states!
+    should_be_muted, should_be_blank, next_point = get_current_state
+    
+    if should_be_muted && !muted?
+      mute!
+    end
+    
+    if !should_be_muted && muted?
+      unmute!
+    end
+    
+    if should_be_blank && !blank?
+      blank!
+    end
+
+    if !should_be_blank && blank?
+      unblank!
+    end
+    
+  end
+  
+  def something_has_possibly_changed
+    current = cur_time
+    muted, blanked, next_point = get_current_state
+    @muted = muted
+    @blanked = blanked
+    @endy = next_point
+    return if next_point == :done
+    if(current < next_point)
+      set_states!
+      duration_left = @endy - current
+      pps 'just muted it at', Time.now_f, current, 'for interval:', 'which is', duration_left, 'more s' if $VERBOSE
+      if duration_left > 0
+        @cv.wait(@mutex, duration_left) if duration_left > 0
+      end
+      pps 'done sleeping', duration_left, 'was muted unmuting now', Time.now_f if $VERBOSE
+      set_states!
+    end
+  end
+  
+end

data/lib/screen_tracker.rb

@@ -0,0 +1,160 @@
+require 'win32/screenshot'
+require 'sane'
+require 'yaml'
+require_relative 'ocr'
+
+class ScreenTracker
+  
+  def self.new_from_yaml yaml, callback
+    settings = YAML.load yaml
+    # heigth is shared...
+    height = settings["height"]
+    digits = settings["digits"]
+    return new(settings["name"], settings["x"], settings["y"], settings["width"], settings["height"], digits, callback)
+  end
+  
+  # digits like {:hours => [100,5], :minute_tens, :minute_ones, :second_tens, :second_ones}
+  # digits share the height...
+  def initialize name_or_regex,x,y,width,height,digits=nil,callback=nil
+    # cache to save us 0.00445136 per time LOL
+    if name_or_regex.to_s.downcase == 'desktop'
+      # full screen option
+      @hwnd = hwnd = Win32::Screenshot::BitmapMaker.desktop_window
+    else
+      @hwnd = Win32::Screenshot::BitmapMaker.hwnd(name_or_regex)
+    end
+    unless @hwnd
+      print 'perhaps not running yet? [%s] START IT QUICKLY' % name_or_regex
+      until @hwnd
+        sleep 2
+        print ' trying again .'
+        STDOUT.flush
+        @hwnd = Win32::Screenshot::BitmapMaker.hwnd(name_or_regex)
+      end
+      puts 'found window'
+    end
+    pps 'height', height, 'width', width if $VERBOSE
+    raise 'poor dimentia' if width <= 0 || height <= 0
+    always_zero, always_zero, max_x, max_y = Win32::Screenshot::BitmapMaker.dimensions_for(@hwnd)
+    if(x < 0 || y < 0)
+      if x < 0
+        x = max_x + x
+      end
+      if y < 0
+        y = max_y + y
+      end
+    end
+    @height = height
+    @x = x; @y = y; @x2 = x+width; @y2 = y+height; @callback = callback    
+    @max_x = max_x
+    raise 'poor width or wrong window' if @x2 > max_x  || @x2 == x
+    raise 'poor height or wrong window' if @y2 > max_y || @y2 == y
+    @digits = digits
+    pps 'using x',@x, 'from x', x, 'y', @y, 'from y', y,'x2',@x2,'y2',@y2,'digits', @digits if $VERBOSE
+  end
+  
+  def get_bmp
+    # Note: we no longer bring the window to the front tho...which it needs to be in both XP and Vista to work...sigh.
+    Win32::Screenshot::BitmapMaker.capture_area(@hwnd,@x,@y,@x2,@y2) {|h,w,bmp| return bmp}
+  end
+  
+  def get_full_bmp
+    Win32::Screenshot.hwnd(@hwnd, 0) {|h,w,bmp| return bmp}
+  end
+  
+  def dump_bmp filename = 'dump.bmp'
+    File.binwrite filename, get_bmp
+    File.binwrite 'all.' + filename, get_full_bmp
+    dump_digits
+  end
+  
+  def dump_digits
+    if @digits
+      for type, bitmap in get_digits_as_bitmaps
+        File.binwrite type.to_s + '.bmp', bitmap
+      end
+    end
+  end
+  
+  DIGIT_TYPES = [:hours, :minute_tens, :minute_ones, :second_tens, :second_ones]
+  # returns like {:hours => nil, :minutes_tens => raw_bmp, ...
+  def get_digits_as_bitmaps
+    # @digits are like {:hours => [100,5], :minute_tens => [x, width], :minute_ones, :second_tens, :second_ones}
+    out = {}
+    for type in DIGIT_TYPES
+      assert @digits.key?(type)
+      if @digits[type]
+        x,w = @digits[type]
+        if(x < 0)
+          x = @max_x + x
+        end
+        out[type] = Win32::Screenshot::BitmapMaker.capture_area(@hwnd, x, @y, x+w, @y2) {|h,w,bmp| bmp}
+      end
+    end
+    out
+  end
+  
+  def get_relative_coords
+    [@x,@y,@x2,@y2]
+  end
+  
+  # split out for unit testing purposes
+  def identify_digit bitmap
+    require 'ruby-debug'
+   # debugger
+    OCR.identify_digit(bitmap, @digits)
+  end
+  
+  def wait_till_next_change
+    original = get_bmp
+    loop {
+      current = get_bmp
+      if current != original
+        if @digits
+          out = {}
+          dump_digits if $DEBUG            
+          digits = get_digits_as_bitmaps # 0.08s [!] not too accurate...
+          start = Time.now
+          DIGIT_TYPES.each{|type|
+            if digits[type]
+              digit = identify_digit(digits[type])
+              unless digit
+                if $DEBUG || $VERBOSE
+                  @a ||= 1
+                  @a += 1
+                  p 'unable to identify digit!' + type.to_s + @a.to_s
+                  File.binwrite("bad_digit#{@a}.bmp", digits[type])
+                end
+                # early return
+                return
+              end
+              out[type] = digit
+            else
+              # there isn't one on screen, so probably zero...
+              out[type] = 0
+            end
+          }
+          out = "%d:%d%d:%d%d" % DIGIT_TYPES.map{|type| out[type]}
+          p 'got new screen time ' + out + " delta:" + (Time.now - start).to_s if $VERBOSE
+          # if the window was in the background it will be all zeroes, so nil it out
+          out = nil unless out =~ /[1-9]/
+          return out, Time.now - start
+        else
+          puts 'screen time change only detected...' if $VERBOSE
+        end
+        return
+      end
+      sleep 0.02
+    }
+  end
+  
+  def process_forever_in_thread
+    Thread.new {
+      loop {
+        out_time, delta = wait_till_next_change
+        @callback.timestamp_changed out_time, delta
+      }
+    }
+  end
+  
+end

data/spec/common.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+begin
+  require 'rspec' # rspec2
+rescue LoadError
+  require 'spec' # rspec1
+  require 'spec/autorun'
+end
+
+# some useful utilities...
+
+require 'sane'
+require 'benchmark'
+Thread.abort_on_exception = true
+require 'timeout'
+require 'fileutils'
+
+begin
+  require 'hitimes'
+  Benchmark.module_eval {
+    def self.realtime
+      Hitimes::Interval.measure { yield }
+    end
+  }
+rescue LoadError
+  if RUBY_PLATFORM =~ /java/
+    require 'java'
+    Benchmark.module_eval {
+      def self.realtime
+        beginy = java.lang.System.nano_time
+        yield
+        (java.lang.System.nano_time - beginy)/1000000000.0
+      end
+    }
+  else
+      puts 'no hitimes available...'
+  end
+    
+end
+
+#for file in Dir[File.dirname(__FILE__) + "/../lib/*"] do
+  # don't load them here in case one or other fails...
+  # require file
+  #end

data/spec/convert_image.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'sane'
+require 'RMagick'
+
+to = ARGV[1] || 'pnm'
+    img = Magick::Image.from_blob(File.binread ARGV[0])
+    png = img[0].to_blob {self.format = to } # TIFF
+    File.open("picture10." + to, "wb") {|file| file.puts png}    

data/spec/mouse_forever.rb

@@ -0,0 +1,2 @@
+require './../lib/mouse.rb'
+Mouse::jitter_forever_in_own_thread.join

data/spec/open.bat

@@ -0,0 +1 @@
+"/program files/VideoLan/VLC/vlc.exe" silence.wav

data/spec/spec.blanker.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/common'
+require_relative '../lib/blanker.rb'
+
+describe Blanker do
+  
+  it "should be able to blank then unblank" do
+    Blanker.blank_full_screen!
+    sleep 3
+    Blanker.unblank_full_screen!
+  end
+  
+  it "should be able to blank several times" do
+    3.times {
+      Blanker.blank_full_screen!
+      Blanker.unblank_full_screen!
+    }
+  end
+  
+  it "should be able to unblank several times I suppose" do
+    3.times {
+      Blanker.unblank_full_screen!
+    }
+  end
+  
+  describe "future work", :pending => true do
+    
+    it "should be able to blank certain coords"
+    
+    it "should have a color optionally"
+    
+    it "should have a picture optionally"
+    
+  end
+  
+end