mmplayer 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d59002ee9d5711a811c980108d0e29c41b19811
-  data.tar.gz: 66a9b65bfb2b421e4fdcba73a04eec30123610af
+  metadata.gz: 14f79ab624c5547f520491380f1fd012f649daad
+  data.tar.gz: a2387b2bdd5e1787dbb3a5913cd9518633a69b58
 SHA512:
-  metadata.gz: a6b900ed7f38488e1f8705a0f4facdf0cf0dc6d44b0fae68c4fb2d06cb5b55b262637890d0c737640b7ca345df1d882a01cbfe1f5b505b44a619db4a2e8461cd
-  data.tar.gz: 9d8b70983896579a071930a32dc9a4de903694383fb7d30cdb4efcf144125ec6dd2ef2d0bab7c78851e6310102f9f1e98333dd3d2bca22c1519b04bf66992014
+  metadata.gz: 10967965c48de9cb4053ce32b41b907b18e1ecc54b33e23f4c9cd63f8d1ca6c7f991ed02fc2694fd5bbd42774874f6eb9a8cafdfcf77b8196a3e9e92f345d57f
+  data.tar.gz: 1c21b76e1044de417220d6706bba6b1300f11d90da9e437ef0a14ecaa1cae550738298b3f679414acfd32946fda2444be6bfb597ca2d897ed717c0e7b5d8deb9

data/lib/mmplayer.rb

@@ -13,18 +13,16 @@ require "unimidi"
 
 # modules
 require "mmplayer/helper/numbers"
-require "mmplayer/instructions/midi"
-require "mmplayer/instructions/player"
+require "mmplayer/instructions"
+require "mmplayer/midi"
+require "mmplayer/player"
 
 # classes
 require "mmplayer/context"
-require "mmplayer/message_handler"
-require "mmplayer/midi"
-require "mmplayer/player"
 
 module MMPlayer
 
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 
   # Shortcut to Context constructor
   def self.new(*args, &block)

data/lib/mmplayer/context.rb

@@ -15,8 +15,8 @@ module MMPlayer
     # @option options [Fixnum] :receive_channel (also: :rx_channel) A MIDI channel to subscribe to. By default, responds to all
     # @yield
     def initialize(midi_input, options = {}, &block)
-      @midi = MIDI.new(midi_input, :receive_channel => options[:receive_channel] || options[:rx_channel])
-      @player = Player.new(:flags => options[:mplayer_flags])
+      @midi = MIDI::Wrapper.new(midi_input, :receive_channel => options[:receive_channel] || options[:rx_channel])
+      @player = Player::Wrapper.new(:flags => options[:mplayer_flags])
       instance_eval(&block) if block_given?
     end
 

data/lib/mmplayer/instructions.rb

@@ -0,0 +1,9 @@
+require "mmplayer/instructions/midi"
+require "mmplayer/instructions/player"
+
+module MMPlayer
+
+  module Instructions
+  end
+
+end

data/lib/mmplayer/instructions/player.rb

@@ -5,6 +5,14 @@ module MMPlayer
     # Instructions dealing with the MPlayer
     module Player
 
+      # Assign a callback for updating progress
+      # @param [Proc] callback The callback to execute when progress is updated
+      # @return [Hash]
+      def on_progress(&callback)
+        @player.add_progress_callback(&callback)
+      end
+      alias_method :progress, :on_progress
+
       # Assign a callback for when a file finishes playback
       # @param [Proc] callback The callback to execute when a file finishes playback
       # @return [Hash]
@@ -19,7 +27,7 @@ module MMPlayer
       # Add delegators to local player methods
       def self.included(base)
         base.send(:extend, Forwardable)
-        base.send(:def_delegators, :@player, :active?, :play, :progress)
+        base.send(:def_delegators, :@player, :active?, :play)
       end
 
       # Add all of the MPlayer::Slave methods to the context as instructions

data/lib/mmplayer/midi.rb

