easy_mplayer 1.0.0

data/lib/easy_mplayer/callback.rb

@@ -0,0 +1,54 @@
+class MPlayer
+  class Callback # :nodoc:all
+    def initialize(callback_options)
+      @block = callback_options[:block]
+      @type  = callback_options[:type]
+      @scope = callback_options[:scope]
+    end
+    
+    def run!(args)
+      unless @block.nil?
+        case @type
+        when :instance then @block.call(*args)
+        when :class    then @scope.instance_exec(*args, &@block)
+        end
+      end
+    end
+  end
+  
+  class CallbackList < Array # :nodoc:all
+    attr_reader :name
+    
+    def initialize(list_name)
+      @name = list_name.to_sym
+    end
+
+    def register(opts)
+      push Callback.new(opts)
+    end
+
+    def run!(args)
+      each do |x|
+        x.run!(args)
+      end
+    end
+
+    class << self
+      def all
+        @all ||= Hash.new
+      end
+      
+      def find(name)
+        all[name.to_sym] ||= new(name)
+      end
+
+      def register(opts)
+        find(opts[:name]).register(opts)
+      end
+
+      def run!(name, args)
+        find(name).run!(args)
+      end
+    end
+  end
+end

data/lib/easy_mplayer/commands.rb

@@ -0,0 +1,83 @@
+class MPlayer
+  class Command # :nodoc:all
+    class << self
+      def cmdlist_raw
+        @cmdlist_raw ||= `mplayer -input cmdlist`.split(/\n/)
+      end
+
+      def list
+        @list ||= returning Hash.new do |hsh|
+          cmdlist_raw.map do |line|
+            cmd, *opts = line.split(/\s+/)
+            hsh[cmd.to_sym] = new(cmd, opts)
+          end
+        end
+      end
+
+      def find(name)
+        list[name.to_sym]
+      end
+
+      def validate!(args)
+        cmd = args.shift
+        obj = find(cmd)
+        raise BadCallName.new(cmd, args) unless obj
+        obj.validate!(args)
+      end
+    end
+
+    attr_reader :cmd, :names, :opts, :max, :min
+
+    def initialize(command_name, opt_list)
+      @cmd   = command_name
+      @min   = 0
+      @max   = opt_list.length
+      @names = opt_list
+      @opts  = opt_list.map do |opt|
+        @min += 1 if opt[0,1] != '['
+        case opt
+        when 'Integer', '[Integer]' then :int
+        when 'Float',   '[Float]'   then :float
+        when 'String',  '[String]'  then :string
+        else raise "Unknown cmd option type: #{opt}"
+        end
+      end
+    end
+
+    def usage
+      "#{cmd}(" + names.join(", ") + ")"
+    end
+
+    def to_s
+      usage
+    end
+
+    def inspect
+      "#<#{self.class} \"#{usage}\">"
+    end
+
+    def convert_arg_type(val, type)
+      begin
+        case type
+        when :int    then Integer(val)
+        when :float  then Float(val)
+        when :string then val.to_s
+        end
+      rescue
+        nil
+      end
+    end
+
+    def validate!(args)
+      len = args.length
+      raise BadCallArgs.new(self, args, "not enough args") if len < min
+      raise BadCallArgs.new(self, args, "too many args")   if len > max
+      returning Array.new do |new_args|
+        args.each_with_index do |x,i|
+          new_args.push convert_arg_type(x, opts[i]) or
+            raise BadCallArgs.new(self, args, "type mismatch")
+        end
+      end
+    end
+  end
+end

data/lib/easy_mplayer/errors.rb

