voicemeeter_api_ruby 4.1.5 → 4.2.0

data/lib/bus.rb

@@ -1,105 +0,0 @@
-require_relative "iremote"
-
-class Bus < IRemote
-  "
-  Concrete Bus class
-  "
-  include Channel_Meta_Functions
-
-  attr_accessor :mode, :levels
-
-  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, :sel
-    self.make_accessor_float :gain
-    self.make_accessor_string :label
-
-    @mode = BusModes.new(remote, i)
-    @levels = BusLevels.new(remote, i)
-  end
-
-  def identifier
-    "bus[#{@index}]"
-  end
-
-  def fadeto(target, time)
-    self.setter("FadeTo", "(#{target}, #{time})")
-    sleep(@remote.delay)
-  end
-
-  def fadeby(change, time)
-    self.setter("FadeBy", "(#{change}, #{time})")
-    sleep(@remote.delay)
-  end
-end
-
-class PhysicalBus < Bus
-  def initialize(remote, i)
-    super
-    self.make_reader_only :device, :sr
-  end
-end
-
-class VirtualBus < Bus
-end
-
-class BusModes < IRemote
-  include Channel_Meta_Functions
-
-  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[#{@index}].mode"
-  end
-end
-
-class BusLevels < IRemote
-  def initialize(remote, i)
-    super
-    @init = i * 8
-    @offset = 8
-  end
-
-  def identifier
-    "bus[#{@index}]"
-  end
-
-  def getter(mode)
-    if @remote.running
-      vals = @remote.cache["bus_level"][@init, @offset]
-    else
-      vals = (@init...@offset).map { |i| @remote.get_level(mode, i) }
-    end
-    vals.map { |x| x > 0 ? (20 * Math.log(x, 10)).round(1) : -200.0 }
-  end
-
-  def all
-    getter(3)
-  end
-
-  def isdirty? = @remote._bus_comp[@init, @offset].any?
-end

data/lib/button.rb

@@ -1,23 +0,0 @@
-require_relative "iremote"
-require_relative "meta"
-
-class MacroButton < IRemote
-  include MacroButton_Meta_Functions
-
-  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
-
-  def getter(mode)
-    @remote.get_buttonstatus(@index, mode)
-  end
-
-  def setter(set, mode)
-    @remote.set_buttonstatus(@index, set, mode)
-  end
-end

data/lib/cbindings.rb

@@ -1,125 +0,0 @@
-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 = FFI::Platform::CPU.downcase == "x64" ? 64 : 32
-    VM_PATH = get_vmpath(OS_BITS)
-    DLL_NAME = "VoicemeeterRemote#{OS_BITS == 64 ? "64" : ""}.dll"
-
-    self.vm_dll = VM_PATH.join(DLL_NAME)
-  rescue InstallErrors => error
-    puts "ERROR: #{error.message}"
-    raise
-  end
-
-  ffi_lib @vm_dll
-  ffi_convention :stdcall
-
-  attach_function :vm_login, :VBVMR_Login, [], :long
-  attach_function :vm_logout, :VBVMR_Logout, [], :long
-  attach_function :vm_runvm, :VBVMR_RunVoicemeeter, [:long], :long
-  attach_function :vm_vmtype, :VBVMR_GetVoicemeeterType, [:pointer], :long
-  attach_function :vm_vmversion, :VBVMR_GetVoicemeeterVersion, [:pointer], :long
-
-  attach_function :vm_mdirty, :VBVMR_MacroButton_IsDirty, [], :long
-  attach_function :vm_get_buttonstatus,
-                  :VBVMR_MacroButton_GetStatus,
-                  %i[long pointer long],
-                  :long
-  attach_function :vm_set_buttonstatus,
-                  :VBVMR_MacroButton_SetStatus,
-                  %i[long float long],
-                  :long
-
-  attach_function :vm_pdirty, :VBVMR_IsParametersDirty, [], :long
-  attach_function :vm_get_parameter_float,
-                  :VBVMR_GetParameterFloat,
-                  %i[string pointer],
-                  :long
-  attach_function :vm_set_parameter_float,
-                  :VBVMR_SetParameterFloat,
-                  %i[string float],
-                  :long
-
-  attach_function :vm_get_parameter_string,
-                  :VBVMR_GetParameterStringA,
-                  %i[string pointer],
-                  :long
-  attach_function :vm_set_parameter_string,
-                  :VBVMR_SetParameterStringA,
-                  %i[string string],
-                  :long
-
-  attach_function :vm_set_parameter_multi,
-                  :VBVMR_SetParameters,
-                  [:string],
-                  :long
-
-  attach_function :vm_get_level, :VBVMR_GetLevel, %i[long long pointer], :long
-
-  attach_function :vm_get_num_indevices, :VBVMR_Input_GetDeviceNumber, [], :long
-  attach_function :vm_get_desc_indevices,
-                  :VBVMR_Input_GetDeviceDescA,
-                  %i[long pointer pointer pointer],
-                  :long
-
-  attach_function :vm_get_num_outdevices,
-                  :VBVMR_Output_GetDeviceNumber,
-                  [],
-                  :long
-  attach_function :vm_get_desc_outdevices,
-                  :VBVMR_Output_GetDeviceDescA,
-                  %i[long pointer pointer pointer],
-                  :long
-
-  @@cdll =
-    lambda { |func, *args| self.retval = [send("vm_#{func}", *args), func] }
-
-  def clear_polling = while pdirty? || mdirty?; end
-
-  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]
-
-    clear_polling if @sync
-
-    yield
-  end
-
-  def retval=(values)
-    " Writer validation for CAPI calls "
-    retval, func = *values
-    unless %i[get_num_indevices get_num_outdevices].include? func
-      raise CAPIErrors.new(retval, func) if retval&.nonzero?
-    end
-    @retval = retval
-  end
-
-  public
-
-  def pdirty? = vm_pdirty&.nonzero?
-
-  def mdirty? = vm_mdirty&.nonzero?
-
-  def ldirty?
-    @strip_buf, @bus_buf = _get_levels
-    return(
-      !(@cache["strip_level"] == @strip_buf && @cache["bus_level"] == @bus_buf)
-    )
-  end
-end

