voicemeeter_api_ruby 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 28ea13d4f9276d77a39c3edb392132cf026d6cb5fd6425c13a1ede4e2d6f9589
+  data.tar.gz: fcc60c1caa213fa159031a2b066f233a0c44872769c5827857708ff3d3531083
+SHA512:
+  metadata.gz: be2142be5a1e2ad1857877f96d435ec912c036ec61a6107bf53ebf5e7f0246391d4e42c17a89aab288981b6c5fac197c44331b3086eaa64dfc7ed86568f4cabd
+  data.tar.gz: 286a5397a410123a5d2fb9795267aa885955bfcfa3dc81b80382b896b06d2648328df723aa2872918436943c8c0f9f543be90a0de5ab6dd5547dc1432b33292b

data/lib/base.rb

@@ -0,0 +1,129 @@
+require 'ffi'
+require_relative 'inst'
+
+include InstallationFunctions
+
+module Base
+    extend FFI::Library
+
+    begin
+        OS_BITS = get_arch
+        VM_PATH = get_vmpath(OS_BITS)
+        DLL_NAME = "VoicemeeterRemote#{OS_BITS == 64 ? "64" : ""}.dll"
+
+        self.vmr_dll = VM_PATH.join(DLL_NAME)
+    rescue InstallErrors => error
+        puts "ERROR: #{error.message}"
+        raise
+    end
+
+    ffi_lib @vmr_dll
+    ffi_convention :stdcall
+
+    attach_function :vmr_login, :VBVMR_Login, [], :long
+    attach_function :vmr_logout, :VBVMR_Logout, [], :long
+    attach_function :vmr_runvm, :VBVMR_RunVoicemeeter, [:long], :long
+    attach_function :vmr_vmtype, :VBVMR_GetVoicemeeterType, [:pointer], :long
+
+    attach_function :vmr_mdirty, :VBVMR_MacroButton_IsDirty, [], :long
+    attach_function :vmr_macro_setstatus, :VBVMR_MacroButton_SetStatus, \
+    [:long, :float, :long], :long
+    attach_function :vmr_macro_getstatus, :VBVMR_MacroButton_GetStatus, \
+    [:long, :pointer, :long], :long
+
+    attach_function :vmr_pdirty, :VBVMR_IsParametersDirty, [], :long
+    attach_function :vmr_set_parameter_float, :VBVMR_SetParameterFloat, \
+    [:string, :float], :long
+    attach_function :vmr_get_parameter_float, :VBVMR_GetParameterFloat, \
+    [:string, :pointer], :long
+
+    attach_function :vmr_set_parameter_string, :VBVMR_SetParameterStringA, \
+    [:string, :string], :long
+    attach_function :vmr_get_parameter_string, :VBVMR_GetParameterStringA, \
+    [:string, :pointer], :long
+
+    attach_function :vmr_set_parameter_multi, :VBVMR_SetParameters, \
+    [:string], :long
+
+    DELAY = 0.001
+    MAX_POLLS = 8
+
+    def pdirty
+        return vmr_pdirty&.nonzero?
+    end
+
+    def mdirty
+        return vmr_mdirty&.nonzero?
+    end
+
+    def clear_polling
+        while self.pdirty || self.mdirty
+        end
+    end
+
+    def polling(func)
+        MAX_POLLS.times do
+            break if func.include?('param') && !self.pdirty
+            break if func.include?('macro') && !self.mdirty
+            sleep(DELAY)
+        end
+    end
+
+    def retval=(values)
+        """ Writer validation for CAPI calls """
+        retval, func = *values
+        raise CAPIErrors.new(retval, func) if retval&.nonzero?
+
+        @retval = retval
+    end
+
+    def run_as(func, *args)
+        val = send('vmr_' + func, *args)
+        sleep(DELAY * 20) if func.include? 'set_param'
+        sleep(DELAY * 50) if func.include? 'macro_set'
+
+        self.retval = [val, func]
+    end
+end
+
+module Define_Version
+    include Base
+
+    def define_version(kind)
+        case kind
+        when "basic"
+            self.properties = {
+                :name => kind,
+                :exe => "voicemeeter.exe"
+            }
+            self.layout = {
+                :strip => {:p_in => 2, :v_in=> 1},
+                :bus => {:p_out => 1, :v_out=> 1},
+                :vban => {:instream => 4, :outstream => 4},
+                :mb => 70,
+            }
+        when "banana"
+            self.properties = {
+                :name => kind,
+                :exe => "voicemeeterpro.exe"
+            }
+            self.layout = {
+                :strip => {:p_in => 3, :v_in=> 2},
+                :bus => {:p_out => 3, :v_out=> 2},
+                :vban => {:instream => 8, :outstream => 8},
+                :mb => 70,
+            }
+        when "potato"
+            self.properties = {
+                :name => kind,
+                :exe => "voicemeeter8#{OS_BITS == 64 ? "x64" : ""}.exe"
+            }
+            self.layout = {
+                :strip => {:p_in => 5, :v_in=> 3},
+                :bus => {:p_out => 5, :v_out=> 3},
+                :vban => {:instream => 8, :outstream => 8},
+                :mb => 70,
+            }
+        end
+    end
+end

