mvlc 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 052f8904644cacbb9b81cc9c9e2e72eef3150cb8
+  data.tar.gz: 88428d64855c4252236e557dd4f68b3748f921a2
+SHA512:
+  metadata.gz: e7e0ba57b4fb5f7e33435f6353187dd8ad57c0c282ea5a8fadc769bbfd03914154da75d0e704bc00318517fa3ca5ae970b1e3065a0faa534d9bee845d695cc5c
+  data.tar.gz: 7c36b2b70a1042f21dac9e9c1ee257a1249c104893b4b422908e564342fd7e10c061cd548bf81f7b08b531cd7a18faee0c0bad59a65addc83d2ad2857fa2cb33

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2017 Ari Russo
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,11 @@
+# mmplayer
+
+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
+
+## License
+
+Apache 2.0, See LICENSE file
+
+Copyright (c) 2017 [Ari Russo](http://arirusso.com)

data/lib/mvlc.rb

@@ -0,0 +1,34 @@
+# MVLC
+# Control VLC media player with MIDI
+#
+# (c)2017 Ari Russo
+# Apache 2.0 License
+
+# libs
+require "forwardable"
+require "midi-eye"
+require "scale"
+require "timeout"
+require "unimidi"
+require "vlc-client"
+
+# modules
+require "mvlc/helper/numbers"
+require "mvlc/instructions"
+require "mvlc/midi"
+require "mvlc/player"
+require "mvlc/thread"
+
+# classes
+require "mvlc/context"
+
+module MVLC
+
+  VERSION = "0.0.1"
+
+  # Shortcut to Context constructor
+  def self.new(*args, &block)
+    Context.new(*args, &block)
+  end
+
+end

data/lib/mvlc/context.rb

@@ -0,0 +1,67 @@
+module MVLC
+
+  # DSL context for interfacing an instance of MPlayer with MIDI
+  class Context
+
+    include Helper::Numbers
+    include Instructions::MIDI
+    include Instructions::Player
+
+    attr_reader :midi, :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)
+      midi_options = {
+        :buffer_length => options[:midi_buffer_length],
+        :receive_channel => options[:receive_channel] || options[:rx_channel]
+      }
+      @midi = MIDI.new(midi_input, midi_options)
+      @player = Player.new(:flags => options[:mplayer_flags])
+      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
+    # @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.join unless !!options[:background]
+      rescue SystemExit, Interrupt
+        stop
+      end
+      true
+    end
+
+    # Stop the player
+    # @return [Boolean]
+    def stop
+      @midi.stop
+      @player.quit
+      @playback_thread.kill
+      true
+    end
+
+    private
+
+    # Main playback loop
+    def playback_loop
+      ::MVLC::Thread.new(:timeout => false) do
+        until @player.active?
+          sleep(0.1)
+        end
+        @player.playback_loop
+      end
+    end
+
+  end
+
+end

data/lib/mvlc/helper/numbers.rb

@@ -0,0 +1,26 @@
+module MVLC
+
+  module Helper
+
+    # Number conversion
+    module Numbers
+
+      # Converts a percentage to a 7-bit int value eg 50 -> 0x40
+      # @param [Integer] num
+      # @return [Integer]
+      def to_midi_value(num)
+        Scale.transform(num).from(0..100).to(0..127.0).round
+      end
+
+      # Converts a MIDI 7-bit int value to a percentage eg 0x40 -> 50
+      # @param [Integer] num
+      # @return [Integer]
+      def to_percent(num)
+        Scale.transform(num).from(0..127).to(0..100.0).round
+      end
+
+    end
+
+  end
+
+end

data/lib/mvlc/instructions.rb

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

data/lib/mvlc/instructions/midi.rb