data/lib/command.rb

@@ -1,36 +0,0 @@
-require_relative "iremote"
-require_relative "meta"
-
-class Command < IRemote
-  include Commands_Meta_Functions
-
-  def initialize(remote)
-    super
-    self.make_action_prop :show, :restart, :shutdown
-    self.make_writer_bool :showvbanchat, :lock
-  end
-
-  def identifier
-    :command
-  end
-
-  def hide
-    self.setter("show", 0)
-  end
-
-  def load(value)
-    raise VMRemoteErrors.new("Expected a string") unless value.is_a? String
-    self.setter("load", value)
-    sleep(0.2)
-  end
-
-  def save(value)
-    raise VMRemoteErrors.new("Expected a string") unless value.is_a? String
-    self.setter("save", value)
-    sleep(0.2)
-  end
-
-  def reset
-    @remote.set_config("reset")
-  end
-end

data/lib/configs.rb

@@ -1,80 +0,0 @@
-require "kinds"
-require "toml"
-
-module Configs
-  private
-
-  @@configs = Hash.new
-
-  class TOMLStrBuilder
-    def initialize(kind)
-      @p_in, @v_in = kind[:layout][:strip].values
-      @p_out, @v_out = kind[:layout][:bus].values
-      @vs_params =
-        ["mute = false", "mono = false", "solo = false", "gain = 0.0"] +
-          (1..@p_out).map { |i| "A#{i} = false" } +
-          (1..@v_out).map { |i| "B#{i} = false" }
-
-      @ps_params = @vs_params + ["comp = 0.0", "gate = 0.0"]
-      @bus_params = ["mono = false", "eq = false", "mute = false"]
-    end
-
-    def build
-      "
-      Builds a TOML script for the parser
-      "
-      @ps = (0...@p_in).map { |i| ["[strip_#{i}]"] + @ps_params }
-      @ps.map! { |a| a.map { |s| s.gsub("B1 = false", "B1 = true") } }
-      @vs = (@p_in...(@p_in + @v_in)).map { |i| ["[strip_#{i}]"] + @vs_params }
-      @vs.map! { |a| a.map { |s| s.gsub("A1 = false", "A1 = true") } }
-
-      @b = (0...(@p_out + @v_out)).map { |i| ["[bus_#{i}]"] + @bus_params }
-
-      [@ps + @vs + @b].join("\n")
-    end
-  end
-
-  def parser(data)
-    TOML::Parser.new(data).parsed
-  end
-
-  def get_configs(kind_id)
-    file_path = File.join(Dir.pwd, "configs", "#{kind_id}")
-
-    if Dir.exist?(file_path)
-      Dir
-        .glob(File.join(file_path, "*.toml"))
-        .to_h do |toml_file|
-          filename = File.basename(toml_file, ".toml")
-          puts "loading config #{kind_id}/#{filename} into memory"
-          [filename, parser(File.read(toml_file))]
-        end
-    end
-  end
-
-  def loader
-    if @@configs.empty?
-      builder = TOMLStrBuilder.new(@kind)
-      puts "loading config reset into memory"
-      @@configs["reset"] = parser(builder.build)
-      configs = get_configs(@kind.name.to_s)
-
-      @@configs.merge!(configs) unless configs.nil?
-    end
-  end
-
-  public
-
-  def set_config(value)
-    loader
-    unless @@configs.key? value
-      raise VMRemoteErrors.new("No profile with name #{value} was loaded")
-    end
-
-    self.send("set_multi", @@configs[value])
-    puts "config #{@kind.name}/#{value} applied!"
-    sleep(@delay)
-  end
-
-  alias_method "apply_config", :set_config
-end

