voicemeeter_api_ruby 2.0.4 → 3.0.0

data/lib/base.rb

@@ -1,171 +1,151 @@
-require 'toml'
-require 'ffi'
-require_relative 'inst'
-
-include InstallationFunctions
-
-
-module Base
-    """
-    Perform low level tasks.
-    """
-    extend FFI::Library
-
-    $kinds_all = ["basic", "banana", "potato"]
-
-    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
-
-    private
-    def clear_polling
-        while self.pdirty? || self.mdirty?
-        end
-    end
-
-    def polling(func, **kwargs)
-        params = {
-            "get_parameter" => kwargs[:name],
-            "macro_getstatus" => "mb_#{kwargs[:id]}_#{kwargs[:mode]}"
-        }
-        @max_polls.times do |i|
-            if @cache.key? params[func]
-                if func.include?('param') && self.pdirty? ||
-                func.include?('macro') && self.mdirty?
-                    return @cache.delete(params[func])[0]
-                end
-                sleep(DELAY)
-                break if @cache[params[func]][1] == false && i == 1
-            end
-        end
-
-        val = yield
-        @cache.store(params[func], [val, false])
-        val
-    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)
-        self.retval = [val, func]
-        sleep(DELAY) if func.include?('set') && @wait
-    end
-end
-
-module Define_Version
-    """
-    Defines the console layout for a specific kind of Voicemeeter.
-    """
-    include Base
-    private
-    def define_version(kind)
-        case kind
-        when "basic"
-            @properties = {
-                :name => kind,
-                :exe => "voicemeeter.exe",
-            }
-            @layout = {
-                :strip => {:p_in => 2, :v_in=> 1},
-                :bus => {:p_out => 1, :v_out=> 1},
-                :vban => {:instream => 4, :outstream => 4},
-                :mb => 70,
-            }
-        when "banana"
-            @properties = {
-                :name => kind,
-                :exe => "voicemeeterpro.exe",
-            }
-            @layout = {
-                :strip => {:p_in => 3, :v_in=> 2},
-                :bus => {:p_out => 3, :v_out=> 2},
-                :vban => {:instream => 8, :outstream => 8},
-                :mb => 70,
-            }
-        when "potato"
-            @properties = {
-                :name => kind,
-                :exe => "voicemeeter8#{OS_BITS == 64 ? "x64" : ""}.exe",
-            }
-            @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
-
-
-module Profiles
-    include Define_Version
-    private
-    def get_profiles
-        filepath = File.join(File.dirname(__dir__), "/profiles/#{@properties[:name]}/*.toml")
-
-        Dir.glob(filepath).to_h do |toml_file|
-            filename = File.basename(toml_file, ".toml")
-            puts "loading profile #{@properties[:name]}/#{filename}"
-            [filename, TOML::Parser.new(File.read(toml_file)).parsed]
-        end
-    end
-    public
-    def set_profile(value)
-        raise VMRemoteErrors.new("No profile with name #{value} was loaded") unless @profiles.key? value
-        self.send("set_multi", @profiles[value])
-        sleep(DELAY)
-    end 
-end
+require_relative 'runvm'
+require_relative 'profiles'
+require_relative 'errors'
+require_relative 'strip'
+require_relative 'bus'
+require_relative 'button'
+require_relative 'vban'
+require_relative 'command'
+require_relative 'recorder'
+
+class Base
+    '
+    Base class responsible for wrapping the C Remote API
+
+    Mixin required modules
+    '
+    include Profiles
+    include RunVM
+
+    attr_accessor :strip, :bus, :button, :vban, :command, :recorder
+
+    attr_reader :kind, :retval, :cache, :profiles, :delay
+
+    DELAY = 0.001
+    SYNC = false
+    SIZE = 1
+    BUFF = 512
+
+    def initialize(kind, **kwargs)
+        @kind = kind
+        @p_in, @v_in = kind.layout[:strip].values
+        @p_out, @v_out = kind.layout[:bus].values
+        @cache = Hash.new
+        @sync = kwargs[:sync] || SYNC
+        @delay = DELAY
+        @profiles = get_profiles(@kind)
+        @cdll =
+            lambda do |func, *args|
+                self.retval = [send("vmr_#{func}", *args), func]
+            end
+    end
+
+    def login
+        @cdll.call('login')
+        clear_polling
+    rescue CAPIErrors => error
+        case
+        when error.value == 1
+            self.start(@kind.name)
+            clear_polling
+        when error.value < 0
+            raise
+        end
+    end
+
+    def logout
+        clear_polling
+        sleep(0.1)
+        @cdll.call('logout')
+    end
+
+    def get_parameter(name, is_string = false)
+        self.polling('get_parameter', name: name) do
+            if is_string
+                c_get = FFI::MemoryPointer.new(:string, BUFF, true)
+                @cdll.call('get_parameter_string', name, c_get)
+                c_get.read_string
+            else
+                c_get = FFI::MemoryPointer.new(:float, SIZE)
+                @cdll.call('get_parameter_float', name, c_get)
+                c_get.read_float.round(1)
+            end
+        end
+    end
+
+    def set_parameter(name, value)
+        if value.is_a? String
+            @cdll.call('set_parameter_string', name, value)
+        else
+            @cdll.call('set_parameter_float', name, value.to_f)
+        end
+        @cache.store(name, value)
+    end
+
+    def get_buttonstatus(id, mode)
+        self.polling('get_buttonstatus', id: id, mode: mode) do
+            c_get = FFI::MemoryPointer.new(:float, SIZE)
+            @cdll.call('get_buttonstatus', id, c_get, mode)
+            c_get.read_float.to_i
+        end
+    end
+
+    def set_buttonstatus(id, state, mode)
+        @cdll.call('set_buttonstatus', id, state, mode)
+        @cache.store("mb_#{id}_#{mode}", state)
+    end
+
+    def set_parameter_multi(param_hash)
+        param_hash.each do |(key, val)|
+            prop, m2, m3, *rem = key.to_s.split('_')
+            if m2.to_i.to_s == m2
+                m2 = m2.to_i
+            elsif m3.to_i.to_s == m3
+                m3 = m3.to_i
+            end
+
+            case prop
+            when 'strip'
+                self.strip[m2].set_multi(val)
+            when 'bus'
+                self.bus[m2].set_multi(val)
+            when 'button', 'mb'
+                self.button[m2].set_multi(val)
+            when 'vban'
+                if %w[instream in].include? m2
+                    self.vban.instream[m3].set_multi(val)
+                elsif %w[outstream out].include? m2
+                    self.vban.outstream[m3].set_multi(val)
+                end
+            end
+            sleep(DELAY)
+        end
+    end
+
+    def get_level(type, index)
+        c_get = FFI::MemoryPointer.new(:float, SIZE)
+        @cdll.call('get_level', type, index, c_get)
+        c_get.read_float
+    end
+
+    def strip_levels
+        '
+        Returns the full level array for strips, PREFADER mode, 
+        before math conversion
+        '
+        (0...(2 * @p_in + 8 * @v_in)).map { |i| get_level(0, i) }
+    end
+
+    def bus_levels
+        '
+        Returns the full level array for buses, before math conversion
+        '
+        (0...(8 * (@p_out + @v_out))).map { |i| get_level(3, i) }
+    end
+
+    alias_method 'set_multi', :set_parameter_multi
+    alias_method 'get', :get_parameter
+    alias_method 'set', :set_parameter
+    alias_method 'pdirty', :pdirty?
+    alias_method 'mdirty', :pdirty?
+end

