content-editing-movie-player 0.38.0

data/lib/keyboard_input.rb

@@ -0,0 +1,60 @@
+=begin
+Copyright 2010, Roger Pack 
+This file is part of Sensible Cinema.
+
+    Sensible Cinema is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Sensible Cinema is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Sensible Cinema.  If not, see <http://www.gnu.org/licenses/>.
+=end
+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
+    # some scary hard coded values here...LODO curses?
+    " " * 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)
+     exit if ch == 3 # ctrl+c
+     # 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/media_info_parser.rb

@@ -0,0 +1,27 @@
+module MediaInfoParser
+  def self.parse_with_convert_command media_info, filename
+    video = audio = nil
+    media_info.split("Track ID").each{ |section|
+      section =~ /:(\W+)(\d+)/
+      id = $2
+      section =~  /Stream ID:   (\S+)/ # like V_MPEG-2
+      stream_type = $1
+      if stream_type
+        raise unless id
+        if section =~ /Frame rate/ && !video
+          section =~ /Frame rate: ([\d\.]+)/
+          fps = $1
+          raise unless fps
+          raise unless section =~ /lang: eng/ # expect...
+          video = "#{stream_type}, \"#{filename}\", fps=#{fps}, track=#{id}, lang=eng"
+        elsif section =~ /Channels:/ && !audio
+          raise unless section =~ /lang: eng/ # hope english audio track comes first...
+          # A_AC3, "G:\Video\Sintel_NTSC\title01.mkv", track=2, lang=eng
+          audio = "#{stream_type}, \"#{filename}\", track=#{id}, lang=eng"
+        end
+      end
+    }
+    raise unless video && audio
+    return "MUXOPT --no-pcr-on-video-pid --new-audio-pes --vbr  --vbv-len=500\n#{video}\n#{audio}"
+  end
+end

data/lib/mouse_forever.rb

@@ -0,0 +1,19 @@
+=begin
+Copyright 2010, Roger Pack 
+This file is part of Sensible Cinema.
+
+    Sensible Cinema is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Sensible Cinema is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Sensible Cinema.  If not, see <http://www.gnu.org/licenses/>.
+=end
+require './../lib/mouse.rb'
+Mouse::jitter_forever_in_own_thread.join

data/lib/movie_hasher.rb

@@ -0,0 +1,27 @@
+module MovieHasher
+
+  CHUNK_SIZE = 64 * 1024 # in bytes
+
+  def self.compute_hash(filename)
+    filesize = File.size(filename)
+    hash = filesize
+
+    # Read 64 kbytes, divide up into 64 bits and add each
+    # to hash. Do for beginning and end of file.
+    File.open(filename, 'rb') do |f|    
+      # Q = unsigned long long = 64 bit
+      f.read(CHUNK_SIZE).unpack("Q*").each do |n|
+        hash = hash + n & 0xffffffffffffffff # to remain as 64 bit number
+      end
+
+      f.seek([0, filesize - CHUNK_SIZE].max, IO::SEEK_SET)
+
+      # And again for the end of the file
+      f.read(CHUNK_SIZE).unpack("Q*").each do |n|
+        hash = hash + n & 0xffffffffffffffff
+      end
+    end
+
+    sprintf("%016x", hash)
+  end
+end

data/lib/mplayer_edl.rb

@@ -0,0 +1,42 @@
+=begin
+Copyright 2010, Roger Pack 
+This file is part of Sensible Cinema.
+
+    Sensible Cinema is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Sensible Cinema is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Sensible Cinema.  If not, see <http://www.gnu.org/licenses/>.
+=end
+
+require_relative 'edl_parser'
+
+class MplayerEdl
+  
+  def self.convert_to_edl specs, add_this_many_to_end = 0, add_this_many_to_beginning = 0, splits = [], extra_time_to_all = 0.0, use_english_timestamps = false
+    
+    # simple re-map to EDL style output
+    combined = EdlParser.convert_incoming_to_split_sectors specs, add_this_many_to_end, add_this_many_to_beginning, splits
+    
+    out = ''
+    map = {:mute => 1, :blank => 0}
+    for start, endy, type in combined
+      start += extra_time_to_all
+      endy += extra_time_to_all
+      if use_english_timestamps
+        start = EdlParser.translate_time_to_human_readable start
+        endy  = EdlParser.translate_time_to_human_readable endy
+      end
+      out += "#{start} #{endy} #{map[type]}\n"
+    end
+    out
+  end
+  
+end

data/lib/muter.rb

