mvlc 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0a3c18e5008e5f8f361494582728609b4e3195e0
-  data.tar.gz: 40608a822d57c28c14b3545afea9f89dd68f2e28
+  metadata.gz: 0f27439f0f528cbacaa62a77d0b6365b218405f6
+  data.tar.gz: 23421cc936761e6786c93c6b8566b24b87f72537
 SHA512:
-  metadata.gz: fb978ef495307a62fde65235ca7834d12ef80eae8a616d8ca81979374b96ea9eda0ae0344e8c181a9641b4fe084792b688436a937ff534daf3f8eb0aa62455ff
-  data.tar.gz: e56d01511db155d0fb4dc9423ef3fe0581f6b761dd5cd84c231421a66a4fbac1910d5031ec68c1f64cb38c0a00b7fd2023c6f05fe3707e5185735abdb32381f9
+  metadata.gz: c609cda1b7f4d7e9f2187bf9f12270c09486b73ce2d9e257bd47ff577471720a9e63e851825065dcbd78c85937b6716860f1bbd8df7e421ab6933121b40234ef
+  data.tar.gz: 8f78ea1cff61ea2d0c6b8e8ca38a111b7f596ea22f9655c0b9e2367721de0303f42c6d53069c274227077d3beaebc0ae46ac0cdca160a6be286da74027a9186a

data/README.md

