sensible-cinema 0.28.1 → 0.34.0

data/lib/keyboard_input.rb

@@ -15,8 +15,6 @@ This file is part of Sensible Cinema.
     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'
-require 'sane'
 require 'Win32API'
 
 # does the jruby check inline

data/lib/mencoder_wrapper.rb

@@ -47,7 +47,12 @@ class MencoderWrapper
     # called from the UI...
     # only for transcoding.
     def get_bat_commands these_settings, this_from_file, to_here_final_file, start_here = nil, end_here = nil, dvd_title_track = "1", delete_partials = false, require_deletion_entry = false
-      combined = EdlParser.convert_incoming_to_split_sectors these_settings
+      
+      dvd_start_offset = these_settings['dvd_start_offset'] # assume we prefer DVD timings which...we do :P
+      raise 'EDL must have a dvd_start_offset, even if just 0.0 (or better yet, 0.28 is a common one), as we use this to translate from DVD to file times' unless dvd_start_offset
+      dvd_start_offset = EdlParser.translate_string_to_seconds(dvd_start_offset)
+      
+      combined = EdlParser.convert_incoming_to_split_sectors these_settings, 0, dvd_start_offset, [], dvd_start_offset
       @dvd_title_track = dvd_title_track
       assert dvd_title_track
       if start_here || end_here
@@ -84,8 +89,8 @@ class MencoderWrapper
         p 'warning, overwriting+deleting previous ' + to_here_final_file
         FileUtils.rm to_here_final_file # raises on deletion failure...which is what we want I think...typically...early warning...
       end
-      out += "call mencoder #{partials.join(' ')} -o #{to_here_final_file} -ovc copy -oac copy\n"
-      out += "@rem old DISABLED join way... call mencoder -oac lavc -ovc lavc -of mpeg -mpegopts format=dvd:tsaf -vf scale=720:480,harddup -srate 48000 -af lavcresample=48000 -lavcopts vcodec=mpeg2video:vrc_buf_size=1835:vrc_maxrate=9800:vbitrate=5000:keyint=18:vstrict=0:acodec=ac3:abitrate=192:aspect=16/9 -ofps 30000/1001  #{partials.join(' ')} -o #{to_here_final_file}\n"
+      out += "mencoder #{partials.join(' ')} -o #{to_here_final_file} -ovc copy -oac copy\n"
+      out += "@rem old DISABLED join way... mencoder -oac lavc -ovc lavc -of mpeg -mpegopts format=dvd:tsaf -vf scale=720:480,harddup -srate 48000 -af lavcresample=48000 -lavcopts vcodec=mpeg2video:vrc_buf_size=1835:vrc_maxrate=9800:vbitrate=5000:keyint=18:vstrict=0:acodec=ac3:abitrate=192:aspect=16/9 -ofps 30000/1001  #{partials.join(' ')} -o #{to_here_final_file}\n"
       
       delete_prefix = delete_partials ? "" : "@rem "
       delete_prefix = "@rem" if am_on_developer_machine? # for ease of double checking...

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

@@ -20,6 +20,7 @@ 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
+    
     # 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
     

data/lib/subtitle_profanity_finder.rb

@@ -1,27 +1,58 @@
 #
-# warning: somewhat scary/explicit!
-
-# see subtitle_todo file
-
-
+# warning: somewhat scary/explicit down there!
+# see also todo.subtitle file, though what's here is mostly pretty well functional
+#
+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_glops subtitles
-     subtitles.scan(/\d\d:\d\d:\d\d.*?^$/m)
+   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?
+	   out.single_line_text = text.strip.gsub(/^[- ,_\.]+/, '').gsub(/[- ,_]+$/, '').gsub(/[\r\n]/, ' ')
+       out
+     }
    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
-        is_single_word_profanity = true
-        raise unless sanitized[1] == :full_word
-        raise unless sanitized.length == 2
+        # 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
       
@@ -33,55 +64,43 @@ module SubtitleProfanityFinder
         permutations << profanity.gsub(/i/i, 'l')
       end
       
-      bracketized = '[' + sanitized + ']'
+      replace_with = '[' + sanitized + ']'
+      category ||= sanitized
       
       for permutation in permutations
         if is_single_word_profanity
-          # oh wow this is ughly...
-          sanitized_version = bracketized
-          as_regexp = Regexp.new("\s" + permutation + "\s", Regexp::IGNORECASE)
-          all_profanity_combinations << [as_regexp, ' ' + bracketized + ' ']
-          as_regexp = Regexp.new("^" + permutation + "\s", Regexp::IGNORECASE)
-          all_profanity_combinations << [as_regexp, bracketized + ' ']
-          as_regexp = Regexp.new("\s" + permutation + "$", Regexp::IGNORECASE)
-          all_profanity_combinations << [as_regexp, ' ' + bracketized]
-          as_regexp = Regexp.new("^" + permutation + "$", Regexp::IGNORECASE)
-          all_profanity_combinations << [as_regexp, bracketized]
+		  # \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, bracketized]
+          all_profanity_combinations << [as_regexp, category, replace_with]
         end
       end
     }
     all_profanity_combinations