@@ -0,0 +1,106 @@
+class MPlayer
+  module Error # :nodoc:all
+    # all errors thrown form this library will be of this type
+    class MPlayerError  < RuntimeError
+    end
+
+    class StartupError  < MPlayerError
+      attr_reader :path
+      
+      def to_s
+        str = "Missing startup requirement!\n"
+        str += "File \"#{path}\" does not exist!\n" unless File.exists?(path)
+      end
+      
+      def initialize(path)
+        @path = path
+        super(to_s)
+      end
+    end
+
+    class NoPlayerFound < StartupError
+      def to_s
+        str = super
+        str += "File \"#{path}\" is not executable!\n" unless File.executable?(path)
+      end
+    end
+
+    class NoTargetPath  < StartupError
+      def to_s
+        str = super
+        str += "file \"#{path}\" is not readable!\n" unless File.readable?(path)
+      end
+    end
+
+    # some unknown error having to do with the streams/threads that
+    # connect us to the mplayer process
+    class BadStream    < MPlayerError
+    end
+
+    # tried to change to a different level of output that doesn't exist
+    class BadMsgType   < MPlayerError
+      attr_reader :badtype
+      
+      def valid_types # :nodoc:
+        DEBUG_MESSAGE_TYPES.keys.inspect
+      end
+      
+      def to_s # :nodoc:
+        "Bad debug message type \"#{badtype}\"\nValid types " + valid_types
+      end
+      
+      def initialize(type)
+        @badtype = type
+        super(to_s)
+      end
+    end
+    
+    # an error in sending a command to mplayer over its slave-mode API
+    class BadCall      < MPlayerError
+      attr_reader :cmd, :args
+
+      # a type-prototype of how we attempted the mplayer API call
+      def called_as
+        "#{cmd}(" + args.map do |x|
+          x.class
+        end.join(", ") + ")"
+      end
+
+      def to_s
+        "\nBad MPlayer call: #{called_as}"
+      end
+      
+      def initialize(command, called_args)
+        @cmd  = command
+        @args = called_args
+        super(to_s)
+      end
+    end
+
+    # tried to pass a slave-mode command to mplayer, but the call didn't
+    # match the API prototype mplayer itself provided
+    class BadCallArgs  < BadCall
+      attr_reader :msg, :usage
+      
+      def to_s # :nodoc:
+        super + " - #{msg}\nusage: #{usage}"
+      end
+      
+      
+      def initialize(command, called_args, message)
+        @msg   = message
+        @usage = command.usage
+        super(command.cmd, called_args)
+      end
+    end
+    
+    # not a valid command name
+    class BadCallName  < BadCall
+      def to_s
+        super + "\nNo such command \"#{cmd.inspect}\""
+      end
+    end
+  end
+  
+  include Error
+end

data/lib/easy_mplayer/helpers.rb

@@ -0,0 +1,91 @@
+class MPlayer
+  # a blocking version of #play for trivial uses. It returns only
+  # after the mplayer process finally terminates itself
+  def play_to_end
+    play
+    sleep 1 while running?
+  end
+  
+  # spawn the mplayer process, which also starts the media playing. It
+  # is requires that #opts[:path] point to a valid media file
+  def play
+    stop if running?
+    
+    info "PLAY: #{opts[:path]}"
+    worker.startup!
+  end
+  
+  # kill off the mplayer process. This invalidates any running media,
+  # though it can be restarted again with another call to #play
+  def stop
+    info "STOP!"
+    @worker.shutdown! if @worker
+  end
+  
+  # pause playback if we are running
+  def pause
+    return if paused?
+    info "PAUSE!"
+    send_command :pause
+    @paused = true
+    callback! :pause, true
+  end
+  
+  # opposite of #pause
+  def unpause
+    return unless paused?
+    info "UNPAUSE!"
+    send_command :pause
+    @paused = false
+    callback! :unpause, false
+  end
+  
+  # use this instead of #pause or #unpause, and the flag will be
+  # toggled with each call
+  def pause_or_unpause
+    paused? ? unpause : pause
+  end
+  
+  # Seek to an absolute position in a file, by percent of the total size.
+  # requires a float argument, that is <tt>(0.0 <= percent <= 100.0)</tt>
+  def seek_to_percent(percent)
+    return if percent.to_i == @stats[:position]
+    percent = percent.to_f
+    percent = 0.0   if percent < 0
+    percent = 100.0 if percent > 100
+    info "SEEK TO: #{percent}%"
+    send_command :seek, percent, 1
+  end
+  
+  # seek to an absolute position in a file, by seconds. requires a
+  # float between 0.0 and the length (in seconds) of the file being played.
+  def seek_to_time(seconds)
+    info "SEEK TO: #{seconds} seconds"
+    send_command :seek, seconds, 1
+  end
+  
+  # seek by a relative amount, in seconds. requires a float. Negative
+  # values rewind to a previous point.
+  def seek_by(amount)
+    info "SEEK BY: #{amount}"
+    send_command :seek, amount, 0
+  end
+  
+  # seek forward a given number of seconds, or
+  # <tt>opts[:seek_size]</tt> seconds by default
+  def seek_forward(amount = opts[:seek_size])
+    seek_by(amount)
+  end
+  
+  # seek backwards (rewind) by a given number of seconds, or
+  # <tt>opts[:seek_size]</tt> seconds by default. Note that a
+  # /positive/ value here rewinds!
+  def seek_reverse(amount = opts[:seek_size])
+    seek_by(-amount)
+  end
+  
+  # reset back to the beginning of the file
+  def seek_start
+    seek_to_percent(0.0)
+  end
+end

data/lib/easy_mplayer/main.rb