data/lib/bus.rb

@@ -0,0 +1,31 @@
+require_relative 'channel'
+
+
+class Bus < IChannel
+    def self.make(remote, layout_bus)
+        "
+        Factory function for Bus classes.
+        "
+        p_out = layout_bus[:p_out]
+        v_out = layout_bus[:v_out]
+        
+        (0...(p_out + v_out)).map do |i|
+            i < p_out ? \
+            PhysicalBus.new(remote, i) : \
+            VirtualBus.new(remote, i)
+        end
+    end
+
+    def initialize(remote, i)
+        super
+        self.make_accessor_bool :mute, :mono, :eq
+        self.make_accessor_float :gain
+    end
+
+    def cmd
+        return "Bus[#{@index}]"
+    end
+end
+
+class PhysicalBus < Bus; end
+class VirtualBus < Bus; end

data/lib/button.rb

@@ -0,0 +1,35 @@
+require_relative 'meta'
+
+
+class IMacroButton
+    include MacroButton_Meta_Functions
+
+    attr_accessor :remote, :index
+
+    def initialize(remote, index)
+        self.remote = remote
+        self.index = index
+    end
+
+    def getter(mode)
+        return @remote.macro_getstatus(@index, mode)
+    end
+
+    def setter(set, mode)
+        @remote.macro_setstatus(@index, set, mode)
+    end
+end
+
+
+class MacroButton < IMacroButton
+    def self.make(remote, num_buttons)
+        (0...num_buttons).map do |i|
+            MacroButton.new(remote, i)
+        end
+    end
+
+    def initialize(remote, i)
+        super
+        self.make_accessor_macrobutton :state, :stateonly, :trigger 
+    end
+end

data/lib/channel.rb

@@ -0,0 +1,25 @@
+require_relative 'meta'
+require_relative 'errors'
+
+class IChannel
+    include Channel_Meta_Functions
+
+    attr_accessor :remote, :index
+
+    def initialize(remote, i)
+        self.remote = remote
+        self.index = i
+    end
+
+    def getter(param, is_string=false)
+        @remote.get_parameter("#{self.cmd}.#{param}", is_string)
+    end
+
+    def setter(param, value)
+        @remote.set_parameter("#{self.cmd}.#{param}", value)
+    end
+
+    def cmd
+        raise NotImplementedError
+    end
+end

data/lib/command.rb