@@ -0,0 +1,46 @@
+module MVLC
+
+  module Instructions
+
+    # Instructions for dealing with MIDI
+    module MIDI
+
+      # Set the MIDI channel to receive messages on
+      # @param [Integer, nil] num The channel number 0-15 or nil for all
+      def receive_channel(num)
+        @midi.channel = num
+      end
+      alias_method :rx_channel, :receive_channel
+
+      # Assign a callback for a given MIDI system command
+      # @param [String, Symbol] note A MIDI system command eg :start, :continue, :stop
+      # @param [Proc] callback The callback to execute when a matching message is received
+      # @return [Hash]
+      def on_system(command, &callback)
+        @midi.add_system_callback(command, &callback)
+      end
+      alias_method :system, :on_system
+
+      # Assign a callback for a given MIDI note
+      # @param [Integer, String] note A MIDI note eg 64 "F4" or nil for all
+      # @param [Proc] callback The callback to execute when a matching message is received
+      # @return [Hash]
+      def on_note(note = nil, &callback)
+        @midi.add_note_callback(note, &callback)
+      end
+      alias_method :note, :on_note
+
+      # Assign a callback for the given MIDI control change
+      # @param [Integer] index The MIDI control change index to assign the callback for or nil for all
+      # @param [Proc] callback The callback to execute when a matching message is received
+      # @return [Hash]
+      def on_cc(index = nil, &callback)
+        @midi.add_cc_callback(index, &callback)
+      end
+      alias_method :cc, :on_cc
+
+    end
+
+  end
+
+end

data/lib/mvlc/instructions/player.rb

@@ -0,0 +1,50 @@
+module MVLC
+
+  module Instructions
+
+    # 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]
+      def on_end_of_file(&callback)
+        @player.add_end_of_file_callback(&callback)
+      end
+      alias_method :end_of_file, :on_end_of_file
+      alias_method :eof, :on_end_of_file
+
+      private
+
+      # Add delegators to local player methods
+      def self.included(base)
+        base.send(:extend, Forwardable)
+        base.send(:def_delegators, :@player, :active?, :play)
+      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
+
+    end
+
+  end
+end

data/lib/mvlc/midi.rb

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

data/lib/mvlc/midi/message_handler.rb

@@ -0,0 +1,112 @@
+module MVLC
+
+  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 [Integer, 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 [Integer, 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 [Integer, nil] channel
+      # @param [MIDIMessage] message
+      # @return [Boolean, nil]
+      def process(channel, message)
+        case message
+        when MIDIMessage::SystemCommon, MIDIMessage::SystemExclusive, 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 [Integer, 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/mvlc/midi/wrapper.rb

@@ -0,0 +1,115 @@
+module MVLC
+
+  module MIDI
+
+    # Wrapper for MIDI functionality
+    class Wrapper
+
+      attr_reader :channel, :listener, :message_handler
+
+      # @param [UniMIDI::Input, Array<UniMIDI::Input>] input
+      # @param [Hash] options
+      # @option options [Integer] :buffer_length Length of MIDI message buffer in seconds
+      # @option options [Integer] :receive_channel A MIDI channel to subscribe to. By default, responds to all
+      def initialize(input, options = {})
+        @buffer_length = options[:buffer_length]
+        @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 [Integer, 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 [Integer, 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 [Integer, nil] channel
+      # @return [Integer, nil]
+      def channel=(channel)
+        @listener.event.clear
+        @channel = channel
+        initialize_listener if @listener.running?
+        @channel
+      end
+
+      # Start the MIDI listener
+      # @return [Boolean]
+      def start
+        initialize_listener
+        @start_time = Time.now.to_i
+        @listener.start(:background => true)
+        true
+      end
+
+      # Whether the player is subscribed to all channels
+      # @return [Boolean]
+      def omni?
+        @channel.nil?
+      end
+
+      private
+
+      # Elapsed time since start in seconds
+      # @return [Integer]
+      def now
+        Time.now.to_i - @start_time
+      end
+
+      # Should the given MIDI event be processed or thrown away?
+      # @param [Hash] event
+      # @return [Boolean]
+      def process_event?(event)
+        @buffer_length.nil? ||
+          event[:timestamp].nil? ||
+          event[:timestamp].to_i >= now - @buffer_length
+      end
+
+      # Handle a new MIDI event received
+      # @param [Hash] event
+      # @return [Hash]
+      def handle_new_event(event)
+        if process_event?(event)
+          message = event[:message]
+          @message_handler.process(@channel, message)
+          event
+        end
+      end
+
+      # Populate the MIDI listener callback
+      # @return [MIDIEye::Listener]
+      def initialize_listener
+        @listener.on_message { |event| handle_new_event(event) }
+        @listener
+      end
+
+    end
+
+  end
+end