data/lib/device.rb

@@ -1,24 +0,0 @@
-require_relative "iremote"
-require_relative "meta"
-
-class Device
-  def initialize(remote)
-    @remote = remote
-  end
-
-  def getter(**kwargs)
-    return @remote.get_num_devices(kwargs[:direction]) if kwargs[:index].nil?
-
-    vals = @remote.get_device_description(kwargs[:index], kwargs[:direction])
-    types = { 1 => "mme", 3 => "wdm", 4 => "ks", 5 => "asio" }
-    { name: vals[0], type: types[vals[1]], id: vals[2] }
-  end
-
-  def ins = getter(direction: "in")
-
-  def outs = getter(direction: "out")
-
-  def input(i) = getter(index: i, direction: "in")
-
-  def output(i) = getter(index: i, direction: "out")
-end

data/lib/errors.rb

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

@@ -1,27 +0,0 @@
-require "win32/registry"
-require "pathname"
-require_relative "errors"
-
-include Errors
-
-module InstallationFunctions
-  private
-
-  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 vm_dll=(value)
-    raise InstallErrors.new("Could not fetch the dll file") unless value.file?
-    @vm_dll = value
-  end
-end

data/lib/iremote.rb

@@ -1,32 +0,0 @@
-require_relative "meta"
-require_relative "errors"
-
-class IRemote
-  "
-  Common interface between base class and higher classes.
-  "
-  include Meta_Functions
-
-  def initialize(remote, i = nil)
-    @remote = remote
-    @index = i
-  end
-
-  def getter(param, is_string = false)
-    @remote.get_parameter("#{self.identifier}.#{param}", is_string)
-  end
-
-  def setter(param, value)
-    @remote.set_parameter("#{self.identifier}.#{param}", value)
-  end
-
-  def identifier
-    raise "Called abstract method: identifier"
-  end
-
-  def set_multi(param_hash)
-    param_hash.each { |(key, val)| self.send("#{key}=", val) }
-  end
-
-  alias_method "apply", :set_multi
-end

data/lib/recorder.rb