@@ -0,0 +1,41 @@
+require_relative 'meta'
+
+
+class ICommand
+    include Commands_Meta_Functions
+
+    attr_accessor :remote
+
+    def initialize(remote)
+        self.remote = remote
+    end
+
+    def setter(param, value)
+        @remote.set_parameter("#{self.cmd}.#{param}", value)
+    end
+
+    def cmd
+        return "command"
+    end
+end
+
+
+class Command < ICommand
+    def initialize(remote)
+        super
+        self.make_writer_only :show, :restart, :reset, :shutdown
+        self.make_writer_bool :showvbanchat, :lock
+    end
+
+    def load(value)
+        raise VMRemoteErrros.new("Expected a string") unless value.is_a? String
+        self.setter("load", value)
+        sleep(0.2)
+    end
+
+    def save(value)
+        raise VMRemoteErrros.new("Expected a string") unless value.is_a? String
+        self.setter("save", value)
+        sleep(0.2)
+    end
+end

data/lib/errors.rb

@@ -0,0 +1,37 @@
+module Errors
+    class VMRemoteErrors < StandardError; end
+
+    class InstallErrors < VMRemoteErrors; end
+
+    class CAPIErrors < VMRemoteErrors
+        attr_accessor :value, :func
+
+        def initialize(value, func)
+            self.value = value
+            self.func = func
+        end
+
+        def message
+            "When attempting to run function #{@func} the
+            C API returned value #{@value}. See documentation for further info"
+        end
+    end
+
+    class OutOfBoundsErrors < VMRemoteErrors
+        attr_accessor :range
+
+        def initialize(range)
+            self.range = range
+        end
+
+        def message
+            if @range.kind_of?(Range)
+                "Value error, expected value in range (#{range.first}..#{range.last})"
+            elsif @range.kind_of?(Array)
+                "Value error, expected one of: #{@range}"
+            else
+                "Value error, expected #{@range}"
+            end
+        end
+    end
+end

data/lib/inst.rb

@@ -0,0 +1,40 @@
+require 'win32/registry'
+require 'pathname'
+require_relative 'errors'
+
+include Errors
+
+BASIC = 1
+BANANA = 2
+POTATO = 3
+
+module InstallationFunctions
+    def get_arch
+        key = 'SYSTEM\CurrentControlSet\Control\Session Manager\Environment'
+        Win32::Registry::HKEY_LOCAL_MACHINE.open(key) do |reg|
+            os_bits = reg["PROCESSOR_ARCHITECTURE"]
+            if os_bits.include? 64.to_s
+                return 64
+            end
+            return 32
+        end
+    end
+
+    def get_vmpath(os_bits)
+        vm_key = "VB:Voicemeeter {17359A74-1236-5467}"
+        reg_key = "Software#{os_bits == 64 ? "\\WOW6432Node" : ""}\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\"
+
+        Win32::Registry::HKEY_LOCAL_MACHINE.open(reg_key + vm_key) do |reg|           
+            value = reg["UninstallString"]
+
+            pn = Pathname.new(value)
+            return pn.dirname
+        end
+        raise InstallErrors.new('Could not get the Voicemeeter path')
+    end
+
+    def vmr_dll=(value)
+        raise InstallErrors.new('Could not fetch the dll file') unless value.file?
+        @vmr_dll = value
+    end
+end

data/lib/meta.rb

