screencaster-gtk 0.0.4.alpha1 → 0.0.5.alpha1

data/bin/screencaster

@@ -1,6 +1,17 @@
 #!/usr/bin/env ruby
 
 require "screencaster-gtk"
+#require "rdoc/usage"
+
+=begin rdoc
+screencaster [OPTION] ... 
+
+-h, --help:
+   show help
+
+-s, -p, --start, --pause:
+  Pause a running capture, or restart a paused capture
+=end
 
 app = ScreencasterGtk.new
 app.set_up

data/lib/screencaster-gtk.rb

@@ -7,19 +7,27 @@ require "screencaster-gtk/savefile"
 
 ##########################
 
-
+=begin rdoc
+A program to capture screencasts -- video from monitor and sound from microphone
+=end
 class ScreencasterGtk
-  attr_reader :capture_window, :window
-  attr_writer :status_icon
+  attr_reader :capture_window
+  
+  protected
+  attr_reader :window
+#  atr_writer :status_icon
     
   SCREENCASTER_DIR = File.join(Dir.home, ".screencaster")
-  # Set up logging. Keep 5 log files of a 100K each
+  # Set up logging. Keep 5 log files of 100K each
   log_dir = File.join(SCREENCASTER_DIR, 'log')
   FileUtils.mkpath log_dir
-  LOGGER = Logger.new(File.join(log_dir, 'screencaster.log'), 5, 100000)
-  LOGGER.level = Logger::DEBUG
+  LOGFILE = File.join(log_dir, 'screencaster.log')
+  @@logger = Logger.new(LOGFILE, 5, 100000)
+  @@logger.level = Logger::DEBUG
   
   PIDFILE = File.join(SCREENCASTER_DIR, "run", "screencaster.pid")
+  
+  SOUND_SETTINGS = "/usr/bin/gnome-control-center"
 
   DEFAULT_SPACE = 10
   RECORD_IMAGE = Gtk::Image.new(Gtk::Stock::MEDIA_RECORD, Gtk::IconSize::SMALL_TOOLBAR)
@@ -28,81 +36,54 @@ class ScreencasterGtk
   CANCEL_IMAGE = Gtk::Image.new(Gtk::Stock::CANCEL, Gtk::IconSize::SMALL_TOOLBAR)
   QUIT_IMAGE = Gtk::Image.new(Gtk::Stock::QUIT, Gtk::IconSize::SMALL_TOOLBAR)
 
+  public
+    def self.logger
+  @@logger
+  end
+  
+  def self.logger=(log_file)
+    @@logger = Logger.new(log_file, 5, 100000)
+  end
+      
 
   def initialize
     #### Create Main Window
     
-    LOGGER.info "Started"
+    @@logger.info "Started"
     
     @window = Gtk::Window.new("Screencaster")
     @window.signal_connect("delete_event") {
-      LOGGER.debug "delete event occurred"
+      @@logger.debug "delete event occurred"
       #true
       self.quit
       false
     }
     
     @window.signal_connect("destroy") {
-      LOGGER.debug "destroy event occurred"
+      @@logger.debug "destroy event occurred"
     }
     
     # The following gets minimize and restore events, but not iconify and de-iconify 
     @window.signal_connect("window_state_event") { |w, e|
-      LOGGER.debug "window_state_event #{e.to_s}"
+      @@logger.debug "window_state_event #{e.to_s}"
     }
     
     @window.border_width = DEFAULT_SPACE
    
     control_bar = Gtk::HBox.new(false, ScreencasterGtk::DEFAULT_SPACE)
     
