voicemeeter_api_ruby 4.1.4 → 4.3.0

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,30 +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
-end

data/lib/kinds.rb

@@ -1,77 +0,0 @@
-module Kinds
-  "
-  A Kind struct for each version of Voicemeeter
-  "
-  attr_reader :kind_map, :kinds_all
-
-  Kind = Struct.new(:name, :layout)
-  basic =
-    Kind.new(
-      "basic",
-      {
-        strip: {
-          p_in: 2,
-          v_in: 1
-        },
-        bus: {
-          p_out: 1,
-          v_out: 1
-        },
-        vban: {
-          instream: 4,
-          outstream: 4
-        },
-        mb: 80
-      }
-    )
-
-  banana =
-    Kind.new(
-      "banana",
-      {
-        strip: {
-          p_in: 3,
-          v_in: 2
-        },
-        bus: {
-          p_out: 3,
-          v_out: 2
-        },
-        vban: {
-          instream: 8,
-          outstream: 8
-        },
-        mb: 80
-      }
-    )
-
-  potato =
-    Kind.new(
-      "potato",
-      {
-        strip: {
-          p_in: 5,
-          v_in: 3
-        },
-        bus: {
-          p_out: 5,
-          v_out: 3
-        },
-        vban: {
-          instream: 8,
-          outstream: 8
-        },
-        mb: 80
-      }
-    )
-
-  @kind_map = [basic, banana, potato].to_h { |kind| [kind.name, kind] }
-
-  def get_kind(kind_id)
-    @kind_map[kind_id]
-  end
-
-  @kinds_all = @kind_map.values
-
-  module_function :get_kind
-end

data/lib/meta.rb

@@ -1,275 +0,0 @@
-require_relative "errors"
-
-module Conversions
-  module_function
-
-  def Boolean(value)
-    case value
-    when true, 1
-      true
-    when false, nil, 0
-      false
-    else
-      raise ArgumentError, "invalid value for Boolean(): \"#{value.inspect}\""
-    end
-  end
-end
-
-module Meta_Functions
-  private
-
-  include Conversions
-
-  def make_accessor_bool(*params)
-    params.each do |param|
-      define_singleton_method("#{param}") do
-        return !(self.getter("#{param}")).zero?
-      end
-
-      define_singleton_method("#{param}=") do |value|
-        self.setter("#{param}", Boolean(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}") { return self.getter("#{param}") }
-      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}") { return self.getter("#{param}") }
-    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)
-    (1..(num_A + num_B)).map { |i| i <= num_A ? "A#{i}" : "B#{i - num_A}" }
-  end
-
-  def make_action_prop(*params)
-    params.each do |param|
-      define_singleton_method("#{param}") { self.setter("#{param}", 1) }
-    end
-  end
-end
-
-module Channel_Meta_Functions
-  private
-
-  include Conversions
-  include Meta_Functions
-
-  def make_accessor_bool(*params)
-    params.each do |param|
-      cmds = { eq: "EQ.on" }
-      if cmds.key? param
-        cmd = cmds[param]
-      else
-        cmd = param
-      end
-
-      define_singleton_method("#{param}") do
-        return !(self.getter("#{cmd}")).zero?
-      end
-
-      define_singleton_method("#{param}=") do |value|
-        self.setter("#{cmd}", Boolean(value) ? 1 : 0)
-      end
-    end
-  end
-
-  def make_accessor_float(*params)
-    params.each do |param|
-      define_singleton_method("#{param}") { return self.getter("#{param}") }
-
-      define_singleton_method("#{param}=") do |value|
-        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
-
-      define_singleton_method("#{param}=") do |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.key? param
-        cmd = cmds[param]
-      else
-        cmd = param
-      end
-
-      define_singleton_method("#{param}") do
-        case param
-        when :device
-          return self.getter("#{cmd}", true)
-        when :sr
-          return self.getter("#{cmd}").to_i
-        end
-      end
-    end
-  end
-
-  def make_bus_modes(*params)
-    params.each do |param|
-      define_singleton_method("#{param}") do
-        @remote.clear_polling
-        return !(self.getter("#{param}")).zero?
-      end
-
-      define_singleton_method("#{param}=") do |value|
-        self.setter("#{param}", Boolean(value) ? 1 : 0)
-      end
-    end
-  end
-end
-
-module Vban_Meta_Functions
-  private
-
-  include Conversions
-  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: [
-          11_025,
-          16_000,
-          22_050,
-          24_000,
-          32_000,
-          44_100,
-          48_000,
-          64_000,
-          88_200,
-          96_000
-        ],
-        channel: (1..8),
-        bit: [16, 24],
-        quality: (0..4),
-        route: (0..8)
-      }
-
-      define_singleton_method("#{param}=") do |value|
-        unless opts[param].member? value
-          raise OutOfBoundsErrors.new(opts[param])
-        end
-        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
-  private
-
-  include Conversions
-
-  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
-
-      define_singleton_method("#{param}=") do |value|
-        self.setter(Boolean(value) ? 1 : 0, mode[param])
-      end
-    end
-  end
-end
-
-module Commands_Meta_Functions
-  private
-
-  include Conversions
-  include Meta_Functions
-  def make_writer_bool(*params)
-    params.each do |param|
-      cmds = { showvbanchat: "DialogShow.VBANCHAT" }
-      if cmds.key? param
-        cmd = cmds[param]
-      else
-        cmd = param
-      end
-
-      define_singleton_method("#{param}=") do |value|
-        self.setter("#{cmd}", Boolean(value) ? 1 : 0)
-      end
-    end
-  end
-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/runvm.rb

@@ -1,29 +0,0 @@
-require_relative "cbindings"
-require_relative "kinds"
-
-include CBindings
-include Kinds
-
-module RunVM
-  "
-  Starts Voicemeeter of the Kind requested.
-  "
-  def start(kind_id)
-    unless Kinds.kind_map.key? kind_id
-      raise VMRemoteErrors.new("Unknown Voicemeeter Kind.")
-    end
-
-    enums =
-      Kinds.kinds_all.map.with_index do |kind, i|
-        if OS_BITS == 64 && kind.name.to_s == "potato"
-          [kind.name.to_s, i + 4]
-        else
-          [kind.name.to_s, i + 1]
-        end
-      end
-    exes = enums.to_h { |k, v| [k, v.to_i] }
-
-    send(:vm_runvm, exes[kind_id])
-    sleep(1)
-  end
-end