sensible-cinema 0.20.0 → 0.20.1

data/TODO

@@ -2,18 +2,24 @@
   
 == up next release ==
 
-  edl straight DVD replay: work HP
+  edl straight DVD replay:
     work cars
   clear runnings
+    finalize
     have ben and chris test it out
 
 == slightly lower than that, somewhat ordered ==
 
-  the 0.5 offset only is applying to mutes currently [fix]
-    also note that the beginning offset is wrong-o [?]
-  "watch edited while grabbing"
+  test HP if I put the whole thing together (2 hour mark)
+    try it again with grabbing from DVD too
+  add "revision"
+  note: you need to offset your start times
+    change it to be aggressive sometimes yes, other times no
+  note: can make several different versions, with different filenames, and should rewatch the film after finalizing it (edited), like "grab to hard drive" and have a friend watch it, if desired.
+  make the other button work again (watch unedited while grabbing)
+  the "edited.avi" *must* be playable in WMP
   don't exit program if they don't select a disk :)
-  if they type in a "new" start time, use that as the default end time input
+  if they type in a "new" start time, use that as the default end time input too
   linearize edl's
     don't use them linear, just linearize
   mpeg is lossy (at least my current one pass conversion still is...)  and smplayer can't play it right unedited
@@ -49,6 +55,10 @@
   
 == DVD backlog (unordered, some very low prio, basically all never do) ==
 
+  @ffmpeg: do you get slower the farther into large files you are?
+  FHE friendly: always harddup, "watch as grabbed" button [plus other ramifications]
+  @ffmpeg: gop 12 for ntsc-dvd?
+  @ffmpeg: doesn't grab the right time frames?
   @mplayer: why you can't play it when VLC can? huh? (audio sync)
   can watch conference like a music video :)
     can play "this section then that, with this one's audio
@@ -345,4 +355,12 @@ donate money to several projects I use/like :)
 @mencoder: ripping like this results in an (avidemux, VLC) fourcc of 'ugh':  mencoder2 dvdnav://1  -oac copy -ovc copy -o D:\raw_rip_mpeg_example.avi -endpos 20 -dvd-device E:\
 
 @jruby: system("mencoder") from a button doesn't get interrupted by an exception [!]
-@vlc: replay mp4's are too dark.
+@vlc: replay mp4's are too dark.
+
+@rspec:   1) EdlParser should raise for end before beginning
+     Failure/Error: proc{ go({"mutes"=>{105=>104.9}})}.should raise_error(/SyntaxError/)
+     expected Exception with message matching /SyntaxError/, got #<SyntaxError: warning--detected an end before a start 104.9 < 105.0>
+     # edl_parser.spec.rb:115
+     # :1
+    
+    message confusing :)

data/VERSION

@@ -1 +1 @@
-0.20.0
+0.20.1

data/bin/sensible-cinema

@@ -107,9 +107,9 @@ module SensibleSwing
         do_copy_dvd_to_hard_drive false
       }
       
-      @mplayer_edl = new_jbutton( "Watch DVD on computer edited realtime (not always be accurate)", false )
+      @mplayer_edl = new_jbutton( "Watch DVD on computer edited realtime", false )
       @mplayer_edl.on_clicked {
-        do_mplayer_edl nil, 0, 0.5
+        do_mplayer_edl
       }
 
       @watch_unedited = new_jbutton("Watch a DVD unedited (while grabbing to hard drive)", true)
@@ -149,7 +149,7 @@ module SensibleSwing
         old_prefs = File.read(smplayer_prefs_file)
         new_prefs = old_prefs.gsub(/mplayer_additional_options=.*/, "mplayer_additional_options=-edl #{EdlTempFile}")
         File.write(smplayer_prefs_file, new_prefs)