@@ -0,0 +1,242 @@
+require_relative 'errors'
+
+module Meta_Functions
+    def make_accessor_bool(*params)
+        params.each do |param|
+            define_singleton_method("#{param}") do
+                return !(self.getter("#{param}")).zero?
+            end
+
+            opts = [false, true]
+            define_singleton_method("#{param}=") do |value|
+                raise OutOfBoundsErrors.new(opts) unless opts.include? value
+                self.setter("#{param}", value ? 1 : 0)
+            end
+        end
+    end
+
+    def make_accessor_int(*params)
+        params.each do |param|
+            define_singleton_method("#{param}") do
+                return self.getter("#{param}").to_i
+            end
+            define_singleton_method("#{param}=") do |value|
+                self.setter("#{param}", value)
+            end
+        end
+    end
+
+    def make_accessor_float(*params)
+        params.each do |param|
+            define_singleton_method("#{param}") do
+                return self.getter("#{param}")
+            end
+            define_singleton_method("#{param}=") do |value|
+                self.setter("#{param}", value)
+            end
+        end
+    end
+
+    def make_accessor_string(*params)
+        params.each do |param|
+            define_singleton_method("#{param}") do
+                return self.getter("#{param}", true)
+            end
+            define_singleton_method("#{param}=") do |value|
+                self.setter("#{param}", value)
+            end
+        end
+    end
+
+    def make_reader_only(*params)
+        params.each do |param|
+            define_singleton_method("#{param}") do
+                return self.getter("#{param}")
+            end
+        end
+    end
+
+    def make_writer_only(*params)
+        params.each do |param|
+            define_singleton_method("#{param}=") do |value=1|
+                self.setter("#{param}", value)
+            end
+        end
+    end
+
+    def _make_channel_props(num_A, num_B)
+        channels = (1..(num_A + num_B)).map.each do |i|
+            i <= num_A ? "A#{i}" : "B#{i - num_A}"
+        end
+
+        self.make_accessor_bool *channels
+    end
+end
+
+
+module Channel_Meta_Functions
+    include Meta_Functions
+
+    def make_accessor_bool(*params)
+        params.each do |param|
+            cmds = {
+                :eq => 'EQ.on',
+            }
+            if cmds[param] then val = cmds[param] else val = param end
+
+            define_singleton_method("#{param}") do
+                return !(self.getter("#{val}")).zero?
+            end
+
+            opts = [false, true]
+            define_singleton_method("#{param}=") do |value|
+                raise OutOfBoundsErrors.new(opts) unless opts.include? value
+                self.setter("#{val}", value ? 1 : 0)
+            end
+        end
+    end
+
+    def make_accessor_float(*params)
+        params.each do |param|
+            define_singleton_method("#{param}") do
+                return self.getter("#{param}")
+            end
+
+            opts = {
+                :gain => [-60,12],
+                :comp => [0,10],
+                :gate => [0,10],
+            }
+            define_singleton_method("#{param}=") do |value|
+                raise OutOfBoundsErrors.new(opts[param]) unless value.between? *opts[param]
+                self.setter("#{param}", value)
+            end
+        end
+    end
+
+    def make_accessor_int(*params)
+        params.each do |param|
+            define_singleton_method("#{param}") do
+                return self.getter("#{param}").to_i
+            end
+
+            opts = {
+                :limit => (-40..12),
+            }
+            define_singleton_method("#{param}=") do |value|
+                raise OutOfBoundsErrors.new(opts[param]) unless opts[param].member? value
+                self.setter("#{param}", value)
+            end
+        end
+    end
+
+    def make_reader_only(*params)
+        params.each do |param|
+            cmds = {
+                :device => 'device.name',
+                :sr => 'device.sr',
+            }
+            if cmds[param] then val = cmds[param] else val = param end
+
+            define_singleton_method("#{param}") do
+                case param
+                when :device
+                    return self.getter("#{val}", true)
+                when :sr
+                    return self.getter("#{val}", true).to_i
+                end
+            end
+        end
+    end
+end
+
+
+module Vban_Meta_Functions
+    include Meta_Functions
+
+    def make_reader_int(*params)
+        params.each do |param|
+            define_singleton_method("#{param}") do
+                case param
+                when :bit
+                    return self.getter("#{param}").to_i == 1 ? 16 : 24
+                else
+                    return self.getter("#{param}").to_i
+                end
+            end
+        end
+    end
+
+    def make_accessor_int(*params)
+        params.each do |param|
+            define_singleton_method("#{param}") do
+                case param
+                when :bit
+                    return self.getter("#{param}").to_i == 1 ? 16 : 24
+                else
+                    return self.getter("#{param}").to_i
+                end
+            end
+
+            opts = {
+                :sr => [11025, 16000, 22050, 24000, 32000, 44100, 48000,
+                64000, 88200, 96000],
+                :channel => (1..8),
+                :bit => [16,24],
+                :quality => (0..4),
+                :route => (0..8),
+            }
+
+            define_singleton_method("#{param}=") do |value|
+                raise OutOfBoundsErrors.new(opts[param]) unless opts[param].member? value
+                case param
+                when :bit
+                    self.setter("#{param}", value == 16 ? 1 : 2)
+                else
+                    self.setter("#{param}", value)
+                end
+            end
+        end
+    end
+end
+
+
+module MacroButton_Meta_Functions
+    def make_accessor_macrobutton(*params)
+        params.each do |param|
+            mode = {
+                :state => 1,
+                :stateonly => 2,
+                :trigger => 3,
+            }
+
+            define_singleton_method("#{param}") do
+                return !(self.getter(mode[param])).zero?
+            end
+
+            opts = [false, true]
+            define_singleton_method("#{param}=") do |value|
+                raise OutOfBoundsErrors.new(opts[param]) unless opts.include? value
+                self.setter(value ? 1 : 0, mode[param])
+            end
+        end
+    end
+end
+
+module Commands_Meta_Functions
+    include Meta_Functions
+    def make_writer_bool(*params)
+        params.each do |param|
+            cmds = {
+                :showvbanchat => 'DialogShow.VBANCHAT',
+            }
+            if cmds[param] then val = cmds[param] else val = param end
+    
+            opts = [false, true]
+            define_singleton_method("#{param}=") do |value|
+                raise OutOfBoundsErrors.new(opts[param]) unless opts.include? value
+                self.setter("#{val}", value ? 1 : 0)
+            end
+        end
+    end
+end