@@ -0,0 +1,180 @@
+class MPlayer
+  # all of these can be overridden by passing them to #new
+  DEFAULT_OPTS = {
+    :program               => '/usr/bin/mplayer',
+    :message_style         => :info,
+    :seek_size             => 10,
+    :select_wait_time      => 1,
+    :thread_safe_callbacks => true
+  }
+  
+  # the color_debug_message parameter sets we can switch
+  # between, for convenience. (flags for ColorDebugMessages)
+  DEBUG_MESSAGE_TYPES = {
+    :quiet => {
+    },
+    :error_only => {
+      :warn       => true
+    },
+    :info => {
+      :warn       => true,
+      :info       => true
+    },
+    :debug => {
+      :warn       => true,
+      :info       => true,
+      :debug      => true,
+      :class_only => false
+    }
+  }
+
+  attr_reader :callbacks, :stats, :opts
+
+  class << self
+    def class_callbacks # :nodoc:
+      @@class_callbacks ||= Array.new
+    end
+    
+    # register a block with the named callback(s). This is the same
+    # as the instance-method, generally, but it uses instance_exec to
+    # give the block the same scope (the MPlayer instance)
+    def callback(*names, &block)
+      names.each do |name|
+        class_callbacks << {
+          :name  => name,
+          :type  => :class,
+          :block => block
+        }
+      end
+    end
+  end
+  
+  # create a new object. The option hash must have, at a minimum, a
+  # :path reference to the file we want to play, or an exception will
+  # be raised.
+  def initialize(new_opts=Hash.new)
+    @opts = DEFAULT_OPTS.merge(new_opts)
+    set_message_style opts[:message_style]
+    
+    unless File.executable?(@opts[:program])
+      raise NoPlayerFound.new(@opts[:program]) 
+    end
+    unless @opts[:path] and File.readable?(new_opts[:path])
+      raise NoTargetPath.new(@opts[:path]) 
+    end
+    
+    @stats     = Hash.new
+    @callbacks = Hash.new
+    @worker    = nil
+
+    self.class.class_callbacks.each do |opts|
+      opts[:scope] = self
+      CallbackList.register opts
+    end
+  end
+
+  callback :update_stat do |*args|
+    update_stat *args
+  end
+
+  callback :file_error do
+    warn "File error!"
+    stop!
+  end
+
+  callback :played_time do |played_time|
+    update_stat :played_seconds, played_time.to_i
+    total = stats[:total_time]
+    if total and total != 0.0
+      pos = (100 * played_time / total)
+      update_stat :raw_position, pos
+      update_stat :position,     pos.to_i
+    end
+  end
+  
+  callback :startup do
+    callback! :play
+  end
+  
+  callback :shutdown do
+    @worker = nil
+    callback! :stop
+  end
+
+  # can be any of:
+  #   :quiet      Supperss all output!
+  #   :error_only Off except for errors
+  #   :info       Also show information messages
+  #   :debug      Heavy debug output (spammy)
+  def set_message_style(type)
+    hsh = DEBUG_MESSAGE_TYPES[type.to_sym] or
+      raise BadMsgType.new(type.inspect)
+    hsh = hsh.dup
+    hsh[:debug]       ||= false
+    hsh[:info]        ||= false
+    hsh[:warn]        ||= false
+    hsh[:class_only]  ||= true
+    hsh[:prefix_only] ||= false
+    ColorDebugMessages.global_debug_flags(hsh)
+    opts[:message_style] = type
+  end
+  
+  def inspect # :nodoc:
+    vals = [['running', running?],
+            ['paused',  paused?]]
+    vals << ['info', stats.inspect] if running?
+    "#<#{self.class} " + vals.map do |x|
+      x.first + '=' + x.last.to_s
+    end.join(' ') + '>'
+  end
+
+  # call an entire callback chain, passing in a list of args
+  def callback!(name, *args) # :nodoc:
+    #puts "CALLBACK! #{name.inspect} #{args.inspect}"
+    CallbackList.run!(name, args)
+  end
+  
+  # register a function into each of the named callback chains
+  def callback(*names, &block)
+    names.each do |name|
+      CallbackList.register :name => name, :block => block, :type => :instance
+    end
+  end
+  
+  # true if we are running, yet the media has stopped
+  def paused?
+    @paused
+  end
+
+  # true if the mplayer process is active and running
+  def running?
+    !!@worker and @worker.ok?
+  end
+  
+  # pipe a command to mplayer via slave mode
+  def send_command(*args)
+    worker.send_command(*args)
+  end
+  
+  def worker # :nodoc:
+    create_worker if @worker.nil?
+    @worker
+  end
+
+  def create_worker # :nodoc:
+    callback! :creating_worker
+    @worker = Worker.new(self)
+    @stats  = Hash.new
+    @paused = false
+    callback! :worker_running
+  end
+  
+  def update_stat(name, newval) # :nodoc:
+    name = name.to_sym
+    if @stats[name] != newval
+      debug "STATS[:#{name}] -> #{newval.inspect}"
+      @stats[name] = newval
+      callback! name, newval
+    end
+  end
+end