-   end
-
-
+  end
 
-  def self.edl_output incoming_filename, extra_profanity_hash = {}, subtract_from_each_beginning_ts = 0, add_to_end_each_ts = 0, beginning_srt = "00:00", beginning_actual_movie = "00:00", ending_srt = "10:00:00", ending_actual = "10:00:00"
-    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
+  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
   
-  def self.edl_output_from_string subtitles, extra_profanity_hash, subtract_from_each_beginning_ts, add_to_end_each_ts, starting_timestamp_given_srt, starting_timestamp_actual, ending_srt, ending_actual
-     subtitles.gsub!("\r\n", "\n")
+  # **_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
 
-     starting_timestamp_given_srt = EdlParser.translate_string_to_seconds(starting_timestamp_given_srt)
-     starting_timestamp_actual = EdlParser.translate_string_to_seconds(starting_timestamp_actual)
-     ending_srt = EdlParser.translate_string_to_seconds(ending_srt)
-     ending_actual = EdlParser.translate_string_to_seconds ending_actual
-
-     # accomodate for both styles of rewrite, except it messes up the math, so just leave it separate:
+     # 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 - starting_timestamp_actual)/(ending_srt - starting_timestamp_given_srt)
-
-     multiply_proc = proc {|you|
-      ((you - starting_timestamp_given_srt) * multiply_by_this_factor) + starting_timestamp_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
     }  
 
 
@@ -112,9 +131,10 @@ module SubtitleProfanityFinder
 
 
 
-    bad_profanities = {'hell' => ['he..', :full_word],
+    bad_profanities = {'hell' => ['h...', :full_word],
       'g' +
-      'o' + 100.chr => 'goodness', 'g' +
+      111.chr + 
+      100.chr => ['vain use', :partial_word, 'deity'], 'g' +
       111.chr + 
       100.chr +
       's' => 'deitys',
@@ -126,7 +146,7 @@ module SubtitleProfanityFinder
       99.chr +
       107.chr =>
       'f...',
-      'allah' => 'allah',
+      'allah' => 'all..',
       'bi' +
       'tc' + 104.chr => 'b....',
       'bas' +
@@ -135,95 +155,113 @@ module SubtitleProfanityFinder
       's'*2)) => ['a..', :full_word],
       arse + 'h' +
       'ole' => 'a..h...',
-      'dieu' => ['deity', :full_word], # TODO fails...
-      arse + 'wipe' => 'a..w....',
+      'dieu' => ['deity', :full_word],
+      arse + 'w' +
+      'ipe' => 'a..w...',
       'jes' +
-      'u' + 's' => 'j....',
+      'u' + 's' => ['vain use', :partial_word, 'deity'],
       'chri' +
-      'st'=> ['chr...', :full_word], # allow for christian[ity] [good idea or not?]
+      'st'=> ['vain use', :full_word, 'deity'], # allow for christian[ity] 
       'sh' +
        'i' + 't' => 'sh..',
-      'a realllly bad word' => ['test edited bad word', :full_word]
+      'cu' +
+      'nt' => 'c...',
+      'cocksucker' => 'cock......',
     }
     
     bad_profanities.merge! extra_profanity_hash # LODO make easier to use...
 
     semi_bad_profanities = {}