-    @select_button = Gtk::Button.new("Select Window")
-    @select_button.signal_connect("clicked") {
-      self.select
-    }
-    control_bar.pack_start(@select_button, true, false)
-    
-    button = Gtk::Button.new
-    button.image = QUIT_IMAGE
-    button.signal_connect("clicked") {
-      self.quit
-    }
-    control_bar.pack_end(button, true, false)
-    
-    control_columns = Gtk::HBox.new(false, ScreencasterGtk::DEFAULT_SPACE) # children have different sizes, spaced by DEFAULT_SPACE
-    
-    @record_pause_button = Gtk::Button.new
-    @record_pause_button.image = RECORD_IMAGE
-    @record_pause_button.sensitive = false
-    @record_pause_button.signal_connect("clicked") {
-      self.record_pause
-    }
-    control_bar.pack_start(@record_pause_button, true, false)
-    
-    # @pause_button = Gtk::Button.new(Gtk::Stock::MEDIA_PAUSE)
-    # @pause_button.sensitive = false
-    # @pause_button.signal_connect("clicked") {
-      # self.pause
-    # }
-    # control_columns.pack_start(@pause_button, true, false)
-    # 
-    @stop_button = Gtk::Button.new
-    @stop_button.image = STOP_IMAGE
-    @stop_button.sensitive = false
-    @stop_button.signal_connect("clicked") {
-      self.stop_recording
-    }
-    control_bar.pack_start(@stop_button, true, false)
-    
-    @cancel_button = Gtk::Button.new
-    @cancel_button.image = CANCEL_IMAGE
-    @cancel_button.sensitive = false
-    @cancel_button.signal_connect("clicked") {
-      self.stop_encoding
-    }
-    control_bar.pack_start(@cancel_button, true, false)
-    
-    control_row = Gtk::VBox.new(false, ScreencasterGtk::DEFAULT_SPACE) # children have different sizes, spaced by DEFAULT_SPACE
-    control_row.pack_start(control_bar, true, false)
+    @select_button = add_button("Select Window", control_bar) { self.select }
+    @record_pause_button = add_button(RECORD_IMAGE, control_bar) { self.record_pause }
+    @stop_button = add_button(STOP_IMAGE, control_bar) { self.stop_recording }
+    @cancel_button = add_button(CANCEL_IMAGE, control_bar) { self.stop_encoding }
+    if File.executable? SOUND_SETTINGS
+      # There appears to be no stock icon for someting like a volume control.
+      #@sound_settings_button.image = AUDIO_VOLUME_MEDIUM
+      @sound_settings_button = add_button("Sound", control_bar, true) {
+        Thread.new { `#{SOUND_SETTINGS} sound` }
+      }
+    end
+    add_button(QUIT_IMAGE, control_bar, true) { self.quit }
     
     columns = Gtk::HBox.new(false, ScreencasterGtk::DEFAULT_SPACE)
     @progress_bar = Gtk::ProgressBar.new
@@ -114,20 +95,15 @@ class ScreencasterGtk
     
     the_box = Gtk::VBox.new(false, ScreencasterGtk::DEFAULT_SPACE)
     the_box.pack_end(progress_row, false, false)
-    the_box.pack_end(control_row, false, false)
+    the_box.pack_end(control_bar, false, false)
     
     @window.add(the_box)
 
     ##### Done Creating Main Window
     
-    #### Accelerator Group
-    group = Gtk::AccelGroup.new
-    group.connect(Gdk::Keyval::GDK_N, Gdk::Window::CONTROL_MASK|Gdk::Window::MOD1_MASK, Gtk::ACCEL_VISIBLE) do
-      #puts "You pressed 'Ctrl+Alt+n'"
-    end
-
     #### Pop up menu on right click
-
+    group = Gtk::AccelGroup.new
+    
     @select = Gtk::ImageMenuItem.new("Select Window")
     @select.signal_connect('activate'){self.select}
 
@@ -198,74 +174,130 @@ class ScreencasterGtk
   #### Done Status Icon
   
   def quit
-    LOGGER.debug "Quitting"
+    @@logger.debug "Quitting"
     # self.status_icon.destroy
-    # LOGGER.debug "After status icon destroy."
+    # @@logger.debug "After status icon destroy."
     # @window.destroy
-    # LOGGER.debug "After window destroy."
+    # @@logger.debug "After window destroy."
     # We don't want to destroy here because the object continues to exist
     # Just hide everything
     self.hide_all_including_status
     # self.status_icon.hide doesn't work/exist
     Gtk.main_quit 
-    LOGGER.debug "After main_quit."
+    @@logger.debug "After main_quit."
   end
   
+  public
   def select
-    LOGGER.debug "Selecting Window"
+    @@logger.debug "Selecting Window"
     @capture_window = Capture.new
     @capture_window.get_window_to_capture
     @record_pause_button.sensitive = true
   end
   
+  protected
   def record_pause
-    LOGGER.debug "Record/Pause state: #{@capture_window.state}"
+    @@logger.debug "Record/Pause state: #{@capture_window.state}"
     case @capture_window.state
     when :recording
-      LOGGER.debug "Record/Pause -- pause"
+      @@logger.debug "Record/Pause -- pause"
       pause
     when :paused, :stopped
-      LOGGER.debug "Record/Pause -- record"
+      @@logger.debug "Record/Pause -- record"
       record
     else
