mmplayer 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b444046bc6129a272ad1354fd79e0226d3fed0f6
-  data.tar.gz: 7a58cbaec278585178e5ea420e3be977711a5f65
+  metadata.gz: eaf5bf960208966f12d484c199d7146229f81f4f
+  data.tar.gz: dc4d8cfbaa2f8554e5f9bd97cbc05be74482f75c
 SHA512:
-  metadata.gz: 7d73ce2e7db56b04f05bde2ce3a713a0b15cb6ed37f944d6d9de8d45859ad6e70265c3f818056aa6e5e8b70f536ae64f265301e39b2986829c0f7080b26ba2aa
-  data.tar.gz: 137bf592cad461210938a051ffad361b48019a55d87a788f76a48bdde80cd767c3729238fcb9c983c5094e44337bef934a13eeed852d1a57799e1ab483eb6689
+  metadata.gz: c269438f243f8a018f7382a39eecf518308162cfc27c27cf3dbda806fe2b9f0cf3a4c0b83533279b5a755305ab76f6f15352a5bac2f1af2471f9e0ed4f5bf6a6
+  data.tar.gz: 7d0dc1ca64157413bb42910dcbf7001e1ea874b074090c7125bf353b3bd817b4d559000de3193ba50b41bb29f28c7c1fc6459aec40076f64c60cacb350188002

data/README.md