data/lib/recorder.rb

@@ -0,0 +1,40 @@
+require_relative 'meta'
+
+
+class IRecorder
+    include Meta_Functions
+
+    attr_accessor :remote
+
+    def initialize(remote)
+        self.remote = remote
+    end
+
+    def getter(param)
+        @remote.get_parameter("#{self.cmd}.#{param}")
+    end
+
+    def setter(param, value)
+        @remote.set_parameter("#{self.cmd}.#{param}", value)
+    end
+
+    def cmd
+        raise NotImplementedError
+    end
+end
+
+
+class Recorder < IRecorder
+    def initialize(remote, layout_bus)
+        super(remote)
+        self.make_writer_only :play, :stop, :record, :ff, :rew
+
+        num_A = layout_bus[:p_out]
+        num_B = layout_bus[:v_out]
+        self._make_channel_props(num_A, num_B)
+    end
+
+    def cmd
+        return "recorder"
+    end
+end

data/lib/routines.rb

@@ -0,0 +1,117 @@
+require_relative 'base'
+require_relative 'runvm'
+require_relative 'strip'
+require_relative 'bus'
+require_relative 'button'
+require_relative 'vban'
+require_relative 'command'
+require_relative 'recorder'
+
+
+class Routines
+    """
+    define basic behaviours of API functions
+    mixin modules
+    """
+    include Define_Version
+    include RunVM
+
+    attr_accessor :properties, :layout, :strip, :bus, :button, :vban, :command,
+    :recorder
+
+    attr_reader :retval
+
+    SIZE = 1
+    BUFF = 512
+
+    def initialize(kind)
+        define_version(kind)
+
+        self.strip = Strip.make(self, @layout[:strip], @layout[:bus])
+        self.bus = Bus.make(self, @layout[:bus])
+        self.button = MacroButton.make(self, @layout[:mb])
+        self.vban = Vban.make(self, @layout[:vban])
+        self.command = Command.new(self)
+        self.recorder = Recorder.new(self, @layout[:bus])
+    end
+
+    def login
+        run_as("login")
+        clear_polling
+
+    rescue CAPIErrors => error
+        case
+        when error.value == 1
+            run_voicemeeter
+        when error.value < 0
+            raise
+        end
+    end
+
+    def logout
+        clear_polling
+        run_as("logout")
+    end
+
+    def get_parameter(name, is_string=false)
+        self.polling(__method__.to_s)
+
+        if is_string
+            c_get = FFI::MemoryPointer.new(:string, BUFF, true)
+            run_as("get_parameter_string", name, c_get)
+            c_get.read_string
+        else
+            c_get = FFI::MemoryPointer.new(:float, SIZE)
+            run_as("get_parameter_float", name, c_get)
+            c_get.read_float.round(1)
+        end
+    end
+
+    def set_parameter(name, value)
+        if value.is_a? String
+            run_as("set_parameter_string", name, value)
+        else    
+            run_as("set_parameter_float", name, value.to_f)
+        end
+    end
+
+    def macro_getstatus(id, mode)
+        self.polling(__method__.to_s)
+
+        c_get = FFI::MemoryPointer.new(:float, SIZE)
+        run_as("macro_getstatus", id, c_get, mode)
+        c_get.read_float.to_i
+    end
+
+    def macro_setstatus(id, state, mode)
+        run_as("macro_setstatus", id, state, mode)
+    end
+
+    def set_parameter_multi(param_hash)
+        param_hash.each do |(key,val)|
+            prop, m2, m3, *remaining = key.to_s.split('_')
+            if m2.to_i.to_s == m2 then m2 = m2.to_i end
+            if m3.to_i.to_s == m3 then m3 = m3.to_i end
+
+            param_hash[key].each do |(k,v)|
+                param = k
+                value = v
+
+                case prop
+                when "strip"
+                    self.strip[m2].send("#{param}=", value)
+                when "bus"
+                    self.bus[m2].send("#{param}=", value)
+                when "button"
+                    self.button[m2].send("#{param}=", value)
+                when "vban"
+                    if m2 == "instream"
+                        self.vban.instream[m3].send("#{param}=", value)
+                    else
+                        self.vban.outstream[m3].send("#{param}=", value)
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/runvm.rb