data/lib/bus.rb

@@ -1,33 +1,64 @@
-require_relative 'channel'
-
-
-class Bus < IChannel
-    """
-    Concrete class for Bus objects
-    """
-    def self.make(remote, layout_bus)
-        "
-        Factory function for Bus classes.
-        "
-        p_out, v_out = layout_bus.map { |k, v| v }
-        (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
-        self.make_accessor_string :label
-    end
-
-    def cmd
-        return "Bus[#{@index}]"
-    end
-end
-
-class PhysicalBus < Bus; end
-class VirtualBus < Bus; end
+require_relative 'channel'
+
+class Bus < IChannel
+    '
+    Concrete Bus class
+    '
+    include Fades
+
+    attr_accessor :mode
+
+    def self.make(remote, layout_bus)
+        '
+        Factory function for Bus classes.
+        '
+        p_out, v_out = layout_bus.values
+        (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
+        self.make_accessor_string :label
+
+        @mode = BusModes.new(remote, i)
+    end
+
+    def identifier
+        :bus
+    end
+end
+
+class PhysicalBus < Bus
+end
+class VirtualBus < Bus
+end
+
+class BusModes < IChannel
+    def initialize(remote, i)
+        super
+        self.make_bus_modes :normal,
+                            :amix,
+                            :bmix,
+                            :repeat,
+                            :composite,
+                            :tvmix,
+                            :upmix21,
+                            :upmix41,
+                            :upmix61,
+                            :centeronly,
+                            :lfeonly,
+                            :rearonly
+    end
+
+    def identifier
+        :bus
+    end
+
+    def cmd
+        "#{super}.mode"
+    end
+end

data/lib/button.rb

@@ -1,42 +1,36 @@
-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
-
-    def set_multi(param_hash)
-        param_hash.each do |(key,val)|
-            self.send("#{key}=", val)
-        end
-        sleep(remote.delay)
-    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
+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)
+        @remote.get_buttonstatus(@index, mode)
+    end
+
+    def setter(set, mode)
+        @remote.set_buttonstatus(@index, set, mode)
+    end
+
+    def set_multi(param_hash)
+        param_hash.each { |(key, val)| self.send("#{key}=", val) }
+        sleep(remote.delay)
+    end
+end
+
+class MacroButton < IMacroButton
+    def self.make(remote, num_buttons)
+        (0...num_buttons).map { |i| MacroButton.new(remote, i) }
+    end
+
+    def initialize(remote, i)
+        super
+        self.make_accessor_macrobutton :state, :stateonly, :trigger
+    end
+end

data/lib/cbindings.rb

@@ -0,0 +1,103 @@
+require 'ffi'
+require_relative 'inst'
+
+include InstallationFunctions
+
+module CBindings
+    '
+    Creates Ruby bindings to the C DLL
+
+    Performs other low level tasks
+    '
+    extend FFI::Library
+
+    private
+
+    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_get_buttonstatus,
+                    :VBVMR_MacroButton_GetStatus,
+                    %i[long pointer long],
+                    :long
+    attach_function :vmr_set_buttonstatus,
+                    :VBVMR_MacroButton_SetStatus,
+                    %i[long float long],
+                    :long
+
+    attach_function :vmr_pdirty, :VBVMR_IsParametersDirty, [], :long
+    attach_function :vmr_get_parameter_float,
+                    :VBVMR_GetParameterFloat,
+                    %i[string pointer],
+                    :long
+    attach_function :vmr_set_parameter_float,
+                    :VBVMR_SetParameterFloat,
+                    %i[string float],
+                    :long
+
+    attach_function :vmr_get_parameter_string,
+                    :VBVMR_GetParameterStringA,
+                    %i[string pointer],
+                    :long
+    attach_function :vmr_set_parameter_string,
+                    :VBVMR_SetParameterStringA,
+                    %i[string string],
+                    :long
+
+    attach_function :vmr_set_parameter_multi,
+                    :VBVMR_SetParameters,
+                    [:string],
+                    :long
+
+    attach_function :vmr_get_level,
+                    :VBVMR_GetLevel,
+                    %i[long long pointer],
+                    :long
+
+    def polling(func, **kwargs)
+        params = {
+            'get_parameter' => kwargs[:name],
+            'get_buttonstatus' => "mb_#{kwargs[:id]}_#{kwargs[:mode]}",
+        }
+        return @cache.delete(params[func]) if @cache.key? params[func]
+
+        self.clear_polling if @sync
+
+        yield
+    end
+
+    def retval=(values)
+        ' Writer validation for CAPI calls '
+        retval, func = *values
+        raise CAPIErrors.new(retval, func) if retval&.nonzero?
+        @retval = retval
+    end
+
+    public
+
+    def clear_polling
+        while self.pdirty? || self.mdirty?
+        end
+    end
+
+    def pdirty?() =  vmr_pdirty&.nonzero?
+
+    def mdirty?() =  vmr_mdirty&.nonzero?
+end