-      LOGGER.error "#{__FILE__} #{__LINE__}: Can't happen (state #{@capture_window.state})."
+      @@logger.error "#{__FILE__} #{__LINE__}: Can't happen (state #{@capture_window.state})."
     end
   end
   
   def record
-    LOGGER.debug "Recording"
+    @@logger.debug "Recording"
     recording
-    @capture_window.record { |percent, time_elapsed| 
-      @progress_bar.text = time_elapsed
-      LOGGER.debug "Did elapsed time: #{time_elapsed}"
-    }
+    spawn_record
   end
   
   def pause
-    LOGGER.debug "Pausing"
+    @@logger.debug "Pausing"
     paused
     @capture_window.pause_recording
   end
   
+  public
   def stop_recording
-    LOGGER.debug "Stopped"
+    @@logger.debug "Stopped"
     not_recording
     @capture_window.stop_recording
     
     SaveFile.get_file_to_save { |filename|
       encoding
-      @capture_window.encode(filename) { |percent, time_remaining| 
-        @progress_bar.fraction = percent 
-        @progress_bar.text = time_remaining
-        LOGGER.debug "Did progress #{percent.to_s} time remaining: #{time_remaining}"
-        percent < 1 || stop_encoding
-      }
-      LOGGER.debug "Back from encode"
+      spawn_encode(filename)
+      @@logger.debug "Encode spawned"
     }
   end
   
+=begin rdoc
+Encode in the background. If the background process fails, be able to pop
+up a window. Give feedback by calling the optional block with | fraction, message |.
+=end
+  def spawn_record
+    @background = Thread.new do
+      @capture_window.record do |percent, time_elapsed| 
+        @progress_bar.text = time_elapsed
+        @progress_bar.pulse
+        @@logger.debug "Did elapsed time: #{time_elapsed}"
+      end
+    end
+    @background
+  end
+  
+=begin rdoc
+Encode in the background. If the background process fails, be able to pop
+up a window. Give feedback by calling the optional block with | fraction, message |.
+=end
+  def spawn_encode(filename)
+    @background = Thread.new do
+      @capture_window.encode(filename) do |fraction, time_remaining| 
+        @progress_bar.pulse if fraction == 0
+        @progress_bar.fraction = fraction 
+        @progress_bar.text = time_remaining
+        @@logger.debug "Did progress #{fraction.to_s} time remaining: #{time_remaining}"
+        not_encoding if fraction >= 1
+      end
+    end
+    @background
+  end
+  
+=begin rdoc
+Check how the background process is doing.
+If there is none, or it's running fine, return true.
+If there was a background process but it failed, return false and
+ensure that the user doesn't get another 
+message about the same condition.
+=end
+  def check_background
+    # TODO: Partially implemented so far
+    return true if @background.nil? 
+    return true if @background.status
+    if ! background_exitstatus
+      @background = nil
+      return false
+    end
+    true 
+  end
+  
+  def background_exitstatus
+    return true if @background.nil?
+    @@logger.debug "background_exitstatus: #{@background.value.exitstatus}"
+    [0, 255].any? { | x | x == @background.value.exitstatus }
+  end
+  
+  def idle
+    error_dialog_tell_about_log unless check_background
+  end
+  
+  protected
   def stop_encoding
-    LOGGER.debug "Cancelled encoding"
+    @@logger.debug "Cancelled encoding"
     not_recording
     @capture_window.stop_encoding
   end
@@ -279,12 +311,12 @@ class ScreencasterGtk
     when :stopped
       # Do nothing
     else
-      LOGGER.error "#{__FILE__} #{__LINE__}: Can't happen (state #{@capture_window.state})."
+      @@logger.error "#{__FILE__} #{__LINE__}: Can't happen (state #{@capture_window.state})."
     end
   end
   
   def toggle_recording
-    LOGGER.debug "Toggle recording"
+    @@logger.debug "Toggle recording"
     return if @capture_window.nil?
     case @capture_window.state
     when :recording
@@ -296,10 +328,12 @@ class ScreencasterGtk
     when :stopped
       # Do nothing
     else
-      LOGGER.error "#{__FILE__} #{__LINE__}: Can't happen (state #{@capture_window.state})."
+      @@logger.error "#{__FILE__} #{__LINE__}: Can't happen (state #{@capture_window.state})."
     end
   end
   