-    ['bloody', 'moron', 'breast', 'idiot', 
-      'sex', 'genital', 'boob', 'make love', 
-      'making love', 'love mak', 
-      'dumb', 'suck', 
-      'piss'
+    ['moron', 'breast', 'idiot', 
+      'sex', 'genital', 
+      'boob', 
+      'tits',
+      'make love', 'pen' +
+	    'is',
+      'pussy',
+      'fart',
+      'making' + 
+	    ' love', 'love mak', 
+      'dumb', 'suck', 'piss', 'c' +
+	    'u' + 'nt',
+	    'd' + 'ick', 'vag' +
+	    'i' + 'na',
 	  ].each{|name|
-      # butter?
       semi_bad_profanities[name] = name
     }
+    semi_bad_profanities['bloody'] = 'bloo..'
     semi_bad_profanities['crap'] = ['crap', :full_word]
     semi_bad_profanities['butt'] = ['butt', :full_word]
-
-    all_profanity_combinationss = [convert_to_regexps(bad_profanities), convert_to_regexps(semi_bad_profanities)]
+    # butter?
+
+    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 glop in split_to_glops(subtitles)
-        for profanity, (sanitized, whole_word) in all_profanity_combinations
-          # dunno if we should force words to just start with this or contain it anywhere...
-          # what about 'g..ly' for example?
-          # or 'un...ly' ? I think we're ok there...
-  
-          if glop =~ profanity
-            # create english-ified version
-            # take out timing line, number line
-            sanitized_glop = glop.lines.to_a[1..-1].join(' ')
-            sanitized_glop.gsub!(/[\r\n]/, '') # flatten 3 lines to 1
-            sanitized_glop.gsub!(/<(.|)(\/|)i>/i, '') # kill <i> 
-            sanitized_glop.gsub!(/[^a-zA-Z0-9'""]/, ' ') # kill weird stuff like ellipses
-            sanitized_glop.gsub!(/\W\W+/, ' ') # remove duplicate "  " 's
-            
-            # sanitize the subtitles themselves...
-            for all_profanity_combinations2 in all_profanity_combinationss
-              for (prof2, (sanitized2, whole_word2)) in all_profanity_combinations2
-                if sanitized_glop =~ prof2
-                  sanitized_glop.gsub!(prof2, sanitized2)
-                end
-              end
-            end
-            
-            # because we have duplicate's for the letter l/i, refactor [[[profanity]]]
-            sanitized_glop.gsub!(/\[+/, '[')
-            sanitized_glop.gsub!(/\]+/, ']')
-            
-            # extract timing info
-            timing_line = glop.split("\n").first.strip
-            timing_line =~ /((\d\d:\d\d:\d\d),(\d\d\d) --> (\d\d:\d\d:\d\d),(\d\d\d))/
-            # "00:03:00.0" , "00:04:00.0", "violence", "of some sort",
-            ts_begin = "#{$2}.#{$3}"
-            ts_begin = EdlParser.translate_string_to_seconds ts_begin
-            ts_begin  -= subtract_from_each_beginning_ts
-            ts_begin = multiply_proc.call(ts_begin)
-            ts_begin = EdlParser.translate_time_to_human_readable ts_begin, true
-            ts_end = "#{$4}.#{$5}"
-            ts_end = EdlParser.translate_string_to_seconds ts_end
-            ts_end += add_to_end_each_ts
-            ts_end = multiply_proc.call(ts_end)
-            ts_end = EdlParser.translate_time_to_human_readable ts_end, true
-            unless output.contain? ts_begin
-              output += %!"#{ts_begin}" , "#{ts_end}", "profanity", "#{sanitized.gsub(/[\[\]]/, '').strip}", "#{sanitized_glop.strip}",\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
+          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
-    output
-
+    # 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 [prof1 sanitized_equivalent1 prof2 sanitized_equivalent2 ...]'
+    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

data/lib/vlc_programmer.rb

@@ -89,7 +89,7 @@ class VLCProgrammer
       </track>"
     else
       "vlc --qt-start-minimized #{loc} --start-time=#{start} --stop-time=#{stop} --sout=\"file/ps:#{@filename_or_playlist_if_nil}.ps.#{idx}\" #{"--no-sout-audio" if no_audio} vlc://quit\n" # + 
-      #"call vlc #{@filename_or_playlist_if_nil}.ps.#{idx}.tmp  --sout=file/ps:go.ps
+      #"vlc #{@filename_or_playlist_if_nil}.ps.#{idx}.tmp  --sout=file/ps:go.ps
     end
   end
   

data/lib/zoom_player_max_edl.rb

@@ -0,0 +1,50 @@
+=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 ZoomPlayerMaxEdl
+  
+  def self.convert_to_edl_string specs
+    
+    raise 'needs timestamps_relative_to--or rather, ping me if you want this for file based' unless specs['timestamps_relative_to']
+    combined = EdlParser.convert_incoming_to_split_sectors specs
+    raise unless mpeg_offset = specs['dvd_start_offset'] # TODO make this a class... also rename it mpeg_dvd_start_offset
+    raise unless dvd_nav_packet_offsets = specs['dvd_nav_packet_offset']
+    combined2 = EdlParser.convert_to_dvd_nav_times combined, specs['timestamps_relative_to'][0], mpeg_offset.to_f, dvd_nav_packet_offsets, specs['timestamps_relative_to'][1].to_f
+    out = ""
+    track = specs['dvd_title_track']
+    out += "DVDTitle(#{track})\n"
+=begin
+    DVDTitle(1)
+    CutSegment("Start=27.389","End=32.209")
+    CutSegment("Start=73.510","End=78.510")
+    MuteAudio("From=39.389","Duration=41.389")
+=end
+    for start, endy, type in combined2      
+      if type == :mute
+        out += %!MuteAudio("From=#{start}","Duration=#{endy-start}")\n!
+      elsif type == :blank
+        out += %!CutSegment("Start=#{start}","End=#{endy}")\n!
+      else
+        raise
+      end
+    end
+    out
+  end
+end