@@ -0,0 +1,20 @@
+require 'open3'
+require_relative 'errors'
+require_relative 'base'
+
+module RunVM
+    include Base
+
+    def run_voicemeeter
+        if VM_PATH.join(@properties[:exe]).executable?
+            exe_path = String(VM_PATH.join(@properties[:exe]))
+        else
+            raise InstallErrors.new("Could not find Voicemeeter exe file")
+        end
+
+        Open3.popen3(exe_path, '')
+        sleep(1)
+
+        clear_polling
+    end
+end

data/lib/strip.rb

@@ -0,0 +1,49 @@
+require_relative 'channel'
+
+
+class Strip < IChannel
+    attr_reader :num_A, :num_B
+
+    def self.make(remote, layout_strip, out_channels)
+        "
+        Factory function for Strip classes.
+        "
+        p_in = layout_strip[:p_in]
+        v_in = layout_strip[:v_in]
+        num_A = out_channels[:p_out]
+        num_B = out_channels[:v_out]
+
+        (0...(p_in + v_in)).map do |i|
+            i < p_in ? \
+            PhysicalStrip.new(remote, i, num_A, num_B) : \
+            VirtualStrip.new(remote, i, num_A, num_B) 
+        end
+    end
+
+    def initialize(remote, i, num_A, num_B)
+        super(remote, i)
+        self.make_accessor_bool :solo, :mute, :mono
+        self.make_accessor_float :gain
+        self._make_channel_props(num_A, num_B)
+    end
+
+    def cmd
+        return "Strip[#{@index}]"
+    end
+end
+
+class PhysicalStrip < Strip
+    def initialize(remote, i, num_A, num_B)
+        super
+        self.make_accessor_float :comp, :gate
+        self.make_accessor_int :limit
+        self.make_reader_only :device, :sr
+    end
+end
+
+class VirtualStrip < Strip
+    def initialize(remote, i, num_A, num_B)
+        super
+        self.make_accessor_bool :mc, :k
+    end
+end

