content-editing-movie-player 0.38.0

data/lib/screen_tracker.rb

@@ -0,0 +1,269 @@
+=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 'win32/screenshot'
+require 'sane'
+require 'yaml'
+require File.dirname(__FILE__)+ '/ocr'
+require 'ffi'
+
+class ScreenTracker
+  
+  extend FFI::Library
+  ffi_lib 'user32'
+  # second parameter, pointer, LPRECT is FFI::MemoryPointer.new(:long, 4)
+  # read it like rect.read_array_of_long(4)
+  attach_function :GetWindowRect, [:long, :pointer], :int # returns a BOOL
+  
+  def self.new_from_yaml yaml, callback # callback can be nil, is used for timestamp changed stuff
+    settings = YAML.load yaml
+    return new(settings["name"], settings["x"], settings["y"], settings["width"], 
+        settings["height"], settings["use_class_name"], settings["digits"], callback)
+  end
+  
+  attr_accessor :hwnd
+  
+  # digits are like {:hours => [100,5], :minute_tens, :minute_ones, :second_tens, :second_ones}
+  # digits share the height start point, have their own x and width...
+  def initialize name_or_regex, x, y, width, height, use_class_name=nil, digits=nil, callback=nil
+    # cache to save us 0.00445136 per time LOL
+    @name_or_regex = name_or_regex
+    @use_class_name = use_class_name
+    pps 'height', height, 'width', width if $VERBOSE
+    raise 'poor dimentia' if width <= 0 || height <= 0
+    get_hwnd_loop_forever
+    max_x, max_y = Win32::Screenshot::Util.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
+    @x = x; @y = y; @x2 = x+width; @y2 = y+height; @callback = callback    
+    @max_x = max_x
+    raise "poor width or wrong window #{@x2} #{max_x} #{x}" if @x2 > max_x  || @x2 == x
+    if @y2 > max_y || @y2 == y || @y2 <= 0
+      raise "poor height or wrong window selected #{@y2} > #{max_y} || #{@y2} == #{y} || #{@y2} <= 0" 
+    end
+    if max_x == 0 || max_y == 0
+      # I don't think we can ever get here, because of the checks above
+      raise 'window invisible?'
+    end
+    @digits = digits
+    @previously_displayed_warning = false
+    @dump_digit_count = 1
+    pps 'using x',@x, 'from x', x, 'y', @y, 'from y', y,'x2',@x2,'y2',@y2,'digits', @digits.inspect if $VERBOSE
+  end
+  
+  def get_hwnd_loop_forever
+    if @name_or_regex.to_s.downcase == 'desktop'
+      # full screen option
+      assert !@use_class_name # not an option
+      @hwnd = hwnd = Win32::Screenshot::BitmapMaker.desktop_window
+      return
+    else
+      raise if OS.mac?
+      @hwnd = Win32::Screenshot::BitmapMaker.hwnd(@name_or_regex, @use_class_name)
+    end
+
+    # display the 'found it message' only if it was previously lost...
+    unless @hwnd
+      until @hwnd
+        print 'unable to find the player window currently [%s] (maybe need to start program or move mouse over it)' % @name_or_regex.inspect
+        sleep 1
+        STDOUT.flush
+
+        hwnd = Win32::Screenshot::BitmapMaker.hwnd(@name_or_regex, @use_class_name)
+        width, height = Win32::Screenshot::Util.dimensions_for(hwnd)
+        p width, height
+        @hwnd = hwnd
+      end
+      puts 're-established contact with window'
+    end
+    true
+  end
+  
+  # gets the snapshot of "all the digits together"
+  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
+  
+  # gets snapshot of the full window
+  def get_full_bmp
+     Win32::Screenshot::BitmapMaker.capture_all(@hwnd) {|h,w,bmp| return bmp}
+  end
+
+  # writes out all screen tracking info to various files in the current pwd
+  def dump_bmps filename = 'dump.bmp'
+    File.binwrite filename, get_bmp
+    File.binwrite 'all.' + filename, get_full_bmp
+    dump_digits(get_digits_as_bitmaps, 'dump_bmp') if @digits
+  end
+  
+  def dump_digits digits, message
+    p "#{message} dumping digits to dump no: #{@dump_digit_count} #{Time.now.to_f}"
+    for type, bitmap in digits
+      File.binwrite type.to_s + '.' + @dump_digit_count.to_s + '.bmp', bitmap    
+    end
+    File.binwrite @dump_digit_count.to_s + '.mrsh', Marshal.dump(digits)
+    @dump_digit_count += 1
+  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
+        x2 = x + w
+        raise 'a digit width can never be negative #{w}' if w <= 0
+        y2 = @y2
+        width = x2 - x
+        height = y2 - @y
+        # lodo calculate these only once...
+        out[type] = Win32::Screenshot::BitmapMaker.capture_area(@hwnd, x, @y, x2, y2) {|h,w,bmp| bmp}
+      end
+    end
+    out
+  end
+  
+  def get_relative_coords_of_timestamp_window
+    [@x,@y,@x2,@y2]
+  end
+  
+  def get_coords_of_window_on_display # yea
+    out = FFI::MemoryPointer.new(:long, 4)
+    ScreenTracker.GetWindowRect @hwnd, out
+    out.read_array_of_long(4)
+  end
+
+  def identify_digit bitmap
+    OCR.identify_digit(bitmap, @digits)
+  end
+  
+  # we have to wait until the next change, because when we start, it might be half-way through
+  # the current second...
+  def wait_till_next_change
+    original = get_bmp
+    time_since_last_screen_change = Time.now
+    loop {
+      # save away the current time to try and be most accurate...
+      time_before_current_scan = Time.now
+      current = get_bmp
+      if current != original
+        if @digits
+          got = attempt_to_get_time_from_screen time_before_current_scan
+          if @previously_displayed_warning && got
+            # reassure user :)
+            p 'tracking it successfully again' 
+            @previously_displayed_warning = false
+          end
+          return got
+        else
+          puts 'screen time change only detected... [unexpected]' # unit tests do this still <sigh>
+          return
+        end
+      else
+        if(Time.now - time_since_last_screen_change > 2.0)
+          got_implies_able_to_still_ocr = attempt_to_get_time_from_screen time_before_current_scan
+          if got_implies_able_to_still_ocr
+            return got_implies_able_to_still_ocr
+          else
+            p 'warning--unable to track screen time for some reason [perhaps screen obscured or it\'s not playing yet?] ' + @hwnd.to_s
+            @previously_displayed_warning = true
+            # also reget window hwnd, just in case that's the problem...(can be with VLC moving from title to title)
+            get_hwnd_loop_forever
+            # LODO loop through all available player descriptions to find the right one, or a changed different new one, et al
+          end
+          time_since_last_screen_change = Time.now
+        end
+      end
+      sleep 0.02
+    }
+  end
+  
+  def attempt_to_get_time_from_screen start_time
+    out = {}
+    # force it to have two matching snapshots in a row, to avoid race conditions grabbing the digits...
+    # allow youtube to update (sigh) lodo just for utube
+    previous = nil 
+    sleep 0.05
+    current = get_digits_as_bitmaps
+    while previous != current
+      previous = current
+      sleep 0.05
+      current = get_digits_as_bitmaps
+      # lodo it should probably poll *before* calling this, not here...maybe?
+    end
+    assert previous == current
+    digits = current = previous    
+    DIGIT_TYPES.each{|type|
+      if digits[type]
+        digit = identify_digit(digits[type])
+        unless digit
+          bitmap = digits[type]
+          # unable to identify a digit?
+          if $DEBUG || $VERBOSE && (type != :hours)
+            @a ||= 1
+            @a += 1
+            @already_wrote ||= {}
+            unless @already_wrote[bitmap]
+              p 'unable to identify capture!' + type.to_s + @a.to_s + ' dump:' + @dump_digit_count.to_s
+              File.binwrite("bad_digit#{@a}#{type}.bmp", bitmap)
+              @already_wrote[bitmap] = true
+            end
+          end
+          if type == :hours
+            digit = 0 # this one can fail and that's ok in VLC bottom right
+          else
+            # early (failure) return
+            return nil
+          end
+        else
+          p " got digit #{type} OCR as #{digit} which was captured to dump #{@dump_digit_count - 1} #{Time.now_f}" if $DEBUG
+        end
+        out[type] = digit
+      else
+        # there isn't one specified as being on screen, so assume it is always zero (like youtube hour)...
+        out[type] = 0
+      end
+    }
+    out = "%d:%d%d:%d%d" % DIGIT_TYPES.map{ |type| out[type] }
+    puts '', 'got new screen time ' + out + " (+ tracking delta:" + (Time.now - start_time).to_s  + ")" if $VERBOSE
+    return out, Time.now-start_time
+  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/lib/subtitle_profanity_finder.rb