+  ##### Methods to set sensitivity of controls
+  
   def recording
     self.status_icon.stock = Gtk::Stock::MEDIA_PAUSE
     @record_pause_button.image = PAUSE_IMAGE
@@ -378,36 +412,45 @@ class ScreencasterGtk
     self.status_icon.visible = false
   end
   
+  public
+  
+  # Shows the screencaster window and starts processing events from the user.
+  #
+  # The hot key toggles between capture and pause. 
+  # The default hot key is Ctrl+Alt+S.
   def main
-    LOGGER.info "Starting"
+    @@logger.info "Starting event loop"
     self.not_recording
     self.show_all_including_status
+    GLib::Idle.add { idle }
     Gtk.main
-    LOGGER.info "Finished"
+    @@logger.info "Finished"
   end
   
+  # Process command line arguments, set up the log file, and set up hot keys.
+  #
+  # * If there's another instance running for the user and the --pause or --start 
+  #   flags are present, send the USR1 signal to the running instance and exit.
+  # * Don't run the program if there's another instance running for the user.
+  # * If there's no other instance running for the user, and the --pause or --start 
+  #   flags are not present, start normally.
+  # *   The default hot key is Ctrl+Alt+S.
   def set_up
-    # Don't run the program if there's another instance running for the user.
-    # If there's another instance running for the user and the --pause or --start 
-    # flags are present, send the USR1 signal to the running instance
-    # and exit.
-    # If there's no other instance running for the user, and the --pause or --start 
-    # flags are not present, start normally.
     
     output_file = "/home/reid/test-key.log"
     
-    ScreencasterGtk::LOGGER.debug("pid_file is #{PIDFILE}")
+    @@logger.debug("pid_file is #{PIDFILE}")
     
     if File.exists? PIDFILE
       begin
         f = File.new(PIDFILE)
-        ScreencasterGtk::LOGGER.debug("Opened PIDFILE")
+        @@logger.debug("Opened PIDFILE")
         existing_pid = f.gets
         existing_pid = existing_pid.to_i
         f.close
-        ScreencasterGtk::LOGGER.debug("existing_pid = #{existing_pid.to_s}")
+        @@logger.debug("existing_pid = #{existing_pid.to_s}")
       rescue StandardError
-        LOGGER.error("File to read #{PIDFILE}")
+        @@logger.error("File to read #{PIDFILE}")
         exit 1
       end
     else
@@ -424,46 +467,57 @@ class ScreencasterGtk
       case opt
         when '--help'
           puts <<-EOF
-    screencaster [OPTION] ... 
-    
-    -h, --help:
-       show help
-    
-    -s, -p, --start, --pause:
-      Pause a running capture, or restart a paused capture
+screencaster [OPTION] ... 
+
+-h, --help:
+   show help
+
+-s, -p, --start, --pause:
+  Pause a running capture, or restart a paused capture
           EOF
           exit 0
         when '--pause', '--start'
           if existing_pid then
-            ScreencasterGtk::LOGGER.debug("Got a pause for PID #{existing_pid}")
+            @@logger.debug("Got a pause for PID #{existing_pid}")
             begin
               Process.kill "USR1", existing_pid
               exit 0
             rescue SystemCallError
-              LOGGER.info("Got a pause but PID #{existing_pid} didn't exist")
+              @@logger.info("Got a pause but PID #{existing_pid} didn't exist")
               exit 1
             end
           else
-            ScreencasterGtk::LOGGER.info("Got a pause but no PID")
+            @@logger.info("Got a pause but no PID")
             exit 1
           end 
       end
     end
     
     # TODO: Check for running process and if not, ignore PIDFILE.
-    (ScreencasterGtk::LOGGER.debug("Can't run two instances at once."); exit 1) if ! existing_pid.nil?
+    unless existing_pid.nil?
+      error_dialog_tell_about_log("Can't run two instances at once.")
+      exit 1 
+    end
     
