voicemeeter_api_ruby 4.1.4 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acb76cc78cf77a922519ddd770f228678575da40dfa679b2adfdbedee6ea1ee6
-  data.tar.gz: daebcd5921873299ba38c5108e624997423566d2fe3c217c0bc2ca994c372825
+  metadata.gz: 4cc1526b0ea929bc7acecca20df4f497aeaacd1a7cca3549369304dec5599dc7
+  data.tar.gz: 8b4acc90968eff552c7b86194b45c513ca3d0fe6e9c1b29ca0a448f67f0fc877
 SHA512:
-  metadata.gz: b2bc3f136101f0f77cddabcc1311d2be414cae27435a15a638db9c2e1314cd390710f7972deb4f2d77e8658679360a2aacf19c2aee3eabdd8fbd8298efe2d35f
-  data.tar.gz: 4cf31208007f988dc8a114ad76cbec5581b0783276d325a305deec988be3a847a08938bb4e2094b9894ecb9de1bd4f6e769eb8edefec923f2cf38d6ec946458b
+  metadata.gz: 8ca033d3cfefdfd1120044cf8a44b105ca29f3eb32ae623cdd91a6b9bad98e2ccf7add3dae67c0407b2ff647eebb070429dfe9b85472ae2daa146ff945f528e9
+  data.tar.gz: f2fae61b46e6596337bbb9915d86c9e653cd2e145a3405d4f2ba9a1ac96f6a0be472f8012610aca237911e5935aa22a29ccc41ec646e196d86296d3a0ae15177

data/CHANGELOG.md

@@ -9,7 +9,24 @@ Before any major/minor/patch is released all unit tests will be run to verify th
 
 ## [Unreleased] - These changes have not been added to RubyGems yet
 
--   [ ] add xy parameters to strip/bus
+-   [ ]
+
+## [4.3.0] - 2022-07-29
+
+### Added
+
+-   Mixin module
+-   xy, fx parameters to strip/bus
+-   unit tests for xy, fx
+-   xy, fx to readme
+-   config tests added
+-   gemfile to obs example
+
+### Changed
+
+-   moved gem files into voicemeeter/ dir
+-   update obs example
+-   using require_relative in case using direct download.
 
 ## [4.1.0] - 2022-07-19
 

data/README.md

@@ -98,6 +98,20 @@ The following properties are available.
 -   `bass`: float, from -12.0 to 12.0
 -   `mid`: float, from -12.0 to 12.0
 -   `treble`: float, from -12.0 to 12.0
+-   `reverb`: float, from 0.0 to 10.0
+-   `delay`: float, from 0.0 to 10.0
+-   `fx1`: float, from 0.0 to 10.0
+-   `fx2`: float, from 0.0 to 10.0
+-   `pan_x`: float, from -0.5 to 0.5
+-   `pan_y`: float, from 0.0 to 1.0
+-   `color_x`: float, from -0.5 to 0.5
+-   `color_y`: float, from 0.0 to 1.0
+-   `fx_x`: float, from -0.5 to 0.5
+-   `fx_y`: float, from 0.0 to 1.0
+-   `postreverb`: boolean
+-   `postdelay`: boolean
+-   `postfx1`: boolean
+-   `postfx2`: boolean
 
 example:
 
@@ -164,6 +178,11 @@ The following properties are available.
 -   `label`: string
 -   `device`: string
 -   `sr`: int
+-   `returnreverb`: float, from 0.0 to 10.0
+-   `returndelay`: float, from 0.0 to 10.0
+-   `returnfx1`: float, from 0.0 to 10.0
+-   `returnfx2`: float, from 0.0 to 10.0
+-   `monitor`: boolean
 
 example:
 
@@ -339,11 +358,11 @@ vm.run { (0...vm.device.ins).each { |i| puts vm.device.input(i) } }
 
 ### Multiple parameters
 
--   `set_multi`
+-   `apply`
     Set many strip/bus/macrobutton/vban parameters at once, for example:
 
 ```ruby
-vm.set_multi(
+vm.apply(
     {
         strip_0: {
             mute: true,
@@ -368,8 +387,8 @@ vm.set_multi(
 Or for each class you may do:
 
 ```ruby