@@ -1,83 +1,9 @@
-module MMPlayer
-
-  # Wrapper for MIDI functionality
-  class MIDI
-
-    attr_reader :channel, :config, :listener, :message_handler
-
-    # @param [UniMIDI::Input] input
-    # @param [Hash] options
-    # @option options [Fixnum] :receive_channel A MIDI channel to subscribe to. By default, responds to all
-    def initialize(input, options = {})
-      @channel = options[:receive_channel]
-      @message_handler = MessageHandler.new
-      @listener = MIDIEye::Listener.new(input)
-    end
-
-    # Add a callback for a given MIDI system message
-    # @param [String, Symbol] command The MIDI system command eg :start, :stop
-    # @param [Proc] callback The callback to execute when the given MIDI command is received
-    # @return [Hash]
-    def add_system_callback(command, &callback)
-      @message_handler.add_callback(:system, command, &callback)
-    end
-
-    # Add a callback for a given MIDI note
-    # @param [Fixnum, String, nil] note The MIDI note to add a callback for eg 64 "E4"
-    # @param [Proc] callback The callback to execute when the given MIDI note is received
-    # @return [Hash]
-    def add_note_callback(note, &callback)
-      @message_handler.add_note_callback(note, &callback)
-    end
-
-    # Add a callback for a given MIDI control change
-    # @param [Fixnum, nil] index The MIDI control change index to add a callback for eg 10
-    # @param [Proc] callback The callback to execute when the given MIDI control change is received
-    # @return [Hash]
-    def add_cc_callback(index, &callback)
-      @message_handler.add_callback(:cc, index, &callback)
-    end
+require "mmplayer/midi/message_handler"
+require "mmplayer/midi/wrapper"
 
-    # Stop the MIDI listener
-    # @return [Boolean]
-    def stop
-      @listener.stop
-    end
-
-    # Change the subscribed MIDI channel (or nil for all)
-    # @param [Fixnum, nil] channel
-    # @return [Fixnum, nil]
-    def channel=(channel)
-      @listener.event.clear
-      @channel = channel
-      populate_listener if @listener.running?
-      @channel
-    end
-
-    # Start the MIDI listener
-    # @return [Boolean]
-    def start
-      populate_listener
-      @listener.start(:background => true)
-      true
-    end
-
-    # Whether the player is subscribed to all channels
-    # @return [Boolean]
-    def omni?
-      @channel.nil?
-    end
-
-    private
-
-    # Populate the MIDI listener callback
-    def populate_listener
-      @listener.on_message do |event|
-        message = event[:message]
-        @message_handler.process(@channel, message)
-      end
-    end
+module MMPlayer
 
+  module MIDI
   end
 
 end

data/lib/mmplayer/midi/message_handler.rb

@@ -0,0 +1,112 @@
+module MMPlayer
+
+  module MIDI
+    # Directs what should happen when messages are received
+    class MessageHandler
+
+      attr_reader :callback
+
+      def initialize
+        @callback = {
+          :cc => {},
+          :note => {},
+          :system => {}
+        }
+      end
+
+      # Add a callback for a given MIDI message type
+      # @param [Symbol] type The MIDI message type (eg :note, :cc)
+      # @param [Fixnum, String] key The ID of the message eg note number/cc index
+      # @param [Proc] callback The callback to execute when the given MIDI command is received
+      # @return [Hash]
+      def add_callback(type, key, &callback)
+        @callback[type][key] = callback
+        @callback[type]
+      end
+
+      # Add a callback for a given MIDI note
+      # @param [Symbol] type The MIDI message type (eg :note, :cc)
+      # @param [Fixnum, String] note
+      # @param [Proc] callback The callback to execute when the given MIDI command is received
+      # @return [Hash]
+      def add_note_callback(note, &callback)
+        note = MIDIMessage::Constant.value(:note, note) if note.kind_of?(String)
+        add_callback(:note, note, &callback)
+      end
+
+      # Process a message for the given channel
+      # @param [Fixnum, nil] channel
+      # @param [MIDIMessage] message
+      # @return [Boolean, nil]
+      def process(channel, message)
+        case message
+        when MIDIMessage::SystemCommon, MIDIMessage::SystemRealtime then system_message(message)
+        else
+          channel_message(channel, message)
+        end
+      end
+
+      # Find and call a note received callback if it exists
+      # @param [MIDIMessage] message
+      # @return [Boolean, nil]
+      def note_message(message)
+        call_callback(:note, message.note, message.velocity) |
+        call_catch_all_callback(:note, message)
+      end
+
+      # Find and call a cc received callback if it exists
+      # @param [MIDIMessage] message
+      # @return [Boolean, nil]
+      def cc_message(message)
+        call_callback(:cc, message.index, message.value) |
+        call_catch_all_callback(:cc, message)
+      end
+
+      # Find and call a system message callback if it exists
+      # @param [MIDIMessage] message
+      # @return [Boolean, nil]
+      def system_message(message)
+        name = message.name.downcase.to_sym
+        call_callback(:system, name)
+      end
+
+      # Find and call a channel message callback if it exists for the given message and channel
+      # @param [Fixnum, nil] channel
+      # @param [MIDIMessage] message
+      # @return [Boolean, nil]
+      def channel_message(channel, message)
+        if channel.nil? || message.channel == channel
+          case message
+          when MIDIMessage::NoteOn then note_message(message)
+          when MIDIMessage::ControlChange then cc_message(message)
+          end
+        end
+      end
+
+      private
+
+      # Execute the catch-all callback for the given type if it exists
+      # @param [Symbol] type
+      # @param [MIDIMessage] message
+      # @return [Boolean]
+      def call_catch_all_callback(type, message)
+        call_callback(type, nil, message)
+      end
+
+      # Execute the callback for the given type and key and pass it the given args
+      # @param [Symbol] type
+      # @param [Object] key
+      # @param [*Object] arguments
+      # @return [Boolean]
+      def call_callback(type, key, *arguments)
+        unless (callback = @callback[type][key]).nil?
+          callback.call(*arguments)
+          true
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/mmplayer/midi/wrapper.rb

