mvlc 0.0.1

data/lib/mvlc/player.rb

@@ -0,0 +1,14 @@
+require "mvlc/player/state"
+require "mvlc/player/wrapper"
+
+module MVLC
+
+  module Player
+
+    def self.new(*args)
+      ::MVLC::Player::Wrapper.new(*args)
+    end
+
+  end
+
+end

data/lib/mvlc/player/state.rb

@@ -0,0 +1,44 @@
+module MVLC
+
+  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/mvlc/player/wrapper.rb

@@ -0,0 +1,148 @@
+module MVLC
+
+  module Player
+
+    # Wrapper for MPlayer functionality
+    class Wrapper
+
+      VOLUME_FACTOR = 2.4
+
+      extend Forwardable
+
+      attr_reader :state, :player
+
+      # @param [Hash] options
+      def initialize(options = {})
+        @callback = {}
+        @state = State.new
+        @player = VLC::System.new(headless: true)
+      end
+
+      def volume(value)
+        @player.volume(value * VOLUME_FACTOR)
+      end
+
+      def seek_percent(percent)
+        begin
+          length_in_seconds = @player.length
+          seconds = length_in_seconds * (percent / 100.0)
+          @player.seek(seconds)
+        rescue VLC::ReadTimeoutError
+        end
+      end
+
+      # Play a media file
+      # @param [String] file
+      # @return [Boolean]
+      def play(file)
+        if @player.nil?
+          false
+        else
+          @player.play(file)
+          handle_start
+          true
+        end
+      end
+
+      # Is MPlayer active?
+      # @return [Boolean]
+      def active?
+        !@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
+          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
+
+      # Cause MPlayer to exit
+      # @return [Boolean]
+      def quit
+        @player.connection.write("quit")
+        @player.connection.write("logout")
+        true
+      end
+
+      # Add all of the MPlayer::Slave methods to the context as instructions
+      def method_missing(method, *args, &block)
+        if @player.respond_to?(method)
+          @player.send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      # Add all of the MPlayer::Slave methods to the context as instructions
+      def respond_to_missing?(method, include_private = false)
+        super || @player.respond_to?(method)
+      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
+
+      # Handle the end of playback for a single media file
+      def handle_eof
+        @callback[:end_of_file].call
+        @state.handle_eof
+        true
+      end
+
+      # Handle the beginning of playback for a single media file
+      def handle_start
+        @state.handle_start
+      end
+
+      # Has the end of a media file been reached?
+      # @return [Boolean]
+      def eof?
+        @state.eof_reached? && !@player.playing?
+      end
+
+    end
+
+  end
+end

data/lib/mvlc/thread.rb

@@ -0,0 +1,28 @@
+module MVLC
+
+  module Thread
+
+    extend self
+
+    def new(options = {}, &block)
+      thread = ::Thread.new do
+        begin
+          if options[:timeout] === false
+            yield
+          else
+            duration = options[:timeout] || 1
+            Timeout::timeout(duration) { yield }
+          end
+        rescue Timeout::Error
+          ::Thread.current.kill
+        rescue Exception => exception
+          ::Thread.main.raise(exception)
+        end
+      end
+      thread.abort_on_exception = true
+      thread
+    end
+
+  end
+
+end

data/test/context_test.rb

@@ -0,0 +1,65 @@
+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

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

data/test/helper/numbers_test.rb

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,78 @@
+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