-vm.strip[0].set_multi(mute: true, gain: 3.2, A1: true)
-vm.vban.outstream[0].set_multi(on: true, name: 'streamname', bit: 24)
+vm.strip[0].apply(mute: true, gain: 3.2, A1: true)
+vm.vban.outstream[0].apply(on: true, name: 'streamname', bit: 24)
 ```
 
 ## Config Files

data/lib/voicemeeter/base.rb

@@ -0,0 +1,223 @@
+require "observer"
+
+require_relative "runvm"
+require_relative "configs"
+require_relative "errors"
+
+module Voicemeeter
+  class Base
+    "
+    Base class responsible for wrapping the C Remote API
+
+    Mixin required modules
+    "
+    include Observable
+    include Configs
+    include RunVM
+
+    attr_accessor :strip, :bus, :button, :vban, :command, :recorder, :device
+    attr_accessor :strip_mode
+
+    attr_reader :kind, :p_in, :v_in, :p_out, :v_out, :retval, :cache
+    attr_reader :running, :_strip_comp, :_bus_comp, :delay
+
+    DELAY = 0.001
+    SYNC = false
+    RATELIMIT = 0.033
+    SIZE = 1
+
+    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
+      @ratelimit = kwargs[:ratelimit] || RATELIMIT
+      @running = false
+      @strip_mode = 0
+      @delay = DELAY
+    end
+
+    def init_thread
+      @running = true
+      @cache["strip_level"], @cache["bus_level"] = _get_levels
+      Thread.new do
+        loop do
+          Thread.stop if !@running
+          if pdirty?
+            changed
+            notify_observers("pdirty")
+          end
+          if mdirty?
+            changed
+            notify_observers("mdirty")
+          end
+          if ldirty?
+            changed
+            @_strip_comp =
+              @cache["strip_level"].map.with_index do |x, i|
+                !(x == @strip_buf[i])
+              end
+            @_bus_comp =
+              @cache["bus_level"].map.with_index { |x, i| !(x == @bus_buf[i]) }
+            @cache["strip_level"] = @strip_buf
+            @cache["bus_level"] = @bus_buf
+            notify_observers("ldirty")
+          end
+          sleep(@ratelimit)
+        end
+      end
+    end
+
+    def end_thread
+      @running = false
+    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 type
+      c_type = FFI::MemoryPointer.new(:long, SIZE)
+      @@cdll.call(:vmtype, c_type)
+      types = { 1 => "basic", 2 => "banana", 3 => "potato" }
+      types[c_type.read_long]
+    end
+
+    def version
+      c_ver = FFI::MemoryPointer.new(:long, SIZE)
+      @@cdll.call(:vmversion, c_ver)
+      v1 = (c_ver.read_long & 0xFF000000) >> 24
+      v2 = (c_ver.read_long & 0x00FF0000) >> 16
+      v3 = (c_ver.read_long & 0x0000FF00) >> 8
+      v4 = c_ver.read_long & 0x000000FF
+      "#{v1}.#{v2}.#{v3}.#{v4}"
+    end
+
+    def get_parameter(name, is_string = false)
+      self.polling("get_parameter", name: name) do
+        if is_string
+          c_get = FFI::MemoryPointer.new(:string, 512, 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 _get_levels
+      [
+        (0...(2 * @p_in + 8 * @v_in)).map { |i| get_level(@strip_mode, i) },
+        (0...(8 * (@p_out + @v_out))).map { |i| get_level(3, i) }
+      ]
+    end
+
+    def get_num_devices(direction)
+      unless %w[in out].include? direction
+        raise VMRemoteErrors.new("expected in or out")
+      end
+      if direction == "in"
+        val = @@cdll.call(:get_num_indevices)
+      else
+        val = @@cdll.call(:get_num_outdevices)
+      end
+      val[0]
+    end
+
+    def get_device_description(index, direction)
+      unless %w[in out].include? direction
+        raise VMRemoteErrors.new("expected in or out")
+      end
+      c_type = FFI::MemoryPointer.new(:long, SIZE)
+      c_name = FFI::MemoryPointer.new(:string, 256, true)
+      c_hwid = FFI::MemoryPointer.new(:string, 256, true)
+      if direction == "in"
+        @@cdll.call(:get_desc_indevices, index, c_type, c_name, c_hwid)
+      else
+        @@cdll.call(:get_desc_outdevices, index, c_type, c_name, c_hwid)
+      end
+      [c_name.read_string, c_type.read_long, c_hwid.read_string]
+    end
+
+    alias_method "set_multi", :set_parameter_multi
+    alias_method "apply", :set_parameter_multi
+    alias_method "get", :get_parameter
+    alias_method "set", :set_parameter
+    alias_method "pdirty", :pdirty?
+    alias_method "mdirty", :mdirty?
+    alias_method "ldirty", :ldirty?
+  end
+end

data/lib/voicemeeter/bus.rb

@@ -0,0 +1,99 @@
+require_relative "iremote"
+
+module Voicemeeter
+  class Bus < IRemote
+    "
+    Concrete Bus class
+    "
+    include Channel_Meta_Functions
+    include Mixin::Fades
+    include Mixin::Return
+
+    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, :eq_ab, :sel, :monitor
+      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
+  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
+end

data/lib/voicemeeter/button.rb

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

data/lib/voicemeeter/cbindings.rb

@@ -0,0 +1,126 @@
+require "ffi"
+require_relative "inst"
+
+module Voicemeeter
+  module CBindings
+    "
+    Creates Ruby bindings to the C DLL
+
+    Performs other low level tasks
+    "
+    extend Voicemeeter::InstallationFunctions
+    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| 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
+end

data/lib/voicemeeter/command.rb

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

data/lib/voicemeeter/configs.rb

@@ -0,0 +1,83 @@
+require "toml"
+require_relative "kinds"
+
+module Voicemeeter
+  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
+end