@@ -0,0 +1,85 @@
+module MMPlayer
+
+  module MIDI
+    # Wrapper for MIDI functionality
+    class Wrapper
+
+      attr_reader :channel, :config, :listener, :message_handler
+
+      # @param [UniMIDI::Input] input
+      # @param [Hash] options
+      # @option options [Fixnum] :receive_channel A MIDI channel to subscribe to. By default, responds to all
+      def initialize(input, options = {})
+        @channel = options[:receive_channel]
+        @message_handler = MessageHandler.new
+        @listener = MIDIEye::Listener.new(input)
+      end
+
+      # Add a callback for a given MIDI system message
+      # @param [String, Symbol] command The MIDI system command eg :start, :stop
+      # @param [Proc] callback The callback to execute when the given MIDI command is received
+      # @return [Hash]
+      def add_system_callback(command, &callback)
+        @message_handler.add_callback(:system, command, &callback)
+      end
+
+      # Add a callback for a given MIDI note
+      # @param [Fixnum, String, nil] note The MIDI note to add a callback for eg 64 "E4"
+      # @param [Proc] callback The callback to execute when the given MIDI note is received
+      # @return [Hash]
+      def add_note_callback(note, &callback)
+        @message_handler.add_note_callback(note, &callback)
+      end
+
+      # Add a callback for a given MIDI control change
+      # @param [Fixnum, nil] index The MIDI control change index to add a callback for eg 10
+      # @param [Proc] callback The callback to execute when the given MIDI control change is received
+      # @return [Hash]
+      def add_cc_callback(index, &callback)
+        @message_handler.add_callback(:cc, index, &callback)
+      end
+
+      # Stop the MIDI listener
+      # @return [Boolean]
+      def stop
+        @listener.stop
+      end
+
+      # Change the subscribed MIDI channel (or nil for all)
+      # @param [Fixnum, nil] channel
+      # @return [Fixnum, nil]
+      def channel=(channel)
+        @listener.event.clear
+        @channel = channel
+        populate_listener if @listener.running?
+        @channel
+      end
+
+      # Start the MIDI listener
+      # @return [Boolean]
+      def start
+        populate_listener
+        @listener.start(:background => true)
+        true
+      end
+
+      # Whether the player is subscribed to all channels
+      # @return [Boolean]
+      def omni?
+        @channel.nil?
+      end
+
+      private
+
+      # Populate the MIDI listener callback
+      def populate_listener
+        @listener.on_message do |event|
+          message = event[:message]
+          @message_handler.process(@channel, message)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mmplayer/player.rb