@@ -0,0 +1,87 @@
+=begin
+Copyright 2010, Roger Pack 
+This file is part of Sensible Cinema.
+
+    Sensible Cinema is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Sensible Cinema is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Sensible Cinema.  If not, see <http://www.gnu.org/licenses/>.
+=end
+require 'rubygems' # ugh
+require 'ffi'
+require 'sane'
+require_relative 'jruby-swing-helpers/mouse'
+require_relative 'jruby-swing-helpers/play_audio'
+
+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
+    p 'hitting up volume key'
+    keybd_event(VK_VOLUME_UP, 0, 0, nil)
+    keybd_event(VK_VOLUME_UP, 0, KEYEVENTF_KEYUP, nil)
+  end
+  
+  def hit_volume_down_key
+    p 'hitting down volume 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...somehow this was causing problems...windows 7 perhaps? VLC? 
+    # anyway we just use a toggle for now...dangerous but works hopefully...
+    if @@use_mouse_click
+      Mouse.single_click_left_mouse_button
+    else
+      hit_mute_key
+    end
+  end
+  
+  @@use_mouse_click = true
+
+  # LODO better for doze 7/xp
+  def unmute!
+    if @@use_mouse_click
+      Mouse.single_click_left_mouse_button
+    elsif @@use_static_on_top
+      stop_playing_static
+    elsif @@use_down_volume_button
+      @@use_down_volume_button_number.times { hit_volume_up_key }
+    else
+      hit_mute_key # Windows XP...
+      hit_volume_down_key
+      hit_volume_up_key
+    end
+    
+  end
+      
+  # allow for Muter.xxx
+  extend self
+  
+end

data/lib/ocr.rb

@@ -0,0 +1,125 @@
+=begin
+Copyright 2010, Roger Pack 
+This file is part of Sensible Cinema.
+
+    Sensible Cinema is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Sensible Cinema is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Sensible Cinema.  If not, see <http://www.gnu.org/licenses/>.
+=end
+require 'sane' # gem
+require 'whichr' # gem
+
+# not a dependency yet, so I don't have to bundle it...
+# im_path = File.expand_path(File.dirname(__FILE__) + "/../vendor/cache/imagemagick") # convert.exe wants to only be chosen from here...
+# ENV['PATH'] = im_path.gsub('/', "\\") + ';' + ENV['PATH']
+
+if RubyWhich.new.which('identify').length == 0 || RubyWhich.new.which('convert').length == 0
+ puts 'appears you do not have imagemagick installed (or not in your path) -- please download and install it first! http://www.imagemagick.org/script/binary-releases.php'
+ raise
+end
+
+# helper for OCR'ing single digits that were screen captured
+module OCR
+  if OS.windows? 
+    GOCR = File.expand_path(File.dirname(__FILE__) + "/../vendor/gocr049.exe -C 0-9:/ ")
+  else
+    require_relative 'check_installed_mac'
+    exit 1 unless CheckInstalledMac.check_for_installed 'gocr'
+    GOCR = "gocr"
+  end
+  
+  CACHE = {}
+  
+  # options are :might_be_colon, :should_invert
+  def identify_digit memory_bitmap, options = {}
+    require 'mini_magick' # here because of installation woe, but actually not a big slowdown
+
+    if CACHE.has_key?(memory_bitmap)
+      return CACHE[memory_bitmap] unless (defined?($OCR_NO_CACHE) && $OCR_NO_CACHE)
+    else
+      puts 'cache miss' if $DEBUG && $VERBOSE
+    end
+    
+    if options[:might_be_colon]
+      # do special processing <sigh>
+      total = (memory_bitmap.scan(/\x00{5}+/)).length
+      if total >= 3 # really should be 4 for VLC
+        # it had some darkness...therefore have been a colon!
+        CACHE[memory_bitmap] = ":"
+        return ":"
+      end
+    end
+    image = MiniMagick::Image.read(memory_bitmap)
+    # any operation on image is expensive, requires convert.exe in path...
+    if options[:should_invert] 
+      # hulu wants negate
+      # but doesn't want sharpen, for whatever reason...
+      # mogrify calls it negate...
+      image.negate 
+    end
+
+    image.format(:pnm)
+    # I think it's VLC full screen that wants sharpening...
+    image.sharpen(2) if options[:sharpen] # hulu does *not* want sharpen, though I haven't checked it too closely...
+
+    previous = nil
+    p options if $DEBUG
+    raise 'you must pass in OCR levels in the player description' unless options[:levels]
+    for level in options[:levels]
+      command = "#{GOCR} -l #{level} #{image.path} 2>NUL"
+      a = `#{command}`
+      if a =~ /[0-9]/
+        # it might be funky like "_1_\n"
+        a.strip!
+        a.gsub!('_', '')
+        a = a.to_i
+        return CACHE[memory_bitmap] = a
+      end
+    end
+    # cache failures here, for VLC's hour clock' sake
+    CACHE[memory_bitmap] = nil
+    nil
+  end
+  
+  def version
+    `#{GOCR} -h 2>&1`
+  end
+  
+  def clear_cache!
+    CACHE.clear
+    File.delete CACHE_FILE if File.exist?(CACHE_FILE)
+  end
+  
+  CACHE_FILE = File.expand_path('~/.sensible-cinema-ocr.marshal')
+  
+  def serialize_cache_to_disk
+    File.binwrite(CACHE_FILE, Marshal.dump(CACHE))
+  end
+  
+  def unserialize_cache_from_disk  
+    if File.exist? CACHE_FILE
+      CACHE.merge!(Marshal.load(File.binread(CACHE_FILE)))
+    end
+  end
+  
+  def load_from_ocr_seed
+    for file in Dir[__DIR__ + "/ocr_seed/*.bmp"]
+      file =~ /(\d+)\.bmp/i
+      digit = $1.to_i
+      raise unless digit < 10
+      CACHE[File.binread(file)] = digit
+    end
+  end
+  
+  extend self
+  
+end