@@ -0,0 +1,294 @@
+#
+# warning: somewhat scary/explicit down there!
+# see also todo.subtitle file, though what's here is mostly pretty well functional/complete
+#
+begin
+  require 'sane'
+rescue LoadError
+  require 'rubygems'
+  require 'sane'
+end
+require_relative 'edl_parser'
+require 'ostruct'
+
+module SubtitleProfanityFinder
+
+   # splits into timestamps -> timestamps\ncontent blocks
+   def self.split_to_entries subtitles_raw_text
+     all = subtitles_raw_text.gsub("\r\n", "\n").scan(/^\d+\n\d\d:\d\d:\d\d.*?^$/m) # line endings so that it parses right when linux reads a windows file <huh?>
+     all.map!{|glop|
+	   lines = glop.lines.to_a
+	   index_line = lines[0]
+       timing_line = lines[1].strip
+       text = lines.to_a[2..-1].join("") # they still have separating "\n"'s
+       # create english-ified version
+       text.gsub!(/<(.|)(\/|)i>/i, '') # kill <i> type things
+       text.gsub!(/[^a-zA-Z0-9\-!,.\?'\n\(\)]/, ' ') # kill weird stuff like ellipseses, also quotes would hurt so kill them too
+       text.gsub!(/  +/, ' ') # remove duplicate "  " 's now since we may have inserted many
+       # extract timing info
+       # "00:03:00.0" , "00:04:00.0", "violence", "of some sort",
+       timing_line =~ /((\d\d:\d\d:\d\d),(\d\d\d) --> (\d\d:\d\d:\d\d),(\d\d\d))/
+       ts_begin = "#{$2}.#{$3}"
+       ts_end =  "#{$4}.#{$5}"
+       out = OpenStruct.new
+	   out.index_number = index_line.strip.to_i
+       out.beginning_time = EdlParser.translate_string_to_seconds ts_begin
+       out.ending_time = EdlParser.translate_string_to_seconds ts_end
+       out.text = text.strip # harmless right?
+       add_single_line_minimized_text_from_multiline out
+       out
+     }
+     if all.size < 10
+       raise "unable to parse subtitle file?"
+     end
+
+     # strip out auto inserted trailers/headers
+     reg =  / by|download| eng|www|http|sub/i
+     while all[0].text =~ reg
+      all.shift
+     end
+     while all[-1] =~ reg
+      all.pop
+     end
+     all
+   end
+
+   def self.add_single_line_minimized_text_from_multiline entry
+     entry.single_line_text = entry.text.strip.gsub(/^[- ,_\.]+/, '').gsub(/[- ,_]+$/, '').gsub(/[\r\n]/, ' ')
+   end
+
+   # convert string to regexp, also accomodating for "full word" type profanities
+   def self.convert_to_regexps profanity_hash
+    all_profanity_combinations = []
+    profanity_hash.to_a.sort.reverse.each{|profanity, sanitized|
+      as_regexp = Regexp.new(profanity, Regexp::IGNORECASE)
+      if sanitized.is_a? Array
+        # like 'bad word' => ['vain use', :partial_word, 'deity']
+        raise unless sanitized.length.in? [2, 3]
+        raise unless sanitized[1].in? [:full_word, :partial_word]
+        is_single_word_profanity = true if sanitized[1] == :full_word
+        if sanitized.length == 3
+          category = sanitized[2]
+        end
+        sanitized = sanitized[0]
+      end
+      
+      permutations = [profanity]
+      if profanity =~ /l/
+        permutations << profanity.gsub(/l/i, 'i')
+      end
+      if profanity =~ /i/
+        permutations << profanity.gsub(/i/i, 'l')
+      end
+      
+      replace_with = '[' + sanitized + ']'
+      category ||= sanitized
+      
+      for permutation in permutations
+        if is_single_word_profanity
+		  # \s is whitespace
+          as_regexp = Regexp.new("(?:\s|^|[^a-zA-Z])" + permutation + "(?:\s|$|[^a-zA-Z])", Regexp::IGNORECASE)
+          all_profanity_combinations << [as_regexp, category, ' ' + replace_with + ' '] # might introduce an extra space in there, but that's prolly ok since they're full-word already, and we collapse them
+        else
+          all_profanity_combinations << [as_regexp, category, replace_with]
+        end
+      end
+    }
+    all_profanity_combinations
+  end
+
+  def self.edl_output incoming_filename, extra_profanity_hash = {}, subtract_from_each_beginning_ts = 0, add_to_end_each_ts = 0, beginning_srt = 0.0, beginning_actual_movie = 0.0, ending_srt = 7200.0, ending_actual = 7200.0
+    edl_output_from_string(File.read(incoming_filename), extra_profanity_hash, subtract_from_each_beginning_ts, add_to_end_each_ts, beginning_srt, beginning_actual_movie, ending_srt, ending_actual)[0]
+  end
+  
+  # **_time means "a float"
+  
+  def self.edl_output_from_string subtitles, extra_profanity_hash, subtract_from_each_beginning_ts, add_to_end_each_ts, starting_time_given_srt, starting_time_actual, ending_srt_time, ending_actual_time, include_minor_profanities=true # lodo may not need include_minor_profs :P
+     raise if subtract_from_each_beginning_ts < 0 # these have to be positive...in my twisted paradigm
+     raise if add_to_end_each_ts < 0
+
+     # accomodate for both styles of rewrite, except it messes up the math...delete this soon...
+     # difference = starting_timestamp_given_srt - starting_timestamp_actual
+     # subtract_from_each_beginning_ts += difference
+     # add_to_end_each_ts -= difference
+
+#     you minus the initial srt time... (given)
+#     ratio = (end actual - init actual/ end given - init given)*(how far you are past the initial srt) plus initial actual
+     multiply_by_this_factor = (ending_actual_time - starting_time_actual)/(ending_srt_time - starting_time_given_srt)
+
+     multiply_proc = proc {|you|
+      ((you - starting_time_given_srt) * multiply_by_this_factor) + starting_time_actual
+    }  
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    bad_profanities = {'hell' => ['h...', :full_word],
+      'g' +
+      111.chr + 
+      100.chr => ['vain use', :partial_word, 'deity'], 'g' +
+      111.chr + 
+      100.chr +
+      's' => 'deitys',
+      'meu deus' => 'l...',
+      'lo' + 
+	  'rd' => 'l...', 'da' +
+      'mn' => 'd...', 
+      'f' +
+      117.chr +
+      99.chr +
+      107.chr =>
+      'f...',
+      'allah' => 'all..',
+      'bi' +
+      'tc' + 104.chr => 'b....',
+      'bas' +
+      'ta' + 
+	  'r' + 100.chr => 'ba.....',
+      ((arse = 'a' +
+      's'*2)) => ['a..', :full_word],
+      arse + 'h' +
+      'ole' => 'a..h...',
+      'dieu' => ['deity', :full_word],
+      arse + 'w' +
+      'ipe' => 'a..w...',
+      'jes' +
+      'u' + 's' => ['vain use', :partial_word, 'deity'],
+      'chri' +
+      'st'=> ['vain use', :full_word, 'deity'], # allow for christian[ity] 
+      'sh' +
+       'i' + 't' => 'sh..',
+      'cu' +
+      'nt' => 'c...',
+      'cock' +
+	  'su' + 
+	  'cker' => 'cock......',
+    }
+    
+	
+    semi_bad_profanities = {}
+    ['moron', 'breast', 'idiot', 
+      'sex', 'genital', 
+      'boob', 
+      'tits',
+      'make love', 'pen' +
+	    'is',
+      'pu' +
+	  'ssy',
+      'fart',
+	  'whore',
+	  'debauch',
+      'making' + 
+	    ' love', 'love mak', 
+      'dumb', 'suck', 'piss', 'c' +
+	    'u' + 'nt',
+	    'd' + 'ick', 'vag' +
+	    'i' + 'na',
+	  ].each{|name|
+      semi_bad_profanities[name] = name
+    }
+    semi_bad_profanities['bloody'] = 'bloo..'
+    semi_bad_profanities['crap'] = ['crap', :full_word]
+    semi_bad_profanities['butt'] = ['butt', :full_word]
+    # butter?
+	
+    semi_bad_profanities.merge! extra_profanity_hash
+
+    all_profanity_combinationss = [convert_to_regexps(bad_profanities)]
+    if include_minor_profanities
+      all_profanity_combinationss += [convert_to_regexps(semi_bad_profanities)]
+    end
+    
+    output = ''
+    entries = split_to_entries(subtitles)
+    for all_profanity_combinations in all_profanity_combinationss
+      output += "\n"
+      for entry in entries
+        text = entry.text
+        ts_begin = entry.beginning_time
+        ts_begin -= subtract_from_each_beginning_ts
+        ts_begin = multiply_proc.call(ts_begin)
+        
+        ts_end = entry.ending_time
+        ts_end += add_to_end_each_ts
+        ts_end = multiply_proc.call(ts_end)
+        found_category = nil
+        for (profanity, category, sanitized) in all_profanity_combinations
+          if text =~ profanity
+            found_category = category
+            break
+          end
+        end
+        
+        if found_category
+          # sanitize/euphemize the subtitle text for all profanities...
+          for all_profanity_combinations2 in all_profanity_combinationss
+            for (profanity, category, sanitized) in all_profanity_combinations2
+              text.gsub!(profanity, sanitized)
+            end
+          end
+          
+          # because we now have duplicate's for the letter l/i, refactor [[[word]]] to just [word]
+          text.gsub!(/\[+/, '[')
+          text.gsub!(/\]+/, ']')
+          entry.text = text
+          add_single_line_minimized_text_from_multiline entry
+          text = text.gsub(/[\r\n]|\n/, ' ') # flatten up to 3 lines of text to just 1
+          ts_begin_human = EdlParser.translate_time_to_human_readable ts_begin, true
+          ts_end_human = EdlParser.translate_time_to_human_readable ts_end, true
+          unless output.contain? ts_begin_human # some previous profanity already found this line :P
+            output += %!  "#{ts_begin_human}" , "#{ts_end_human}", "profanity", "#{found_category}", "#{text}",\n!
+          end
+        end
+      end
+    end
+    # update timestamps to be synchro'ed
+    for entry in entries
+      entry.beginning_time = multiply_proc.call(entry.beginning_time)
+      entry.ending_time = multiply_proc.call(entry.ending_time)
+    end
+    [output, entries]
+  end
+end
+
+if $0 == __FILE__
+  if ARGV.empty?
+    p 'syntax: [filename.srt | [--create-edl|--create-edl-including-minor-profanities] input_name.srt output_name.edl]'
+    exit
+  elsif ARGV[0].in? ['--create-edl', '--create-edl-including-minor-profanities']
+    require_relative 'mplayer_edl'
+    incoming_filename = ARGV[1]
+    include_minors = true if ARGV[0] == '--create-edl-including-minor-profanities'
+    mutes = SubtitleProfanityFinder.edl_output_from_string File.read(incoming_filename), {}, 0, 0, "00:00", "00:00", "10:00:00", "10:00:00", include_minors
+    specs = EdlParser.parse_string %!"mutes" => [#{mutes}]!
+    File.write(ARGV[2], MplayerEdl.convert_to_edl(specs))
+    puts "wrote to #{ARGV[2]}"
+  else
+    print SubtitleProfanityFinder.edl_output ARGV.first
+  end
+end