@@ -4,6 +4,12 @@
 
 Control [MPlayer](http://en.wikipedia.org/wiki/MPlayer) with MIDI
 
+MPlayer is a free, cross-platform, command-line driven, highly configurable, (often) GUI-less open-source media player. 
+
+Enabling MPlayer to be controlled by MIDI opens up a host of possibilities for live video performance, media automation and more
+
+This project provides a Ruby DSL to define realtime interactions between MIDI input and MPlayer
+
 ## Install
 
 You'll need to install MPlayer before using this.  That can usually be accomplished with a package manager eg `brew install mplayer` depending on what OS you're using.
@@ -18,8 +24,6 @@ Or if you're using Bundler, add this to your Gemfile
 
 ## Usage
 
-MMplayer provides a Ruby DSL to define interactions between MIDI input and MPlayer
-
 ```ruby
 require "mmplayer"
 
@@ -47,9 +51,7 @@ An annotated breakdown of this example can be found [here](https://github.com/ar
 
 [The MPlayer Man Page](http://www.mplayerhq.hu/DOCS/man/en/mplayer.1.html#GENERAL OPTIONS) has a full list of MPlayer startup flags
 
-All MPlayer runtime commands enabled by the [mplayer-ruby](https://rubygems.org/gems/mplayer-ruby) project are available here too. (eg `seek` and `volume` in the example above)
-
-[The RDOC for mplayer-ruby](http://mplayer-ruby.rubyforge.org/mplayer-ruby/index.html) has a full list of runtime commands
+All MPlayer runtime commands enabled by the [mplayer-ruby](https://rubygems.org/gems/mplayer-ruby) project are available here too. (eg `seek` and `volume` in the example above).  [The RDOC for mplayer-ruby](http://mplayer-ruby.rubyforge.org/mplayer-ruby/index.html) has a full list of runtime commands
 
 ##Author
 

data/lib/mmplayer.rb

@@ -18,12 +18,13 @@ require "mmplayer/instructions/player"
 
 # classes
 require "mmplayer/context"
+require "mmplayer/message_handler"
 require "mmplayer/midi"
 require "mmplayer/player"
 
 module MMPlayer
 
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 
   # Shortcut to Context constructor
   def self.new(*args, &block)

data/lib/mmplayer/message_handler.rb

@@ -0,0 +1,84 @@
+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 system message type
+    # @param [Symbol] type The MIDI message type (eg :note, :cc)
+    # @param [String, Symbol] key
+    # @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
+
+    # 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::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)
+      unless (callback = @callback[:note][message.note] || @callback[:note][message.name]).nil?
+        callback.call(message.velocity)
+        true
+      end
+    end
+
+    # Find and call a cc received callback if it exists
+    # @param [MIDIMessage] message
+    # @return [Boolean, nil]
+    def cc_message(message)
+      unless (callback = @callback[:cc][message.index] || @callback[:cc][message.name]).nil?
+        callback.call(message.value)
+        true
+      end
+    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
+      unless (callback = @callback[:system][name]).nil?
+        callback.call
+        true
+      end
+    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
+
+  end
+
+end

data/lib/mmplayer/midi.rb

@@ -3,18 +3,14 @@ module MMPlayer
   # Wrapper for MIDI functionality
   class MIDI
 
-    attr_reader :channel, :config, :listener
+    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]
-      @config = {
-        :cc => {},
-        :note => {},
-        :system => {}
-      }
+      @message_handler = MessageHandler.new
       @listener = MIDIEye::Listener.new(input)
     end
 
@@ -23,8 +19,7 @@ module MMPlayer
     # @param [Proc] callback The callback to execute when the given MIDI command is received
     # @return [Hash]
     def add_system_callback(command, &callback)
-      @config[:system][command] = callback
-      @config[:system]
+      @message_handler.add_callback(:system, command, &callback)
     end
 
     # Add a callback for a given MIDI note
@@ -32,8 +27,7 @@ module MMPlayer
     # @param [Proc] callback The callback to execute when the given MIDI note is received
     # @return [Hash]
     def add_note_callback(note, &callback)
-      @config[:note][note] = callback
-      @config[:note]
+      @message_handler.add_callback(:note, note, &callback)
     end
 
     # Add a callback for a given MIDI control change
@@ -41,8 +35,7 @@ module MMPlayer
     # @param [Proc] callback The callback to execute when the given MIDI control change is received
     # @return [Hash]
     def add_cc_callback(index, &callback)
-      @config[:cc][index] = callback
-      @config[:cc]
+      @message_handler.add_callback(:cc, index, &callback)
     end
 
     # Stop the MIDI listener
@@ -69,35 +62,20 @@ module MMPlayer
       true
     end
 
+    # Whether the player is subscribed to all channels
+    # @return [Boolean]
+    def omni?
+      @channel.nil?
+    end
+
     private
 
-    # Populate the MIDI listener events
+    # Populate the MIDI listener callback
     def populate_listener
-      # Channel messages
-      listener_options = {}
-      # omni by default
-      listener_options[:channel] = @channel unless @channel.nil?
-      @listener.on_message(listener_options.merge(:class => MIDIMessage::NoteOn)) do |event|
-        message = event[:message]
-        unless (callback = @config[:note][message.note] || @config[:note][message.name]).nil?
-          callback.call(message.velocity)
-        end
-      end
-      @listener.on_message(listener_options.merge(:class => MIDIMessage::ControlChange)) do |event|
-        message = event[:message]
-        unless (callback = @config[:cc][message.index] || @config[:cc][message.name]).nil?
-          callback.call(message.value)
-        end
-      end
-      # Short messages
-      @listener.on_message(:class => MIDIMessage::SystemRealtime) do |event|
+      @listener.on_message do |event|
         message = event[:message]
-        name = message.name.downcase.to_sym
-        unless (callback = @config[:system][name]).nil?
-          callback.call
-        end
+        @message_handler.process(@channel, message)
       end
-      true
     end
 
   end

data/lib/mmplayer/player.rb

@@ -6,9 +6,9 @@ module MMPlayer
     # @param [Hash] options
     # @option options [String] :flags MPlayer command-line flags to use on startup
     def initialize(options = {})
-      @mplayer_messages = []
       @flags = "-fixed-vo -idle"
       @flags += " #{options[:flags]}" unless options[:flags].nil?
+      @messenger = Messenger.new
     end
 
     # Play a media file
@@ -51,7 +51,7 @@ module MMPlayer
       if @player.nil? && MPlayer::Slave.method_defined?(method)
         # warn
       else
-        send_mplayer_message { @player.send(method, *args, &block) }
+        @messenger.send_message { @player.send(method, *args, &block) }
       end
     end
 
@@ -59,7 +59,7 @@ module MMPlayer
     # @return [Boolean]
     def mplayer_respond_to?(method, include_private = false)
       (@player.nil? && MPlayer::Slave.method_defined?(method)) ||
-        @player.respond_to?(method)
+      @player.respond_to?(method)
     end
 
     # Cause MPlayer to exit
@@ -72,32 +72,6 @@ module MMPlayer
 
     private
 
-    # Sweep for leftover/hanging message threads
-    def sweep_messages
-      if @mplayer_messages.empty?
-        false
-      else
-        sleep(0.01)
-        @mplayer_messages.each(&:kill)
-        true
-      end
-    end
-
-    # Send mplayer a message async
-    def send_mplayer_message(&block)
-      sweep_messages
-      thread = Thread.new do
-        begin
-          yield
-        rescue Exception => exception
-          Thread.main.raise(exception)
-        end
-      end
-      thread.abort_on_exception = true
-      @mplayer_messages << thread
-      thread
-    end
-
     # Get progress percentage from the MPlayer report
     def get_percentage(report)
       percent = (report[:position] / report[:length]) * 100
@@ -107,7 +81,7 @@ module MMPlayer
     # Poll MPlayer for progress information
     def poll_mplayer_progress
       time = nil
-      send_mplayer_message do
+      @messenger.send_message do
         time = {
           :length => get_mplayer_float("time_length"),
           :position => get_mplayer_float("time_pos")
@@ -125,7 +99,7 @@ module MMPlayer
     # @param [String] file The media file to invoke MPlayer with
     # @return [MPlayer::Slave]
     def ensure_player(file)
-      if @player.nil?
+      if @player.nil? && @player_thread.nil?
         @player_thread = Thread.new do
           begin
             @player = MPlayer::Slave.new(file, :options => @flags)
@@ -137,6 +111,57 @@ module MMPlayer
       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
+        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/test/context_test.rb

@@ -22,7 +22,7 @@ class MMPlayer::ContextTest < Minitest::Test
     context "#start" do
 
       setup do
-        @context.midi.listener.expects(:on_message).times(3)
+        @context.midi.listener.expects(:on_message).once
         @context.midi.listener.expects(:start).once
       end
 
@@ -33,7 +33,7 @@ class MMPlayer::ContextTest < Minitest::Test
 
       should "activate player" do
         assert @context.start(:background => true)
-        @context.stop
+        assert @context.stop
       end
 
     end
@@ -41,7 +41,7 @@ class MMPlayer::ContextTest < Minitest::Test
     context "#stop" do
 
       setup do
-        @context.midi.listener.expects(:on_message).times(3)
+        @context.midi.listener.expects(:on_message).once
         @context.midi.listener.expects(:start).once
         @context.midi.listener.expects(:stop).once
         @context.player.expects(:quit).once
@@ -55,7 +55,7 @@ class MMPlayer::ContextTest < Minitest::Test
       end
 
       should "stop player" do
-        @context.stop
+        assert @context.stop
       end
 
     end

data/test/message_handler_test.rb

@@ -0,0 +1,254 @@
+require "helper"
+
+class MMPlayer::MessageHandlerTest < Minitest::Test
+
+  context "MessageHandler" do
+
+    setup do
+      @handler = MMPlayer::MessageHandler.new
+    end
+
+    context "#note_message" do
+
+      setup do
+        @message = MIDIMessage::NoteOn.new(0, 10, 100)
+      end
+
+      context "callback exists" do
+
+        setup do
+          @var = nil
+          @callback = proc { |vel| @var = vel }
+          @handler.add_callback(:note, @message.note, &@callback)
+          @callback.expects(:call).once
+        end
+
+        teardown do
+          @callback.unstub(:call)
+        end
+
+        should "call callback" do
+          assert @handler.send(:note_message, @message)
+        end
+
+      end
+
+      context "callback doesn't exist" do
+
+        should "do nothing" do
+          refute @handler.send(:note_message, @message)
+        end
+
+      end
+
+    end
+
+    context "#cc_message" do
+
+      setup do
+        @message = MIDIMessage::ControlChange.new(0, 8, 100)
+      end
+
+      context "callback exists" do
+
+        setup do
+          @var = nil
+          @callback = proc { |vel| @var = vel }
+          @handler.add_callback(:cc, @message.index, &@callback)
+          @callback.expects(:call).once
+        end
+
+        teardown do
+          @callback.unstub(:call)
+        end
+
+        should "call callback" do
+          assert @handler.send(:cc_message, @message)
+        end
+
+      end
+
+      context "callback doesn't exist" do
+
+        should "do nothing" do
+          refute @handler.send(:cc_message, @message)
+        end
+
+      end
+
+    end
+
+    context "#system_message" do
+
+      setup do
+        @message = MIDIMessage::SystemRealtime.new(0x8) # clock
+      end
+
+      context "callback exists" do
+
+        setup do
+          @var = nil
+          @callback = proc { |vel| @var = vel }
+          @handler.add_callback(:system, :clock, &@callback)
+          @callback.expects(:call).once
+        end
+
+        teardown do
+          @callback.unstub(:call)
+        end
+
+        should "call callback" do
+          assert @handler.send(:system_message, @message)
+        end
+
+      end
+
+      context "callback doesn't exist" do
+
+        should "do nothing" do
+          refute @handler.send(:system_message, @message)
+        end
+
+      end
+
+    end
+
+    context "#channel_message" do
+
+      context "omni" do
+
+        setup do
+          @channel = nil
+        end
+
+        context "control change" do
+
+          setup do
+            @message = MIDIMessage::ControlChange.new(0, 8, 100)
+            @handler.expects(:cc_message).once.with(@message).returns(true)
+          end
+
+          teardown do
+            @handler.unstub(:cc_message)
+          end
+
+          should "handle control change" do
+            assert @handler.send(:channel_message, @channel, @message)
+          end
+
+        end
+
+        context "note" do
+
+          setup do
+            @message = MIDIMessage::NoteOn.new(0, 10, 100)
+            @handler.expects(:note_message).once.with(@message).returns(true)
+          end
+
+          teardown do
+            @handler.unstub(:note_message)
+          end
+
+          should "handle note" do
+            assert @handler.send(:channel_message, @channel, @message)
+          end
+
+        end
+
+      end
+
+      context "with channel" do
+
+        setup do
+          @channel = 5
+        end
+
+        context "control change" do
+
+          setup do
+            @message = MIDIMessage::ControlChange.new(@channel, 8, 100)
+          end
+
+          context "matching channel" do
+
+            setup do
+              @handler.expects(:cc_message).once.with(@message).returns(true)
+            end
+
+            teardown do
+              @handler.unstub(:cc_message)
+            end
+
+            should "handle control change" do
+              assert @handler.send(:channel_message, @channel, @message)
+            end
+
+          end
+
+          context "non matching channel" do
+
+            setup do
+              @handler.expects(:cc_message).never
+              @other_message = MIDIMessage::ControlChange.new(@channel + 1, 8, 100)
+            end
+
+            teardown do
+              @handler.unstub(:cc_message)
+            end
+
+            should "do nothing" do
+              refute @handler.send(:channel_message, @channel, @other_message)
+            end
+
+          end
+
+        end
+
+        context "note" do
+
+          setup do
+            @message = MIDIMessage::NoteOn.new(@channel, 10, 100)
+          end
+
+          context "matching channel" do
+
+            setup do
+              @handler.expects(:note_message).once.with(@message).returns(true)
+            end
+
+            teardown do
+              @handler.unstub(:note_message)
+            end
+
+            should "call callback" do
+              assert @handler.send(:channel_message, @channel, @message)
+            end
+
+          end
+
+          context "non matching channel" do
+
+            setup do
+              @handler.expects(:note_message).never
+              @other_message = MIDIMessage::ControlChange.new(@channel + 1, 8, 100)
+            end
+
+            teardown do
+              @handler.unstub(:note_message)
+            end
+
+            should "not call callback" do
+              refute @handler.send(:channel_message, @channel, @other_message)
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/midi_test.rb

@@ -12,7 +12,7 @@ class MMPlayer::MIDITest < Minitest::Test
     context "#start" do
 
       setup do
-        @midi.listener.expects(:on_message).times(3)
+        @midi.listener.expects(:on_message).once
         @midi.listener.expects(:start).once
       end
 
@@ -35,8 +35,8 @@ class MMPlayer::MIDITest < Minitest::Test
       end
 
       should "store callback" do
-        refute_nil @midi.config[:note][10]
-        assert_equal Proc, @midi.config[:note][10].class
+        refute_nil @midi.message_handler.callback[:note][10]
+        assert_equal Proc, @midi.message_handler.callback[:note][10].class
       end
 
     end
@@ -49,8 +49,8 @@ class MMPlayer::MIDITest < Minitest::Test
       end
 
       should "store callback" do
-        refute_nil @midi.config[:system][:start]
-        assert_equal Proc, @midi.config[:system][:start].class
+        refute_nil @midi.message_handler.callback[:system][:start]
+        assert_equal Proc, @midi.message_handler.callback[:system][:start].class
       end
 
     end
@@ -63,8 +63,8 @@ class MMPlayer::MIDITest < Minitest::Test
       end
 
       should "store callback" do
-        refute_nil @midi.config[:cc][2]
-        assert_equal Proc, @midi.config[:cc][2].class
+        refute_nil @midi.message_handler.callback[:cc][2]
+        assert_equal Proc, @midi.message_handler.callback[:cc][2].class
       end
 
     end
@@ -96,11 +96,13 @@ class MMPlayer::MIDITest < Minitest::Test
         should "change channel" do
           assert_equal 3, @midi.channel = 3
           assert_equal 3, @midi.channel
+          refute @midi.omni?
         end
 
         should "set channel nil" do
           assert_equal nil, @midi.channel = nil
           assert_nil @midi.channel
+          assert @midi.omni?
         end
       end
 
@@ -109,17 +111,19 @@ class MMPlayer::MIDITest < Minitest::Test
         setup do
           @listener.stubs(:running?).returns(true)
           @listener.expects(:clear).once
-          @listener.expects(:on_message).times(3)
+          @listener.expects(:on_message).once
         end
 
         should "change channel" do
           assert_equal 3, @midi.channel = 3
           assert_equal 3, @midi.channel
+          refute @midi.omni?
         end
 
         should "set channel nil" do
           assert_equal nil, @midi.channel = nil
           assert_nil @midi.channel
+          assert @midi.omni?
         end
 
       end
@@ -127,4 +131,5 @@ class MMPlayer::MIDITest < Minitest::Test
     end
 
   end
+
 end

data/test/player_test.rb

@@ -120,6 +120,24 @@ class MMPlayer::PlayerTest < Minitest::Test
 
     end
 
+    context "Messenger" do
+
+      context "#throttle?" do
+
+        setup do
+          @messenger = MMPlayer::Player::Messenger.new
+          @limit = MMPlayer::Player::Messenger::FREQUENCY_LIMIT
+        end
+
+        should "respect message frequency" do
+          assert @messenger.send(:throttle?, 1234, 1234 - @limit / 2)
+          refute @messenger.send(:throttle?, 1234, 1234 - @limit * 2)
+        end
+
+      end
+
+    end
+
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mmplayer
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Ari Russo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-24 00:00:00.000000000 Z
+date: 2015-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -204,6 +204,7 @@ files:
 - lib/mmplayer/helper/numbers.rb
 - lib/mmplayer/instructions/midi.rb
 - lib/mmplayer/instructions/player.rb
+- lib/mmplayer/message_handler.rb
 - lib/mmplayer/midi.rb
 - lib/mmplayer/player.rb
 - test/context_test.rb
@@ -211,6 +212,7 @@ files:
 - test/helper/numbers_test.rb
 - test/instructions/midi_test.rb
 - test/instructions/player_test.rb
+- test/message_handler_test.rb
 - test/midi_test.rb
 - test/player_test.rb
 homepage: http://github.com/arirusso/mmplayer