@@ -1,20 +0,0 @@
-require_relative "iremote"
-require_relative "meta"
-
-class Recorder < IRemote
-  "
-  Concrete Recorder class
-  "
-
-  def initialize(remote)
-    super
-    self.make_action_prop :play, :stop, :record, :ff, :rew
-
-    num_A, num_B = remote.kind.layout[:bus].values
-    self.make_accessor_bool *make_channel_props(num_A, num_B)
-  end
-
-  def identifier
-    :recorder
-  end
-end

data/lib/strip.rb

@@ -1,135 +0,0 @@
-require_relative "iremote"
-
-class Strip < IRemote
-  "
-  Concrete Strip class
-  "
-  include Channel_Meta_Functions
-
-  attr_accessor :gainlayer, :levels
-
-  def self.make(remote, layout_strip)
-    "
-    Factory function for Strip classes.
-    "
-    p_in, v_in = layout_strip.values
-    (0...(p_in + v_in)).map do |i|
-      i < p_in ? PhysicalStrip.new(remote, i) : VirtualStrip.new(remote, i)
-    end
-  end
-
-  def initialize(remote, i)
-    super
-    self.make_accessor_bool :solo, :mute, :mono
-    self.make_accessor_float :gain
-    self.make_accessor_int :limit
-    self.make_accessor_string :label
-
-    num_A, num_B = remote.kind.layout[:bus].values
-    self.make_accessor_bool *make_channel_props(num_A, num_B)
-
-    @gainlayer = (0...8).map { |j| GainLayer.new(remote, i, j) }
-    @levels = StripLevels.new(remote, i)
-  end
-
-  def identifier
-    "strip[#{@index}]"
-  end
-
-  def fadeto(target, time)
-    self.setter("FadeTo", "(#{target}, #{time})")
-    sleep(@remote.delay)
-  end
-
-  def fadeby(change, time)
-    self.setter("FadeBy", "(#{change}, #{time})")
-    sleep(@remote.delay)
-  end
-end
-
-class PhysicalStrip < Strip
-  def initialize(remote, i)
-    super
-    self.make_accessor_float :comp, :gate, :audibility
-    self.make_reader_only :device, :sr
-  end
-end
-
-class VirtualStrip < Strip
-  def initialize(remote, i)
-    super
-    self.make_accessor_bool :mc
-    self.make_accessor_int :k
-    self.make_accessor_float :bass, :mid, :treble
-  end
-
-  def appgain(name, gain)
-    self.setter("AppGain", "(\"#{name}\", #{gain})")
-  end
-
-  def appmute(name, mute)
-    self.setter("AppMute", "(\"#{name}\", #{mute ? 1 : 0})")
-  end
-end
-
-class GainLayer < IRemote
-  def initialize(remote, i, j)
-    super(remote, i)
-    @j = j
-  end
-
-  def identifier
-    "strip[#{@index}]"
-  end
-
-  def gain
-    self.getter("gainlayer[#{@j}]")
-  end
-
-  def gain=(value)
-    self.setter("gainlayer[#{@j}]", value)
-  end
-end
-
-class StripLevels < IRemote
-  def initialize(remote, i)
-    super
-    if i < @remote.p_in
-      @init = i * 2
-      @offset = 2
-    else
-      @init = (@remote.p_in * 2) + ((i - @remote.p_in) * 8)
-      @offset = 8
-    end
-  end
-
-  def identifier
-    "strip[#{@index}]"
-  end
-
-  def get_level(mode)
-    if @remote.running
-      vals = @remote.cache["strip_level"][@init, @offset]
-    else
-      vals = (@init...@offset).map { |i| get_level(mode, i) }
-    end
-    vals.map { |x| x > 0 ? (20 * Math.log(x, 10)).round(1) : -200.0 }
-  end
-
-  def prefader
-    @remote.strip_mode = 0
-    get_level(0)
-  end
-
-  def postfader
-    @remote.strip_mode = 1
-    get_level(1)
-  end
-
-  def postmute
-    @remote.strip_mode = 2
-    get_level(2)
-  end
-
-  def isdirty? = @remote._strip_comp[@init, @offset].any?
-end