voicemeeter_api_ruby 4.1.5 → 4.3.1

data/lib/voicemeeter/device.rb

@@ -0,0 +1,26 @@
+require_relative "iremote"
+require_relative "meta"
+
+module Voicemeeter
+  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
+end

data/lib/voicemeeter/errors.rb

@@ -0,0 +1,43 @@
+module Voicemeeter
+  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
+end

data/lib/voicemeeter/inst.rb

@@ -0,0 +1,27 @@
+require "win32/registry"
+require "pathname"
+require_relative "errors"
+
+module Voicemeeter
+  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
+end

data/lib/voicemeeter/iremote.rb

@@ -0,0 +1,34 @@
+require_relative "meta"
+require_relative "errors"
+
+module Voicemeeter
+  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
+end

data/lib/voicemeeter/kinds.rb

@@ -0,0 +1,79 @@
+module Voicemeeter
+  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, :kind_map, :kinds_all
+  end
+end

data/lib/voicemeeter/meta.rb

@@ -0,0 +1,251 @@
+require_relative "errors"
+
+module Voicemeeter
+  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_action_prop(*params)
+      params.each do |param|
+        define_singleton_method("#{param}") { self.setter("#{param}", 1) }
+      end
+    end
+  end
+
+  module Channel_Meta_Functions
+    private
+
+    include Meta_Functions
+
+    def make_accessor_bool(*params)
+      params.each do |param|
+        cmds = { eq: "EQ.on", eq_ab: "EQ.ab" }
+        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_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 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 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
+end

data/lib/voicemeeter/mixin.rb

@@ -0,0 +1,74 @@
+module Voicemeeter
+  module Mixin
+    module Fades
+      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
+
+    module Apps
+      def appgain(name, gain)
+        self.setter("AppGain", "(\"#{name}\", #{gain})")
+      end
+
+      def appmute(name, mute)
+        self.setter("AppMute", "(\"#{name}\", #{mute ? 1 : 0})")
+      end
+    end
+
+    module Outputs
+      include Channel_Meta_Functions
+      def initialize(remote, i = nil)
+        super
+        num_A, num_B = remote.kind.layout[:bus].values
+        channels =
+          (1..(num_A + num_B)).map do |i|
+            i <= num_A ? "A#{i}" : "B#{i - num_A}"
+          end
+        self.make_accessor_bool *channels
+      end
+    end
+
+    module Xy
+      include Channel_Meta_Functions
+
+      def initialize(remote, i)
+        super
+        self.make_accessor_float :pan_x,
+                                 :pan_y,
+                                 :color_x,
+                                 :color_y,
+                                 :fx_x,
+                                 :fx_y
+      end
+    end
+
+    module Fx
+      include Channel_Meta_Functions
+
+      def initialize(remote, i)
+        super
+        self.make_accessor_float :reverb, :delay, :fx1, :fx2
+        self.make_accessor_bool :postreverb, :postdelay, :postfx1, :postfx2
+      end
+    end
+
+    module Return
+      include Channel_Meta_Functions
+
+      def initialize(remote, i)
+        super
+        self.make_accessor_float :returnreverb,
+                                 :returndelay,
+                                 :returnfx1,
+                                 :returnfx2
+      end
+    end
+  end
+end

data/lib/voicemeeter/recorder.rb

@@ -0,0 +1,20 @@
+require_relative "iremote"
+require_relative "meta"
+
+module Voicemeeter
+  class Recorder < IRemote
+    "
+    Concrete Recorder class
+    "
+    include Mixin::Outputs
+
+    def initialize(remote)
+      super
+      self.make_action_prop :play, :stop, :record, :ff, :rew
+    end
+
+    def identifier
+      :recorder
+    end
+  end
+end

data/lib/voicemeeter/runvm.rb

@@ -0,0 +1,31 @@
+require_relative "cbindings"
+require_relative "kinds"
+
+module Voicemeeter
+  module RunVM
+    "
+    Starts Voicemeeter of the Kind requested.
+    "
+    include CBindings
+    include Kinds
+
+    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 CBindings::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] }
+
+      CBindings.vm_runvm(exes[kind_id])
+      sleep(1)
+    end
+  end
+end

data/lib/voicemeeter/strip.rb

@@ -0,0 +1,124 @@
+require_relative "iremote"
+require_relative "mixin"
+
+module Voicemeeter
+  class Strip < IRemote
+    "
+    Concrete Strip class
+    "
+    include Channel_Meta_Functions
+    include Mixin::Outputs
+    include Mixin::Fades
+
+    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
+
+      @gainlayer = (0...8).map { |j| GainLayer.new(remote, i, j) }
+      @levels = StripLevels.new(remote, i)
+    end
+
+    def identifier
+      "strip[#{@index}]"
+    end
+  end
+
+  class PhysicalStrip < Strip
+    include Mixin::Xy
+    include Mixin::Fx
+
+    def initialize(remote, i)
+      super
+      self.make_accessor_float :comp, :gate, :audibility
+      self.make_reader_only :device, :sr
+    end
+  end
+
+  class VirtualStrip < Strip
+    include Mixin::Apps
+
+    def initialize(remote, i)
+      super
+      self.make_accessor_bool :mc
+      self.make_accessor_int :k
+      self.make_accessor_float :bass, :mid, :treble
+    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
+end