-        thread = do_mplayer_edl( "smplayer #{nice_file}", 0, 0.5)
+        thread = do_mplayer_edl( "smplayer #{nice_file}")
         Thread.new { # XX do we need this?
           begin
             thread.join
@@ -189,7 +189,7 @@ module SensibleSwing
 # "dvd_title_track" => "1", # most DVD's use title 1. Yours might not.  If it plays anything except the main title, see http://goo.gl/QHLIF
 # "not edited out stuff" => "",
 # "closing thoughts" => "still a fairly dark movie",
-
+# "mplayer_dvd_splits" => ["59:59", "1:04:59"], # find these by playing your dvd with smplayer, and noting where the timing switches [buggedly] back to zero in error--common on many DVD's.  Setting it here lets the 'insta play' feature work right.
 EOL
         filename = EDL_DIR + "\\" + name.gsub(' ', '_') + '.txt'
         filename.downcase!
@@ -239,21 +239,27 @@ EOL
     
     EdlTempFile = Dir.tmpdir + '/mplayer.temp.edl'
     
-    def do_mplayer_edl play_this_start, add_secs_end, add_secs_beginning
-        drive, dvd_volume_name, md5sum, edl_path, descriptors = choose_dvd_and_edl_for_it
-        descriptors = EdlParser.parse_file edl_path
-        edl_contents = MplayerEdl.convert_to_edl descriptors, add_secs_end, add_secs_beginning # add a sec to mutes to accomodate for mplayer's oddness...
-        File.write(EdlTempFile, edl_contents)
-        title_track = get_title_track(descriptors)
-        # oh the insanity of the console UI...LODO more user friendly player
-        @popup ||= NonBlockingDialog.new("Running mplayer.  To control it, use space for pause.\n
-        Also right and left arrows to seek, F key for full screen, [, ] to control playback speed.
-        q to quit.")
-        # LODO dry up mplayer dvd opts...
-        play_this_start ||= "mplayer dvd://#{title_track}"
-        command =  "#{play_this_start} -nocache -alang en -sid 1000 -edl #{File.expand_path EdlTempFile} -dvd-device #{drive}"
-        p command
-        Thread.new { system_blocking command; @popup.dispose }
+    def do_mplayer_edl play_this_mplayer = nil, add_secs_end = 0, add_secs_beginning = 0.5
+      drive, dvd_volume_name, md5sum, edl_path, descriptors = choose_dvd_and_edl_for_it
+      descriptors = EdlParser.parse_file edl_path
+      splits = descriptors['mplayer_dvd_splits']
+      if splits == nil
+        show_blocking_message_dialog("warning: delete list does not contain mplayer replay information [mplayer_dvd_splits] so edits past a certain time period won't work (fixable...).")
+        splits = []
+      end
+      splits.map!{|s|  EdlParser.translate_string_to_seconds(s) }
+      edl_contents = MplayerEdl.convert_to_edl descriptors, add_secs_end, add_secs_beginning, splits # add a sec to mutes to accomodate for mplayer's oddness...
+      File.write(EdlTempFile, edl_contents)
+      title_track = get_title_track(descriptors)
+      # oh the insanity of the console UI...LODO more user friendly player
+      @popup ||= NonBlockingDialog.new("Running mplayer.  To control it, use space for pause.\n
+      Also right and left arrows to seek, F key for full screen, [, ] to control playback speed.
+      q or escape to quit.")
+      # LODO dry up mplayer dvd opts...
+      play_this_mplayer ||= "mplayer dvd://#{title_track}"
+      command =  "#{play_this_mplayer} -nocache -alang en -sid 1000 -edl #{File.expand_path EdlTempFile} -dvd-device #{drive}"
+      p command
+      Thread.new { system_blocking command; @popup.dispose }
     end
       
     def show_blocking_license_accept_dialog program, license_name, license_url_should_also_be_embedded_by_you_in_message, title = 'Confirm Acceptance of License Agreement', message = nil
@@ -369,8 +375,8 @@ EOL
       start_time = JOptionPane.showInputDialog(message, default)
     end
     
-    def parse_edl path, ignore_settings = false
-      EdlParser.parse_file path, ignore_settings
+    def parse_edl path
+      EdlParser.parse_file path
     end
     
     def get_freespace path
@@ -431,10 +437,13 @@ EOL
       end
     end
 
-    def do_copy_dvd_to_hard_drive should_prompt_for_start_and_end_times, exit_early_if_fulli_exists = false, ignore_settings = false
+    def do_copy_dvd_to_hard_drive should_prompt_for_start_and_end_times, exit_early_if_fulli_exists = false, watch_unedited = false
       drive, dvd_volume_name, md5sum, edit_list_path, descriptors = choose_dvd_and_edl_for_it
       
-      descriptors = parse_edl(edit_list_path, ignore_settings)
+      descriptors = parse_edl(edit_list_path)
+      if watch_unedited
+        descriptors['mutes'] = descriptors['blank_outs'] = []
+      end
       
       # LODO allow for spaces in the save_to filename
       if should_prompt_for_start_and_end_times
@@ -464,7 +473,8 @@ EOL
       
       dvd_title_track = get_title_track(descriptors)
       should_run_mplayer = should_prompt_for_start_and_end_times || exit_early_if_fulli_exists
-      generate_and_run_bat_file save_to, edit_list_path, descriptors, drive, dvd_title, start_time, end_time, dvd_title_track, should_run_mplayer, !ignore_settings
+      require_deletion_entry = true unless watch_unedited
+      generate_and_run_bat_file save_to, edit_list_path, descriptors, drive, dvd_title, start_time, end_time, dvd_title_track, should_run_mplayer, require_deletion_entry
       [false, fulli] # false means it's running in a background thread :P
     end
 
@@ -474,7 +484,8 @@ EOL
     
     # stubbable :)
     def get_mencoder_commands descriptors, drive, save_to, start_time, end_time, dvd_title_track, require_deletion_entry
-      MencoderWrapper.get_bat_commands descriptors, drive, save_to, start_time, end_time, dvd_title_track, true, require_deletion_entry # delete partials...
+      delete_partials = true unless start_time
+      MencoderWrapper.get_bat_commands descriptors, drive, save_to, start_time, end_time, dvd_title_track, delete_partials, require_deletion_entry # delete partials...
     end
 
     def generate_and_run_bat_file save_to, edit_list_path, descriptors, drive, dvd_title, start_time, end_time, dvd_title_track, run_mplayer, require_deletion_entry

data/lib/edl_parser.rb

@@ -24,8 +24,8 @@ class EdlParser
     parse_string File.read(filename), filename, [], ignore_settings
   end
   
-  # better eye-ball these before letting people run them, eh?
-  # but I couldn't think of any other way
+  # better eye-ball these before letting people run them, eh? XXXX
+  # but I couldn't think of any other way to parse the files tho
   def self.parse_string string, filename, ok_categories_array = [], ignore_settings = false
     string = '{' + string + "\n}"
     if filename
@@ -47,6 +47,7 @@ class EdlParser
     raw
   end
   
+  # converts "blanks" => ["00:00:00", "00", "reason", "01", "01", "02", "02"] into sane arrays, also filters based on category, though disabled
   def self.convert_to_timestamp_arrays array, ok_categories_array
     out = []
     while(single_element = extract_entry!(array))
@@ -76,60 +77,79 @@ class EdlParser
     out
   end
   
+  def self.get_secs timestamp_string_begin, timestamp_string_end, add_begin, add_end, splits
+    answers = []
+    for type, offset, multiplier in [[timestamp_string_begin, add_begin, -1], [timestamp_string_end, add_end, 1]]
+      original_secs = translate_string_to_seconds(type) + offset
+      # now if splits is 900 and we'are at 909, then we're just 9
+      closest_split_idx = splits.reverse.index{|t| t < original_secs}
+      if closest_split_idx
+        closest_split = splits.reverse[closest_split_idx]
+        # add some extra seconds onto these if they're "past" a split, too
+        original_secs = original_secs - closest_split + multiplier * (splits.length - closest_split_idx)
+        original_secs = [0, original_secs].max # no negatives allowed :)
+      end
+      answers << original_secs
+    end
+    answers
+  end
+  
   # divides up mutes and blanks so that they don't overlap, preferring blanks over mutes
   # returns it like [[start,end,type], [s,e,t]...] type like :blank and :mute
-  def self.convert_incoming_to_split_sectors incoming, add_this_to_mutes_end = 0, add_this_to_mutes_beginning = 0
+  def self.convert_incoming_to_split_sectors incoming, add_this_to_mutes_end = 0, add_this_to_mutes_beginning = 0, splits = []
+    if splits != []
+      # allow it to do all the double checks we later skip, just in case :)
+      self.convert_incoming_to_split_sectors incoming
+    end
     mutes = incoming["mutes"] || {}
     blanks = incoming["blank_outs"] || {}
-    mutes = mutes.map{|k, v| [OverLayer.translate_string_to_seconds(k) - add_this_to_mutes_beginning, OverLayer.translate_string_to_seconds(v) + add_this_to_mutes_end, :mute]}
-    blanks = blanks.map{|k, v| [OverLayer.translate_string_to_seconds(k), OverLayer.translate_string_to_seconds(v), :blank]}
-
-    combined = (mutes+blanks).sort_by{|entry| entry[0,1]}
+    mutes = mutes.map{|k, v| get_secs(k, v, -add_this_to_mutes_beginning, add_this_to_mutes_end, splits) + [:mute]}
+    blanks = blanks.map{|k, v| get_secs(k, v, -add_this_to_mutes_beginning, add_this_to_mutes_end, splits) + [:blank]}
+    p mutes, blanks
     combined = (mutes+blanks).sort
-
-    combined.each{|s, e, t|
-      puts 'warning--detected an end before a start' if e < s
-    }
-
-    # VLCProgrammer.convert_to_full_xspf({ "mutes" => {5=> 7}, "blank_outs" => {6=>7} } )
-    # should mute 5-6, skip 6-7
-    previous = combined[0]
-    combined.each_with_index{|(start, endy, type), index|
-      next if index == 0 # nothing to do there..
-      previous_end = previous[1]
-      previous_type = previous[2]
-      previous_start = previous[0]
-      if type == :blank
-        raise 'no overlap like that allowed as of yet' unless previous_end <= endy
-        if previous_type == :mute && previous_end > start
-          previous[1] = start # make it end when we start...
-        end
-      elsif type == :mute
-        if previous_end > start
-          
-          if previous_end >= endy
-            combined[index] = [nil] # null it out...it's a mute subsumed by a blank apparently...
-            if previous_type == :mute
-               raise 'overlapping mute?'
-            end
-            next
-          else
-             # start mine when the last one ended...
-             combined[index] = [previous_end, endy, type]
-          end
-
+    
+    previous = nil
+    combined.each_with_index{|current, idx|
+      s,e,t = current
+      if e < s
+       raise SyntaxError.new("detected an end before a start: #{e} < #{s}") if e < s unless splits.length > 0
+      end
+      if previous
+        ps, pe, pt = previous
+        if (s < pe)
+          raise SyntaxError.new("detected an overlap #{[s,e,t].join(' ')} #{previous.join(' ')}") unless splits.length > 0
+          # our start might be within the previous' in which case its their start, with (greater of our, their endig)
+          preferred_end = [e,pe].max
+          preferred_type = [t,pt].detect{|t| t == :blank} || :mute # prefer blank to mute
+          combined[idx-1] = [ps, preferred_end, preferred_type]
+          combined[idx] = nil # allow it to be culled later
         end
-      else
-        raise 'unexpected'
+        
       end
-      previous = combined[index] 
+      previous = current
     }
+    combined.compact
+  end
+
+  def self.translate_string_to_seconds s
+    # might actually already be a float, or int, depending on the yaml
+    # int for 8 => 9 and also for 1:09 => 1:10
+    if s.is_a? Numeric
+      return s.to_f
+    end
     
-    combined.select{|start, endy, type|
-     (start != nil) && (endy > start) # ignore mutes wholly contained within blanks...
-    }
+    # 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
 
+  
 end
 
 # <= 1.8.7 Symbol compat

data/lib/mencoder_wrapper.rb

@@ -44,8 +44,8 @@ class MencoderWrapper
       assert dvd_title_track
       if start_here || end_here
         raise 'need both' unless end_here && start_here
-        start_here = OverLayer.translate_string_to_seconds(start_here)
-        end_here   = OverLayer.translate_string_to_seconds(end_here)
+        start_here = EdlParser.translate_string_to_seconds(start_here)
+        end_here   = EdlParser.translate_string_to_seconds(end_here)
         combined.select!{|start, endy, type| start > start_here && endy < end_here }
         raise TimingError.new("unable to find deletion entry between #{start_here} and #{end_here}") if require_deletion_entry && combined.length == 0
         # it's relative now, since we rip from not the beginning

data/lib/mplayer_edl.rb

@@ -20,9 +20,9 @@ require_relative 'overlayer'
 require_relative 'edl_parser'
 
 class MplayerEdl
-  def self.convert_to_edl specs, add_this_many_to_end = 0, add_this_many_to_beginning = 0
-    # simple re-map.
-    combined = EdlParser.convert_incoming_to_split_sectors specs, add_this_many_to_end, add_this_many_to_beginning
+  def self.convert_to_edl specs, add_this_many_to_end = 0, add_this_many_to_beginning = 0, splits = []
+    # 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

data/lib/overlayer.rb

@@ -105,6 +105,7 @@ class OverLayer
     @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_yaml raw_yaml
     begin
       all = YAML.load(raw_yaml) || {}      
@@ -120,8 +121,8 @@ class OverLayer
       new = {}
       maps.each{|start,endy|
         # both are like 1:02.0
-        start2 = translate_string_to_seconds(start) if start
-        endy2 = translate_string_to_seconds(endy) if endy
+        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...
@@ -164,27 +165,10 @@ class OverLayer
       @just_unblanked = false
       p 'ignoring timestamp update ' + to_this_exact_string_might_be_nil.to_s if $VERBOSE
     else
-      set_seconds OverLayer.translate_string_to_seconds(to_this_exact_string_might_be_nil) + delta if to_this_exact_string_might_be_nil
+      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
   
-  def self.translate_string_to_seconds s
-    # might actually already be a float, or int, depending on the yaml
-    # int for 8 => 9 and also for 1:09 => 1:10
-    if s.is_a? Numeric
-      return s.to_f
-    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

data/sensible-cinema.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{sensible-cinema}
-  s.version = "0.20.0"
+  s.version = "0.20.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Roger Pack"]
-  s.date = %q{2011-01-03}
+  s.date = %q{2011-01-04}
   s.email = %q{rogerdpack@gmail.com}
   s.executables = ["sensible-cinema", "sensible-cinema-cli"]
   s.extensions = ["ext/mkrf_conf.rb"]

data/spec/edl_parser.spec.rb

@@ -89,6 +89,11 @@ describe EdlParser do
     end
   end
   
+  it "should parse mplayer_dvd_splits as floats" do
+    E.parse_string('"mplayer_dvd_splits" => []', 'fakename')['mplayer_dvd_splits'].should == []
+    E.parse_string('"mplayer_dvd_splits" => ["123.5","124.5"]', 'fakename')['mplayer_dvd_splits'].should == ["123.5","124.5"]
+  end
+  
   it "should reject misformatted files" do
     proc {E.parse_string 'mutes=>["0:33", "0:34"]', 'filename'}.should raise_error(SyntaxError)
     proc {E.parse_string '"mutes"=>["0:33", "0:34"]', 'filename'}.should_not raise_error
@@ -99,12 +104,52 @@ describe EdlParser do
   end
   
   it "should sort exactly overlapping segments" do
-    EdlParser.convert_incoming_to_split_sectors({"mutes"=>{105=>145}, "blank_outs"=>{105=>145}}).should == [[105.0, 145.0, :blank]]
+    proc { go({"mutes"=>{105=>145}, "blank_outs"=>{105=>145}})}.should raise_error(SyntaxError)
+    proc { go({"mutes"=>{105=>145}, "blank_outs"=>{110=>130}})}.should raise_error(SyntaxError)
+    proc { go({"mutes"=>{105=>145}, "blank_outs"=>{110=>150}})}.should raise_error(SyntaxError)
   end
   
   it "should add to both ends" do
-    EdlParser.convert_incoming_to_split_sectors({"mutes"=>{105=>145}}, 1).should == [[105.0, 146.0, :mute]]
-    EdlParser.convert_incoming_to_split_sectors({"mutes"=>{105=>145}}, 1,1).should == [[104.0, 146.0, :mute]]
+    go({"mutes"=>{105=>145}}, 1).should == [[105.0, 146.0, :mute]]
+    go({"mutes"=>{105=>145}}, 1,1).should == [[104.0, 146.0, :mute]]
+  end
+  
+  def go *args
+    EdlParser.convert_incoming_to_split_sectors *args
+  end
+  
+  it "should raise for end before beginning" do
+    proc{ go({"mutes"=>{105=>104.9}})}.should raise_error(SyntaxError)
+  end
+  
+  it "should allow for splits in its parseage" do
+    go({ "mutes"=>{5=>6,105=>106}, "blank_outs" => {110 => 111} }, 0, 0, [103]).should == 
+      [[1.0, 4.0, :mute], [5.0, 6.0, :mute], [6.0, 9.0, :blank]]
   end
   
-end
+  it "should raise on poor overlap" do
+    proc{go({ "mutes"=>{5=>10, 6=>7}}, 0, 0, [1000])}.should raise_error(/overlap/i)
+  end
+  
+  # I put down it at 10:00 it's at 10:00.5
+  # so...postludingers should be...too early now?
+  # change when complaints come in :P
+  it "should take the greater of the end and beginning on combined splits and greater of the blank versus mute" do
+    # so if I have a very long mute with a mute in the middle, it should turn into a very long mute
+    go({ "mutes"=>{5=>10, 103=>107}}, 0, 0, [100]).should == [[2.0, 10.0, :mute]]
+    go({ "mutes"=>{5=>10, 103=>110}}, 0, 0, [100]).should == [[2.0, 11.0, :mute]]
+    go({ "mutes"=>{5=>15, 103=>110}}, 0, 0, [100]).should == [[2.0, 15.0, :mute]]
+    go({ "mutes"=>{5=>10, 103=>111}}, 0, 0, [100]).should == [[2.0, 12.0, :mute]]
+    # now throw in blanks to the mix...
+    go({ "mutes"=>{5=>10}, "blank_outs" => {103=>110}}, 0, 0, [100]).should == [[2.0, 11.0, :blank]]
+    go({ "blank_outs"=>{5=>10}, "mutes" => {103=>110}}, 0, 0, [100]).should == [[2.0, 11.0, :blank]]
+  end
+  
+  it "should accomodate well for multiples, and zero" do
+    go({ "mutes"=>{5=>10, 75 => 76, 101 => 102}}, 0, 0, [50, 100]).should == 
+      [[0.0, 4.0, :mute], [5.0, 10.0, :mute], [24.0, 27.0, :mute]]
+  end
+  
+  it "should handle edge cases, like where an entry overlaps the divider, or the added stuff causes it to"
+  
+end