+    # Add application properties for PulseAudio
+    # See: http://www.freedesktop.org/wiki/Software/PulseAudio/Documentation/Developer/Clients/ApplicationProperties/
+    # Unfortunately, this doesn't seem to help
+    # Perhaps because avconv is a separate program and is setting its own values
+    GLib::application_name = "Screencaster"
+    Gtk::Window.default_icon_name = "screencaster"
+    GLib::setenv("PULSE_PROP_media.role", "video")
+
     @chain = Signal.trap("EXIT") { 
-      LOGGER.debug "In ScreencasterGtk exit handler @chain: #{@chain}"
-      ScreencasterGtk::LOGGER.debug("Exiting")
-      ScreencasterGtk::LOGGER.debug("unlinking") if File.file?(PIDFILE)
+      @@logger.debug "In ScreencasterGtk exit handler @chain: #{@chain}"
+      @@logger.debug("Exiting")
+      @@logger.debug("unlinking") if File.file?(PIDFILE)
       File.unlink(PIDFILE) if File.file?(PIDFILE)
       `gconftool-2 --unset /apps/metacity/keybinding_commands/screencaster_pause`
       `gconftool-2 --unset /apps/metacity/global_keybindings/run_screencaster_pause`
-      LOGGER.debug "About to call next trap with @chain: #{@chain}"
+      @@logger.debug "About to call next trap with @chain: #{@chain}"
       @chain.call unless @chain.nil?
     }
-    LOGGER.debug "ScreencasterGtk.whatever @chain: #{@chain}"
+    @@logger.debug "ScreencasterGtk.whatever @chain: #{@chain}"
 
     `gconftool-2 --set /apps/metacity/keybinding_commands/screencaster_pause --type string "screencaster --pause"`
     `gconftool-2 --set /apps/metacity/global_keybindings/run_screencaster_pause --type string "<Control><Alt>S"`
@@ -473,18 +527,52 @@ class ScreencasterGtk
       f = File.new(PIDFILE, "w")
       f.puts(Process.pid.to_s)
       f.close
-      LOGGER.debug("Wrote PID #{Process.pid}")
+      @@logger.debug("Wrote PID #{Process.pid}")
     rescue StandardError
-      LOGGER.error("Failed to write #{PIDFILE}")
+      @@logger.error("Failed to write #{PIDFILE}")
       exit 1
     end
     
     Signal.trap("USR1") { 
-      ScreencasterGtk::LOGGER.debug("Pause/Resume") 
+      @@logger.debug("Pause/Resume") 
       self.toggle_recording
     }
     
-    $logger = ScreencasterGtk::LOGGER # TODO: Fix logging
+    $logger = @@logger # TODO: Fix logging
+  end
+  
+  # Helper functions
+  private
+  def add_button(label, box, sensitive = false, &callback)
+    b = Gtk::Button.new
+    b.image = label if label.is_a? Gtk::Image
+    b.label = label if label.is_a? String
+    b.sensitive = sensitive
+    b.signal_connect("clicked") { callback.call }
+    box.pack_start(b, true, false)
+    b
+  end
+  
+  public
+  def error_dialog_tell_about_log(msg = "", file = nil, line = nil)
+    d = Gtk::MessageDialog.new(@window, 
+      Gtk::Dialog::DESTROY_WITH_PARENT, 
+      Gtk::MessageDialog::WARNING, 
+      Gtk::MessageDialog::BUTTONS_CLOSE, 
+      "Internal Error")
+    
+    d.secondary_text = msg
+    d.secondary_text += " in #{file}" unless file.nil?
+    d.secondary_text += ", line: #{line}" unless line.nil?
+    d.secondary_text.strip!
+
+    @@logger.warn(d.secondary_text)
+
+    d.secondary_text += "\nLook in #{LOGFILE} for further information"
+    d.secondary_text.strip!
+    
+    d.run
+    d.destroy
   end
 end
 

data/lib/screencaster-gtk/capture.rb

@@ -2,13 +2,26 @@ require 'open3'
 require 'logger'
 require "screencaster-gtk/progresstracker"
 
+=begin rdoc
+Select a window or area of the screen to capture, capture it, and encode it.
+=end
 class Capture
   include ProgressTracker
   
   attr_writer :left, :top, :right, :bottom
   attr_reader :state
-  attr :pid
-  attr :tmp_files
+  attr_accessor :pid
+  attr_accessor :tmp_files
+
+  attr_accessor :capture_fps
+  attr_accessor :encode_fps
+  attr_accessor :capture_vcodec 
+  attr_accessor :qscale
+  attr_accessor :encode_vcodec
+  attr_accessor :acodec
+  attr_accessor :audio_sample_frequency
+  attr_accessor :audio_input
+  
   
   def initialize
     @tmp_files = []
@@ -17,8 +30,30 @@ class Capture
       $logger.debug "In capture about to chain to trap @exit_chain: #{@exit_chain}"
       @exit_chain.call unless @exit_chain.nil? 
     }