data/lib/vban.rb

@@ -0,0 +1,92 @@
+require_relative 'meta'
+require_relative 'errors'
+
+
+class IVban
+    include Vban_Meta_Functions
+
+    attr_accessor :remote, :index
+
+    def initialize(remote, index)
+        self.remote = remote
+        self.index = index
+    end
+
+    def getter(param, is_string=false)
+        @remote.get_parameter("#{self.cmd}.#{param}", is_string)
+    end
+
+    def setter(param, value)
+        @remote.set_parameter("#{self.cmd}.#{param}", value)
+    end
+
+    def cmd
+        return "vban.#{self.direction}stream[#{@index}]"
+    end
+
+    def direction
+        raise NotImplementedError
+    end
+end
+
+
+class Vban < IVban
+    def self.make(remote, vban_streams)
+        "
+        Factory function for Vban class.
+
+        Returns a mixin of instream/outstream subclasses
+        "
+        class << self
+            attr_accessor :instream, :outstream, :remote
+
+            def enable
+                @remote.set_parameter("vban.enable", 1)
+            end
+            def disable
+                @remote.set_parameter("vban.enable", 0)
+            end
+        end
+
+        self.instream = 
+        (0...vban_streams[:instream]).map do |i|
+            VbanInstream.new(remote, i)
+        end
+        self.outstream = 
+        (0...vban_streams[:outstream]).map do |i|
+            VbanOutstream.new(remote, i)
+        end
+
+        self.remote = remote
+        return self
+    end
+
+    def initialize(remote, i)
+        super
+        self.make_accessor_bool :on
+        self.make_accessor_string :name, :ip
+        self.make_accessor_int :quality, :route
+    end
+end
+
+class VbanInstream < Vban
+    def initialize(remote, i)
+        super
+        self.make_reader_int :sr, :channel, :bit
+    end
+
+    def direction
+        return "in"
+    end
+end
+
+class VbanOutstream < Vban
+    def initialize(remote, i)
+        super
+        self.make_accessor_int :sr, :channel, :bit
+    end
+
+    def direction
+        return "out"
+    end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Voicemeeter_API_Ruby
+    VERSION = '2.0.0'
+end

data/lib/voicemeeter.rb

@@ -0,0 +1,30 @@
+require_relative 'routines'
+require_relative 'errors'
+
+module Voicemeeter
+    class Remote < Routines
+        def self.make
+            ["basic", "banana", "potato"].to_h do |kind|
+                [kind, Remote.new(kind)]
+            end
+        end
+
+        def run
+            if block_given?
+                yield
+                
+                logout
+            end
+        end
+    end
+
+    def remote(kind)
+        _remotes = Remote.make
+
+        raise VMRemoteErrors.new("Unknown Voicemeeter Kind") unless _remotes[kind]
+        _remotes[kind].login
+        return _remotes[kind]
+    end
+
+    module_function :remote
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: voicemeeter_api_ruby
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- onyx_online
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-01-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.10
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.3
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.14.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.14.4
+description: A wrapper for Voicemeeter virtual mixer API in Ruby
+email: code@onyxandiris.online
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/base.rb
+- lib/bus.rb
+- lib/button.rb
+- lib/channel.rb
+- lib/command.rb
+- lib/errors.rb
+- lib/inst.rb
+- lib/meta.rb
+- lib/recorder.rb
+- lib/routines.rb
+- lib/runvm.rb
+- lib/strip.rb
+- lib/vban.rb
+- lib/version.rb
+- lib/voicemeeter.rb
+homepage: https://rubygems.org/gems/voicemeeter_api_ruby
+licenses:
+- NGPL
+metadata:
+  source_code_uri: https://github.com/onyx-and-iris/voicemeeter-api-ruby.git
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: Voicemeeter API wrapper
+test_files: []