data/lib/overlayer.rb

@@ -0,0 +1,373 @@
+=begin
+Copyright 2010, Roger Pack 
+This file is part of Sensible Cinema.
+
+    Sensible Cinema is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    Sensible Cinema is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with Sensible Cinema.  If not, see <http://www.gnu.org/licenses/>.
+=end
+
+require 'sane'
+require 'thread'
+require 'timeout'
+require 'yaml'
+require_relative 'muter'
+require_relative 'blanker'
+require_relative 'edl_parser'
+
+require 'pp' # for pretty_inspect
+
+class OverLayer
+  
+  def muted?
+    @am_muted
+  end
+  
+  def blank?
+    @am_blanked
+  end
+  
+  def mute!
+    @am_muted = true
+    puts 'muting!' if $VERBOSE
+    Muter.mute! unless defined?($AM_IN_UNIT_TEST)
+  end
+  
+  def unmute!
+    @am_muted = false
+    puts 'unmuting!' if $VERBOSE
+    Muter.unmute! unless defined?($AM_IN_UNIT_TEST)
+  end
+  
+  def blank! seconds
+    @am_blanked = true
+    Blanker.blank_full_screen! seconds
+  end
+  
+  def unblank!
+    @just_unblanked = true
+    @am_blanked = false
+    Blanker.unblank_full_screen!
+  end
+  
+  def check_reload_yaml
+    current_mtime = File.stat(@filename).mtime
+    if @file_mtime != current_mtime
+      reload_yaml!
+      @file_mtime = current_mtime 
+    else
+      #p 'same mtime:', @file_mtime if $DEBUG && $VERBOSE
+    end
+  end
+  
+  attr_accessor :all_sequences
+  
+  def reload_yaml!
+    @all_sequences = OverLayer.translate_file(@filename)
+    puts '(re) loaded mute sequences from ' + File.basename(@filename) + ' as', pretty_sequences.pretty_inspect, "" unless defined?($AM_IN_UNIT_TEST)
+    signal_change
+  end  
+  
+  def pretty_sequences
+    new_sequences = {}
+    @all_sequences.each{|type, values|
+      if values.is_a? Array
+        new_sequences[type] = values.map{|s, f|
+          [EdlParser.translate_time_to_human_readable(s), EdlParser.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
+    @filename = filename
+    @am_muted = false
+    @am_blanked = false
+    @mutex = Mutex.new
+    @cv = ConditionVariable.new
+    @file_mtime = nil
+    check_reload_yaml
+    @just_unblanked = false
+    @start_time = Time.now_f # assume they want to start immediately...
+  end
+  
+  # note this is actually deprecated and won't work anymore <sigh> and needs to be updated.
+  def self.translate_file filename
+    begin
+      all = EdlParser.parse_file(filename)
+    rescue NoMethodError, ArgumentError => e
+      p 'appears your file has a syntax error in it--perhaps missing quotation marks?', e.to_s
+      raise e # hope this is ok...
+    end
+    
+    # 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] # LODO standardize these :mutes and :blank_outs somewhere...scary to have them repeated *everywhere*
+      maps = all[type] || all[type.to_s] || {}
+      new = {}
+      maps.each{|start,endy|
+        # both are like 1:02.0
+        start2 = EdlParser.translate_string_to_seconds(start) if start
+        endy2 = EdlParser.translate_string_to_seconds(endy) if endy
+        if start2 == 0 || endy2 == 0 || start == nil || endy == nil
+          p 'warning--possible error in the Edit Decision List file some line not parsed! (NB if you want one to start at time 0 please use 0.0001)', start, endy unless $AM_IN_UNIT_TEST
+          # drop this line into the bitbucket...
+          next
+        end
+        
+        if start2 == endy2 || endy2 < start2
+          p 'warning--found a line that had poor interval', start, endy, type unless defined?($AM_IN_UNIT_TEST)
+          next
+        end
+        if(endy2 > 60*60*3)
+          p 'warning--found setting past 3 hours [?]', start, endy, type unless defined?($AM_IN_UNIT_TEST)
+        end
+        new[start2] = endy2
+      }
+      all.delete(type.to_s) # cleanup
+      all[type] = new.sort
+    end
+    all
+  end  
+  
+  def timestamp_changed to_this_exact_string_might_be_nil, delta
+    if @just_unblanked
+      # ignore it, since it was probably just caused by the screen blipping
+      # at worse this will put us 1s behind...hmm.
+      @just_unblanked = false
+      p 'ignoring timestamp update ' + to_this_exact_string_might_be_nil.to_s if $VERBOSE
+    else
+      set_seconds EdlParser.translate_string_to_seconds(to_this_exact_string_might_be_nil) + delta if to_this_exact_string_might_be_nil
+    end
+  end
+  
+  
+  # returns seconds it's at currently...
+  def cur_time
+    Time.now_f - @start_time
+  end
+  
+  def cur_english_time
+    EdlParser.translate_time_to_human_readable(cur_time)
+  end
+  
+  def status
+    time = cur_english_time
+    begin
+      mute, blank, next_sig = get_current_state
+      if next_sig == :done
+        state = " no more after this point..."
+      else
+        state = " next will be at #{EdlParser.translate_time_to_human_readable next_sig}s "
+      end
+      if blank? or muted?
+        state += "(" + [muted? ? "muted" : nil, blank? ? "blanked" : nil ].compact.join(' ') + ") "
+      end
+    end
+    check_reload_yaml
+    time + state + "(r [ctrl+c or q to quit]): "
+  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 'q' then
+        puts '','quitting'
+        exit(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 'timestamp:' + cur_english_time
+        return
+      when 'r' then
+        reload_yaml!
+        puts
+        return
+      else nil
+    end
+    if delta
+      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
+    }
+    signal_change
+  end
+  
+  def signal_change
+    @mutex.synchronize {
+      # tell the driver thread to wake up and re-check state. 
+      # 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 = Thread.new { continue_until_past_all continue_forever }
+  end
+  
+  def kill_thread!
+    @thread.kill
+  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] ( true, false for if it should be currently muted, blanked )
+  #
+  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]
+    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 for the mutex stuff' unless RUBY_PLATFORM =~ /java/
+    end
+
+    @mutex.synchronize {
+      loop {
+        muted, blanked, next_point = get_current_state
+        if next_point == :done
+          if continue_forever
+            time_till_next_mute_starts = 1_000_000
+          else
+            #set_states! # for the unit tests' sake
+            return
+          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
+        set_states!
+      }
+    }
+  end  
+  
+  def display_change change
+    puts '' unless defined?($AM_IN_UNIT_TEST)
+    if $VERBOSE
+      puts change + ' at ' + cur_english_time
+    end    
+  end
+  
+  def set_states!
+    should_be_muted, should_be_blank, next_point = get_current_state
+    
+    if should_be_muted && !muted?
+      mute!
+      display_change 'muted'
+    end
+    
+    if !should_be_muted && muted?
+      unmute!      
+      display_change 'unmuted'
+    end
+    
+    if should_be_blank && !blank?
+      blank! "%.02f" % (next_point - cur_time)
+      mute! # mute with blanks currently...
+      display_change 'blanked'
+    end
+
+    if !should_be_blank && blank?
+      unblank!
+      display_change 'unblanked'
+    end
+    
+  end
+  
+end
+
+class Time
+  def self.now_f
+    now.to_f
+  end
+end