-    $logger.debug "@exit_chain: #{@exit_chain.to_s}"
+    #$logger.debug "@exit_chain: #{@exit_chain.to_s}"
+    
     @state = :stopped
+    @coprocess = nil
+    
+    @capture_fps = 30
+    @encode_fps = 30 # Don't use this. Just copy through
+    @capture_vcodec = 'huffyuv' # I used to use ffv1. This is for capture
+    @qscale = '4' # Recommended for fast encoding by avconv docs
+    @encode_vcodec = 'libx264'
+    @acodec = 'aac' # Youtube prefers "AAC-LC" but I don't see one called "-LC"
+    @audio_sample_frequency = "48k"
+    @audio_input = "pulse"
+  end
+  
+  def wait
+    $logger.debug "wait: Current thread #{Thread.current}"
+    @coprocess.value
+  end
+  
+  def status
+    $logger.debug "status: Current thread #{Thread.current}"
+    return false if @coprocess.nil?
+    @coprocess.status
   end
   
   def current_tmp_file
@@ -79,24 +114,6 @@ class Capture
     info =~ /Height:\s+([[:digit:]]+)/
     @height = $1.to_i
     
-    $logger.debug "Before xprop: Capturing #{@left.to_s},#{@top.to_s} to #{(@left+@width).to_s},#{(@top+@height).to_s}. Dimensions #{@width.to_s},#{@height.to_s}.\n"
-    
-    # Use xprop on the window to figure out decorations? Maybe...
-    # $logger.debug "Window ID: #{window_id}"
-    # info = `xprop -id #{window_id}`
-    # info =~ /_NET_FRAME_EXTENTS\(CARDINAL\) = ([[:digit:]]+), ([[:digit:]]+), ([[:digit:]]+), ([[:digit:]]+)/
-    # border_left = $1.to_i
-    # border_right = $2.to_i
-    # border_top = $3.to_i
-    # border_bottom = $4.to_i
-    # 
-    # $logger.debug "Borders: #{border_left.to_s},#{border_top.to_s},#{border_right.to_s},#{border_bottom.to_s}.\n"
-    # 
-    # top += border_top
-    # left += border_left
-    # height -= border_top + border_bottom
-    # width -= border_left + border_right
-    
     @height +=  @height % 2
     @width += @width % 2
 
@@ -112,60 +129,44 @@ class Capture
     output_file = self.new_tmp_file
 
     @state = :recording
-    capture_fps=24
-    audio_options="-f alsa -ac 1 -ab 192k -i pulse -acodec pcm_s16le"
+    audio_options="-f alsa -ac 1 -ab #{@audio_sample_frequency} -i #{@audio_input} -acodec #{@acodec}"
     
     # And i should probably popen here, save the pid, then fork and start
     # reading the input, updating the number of frames saved, or the time
     # recorded.
     $logger.debug "Capturing...\n"
-    # @pid = Process.spawn("avconv \
-        # #{audio_options} \
-        # -f x11grab \
-        # -show_region 1 \
-        # -r #{capture_fps} \
-        # -s #{@width}x#{@height} \
-        # -i :0.0+#{@left},#{@top} \
-        # -qscale 0 -vcodec ffv1 \
-        # -y \
-        # #{TMP_FILE}")
-    # Process.detach(@pid)
-    # avconv writes output to stderr, why?
-    # writes with CR and not LF, so it's hard to read
-    # with popen and 2>&1, an extra shell gets created that messed things up.
-    # popen2e helps.
-    vcodec = 'huffyuv' # I used to use ffv1
-    
+
     cmd_line = "avconv \
       #{audio_options} \
       -f x11grab \
       -show_region 1 \
-      -r #{capture_fps} \
+      -r #{@capture_fps} \
       -s #{@width}x#{@height} \
       -i :0.0+#{@left},#{@top} \
-      -qscale 0 -vcodec #{vcodec} \
+      -qscale #{@qscale} \
+      -vcodec #{@capture_vcodec} \
       -y \
       #{output_file}"
     
     $logger.debug cmd_line
 
-    i, oe, t = Open3.popen2e(cmd_line)
-    @pid = t.pid
-    Process.detach(@pid)
-    
     duration = 0.0