@@ -1,248 +1,11 @@
-module MMPlayer
-
-  # Wrapper for MPlayer functionality
-  class Player
-
-    # @param [Hash] options
-    # @option options [String] :flags MPlayer command-line flags to use on startup
-    def initialize(options = {})
-      @flags = "-fixed-vo -idle"
-      @flags += " #{options[:flags]}" unless options[:flags].nil?
-      @messenger = Messenger.new
-      @callback = {}
-      @playback_state = {
-        :eof => false,
-        :play => false,
-        :pause => false
-      }
-      @player_threads = []
-    end
-
-    # Play a media file
-    # @param [String] file
-    # @return [Boolean]
-    def play(file)
-      ensure_player(file)
-      if @player.nil?
-        false
-      else
-        with_player_thread do
-          @player.load_file(file)
-          handle_start
-        end
-        true
-      end
-    end
-
-    # Is MPlayer active?
-    # @return [Boolean]
-    def active?
-      !@player.nil?
-    end
-
-    # Is the player paused?
-    # @return [Boolean]
-    def paused?
-      @playback_state[:pause]
-    end
-    alias_method :pause?, :paused?
-
-    # Toggles pause
-    # @return [Boolean]
-    def pause
-      @playback_state[:pause] = !@playback_state[:pause]
-      @player.pause
-      @playback_state[:pause]
-    end
-
-    # Handle events while the player is running
-    # @return [Boolean]
-    def playback_loop
-      loop do
-        handle_eof if eof?
-        sleep(0.05)
-      end
-      true
-    end
-
-    # Add a callback to be called at the end of playback of a media file
-    # @param [Proc] block
-    # @return [Boolean]
-    def add_end_of_file_callback(&block)
-      @callback[:end_of_file] = block
-      true
-    end
-
-    # Media progress information
-    # eg {
-    #  :length => 90.3,
-    #  :percent => 44,
-    #  :position => 40.1
-    # }
-    # Length and position are in seconds
-    # @return [Hash, nil]
-    def progress
-      unless (time = poll_mplayer_progress).nil?
-        time[:percent] = get_percentage(time)
-        time
-      end
-    end
-
-    # Shortcut to send a message to the MPlayer
-    # @return [Object]
-    def mplayer_send(method, *args, &block)
-      if @player.nil? && MPlayer::Slave.method_defined?(method)
-        # warn
-      else
-        @messenger.send_message { @player.send(method, *args, &block) }
-      end
-    end
-
-    # Does the MPlayer respond to the given message?
-    # @return [Boolean]
-    def mplayer_respond_to?(method, include_private = false)
-      (@player.nil? && MPlayer::Slave.method_defined?(method)) ||
-      @player.respond_to?(method)
-    end
-
-    # Cause MPlayer to exit
-    # @return [Boolean]
-    def quit
-      @player.quit
-      @player_threads.each(&:kill)
-      true
-    end
-
-    private
-
-    # Has the end of a media file been reached?
-    # @return [Boolean]
-    def eof?
-      @playback_state[:play] && !@playback_state[:eof] && !@playback_state[:pause] && get_player_output.size < 1
-    end
-
-    # Get player output from stdout
-    def get_player_output
-      @player.stdout.gets.inspect.strip.gsub(/(\\n|[\\"])/, '').strip
-    end
+require "mmplayer/player/invoker"
+require "mmplayer/player/messenger"
+require "mmplayer/player/state"
+require "mmplayer/player/wrapper"
 
-    # Handle the end of playback for a single media file
-    def handle_eof
-      @playback_state[:eof] = true
-      @playback_state[:play] = false
-      STDOUT.flush
-      @callback[:end_of_file].call unless @callback[:end_of_file].nil?
-      true
-    end
-
-    # Handle the beginning of playback for a single media file
-    def handle_start
-      loop until get_player_output.size > 1
-      @playback_state[:play] = true
-      @playback_state[:eof] = false
-    end
-
-    # Get progress percentage from the MPlayer report
-    def get_percentage(report)
-      percent = (report[:position] / report[:length]) * 100
-      percent.round
-    end
-
-    # Poll MPlayer for progress information
-    def poll_mplayer_progress
-      time = nil
-      @messenger.send_message do
-        time = {
-          :length => get_mplayer_float("time_length"),
-          :position => get_mplayer_float("time_pos")
-        }
-      end
-      time
-    end
-
-    # Poll a single MPlayer value for the given key
-    def get_mplayer_float(key)
-      @player.get(key).strip.to_f
-    end
-
-    # Call the given block within a new thread
-    def with_player_thread(&block)
-      thread = Thread.new do
-        begin
-          yield
-        rescue Exception => exception
-          Thread.main.raise(exception)
-        end
-      end
-      thread.abort_on_exception = true
-      @player_threads << thread
-      thread
-    end
-
-    # Ensure that the MPlayer process is invoked
-    # @param [String] file The media file to invoke MPlayer with
-    # @return [MPlayer::Slave]
-    def ensure_player(file)
-      if @player.nil? && @player_threads.empty?
-        with_player_thread do
-          @player = MPlayer::Slave.new(file, :options => @flags)
-          handle_start
-        end
-      end
-    end
-
-    # Handle sending MPlayer messages
-    class Messenger
-
-      FREQUENCY_LIMIT = 0.1 # Throttle messages to 1 per this number seconds
-
-      def initialize
-        @messages = []
-      end
-
-      # Send mplayer a message asynch
-      # @return [Hash, nil]
-      def send_message(&block)
-        timestamp = Time.now.to_f
-        # Throttled messages are disregarded
-        if @messages.empty? || !throttle?(timestamp, @messages.last[:timestamp])
-          thread = Thread.new do
-            begin
-              yield
-            rescue Exception => exception
-              Thread.main.raise(exception)
-            end
-          end
-          thread.abort_on_exception = true
-          record_message(thread, timestamp)
-        end
-      end
-
-      private
-
-      # Should adding a message be throttled for the given timestamp?
-      # @param [Float] timestamp
-      # @param [Float] last_timestamp
-      # @return [Boolean]
-      def throttle?(timestamp, last_timestamp)
-        timestamp - last_timestamp <= FREQUENCY_LIMIT
-      end
-
-      # Record that a message has been sent
-      # @param [Thread] thread
-      # @param [Float] timestamp
-      # @return [Hash]
-      def record_message(thread, timestamp)
-        message = {
-          :thread => thread,
-          :timestamp => timestamp
-        }
-        @messages << message
-        message
-      end
-
-    end
+module MMPlayer
 
+  module Player
   end
 
 end

data/lib/mmplayer/player/invoker.rb

@@ -0,0 +1,45 @@
+module MMPlayer
+
+  module Player
+
+    # Invoke MPlayer
+    class Invoker
+
+      attr_reader :player, :thread
+
+      # @param [Hash] options
+      # @option options [String] :flags MPlayer command-line flags to use on startup
+      def initialize(options = {})
+        @flags = "-fixed-vo -idle"
+        @flags += " #{options[:flags]}" unless options[:flags].nil?
+        @player.nil?
+        @thread = nil
+      end
+
+      def destroy
+        @thread.kill unless @thread.nil?
+      end
+
+      # Ensure that the MPlayer process is invoked
+      # @param [String] file The media file to invoke MPlayer with
+      # @param [MMplayer::Player::State] state
+      # @return [MPlayer::Slave]
+      def ensure_invoked(file, state)
+        if @player.nil? && @thread.nil?
+          @thread = Thread.new do
+            begin
+              @player = MPlayer::Slave.new(file, :options => @flags)
+              state.handle_start
+            rescue Exception => exception
+              Thread.main.raise(exception)
+            end
+          end
+          @thread.abort_on_exception
+        end
+        @player
+      end
+
+    end
+
+  end
+end

data/lib/mmplayer/player/messenger.rb

@@ -0,0 +1,57 @@
+module MMPlayer
+
+  module Player
+
+    # Handle sending MPlayer messages
+    class Messenger
+
+      FREQUENCY_LIMIT = 0.1 # Throttle messages to 1 per this number seconds
+
+      def initialize
+        @messages = []
+      end
+
+      # Send mplayer a message asynch
+      # @return [Hash, nil]
+      def send_message(&block)
+        timestamp = Time.now.to_f
+        # Throttled messages are disregarded
+        if @messages.empty? || !throttle?(timestamp, @messages.last[:timestamp])
+          thread = Thread.new do
+            begin
+              yield
+            rescue Exception => exception
+              Thread.main.raise(exception)
+            end
+          end
+          thread.abort_on_exception = true
+          record_message(thread, timestamp)
+        end
+      end
+
+      private
+
+      # Should adding a message be throttled for the given timestamp?
+      # @param [Float] timestamp
+      # @param [Float] last_timestamp
+      # @return [Boolean]
+      def throttle?(timestamp, last_timestamp)
+        timestamp - last_timestamp <= FREQUENCY_LIMIT
+      end
+
+      # Record that a message has been sent
+      # @param [Thread] thread
+      # @param [Float] timestamp
+      # @return [Hash]
+      def record_message(thread, timestamp)
+        message = {
+          :thread => thread,
+          :timestamp => timestamp
+        }
+        @messages << message
+        message
+      end
+
+    end
+  end
+end

data/lib/mmplayer/player/state.rb

@@ -0,0 +1,44 @@
+module MMPlayer
+
+  module Player
+
+    class State
+
+      attr_accessor :eof, :pause, :play
+      alias_method :eof?, :eof
+      alias_method :pause?, :pause
+      alias_method :paused?, :pause
+      alias_method :play?, :play
+      alias_method :playing?, :play
+
+      def initialize
+        @eof = false
+        @play = false
+        @pause = false
+      end
+
+      def toggle_pause
+        @pause = !@pause
+      end
+
+      def progressing?
+        @play && !@pause
+      end
+
+      def eof_reached?
+        @play && !@eof && !@pause
+      end
+
+      def handle_eof
+        @eof = true
+        @play = false
+      end
+
+      def handle_start
+        @play = true
+        @eof = false
+      end
+
+    end
+  end
+end

data/lib/mmplayer/player/wrapper.rb

@@ -0,0 +1,209 @@
+module MMPlayer
+
+  module Player
+
+    # Wrapper for MPlayer functionality
+    class Wrapper
+
+      attr_reader :player, :state
+
+      # @param [Hash] options
+      # @option options [String] :flags MPlayer command-line flags to use on startup
+      def initialize(options = {})
+        @invoker = Invoker.new(options)
+        @messenger = Messenger.new
+        @callback = {}
+        @state = State.new
+        @threads = []
+      end
+
+      # Play a media file
+      # @param [String] file
+      # @return [Boolean]
+      def play(file)
+        @player ||= @invoker.ensure_invoked(file, @state)
+        if @player.nil?
+          false
+        else
+          @threads << with_thread do
+            @player.load_file(file)
+            handle_start
+          end
+          true
+        end
+      end
+
+      # Is MPlayer active?
+      # @return [Boolean]
+      def active?
+        !(@player ||= @invoker.player).nil?
+      end
+
+      # Toggles pause
+      # @return [Boolean]
+      def pause
+        @state.toggle_pause
+        @player.pause
+        @state.pause?
+      end
+
+      # Handle events while the player is running
+      # @return [Boolean]
+      def playback_loop
+        loop do
+          if handle_progress?
+            @threads << with_thread { handle_progress }
+          end
+          handle_eof if handle_eof?
+          sleep(0.05)
+        end
+        true
+      end
+
+      # Add a callback to be called when progress is updated during playback
+      # @param [Proc] block
+      # @return [Boolean]
+      def add_progress_callback(&block)
+        @callback[:progress] = block
+        true
+      end
+
+      # Add a callback to be called at the end of playback of a media file
+      # @param [Proc] block
+      # @return [Boolean]
+      def add_end_of_file_callback(&block)
+        @callback[:end_of_file] = block
+        true
+      end
+
+      # Shortcut to send a message to the MPlayer
+      # @return [Object]
+      def mplayer_send(method, *args, &block)
+        if @player.nil? && MPlayer::Slave.method_defined?(method)
+          # warn
+        else
+          @messenger.send_message do
+            @player.send(method, *args, &block)
+          end
+        end
+      end
+
+      # Does the MPlayer respond to the given message?
+      # @return [Boolean]
+      def mplayer_respond_to?(method, include_private = false)
+        (@player.nil? && MPlayer::Slave.method_defined?(method)) ||
+        @player.respond_to?(method)
+      end
+
+      # Cause MPlayer to exit
+      # @return [Boolean]
+      def quit
+        @player.quit
+        @threads.each(&:kill)
+        @invoker.destroy
+        true
+      end
+
+      private
+
+      def handle_progress?
+        @state.progressing? && progress_callback?
+      end
+
+      def progress_callback?
+        !@callback[:progress].nil?
+      end
+
+      def eof_callback?
+        !@callback[:end_of_file].nil?
+      end
+
+      def handle_eof?
+        eof? && eof_callback?
+      end
+
+      # Has the end of a media file been reached?
+      # @return [Boolean]
+      def eof?
+        @state.eof_reached? && get_player_output.size < 1
+      end
+
+      # Get player output from stdout
+      def get_player_output
+        @player.stdout.gets.inspect.strip.gsub(/(\\n|[\\"])/, '').strip
+      end
+
+      def handle_progress
+        poll_mplayer_progress do |time|
+          time[:percent] = get_percentage(time)
+          # do the check again for thread safety
+          @callback[:progress].call(time) if handle_progress?
+        end
+      end
+
+      # Handle the end of playback for a single media file
+      def handle_eof
+        # do this check again for thread safety
+        if @state.eof_reached?
+          STDOUT.flush
+          @callback[:end_of_file].call
+          @state.handle_eof
+        end
+        true
+      end
+
+      # Handle the beginning of playback for a single media file
+      def handle_start
+        loop until get_player_output.size > 1
+        @state.handle_start
+      end
+
+      # Get progress percentage from the MPlayer report
+      def get_percentage(report)
+        percent = (report[:position] / report[:length]) * 100
+        percent.round
+      end
+
+      # Poll MPlayer for progress information
+      # Media progress information
+      # eg {
+      #  :length => 90.3,
+      #  :percent => 44,
+      #  :position => 40.1
+      # }
+      # Length and position are in seconds
+      def poll_mplayer_progress(&block)
+        time = nil
+        @messenger.send_message do
+          time = {
+            :length => get_mplayer_float("time_length"),
+            :position => get_mplayer_float("time_pos")
+          }
+          yield(time)
+        end
+        time
+      end
+
+      # Poll a single MPlayer value for the given key
+      def get_mplayer_float(key)
+        result = @player.get(key)
+        result.strip.to_f
+      end
+
+      # Call the given block within a new thread
+      def with_thread(&block)
+        thread = Thread.new do
+          begin
+            yield
+          rescue Exception => exception
+            Thread.main.raise(exception)
+          end
+        end
+        thread.abort_on_exception = true
+        thread
+      end
+
+    end
+
+  end
+end

data/test/context_test.rb

@@ -8,13 +8,13 @@ class MMPlayer::ContextTest < Minitest::Test
       @input = Object.new
       @context = MMPlayer::Context.new(@input)
       @player = Object.new
-      @context.player.stubs(:ensure_player).returns(@player)
+      @context.player.stubs(:player).returns(@player)
       @context.player.stubs(:quit).returns(true)
       @context.player.stubs(:active?).returns(true)
     end
 
     teardown do
-      @context.player.unstub(:ensure_player)
+      @context.player.unstub(:player)
       @context.player.unstub(:quit)
       @context.player.unstub(:active?)
     end

data/test/instructions/player_test.rb

@@ -10,6 +10,22 @@ class MMPlayer::Instructions::PlayerTest < Minitest::Test
       assert @context.kind_of?(MMPlayer::Instructions::Player)
     end
 
+    context "#on_end_of_file" do
+
+      setup do
+        @context.player.expects(:add_end_of_file_callback).once.returns({})
+      end
+
+      teardown do
+        @context.player.unstub(:add_end_of_file_callback)
+      end
+
+      should "assign callback" do
+        refute_nil @context.on_end_of_file { something }
+      end
+
+    end
+
     context "#method_missing" do
 
       setup do

data/test/{message_handler_test.rb → midi/message_handler_test.rb}

@@ -1,11 +1,11 @@
 require "helper"
 
-class MMPlayer::MessageHandlerTest < Minitest::Test
+class MMPlayer::MIDI::MessageHandlerTest < Minitest::Test
 
   context "MessageHandler" do
 
     setup do
-      @handler = MMPlayer::MessageHandler.new
+      @handler = MMPlayer::MIDI::MessageHandler.new
     end
 
     context "#note_message" do

data/test/midi_test.rb

@@ -6,7 +6,7 @@ class MMPlayer::MIDITest < Minitest::Test
 
     setup do
       @input = Object.new
-      @midi = MMPlayer::MIDI.new(@input)
+      @midi = MMPlayer::MIDI::Wrapper.new(@input)
     end
 
     context "#start" do

data/test/player_test.rb

@@ -5,17 +5,16 @@ class MMPlayer::PlayerTest < Minitest::Test
   context "Player" do
 
     setup do
-      @player = MMPlayer::Player.new
+      @player = MMPlayer::Player::Wrapper.new
       @mplayer = Object.new
       @mplayer.stubs(:load_file).returns(true)
       out = Object.new
       out.stubs(:gets).returns("")
       @mplayer.stubs(:stdout).returns(out)
       @mplayer.stubs(:get).returns("0.1\n")
-      @player.stubs(:ensure_player).returns(@mplayer)
+      @player.stubs(:player).returns(@mplayer)
       @player.instance_variable_set("@player", @mplayer)
-      @player.instance_variable_set("@player_threads", [Thread.new {}])
-      @player.send(:ensure_player, "")
+      @player.instance_variable_set("@threads", [Thread.new {}])
     end
 
     context "#mplayer_send" do
@@ -38,7 +37,6 @@ class MMPlayer::PlayerTest < Minitest::Test
     context "#mplayer_respond_to?" do
 
       setup do
-        @player.send(:ensure_player, "")
         @mplayer.expects(:respond_to?).with(:hello).once.returns(true)
       end
 
@@ -67,12 +65,12 @@ class MMPlayer::PlayerTest < Minitest::Test
 
       setup do
         @mplayer.expects(:quit).once
-        @player.instance_variable_get("@player_threads").first.expects(:kill).once
+        @player.instance_variable_get("@threads").first.expects(:kill).once
       end
 
       teardown do
         @mplayer.unstub(:quit)
-        @player.instance_variable_get("@player_threads").first.unstub(:kill)
+        @player.instance_variable_get("@threads").first.unstub(:kill)
       end
 
       should "exit MPlayer and kill the player thread" do
@@ -103,11 +101,11 @@ class MMPlayer::PlayerTest < Minitest::Test
     context "#play" do
 
       setup do
-        @player.expects(:ensure_player).once.returns(@mplayer)
+        @player.expects(:player).once.returns(@mplayer)
       end
 
       teardown do
-        @player.unstub(:ensure_player)
+        @player.unstub(:player)
       end
 
       should "lazily invoke mplayer and play" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mmplayer
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Ari Russo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-08 00:00:00.000000000 Z
+date: 2015-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -190,7 +190,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.4.3
-description: Define interactions between MIDI input and MPlayer
+description: Control MPlayer with MIDI
 email:
 - ari.russo@gmail.com
 executables: []
@@ -202,17 +202,23 @@ files:
 - lib/mmplayer.rb
 - lib/mmplayer/context.rb
 - lib/mmplayer/helper/numbers.rb
+- lib/mmplayer/instructions.rb
 - lib/mmplayer/instructions/midi.rb
 - lib/mmplayer/instructions/player.rb
-- lib/mmplayer/message_handler.rb
 - lib/mmplayer/midi.rb
+- lib/mmplayer/midi/message_handler.rb
+- lib/mmplayer/midi/wrapper.rb
 - lib/mmplayer/player.rb
+- lib/mmplayer/player/invoker.rb
+- lib/mmplayer/player/messenger.rb
+- lib/mmplayer/player/state.rb
+- lib/mmplayer/player/wrapper.rb
 - test/context_test.rb
 - test/helper.rb
 - test/helper/numbers_test.rb
 - test/instructions/midi_test.rb
 - test/instructions/player_test.rb
-- test/message_handler_test.rb
+- test/midi/message_handler_test.rb
 - test/midi_test.rb
 - test/player_test.rb
 homepage: http://github.com/arirusso/mmplayer

data/lib/mmplayer/message_handler.rb

@@ -1,109 +0,0 @@
-module MMPlayer
-
-  # Directs what should happen when messages are received
-  class MessageHandler
-
-    attr_reader :callback
-
-    def initialize
-      @callback = {
-        :cc => {},
-        :note => {},
-        :system => {}
-      }
-    end
-
-    # Add a callback for a given MIDI message type
-    # @param [Symbol] type The MIDI message type (eg :note, :cc)
-    # @param [Fixnum, String] key The ID of the message eg note number/cc index
-    # @param [Proc] callback The callback to execute when the given MIDI command is received
-    # @return [Hash]
-    def add_callback(type, key, &callback)
-      @callback[type][key] = callback
-      @callback[type]
-    end
-
-    # Add a callback for a given MIDI note
-    # @param [Symbol] type The MIDI message type (eg :note, :cc)
-    # @param [Fixnum, String] note
-    # @param [Proc] callback The callback to execute when the given MIDI command is received
-    # @return [Hash]
-    def add_note_callback(note, &callback)
-      note = MIDIMessage::Constant.value(:note, note) if note.kind_of?(String)
-      add_callback(:note, note, &callback)
-    end
-
-    # Process a message for the given channel
-    # @param [Fixnum, nil] channel
-    # @param [MIDIMessage] message
-    # @return [Boolean, nil]
-    def process(channel, message)
-      case message
-      when MIDIMessage::SystemCommon, MIDIMessage::SystemRealtime then system_message(message)
-      else
-        channel_message(channel, message)
-      end
-    end
-
-    # Find and call a note received callback if it exists
-    # @param [MIDIMessage] message
-    # @return [Boolean, nil]
-    def note_message(message)
-      call_callback(:note, message.note, message.velocity) |
-      call_catch_all_callback(:note, message)
-    end
-
-    # Find and call a cc received callback if it exists
-    # @param [MIDIMessage] message
-    # @return [Boolean, nil]
-    def cc_message(message)
-      call_callback(:cc, message.index, message.value) |
-        call_catch_all_callback(:cc, message)
-    end
-
-    # Find and call a system message callback if it exists
-    # @param [MIDIMessage] message
-    # @return [Boolean, nil]
-    def system_message(message)
-      name = message.name.downcase.to_sym
-      call_callback(:system, name)
-    end
-
-    # Find and call a channel message callback if it exists for the given message and channel
-    # @param [Fixnum, nil] channel
-    # @param [MIDIMessage] message
-    # @return [Boolean, nil]
-    def channel_message(channel, message)
-      if channel.nil? || message.channel == channel
-        case message
-        when MIDIMessage::NoteOn then note_message(message)
-        when MIDIMessage::ControlChange then cc_message(message)
-        end
-      end
-    end
-
-    private
-
-    # Execute the catch-all callback for the given type if it exists
-    # @param [Symbol] type
-    # @param [MIDIMessage] message
-    # @return [Boolean]
-    def call_catch_all_callback(type, message)
-      call_callback(type, nil, message)
-    end
-
-    # Execute the callback for the given type and key and pass it the given args
-    # @param [Symbol] type
-    # @param [Object] key
-    # @param [*Object] arguments
-    # @return [Boolean]
-    def call_callback(type, key, *arguments)
-      unless (callback = @callback[type][key]).nil?
-        callback.call(*arguments)
-        true
-      end
-    end
-
-  end
-
-end