@@ -2,7 +2,52 @@
 
 Control [VLC Media Player](https://en.wikipedia.org/wiki/VLC_media_player) with MIDI
 
-This is a fork of [mmplayer](https://github.com/arirusso/mvlc), a gem to control MPlayer with MIDI
+*This is a fork of [mmplayer](https://github.com/arirusso/mvlc), a gem to control MPlayer with MIDI*
+
+Enabling VLC 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 VLC
+
+## Install
+
+You'll need to install VLC before using this.  More information about that is available on [the VLC website](http://www.videolan.org/vlc/index.html)
+
+This project itself can be installed as a Ruby Gem using
+
+`gem install mvlc`
+
+Or if you're using Bundler, add this to your Gemfile
+
+`gem "mvlc"`
+
+## Usage
+
+```ruby
+require "mvlc"
+
+@input = UniMIDI::Input.gets
+
+@player = MVLC.new(@input) do
+
+  rx_channel 0
+
+  system(:start) { play("1.mov") }
+
+  note(1) { play("2.mov") }
+  note("C2") { play("3.mov") }
+
+  cc(1) { |value| set_volume(value) }
+  cc(20) { |value| seek_percent(to_percent(value)) }
+
+  eof { puts "finished" }
+
+end
+
+@player.start
+
+```
+
+An annotated breakdown of this example can be found [here](https://github.com/arirusso/mvlc/blob/master/examples/simple.rb)
 
 ## License
 

data/lib/mvlc.rb

@@ -24,7 +24,7 @@ require "mvlc/context"
 
 module MVLC
 
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 
   # Shortcut to Context constructor
   def self.new(*args, &block)

data/lib/mvlc/context.rb

@@ -1,18 +1,17 @@
 module MVLC
 
-  # DSL context for interfacing an instance of MPlayer with MIDI
+  # DSL context for interfacing an video player instance with MIDI
   class Context
 
     include Helper::Numbers
     include Instructions::MIDI
     include Instructions::Player
 
-    attr_reader :midi, :player
+    attr_reader :midi, :playback_thread, :player
 
     # @param [UniMIDI::Input, Array<UniMIDI::Input>] midi_input
     # @param [Hash] options
     # @option options [Integer] :midi_buffer_length Length of MIDI message buffer in seconds
-    # @option options [String] :mplayer_flags The command-line flags to invoke MPlayer with
     # @option options [Integer] :receive_channel (also: :rx_channel) A MIDI channel to subscribe to. By default, responds to all
     # @yield
     def initialize(midi_input, options = {}, &block)
@@ -21,19 +20,20 @@ module MVLC
         :receive_channel => options[:receive_channel] || options[:rx_channel]
       }
       @midi = MIDI.new(midi_input, midi_options)
-      @player = Player.new(:flags => options[:mplayer_flags])
+      @player = Player.new
       instance_eval(&block) if block_given?
     end
 
-    # Start listening for MIDI
-    # Note that MPlayer will start when Context#play (aka Instructions::Player#play) is called
+    # Start listening for MIDI, start video player
     # @param [Hash] options
     # @option options [Boolean] :background Whether to run in a background thread
     # @return [Boolean]
     def start(options = {})
       @midi.start
       begin
-        @playback_thread = playback_loop
+        @playback_thread = ::MVLC::Thread.new(:timeout => false) do
+          playback_loop
+        end
         @playback_thread.join unless !!options[:background]
       rescue SystemExit, Interrupt
         stop
@@ -54,12 +54,11 @@ module MVLC
 
     # Main playback loop
     def playback_loop
-      ::MVLC::Thread.new(:timeout => false) do
-        until @player.active?
-          sleep(0.1)
-        end
-        @player.playback_loop
+      until @player.active?
+        sleep(0.1)
       end
+      @player.playback_loop
+      true
     end
 
   end

data/lib/mvlc/instructions/player.rb

@@ -2,7 +2,7 @@ module MVLC
 
   module Instructions
 
-    # Instructions dealing with the MPlayer
+    # Instructions dealing with the video player
     module Player
 
       # Assign a callback for updating progress
@@ -30,7 +30,7 @@ module MVLC
         base.send(:def_delegators, :@player, :active?, :play)
       end
 
-      # Add all of the MPlayer::Slave methods to the context as instructions
+      # Add all of the video player methods to the context as instructions
       def method_missing(method, *args, &block)
         if @player.respond_to?(method)
           @player.send(method, *args, &block)
@@ -39,7 +39,7 @@ module MVLC
         end
       end
 
-      # Add all of the MPlayer::Slave methods to the context as instructions
+      # Add all of the video player methods to the context as instructions
       def respond_to_missing?(method, include_private = false)
         super || @player.respond_to?(method)
       end

data/lib/mvlc/player/state.rb

@@ -4,39 +4,40 @@ module MVLC
 
     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
+      attr_accessor :is_eof, :is_paused, :is_playing, :volume
+      alias_method :eof?, :is_eof
+      alias_method :pause?, :is_paused
+      alias_method :paused?, :is_paused
+      alias_method :play?, :is_playing
+      alias_method :playing?, :is_playing
 
       def initialize
-        @eof = false
-        @play = false
-        @pause = false
+        @is_eof = false
+        @is_playing = false
+        @is_paused = false
+        @volume = nil
       end
 
       def toggle_pause
-        @pause = !@pause
+        @is_paused = !@is_paused
       end
 
       def progressing?
-        @play && !@pause
+        @is_playing && !@is_paused
       end
 
-      def eof_reached?
-        @play && !@eof && !@pause
+      def eof_possible?
+        @is_playing && !@is_paused && !@is_eof
       end
 
       def handle_eof
-        @eof = true
-        @play = false
+        @is_eof = true
+        @is_playing = false
       end
 
       def handle_start
-        @play = true
-        @eof = false
+        @is_playing = true
+        @is_eof = false
       end
 
     end

data/lib/mvlc/player/wrapper.rb

@@ -2,10 +2,10 @@ module MVLC
 
   module Player
 
-    # Wrapper for MPlayer functionality
+    # Wrapper for video player functionality
     class Wrapper
 
-      VOLUME_FACTOR = 2.4
+      VOLUME_FACTOR = 2.4 # Factor at which volume value is scaled
 
       extend Forwardable
 
@@ -15,13 +15,25 @@ module MVLC
       def initialize(options = {})
         @callback = {}
         @state = State.new
-        @player = VLC::System.new(headless: true)
+        @player = initialize_player
+        @pid = player_pid
       end
 
-      def volume(value)
-        @player.volume(value * VOLUME_FACTOR)
+      # Set the volume level to the given value.
+      # Value is expected to be 0..100 but this is not strictly enforced
+      # @param [Integer] value
+      # @return [Integer]
+      def volume=(value)
+        @state.volume = value * VOLUME_FACTOR
+        @player.volume(@state.volume)
+        @state.volume
       end
+      alias_method :set_volume, :volume=
 
+      # Seek to the given percent in the currently playing file
+      # Value is expected to be 0..100
+      # @param [Integer] value
+      # @return [Integer]
       def seek_percent(percent)
         begin
           length_in_seconds = @player.length
@@ -44,7 +56,7 @@ module MVLC
         end
       end
 
-      # Is MPlayer active?
+      # Is the video player active?
       # @return [Boolean]
       def active?
         !@player.nil?
@@ -62,8 +74,7 @@ module MVLC
       # @return [Boolean]
       def playback_loop
         loop do
-          handle_eof if handle_eof?
-          handle_progress if handle_progress?
+          handle_playback_events
           sleep(0.05)
         end
         true
@@ -85,14 +96,14 @@ module MVLC
         true
       end
 
-      # Cause MPlayer to exit
+      # Exit the video player
       # @return [Boolean]
       def quit
-        @player.server.stop
+        kill_player
         true
       end
 
-      # Add all of the MPlayer::Slave methods to the context as instructions
+      # Add all of the video player methods to the wrapper as instructions
       def method_missing(method, *args, &block)
         if @player.respond_to?(method)
           @player.send(method, *args, &block)
@@ -101,35 +112,77 @@ module MVLC
         end
       end
 
-      # Add all of the MPlayer::Slave methods to the context as instructions
+      # Add all of the video player methods to the wrapper as instructions
       def respond_to_missing?(method, include_private = false)
         super || @player.respond_to?(method)
       end
 
       private
 
+      # Fire playback event callbacks when appropriate during
+      # the playback loop
+      # @return [Boolean]
+      def handle_playback_events
+        handle_eof if handle_eof?
+        handle_progress if handle_progress?
+        true
+      end
+
+      # Instantiate the VLC player instance
+      # @return [VLC::System]
+      def initialize_player
+        VLC::System.new(headless: true)
+      end
+
+      # The OS PID of the player
+      # @return [Integer]
+      def player_pid
+        @player.server.instance_variable_get("@pid")
+      end
+
+      # Kill the VLC player instance
+      # @return [Boolean]
+      def kill_player
+        @player.connection.write("quit")
+        # TODO: Process.kill not working here
+        `kill -9 #{@pid}`
+        @player.server.stop
+        true
+      end
+
+      # Should a progress callback be fired?
+      # @return [Boolean]
       def handle_progress?
         @state.progressing? && progress_callback?
       end
 
+      # Has a progress callback been specified?
+      # @return [Boolean]
       def progress_callback?
         !@callback[:progress].nil?
       end
 
+      # Has an EOF callback been specified?
+      # @return [Boolean]
       def eof_callback?
         !@callback[:end_of_file].nil?
       end
 
+      # Should an EOF callback be fired?
+      # @return [Boolean]
       def handle_eof?
         eof? && eof_callback?
       end
 
+      # Fire the progress callback. Used during the playback loop
+      # @return [Boolean]
       def handle_progress
-        @callback[:progress].call
+        @callback[:progress].call(@player.progress)
         true
       end
 
       # Handle the end of playback for a single media file
+      # @return [Boolean]
       def handle_eof
         @callback[:end_of_file].call
         @state.handle_eof
@@ -137,10 +190,14 @@ module MVLC
       end
 
       # Handle the beginning of playback for a single media file
+      # @return [Boolean]
       def handle_start
         @state.handle_start
+        true
       end
 
+      # Is media playing?
+      # @return [Boolean]
       def playing?
         begin
           @player.playing?
@@ -152,7 +209,7 @@ module MVLC
       # Has the end of a media file been reached?
       # @return [Boolean]
       def eof?
-        @state.eof_reached? && !playing?
+        @state.eof_possible? && !playing?
       end
 
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mvlc
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Ari Russo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-20 00:00:00.000000000 Z
+date: 2017-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -212,17 +212,6 @@ files:
 - lib/mvlc/player/state.rb
 - lib/mvlc/player/wrapper.rb
 - lib/mvlc/thread.rb
-- test/context_test.rb
-- test/helper.rb
-- test/helper/numbers_test.rb
-- test/instructions/midi_test.rb
-- test/instructions/player_test.rb
-- test/media/1.mov
-- test/media/2.mov
-- test/media/3.mov
-- test/midi/message_handler_test.rb
-- test/midi/wrapper_test.rb
-- test/player/wrapper_test.rb
 homepage: http://github.com/arirusso/mvlc
 licenses:
 - Apache-2.0

data/test/context_test.rb

@@ -1,65 +0,0 @@
-require "helper"
-
-class MVLC::ContextTest < Minitest::Test
-
-  context "Context" do
-
-    setup do
-      VLC::System.stubs(:new)
-      @input = Object.new
-      @context = MVLC::Context.new(@input)
-      @player = Object.new
-      @context.player.stubs(:player).returns(@player)
-      @context.player.stubs(:quit).returns(true)
-      @context.player.stubs(:active?).returns(true)
-    end
-
-    teardown do
-      @context.player.unstub(:player)
-      @context.player.unstub(:quit)
-      @context.player.unstub(:active?)
-    end
-
-    context "#start" do
-
-      setup do
-        @context.midi.listener.expects(:on_message).once
-        @context.midi.listener.expects(:start).once
-      end
-
-      teardown do
-        @context.midi.listener.unstub(:on_message)
-        @context.midi.listener.unstub(:start)
-      end
-
-      should "activate player" do
-        assert @context.start(:background => true)
-        assert @context.stop
-      end
-
-    end
-
-    context "#stop" do
-
-      setup do
-        @context.midi.listener.expects(:on_message).once
-        @context.midi.listener.expects(:start).once
-        @context.midi.listener.expects(:stop).once
-        @context.player.expects(:quit).once
-        assert @context.start(:background => true)
-      end
-
-      teardown do
-        @context.midi.listener.unstub(:on_message)
-        @context.midi.listener.unstub(:start)
-        @context.player.unstub(:quit)
-      end
-
-      should "stop player" do
-        assert @context.stop
-      end
-
-    end
-
-  end
-end

data/test/helper.rb

@@ -1,6 +0,0 @@
-$:.unshift(File.join("..", "lib"))
-
-require "minitest/autorun"
-require "mocha/test_unit"
-require "shoulda-context"
-require "mvlc"

data/test/helper/numbers_test.rb

@@ -1,57 +0,0 @@
-require "helper"
-
-class MVLC::Helper::NumbersTest < Minitest::Test
-
-  context "Numbers" do
-
-    setup do
-      @util = Object.new
-      @util.class.send(:include, MVLC::Helper::Numbers)
-    end
-
-    context "#to_midi_value" do
-
-      should "convert 0" do
-        val = @util.to_midi_value(0)
-        refute_nil val
-        assert_equal 0x0, val
-      end
-
-      should "convert 64" do
-        val = @util.to_midi_value(50)
-        refute_nil val
-        assert_equal 0x40, val
-      end
-
-      should "convert 127" do
-        val = @util.to_midi_value(100)
-        refute_nil val
-        assert_equal 0x7F, val
-      end
-
-    end
-
-    context "#to_percent" do
-
-      should "convert 0%" do
-        val = @util.to_percent(0x0)
-        refute_nil val
-        assert_equal 0, val
-      end
-
-      should "convert 50%" do
-        val = @util.to_percent(0x40)
-        refute_nil val
-        assert_equal 50, val
-      end
-
-      should "convert 100%" do
-        val = @util.to_percent(0x7F)
-        refute_nil val
-        assert_equal 100, val
-      end
-
-    end
-
-  end
-end

data/test/instructions/midi_test.rb

@@ -1,78 +0,0 @@
-require "helper"
-
-class MVLC::Instructions::MIDITest < Minitest::Test
-
-  context "MIDI" do
-
-    setup do
-      @input = Object.new
-      @context = MVLC::Context.new(@input)
-      assert @context.kind_of?(MVLC::Instructions::MIDI)
-    end
-
-    context "#note" do
-
-      setup do
-        @context.midi.expects(:add_note_callback).once.returns({})
-      end
-
-      teardown do
-        @context.midi.unstub(:add_note_callback)
-      end
-
-      should "assign callback" do
-        refute_nil @context.note(1) { something }
-      end
-
-    end
-
-    context "#cc" do
-
-      setup do
-        @context.midi.expects(:add_cc_callback).once.returns({})
-      end
-
-      teardown do
-        @context.midi.unstub(:add_cc_callback)
-      end
-
-      should "assign callback" do
-        refute_nil @context.cc(1) { |val| something }
-      end
-
-    end
-
-    context "#system" do
-
-      setup do
-        @context.midi.expects(:add_system_callback).once.returns({})
-      end
-
-      teardown do
-        @context.midi.unstub(:add_system_callback)
-      end
-
-      should "assign callback" do
-        refute_nil @context.system(:stop) { something }
-      end
-
-    end
-
-    context "#receive_channel" do
-
-      setup do
-        @context.midi.expects(:channel=).once.with(3).returns(3)
-      end
-
-      teardown do
-        @context.midi.unstub(:channel=)
-      end
-
-      should "assign callback" do
-        refute_nil @context.receive_channel(3)
-      end
-
-    end
-
-  end
-end

data/test/instructions/player_test.rb

@@ -1,66 +0,0 @@
-require "helper"
-
-class MVLC::Instructions::PlayerTest < Minitest::Test
-
-  context "Player" do
-
-    setup do
-      @player = Object.new
-      @player.stubs(:quit)
-      @player.stubs(:seek).returns(true)
-      VLC::System.stubs(:new).returns(@player)
-      @input = Object.new
-      @context = MVLC::Context.new(@input)
-      assert @context.kind_of?(MVLC::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
-        @context.player.expects(:mplayer_send).once.with(:seek, 50, :percent).returns(true)
-      end
-
-      teardown do
-        @context.player.unstub(:mplayer_send)
-      end
-
-      should "delegate" do
-        refute_nil @context.seek(50, :percent)
-      end
-
-    end
-
-    context "#respond_to?" do
-
-      setup do
-        @context.player.expects(:mplayer_respond_to?).once.with(:seek).returns(true)
-      end
-
-      teardown do
-        @context.player.unstub(:mplayer_respond_to?)
-      end
-
-      should "delegate" do
-        refute_nil @context.respond_to?(:seek)
-      end
-
-    end
-
-  end
-end

data/test/midi/message_handler_test.rb

@@ -1,315 +0,0 @@
-require "helper"
-
-class MVLC::MIDI::MessageHandlerTest < Minitest::Test
-
-  context "MessageHandler" do
-
-    setup do
-      @handler = MVLC::MIDI::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
-
-        context "has catch-all callback" do
-
-          setup do
-            @var2 = nil
-            @catchall = proc { |vel| @var2 = vel }
-            @handler.add_callback(:note, nil, &@catchall)
-            @catchall.expects(:call).once
-          end
-
-          teardown do
-            @catchall.unstub(:call)
-          end
-
-          should "call both callbacks" do
-            assert @handler.send(:note_message, @message)
-          end
-
-        end
-
-        context "no catch-all callback" do
-
-          should "call specific callback" do
-            assert @handler.send(:note_message, @message)
-          end
-
-        end
-
-      end
-
-      context "callback doesn't exist" do
-
-        context "has catch-all callback" do
-
-          setup do
-            @var = nil
-            @callback = proc { |vel| @var = vel }
-            @handler.add_callback(:note, nil, &@callback)
-            @callback.expects(:call).once
-          end
-
-          should "call callback" do
-            assert @handler.send(:note_message, @message)
-          end
-
-        end
-
-        context "no catch-all callback" do
-
-          should "do nothing" do
-            refute @handler.send(:note_message, @message)
-          end
-
-        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
-
-        context "has catch-all callback" do
-
-          setup do
-            @var = nil
-            @callback = proc { |vel| @var = vel }
-            @handler.add_callback(:cc, nil, &@callback)
-            @callback.expects(:call).once
-          end
-
-          should "call callback" do
-            assert @handler.send(:cc_message, @message)
-          end
-
-        end
-
-        context "no catch-all callback" do
-
-          should "do nothing" do
-            refute @handler.send(:cc_message, @message)
-          end
-
-        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/wrapper_test.rb

@@ -1,229 +0,0 @@
-require "helper"
-
-class MVLC::MIDI::WrapperTest < Minitest::Test
-
-  context "Wrapper" do
-
-    setup do
-      @input = Object.new
-      @midi = MVLC::MIDI::Wrapper.new(@input)
-    end
-
-    context "#handle_new_event" do
-
-      context "with no buffer length" do
-
-        setup do
-          @midi.message_handler.expects(:process).once
-          @event = {
-            :message => MIDIMessage::NoteOn.new(0, 64, 120),
-            :timestamp=> 9266.395330429077
-          }
-          @result = @midi.send(:handle_new_event, @event)
-        end
-
-        teardown do
-          @midi.message_handler.unstub(:process)
-        end
-
-        should "return event" do
-          refute_nil @result
-          assert_equal @event, @result
-        end
-
-      end
-
-      context "with buffer length" do
-
-        context "recent message" do
-
-          setup do
-            @midi.message_handler.expects(:process).once
-            @event = {
-              :message => MIDIMessage::NoteOn.new(0, 64, 120),
-              :timestamp=> 9266.395330429077
-            }
-            @result = @midi.send(:handle_new_event, @event)
-          end
-
-          teardown do
-            @midi.message_handler.unstub(:process)
-          end
-
-          should "return event" do
-            refute_nil @result
-            assert_equal @event, @result
-          end
-
-        end
-
-        context "with too-old message" do
-
-          setup do
-            @midi.instance_variable_set("@buffer_length", 1)
-            @midi.instance_variable_set("@start_time", Time.now.to_i)
-            sleep(2)
-            @midi.message_handler.expects(:process).never
-            @event = {
-              :message => MIDIMessage::NoteOn.new(0, 64, 120),
-              :timestamp => 0.1
-            }
-            @result = @midi.send(:handle_new_event, @event)
-          end
-
-          teardown do
-            @midi.message_handler.unstub(:process)
-          end
-
-          should "not return event" do
-            assert_nil @result
-          end
-
-        end
-
-      end
-
-    end
-
-    context "#initialize_listener" do
-
-      setup do
-        @midi.listener.expects(:on_message).once
-        @result = @midi.send(:initialize_listener)
-      end
-
-      teardown do
-        @midi.listener.unstub(:on_message)
-      end
-
-      should "return listener" do
-        refute_nil @result
-        assert_equal MIDIEye::Listener, @result.class
-      end
-
-    end
-
-    context "#start" do
-
-      setup do
-        @midi.listener.expects(:on_message).once
-        @midi.listener.expects(:start).once
-      end
-
-      teardown do
-        @midi.listener.unstub(:on_message)
-        @midi.listener.unstub(:start)
-      end
-
-      should "activate callbacks" do
-        assert @midi.start
-      end
-
-    end
-
-    context "#add_note_callback" do
-
-      setup do
-        @var = nil
-        @midi.add_note_callback(10) { |vel| @var = vel }
-      end
-
-      should "store callback" do
-        refute_nil @midi.message_handler.callback[:note][10]
-        assert_equal Proc, @midi.message_handler.callback[:note][10].class
-      end
-
-    end
-
-    context "#add_system_callback" do
-
-      setup do
-        @var = nil
-        @midi.add_system_callback(:start) { |val| @var = val }
-      end
-
-      should "store callback" do
-        refute_nil @midi.message_handler.callback[:system][:start]
-        assert_equal Proc, @midi.message_handler.callback[:system][:start].class
-      end
-
-    end
-
-    context "#add_cc_callback" do
-
-      setup do
-        @var = nil
-        @midi.add_cc_callback(2) { |val| @var = val }
-      end
-
-      should "store callback" do
-        refute_nil @midi.message_handler.callback[:cc][2]
-        assert_equal Proc, @midi.message_handler.callback[:cc][2].class
-      end
-
-    end
-
-    context "#channel=" do
-
-      setup do
-        # stub out MIDIEye
-        @listener = Object.new
-        @listener.stubs(:event).returns([])
-        @midi.instance_variable_set("@listener", @listener)
-      end
-
-      teardown do
-        @listener.unstub(:clear)
-        @listener.unstub(:on_message)
-        @listener.unstub(:event)
-        @listener.unstub(:running?)
-      end
-
-      context "before listener is started" do
-
-        setup do
-          @listener.stubs(:running?).returns(false)
-          @listener.expects(:clear).never
-          @listener.expects(:on_message).never
-        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_nil @midi.channel = nil
-          assert_nil @midi.channel
-          assert @midi.omni?
-        end
-      end
-
-      context "after listener is started" do
-
-        setup do
-          @listener.stubs(:running?).returns(true)
-          @listener.expects(:clear).once
-          @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_nil @midi.channel = nil
-          assert_nil @midi.channel
-          assert @midi.omni?
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/test/player/wrapper_test.rb

@@ -1,53 +0,0 @@
-require "helper"
-
-class MVLC::Player::WrapperTest < Minitest::Test
-
-  context "Wrapper" do
-
-    setup do
-      @player = Object.new
-      @player.stubs(:quit)
-      conn = Object.new
-      conn.stubs(:write)
-      @player.stubs(:connection).returns(conn)
-      VLC::System.stubs(:new).returns(@player)
-      @player = MVLC::Player::Wrapper.new
-    end
-
-    context "#quit" do
-
-      setup do
-        #@vlc.expects(:quit).once
-        #@player.instance_variable_get("@threads").first.expects(:kill).once
-      end
-
-      teardown do
-        #@vlc.unstub(:quit)
-      #  @player.instance_variable_get("@threads").first.unstub(:kill)
-      end
-
-      should "exit MPlayer and kill the player thread" do
-        assert @player.quit
-      end
-
-    end
-
-    context "#play" do
-
-      setup do
-        @player.expects(:play).once.returns(true)
-      end
-
-      teardown do
-        @player.unstub(:play)
-      end
-
-      should "lazily invoke mplayer and play" do
-        assert @player.play("file.mov")
-      end
-
-    end
-
-  end
-
-end