-    Thread.new do
-      while line = oe.gets("\r")
-        $logger.debug "****" + line
-        if (line =~ /time=([0-9]*\.[0-9]*)/)
-          duration = $1.to_f
-          $logger.debug "Recording about to yield #{self.total_amount + duration}"
-          yield 0.0, ProgressTracker::format_seconds(self.total_amount + duration)
-        end
+    i, oe, @coprocess = Open3.popen2e(cmd_line)
+    $logger.debug "record: co-process started #{@coprocess}"
+    @pid = @coprocess.pid
+  
+    while line = oe.gets("\r")
+      $logger.debug "****" + line
+      if (line =~ /time=([0-9]*\.[0-9]*)/)
+        duration = $1.to_f
+        $logger.debug "Recording about to yield #{self.total_amount + duration}"
+        yield 0.0, ProgressTracker::format_seconds(self.total_amount + duration) if block_given?
       end
-      self.total_amount += duration
-      yield 0.0, ProgressTracker::format_seconds(self.total_amount)
     end
+    self.total_amount += duration
+    yield 1.0, ProgressTracker::format_seconds(self.total_amount) if block_given?
+    $logger.debug "Leaving record"
+    @coprocess.value
   end
   
   def stop_recording
@@ -201,9 +202,8 @@ class Capture
     $logger.debug "Encoding #{Capture.format_input_files_for_mkvmerge(@tmp_files)}...\n"
     $logger.debug("Total duration #{self.total_amount.to_s}")
 
-    t = self.merge(Capture.tmp_file_name, @tmp_files)
-    t.value
-    self.final_encode(output_file, Capture.tmp_file_name, feedback)
+    merge(Capture.tmp_file_name, @tmp_files, feedback)
+    final_encode(output_file, Capture.tmp_file_name, feedback)
   end 
   
   # This is ugly.
@@ -222,73 +222,57 @@ class Capture
     else
       cmd_line = "mkvmerge -v -o #{output_file} #{Capture.format_input_files_for_mkvmerge(input_files)}"
     end
-    $logger.debug "Merge command line: #{cmd_line}"
-    i, oe, t = Open3.popen2e(cmd_line)
-    $logger.debug "Thread from popen2e: #{t}"
-    @pid = t.pid
-    Process.detach(@pid)
+    $logger.debug "merge: command line: #{cmd_line}"
+    i, oe, @coprocess = Open3.popen2e(cmd_line)
+    $logger.debug "merge: Thread from popen2e: #{@coprocess}"
+    @pid = @coprocess.pid
     $logger.debug "@pid: #{@pid.to_s}"
-    
-    t = Thread.new do
-      $logger.debug "Thread from Thread.new: #{t}"
-      # $logger.debug "Sleeping..."
-      # sleep 2
-      # $logger.debug "Awake!"
-      while l = oe.gets do
-        # TODO: Lots for duplicate code in this line to clean up.
-        if block_given? 
-          yield 0.5, ""
-        else
-          feedback.call 0.5, ""
-        end
-      end
-      if block_given?
-        yield 1.0, "Done"
+    while l = oe.gets do
+      # TODO: Lots of duplicate code in this line to clean up.
+      if block_given? 
+        yield 0.5, "Merging..."
       else
-        feedback.call 1.0, "Done"
+        feedback.call 0.5, "Merging..."
       end
     end
-    return t
+    if block_given?
+      yield 1.0, "Done"
+    else
+      feedback.call 1.0, "Done"
+    end
+    @coprocess.value
   end
   
   def final_encode(output_file, input_file, feedback = proc {} )
-    encode_fps=24
-    video_encoding_options="-vcodec libx264 -pre:v ultrafast"
-    
     # I think I want to popen here, save the pid, then fork and start
-    # updating progress based on what I read, which the main body
+    # updating progress based on what I read, while the main body
     # returns and carries on.
     
-    # The following doesn't seem to be necessary
-#      -s #{@width}x#{@height} \
     cmd_line = "avconv \
       -i #{input_file} \
-      #{video_encoding_options} \
-      -r #{encode_fps} \
-      -threads 0 \
+      -vcodec #{@encode_vcodec} \
       -y \
       '#{output_file}'"
       
     $logger.debug cmd_line
     
-    i, oe, t = Open3.popen2e(cmd_line)
-    @pid = t.pid
-    Process.detach(@pid)
-    
-    Thread.new do
-      while (line = oe.gets("\r"))
-        $logger.debug "****" + line
-        if (line =~ /time=([0-9]*\.[0-9]*)/) 
-          $logger.debug '******' + $1
-          self.current_amount = $1.to_f
-        end
-        $logger.debug "******** #{self.current_amount} #{self.fraction_complete}"
-        feedback.call self.fraction_complete, self.time_remaining_s
+    i, oe, @coprocess = Open3.popen2e(cmd_line)
+    @pid = @coprocess.pid
+
+    while (line = oe.gets("\r"))
+      $logger.debug "****" + line
+      if (line =~ /time=([0-9]*\.[0-9]*)/) 
+        $logger.debug '******' + $1
+        self.current_amount = $1.to_f
       end
-      $logger.debug "reached end of file"
-      @state = :stopped
-      feedback.call self.fraction_complete = 1, self.time_remaining_s
+      $logger.debug "******** #{self.current_amount} #{self.fraction_complete}"
+      feedback.call self.fraction_complete, self.time_remaining_s
     end
+    $logger.debug "reached end of file"
+    @state = :stopped
+    self.fraction_complete = 1
+    feedback.call self.fraction_complete, self.time_remaining_s
+    @coprocess.value # A little bit of a head game here. Either return this, or maybe have to do t.value.value in caller
   end
   
   def stop_encoding

data/lib/screencaster-gtk/progresstracker.rb

@@ -1,7 +1,10 @@
 module ProgressTracker
-  attr_reader :start_time
   attr_writer :start_time, :total_amount
   
+  def start_time
+    @start_time || @start_time = Time.now
+  end
+
   def percent_complete
     self.fraction_complete * 100
   end
@@ -19,9 +22,7 @@ module ProgressTracker
   end
 
   def current_amount=(amt)
-    @start_time || @start_time = Time.new
-
-    # puts "Setting current_amount #{amt}"
+    self.start_time
     @current_amount = amt
   end
   
@@ -30,7 +31,11 @@ module ProgressTracker
   end
   
   def time_remaining
-    (Time.new - @start_time) * (1 - self.fraction_complete) / self.fraction_complete
+    if self.fraction_complete == 0.0
+      1.0
+    else
+      (Time.new - self.start_time) * (1 - self.fraction_complete) / self.fraction_complete
+    end
   end
   
   def time_remaining_s(format = "%dh %02dm %02ds remaining")

data/lib/screencaster-gtk/savefile.rb

@@ -1,6 +1,13 @@
 require 'gtk2'
 
+=begin rdoc
+Run the standard save file dialog for screencaster
+=end
 class SaveFile
+  
+=begin rdoc
+Create the file chooser dialogue with a default file name.
+=end
   def self.set_up_dialog(file_name = "output.mp4")
     @dialog = Gtk::FileChooserDialog.new(
         "Save File As ...",
@@ -10,22 +17,15 @@ class SaveFile
         [ Gtk::Stock::CANCEL, Gtk::Dialog::RESPONSE_CANCEL ],
         [ Gtk::Stock::SAVE, Gtk::Dialog::RESPONSE_ACCEPT ]
     )
-    # dialog.signal_connect('response') do |w, r|
-      # odg = case r
-        # when Gtk::Dialog::RESPONSE_ACCEPT
-          # filename = dialog.filename
-          # "'ACCEPT' (#{r}) button pressed -- filename is {{ #{filename} }}"
-        # when Gtk::Dialog::RESPONSE_CANCEL;   "'CANCEL' (#{r}) button pressed"
-        # else; "Undefined response ID; perhaps Close-x? (#{r})"
-      # end
-      # puts odg
-      # dialog.destroy 
-    # end
     @dialog.current_name = GLib.filename_to_utf8(file_name)
     @dialog.current_folder = GLib.filename_to_utf8(Dir.getwd)
     @dialog.do_overwrite_confirmation = true
   end
   
+=begin rdoc
+Do the workflow around saving a file, warning the user before allow
+them to abandon their capture.
+=end
   def self.get_file_to_save
     @dialog || SaveFile.set_up_dialog
     result = @dialog.run
@@ -43,6 +43,10 @@ class SaveFile
     end
   end
   
+=begin rdoc
+Confirm cancellation when the user has captured something but not
+saved it.
+=end
   def self.confirm_cancel(parent)
     dialog = Gtk::Dialog.new(
       "Confirm Cancel",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: screencaster-gtk
 version: !ruby/object:Gem::Version
-  version: 0.0.4.alpha1
+  version: 0.0.5.alpha1
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-29 00:00:00.000000000 Z
+date: 2013-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gdk_pixbuf2
@@ -141,3 +141,4 @@ signing_key:
 specification_version: 3
 summary: Screencaster
 test_files: []
+has_rdoc: