voicemeeter 0.0.1

data/lib/voicemeeter/base.rb

@@ -0,0 +1,225 @@
+module Voicemeeter
+  # Base class for Remote
+  class Base
+    include Logging
+    include Worker
+    include Events::Director
+    prepend Util::Cache
+
+    attr_reader :kind, :midi, :event, :delay, :cache
+
+    RATELIMIT = 0.033
+    DELAY = 0.001
+
+    def initialize(kind, **kwargs)
+      @kind = kind
+      @sync = kwargs[:sync] || false
+      @ratelimit = kwargs[:ratelimit] || RATELIMIT
+      @delay = kwargs[:delay] || DELAY
+      @event =
+        Events::Tracker.new(
+          **(kwargs.select { |k, _| %i[pdirty mdirty ldirty midi].include? k })
+        )
+      @midi = Midi.new
+      @cache = {strip_mode: 0}
+    end
+
+    def to_s
+      "Voicemeeter #{kind}"
+    end
+
+    def login
+      CBindings.call(:bind_login, ok: [0, 1]) == 1 and run_voicemeeter(kind.name)
+      clear_dirty
+      logger.info "Successfully logged into #{self} version #{version}"
+    end
+
+    def logout
+      sleep(0.1)
+      CBindings.call(:bind_logout)
+      logger.info "Successfully logged out of #{self}"
+    end
+
+    def pdirty?
+      CBindings.call(:bind_is_parameters_dirty, ok: [0, 1]) == 1
+    end
+
+    def mdirty?
+      CBindings.call(:bind_macro_button_is_dirty, ok: [0, 1]) == 1
+    end
+
+    def ldirty?
+      cache[:strip_buf], cache[:bus_buf] = _get_levels
+      !(
+        cache[:strip_level] == cache[:strip_buf] &&
+          cache[:bus_level] == cache[:bus_buf]
+      )
+    end
+
+    def clear_dirty
+      catch(:clear) do
+        loop { throw(:clear) unless pdirty? || mdirty? }
+      end
+    end
+
+    def run_voicemeeter(kind_id)
+      kinds = {
+        basic: Kinds::KindEnum::BASIC,
+        banana: Kinds::KindEnum::BANANA,
+        potato: (Install::OS_BITS == 64) ? Kinds::KindEnum::POTATOX64 : Kinds::KindEnum::POTATO
+      }
+      if caller(1..1).first[/`(.*)'/, 1] == "login"
+        logger.debug "Voicemeeter engine running but the GUI appears to be down... launching."
+      end
+      CBindings.call(:bind_run_voicemeeter, kinds[kind_id])
+      sleep(1)
+    end
+
+    def type
+      ckind = FFI::MemoryPointer.new(:long, 1)
+      CBindings.call(:bind_get_voicemeeter_type, ckind)
+      kinds = [nil, :basic, :banana, :potato]
+      kinds[ckind.read_long]
+    end
+
+    def version
+      cver = FFI::MemoryPointer.new(:long, 1)
+      CBindings.call(:bind_get_voicemeeter_version, cver)
+      [
+        (cver.read_long & 0xFF000000) >> 24,
+        (cver.read_long & 0x00FF0000) >> 16,
+        (cver.read_long & 0x0000FF00) >> 8,
+        cver.read_long & 0x000000FF
+      ].join(".")
+    end
+
+    def get(name, is_string = false)
+      if is_string
+        cget = FFI::MemoryPointer.new(:string, 512, true)
+        CBindings.call(:bind_get_parameter_string_a, name, cget)
+        cget.read_string
+      else
+        cget = FFI::MemoryPointer.new(:float, 1)
+        CBindings.call(:bind_get_parameter_float, name, cget)
+        cget.read_float.round(1)
+      end
+    end
+
+    def set(name, value)
+      if value.is_a? String
+        CBindings.call(:bind_set_parameter_string_a, name, value)
+      else
+        CBindings.call(:bind_set_parameter_float, name, value.to_f)
+      end
+      cache.store(name, value)
+    end
+
+    def get_buttonstatus(id, mode)
+      cget = FFI::MemoryPointer.new(:float, 1)
+      CBindings.call(:bind_macro_button_get_status, id, cget, mode)
+      cget.read_float.to_i
+    end
+
+    def set_buttonstatus(id, mode, state)
+      CBindings.call(:bind_macro_button_set_status, id, state, mode)
+      cache.store("mb_#{id}_#{mode}", state)
+    end
+
+    def get_level(mode, index)
+      cget = FFI::MemoryPointer.new(:float, 1)
+      CBindings.call(:bind_get_level, mode, index, cget)
+      cget.read_float
+    end
+
+    private def _get_levels
+      strip_mode = cache[:strip_mode]
+      [
+        (0...kind.num_strip_levels).map { get_level(strip_mode, _1) },
+        (0...kind.num_bus_levels).map { get_level(3, _1) }
+      ]
+    end
+
+    def get_num_devices(dir)
+      unless %i[in out].include? dir
+        raise Errors::VMError.new "dir got: #{dir}, expected :in or :out"
+      end
+      if dir == :in
+        CBindings.call(:bind_input_get_device_number, exp: ->(x) { x >= 0 })
+      else
+        CBindings.call(:bind_output_get_device_number, exp: ->(x) { x >= 0 })
+      end
+    end
+
+    def get_device_description(index, dir)
+      unless %i[in out].include? dir
+        raise Errors::VMError.new "dir got: #{dir}, expected :in or :out"
+      end
+      ctype = FFI::MemoryPointer.new(:long, 1)
+      cname = FFI::MemoryPointer.new(:string, 256, true)
+      chwid = FFI::MemoryPointer.new(:string, 256, true)
+      if dir == :in
+        CBindings.call(
+          :bind_input_get_device_desc_a,
+          index,
+          ctype,
+          cname,
+          chwid
+        )
+      else
+        CBindings.call(
+          :bind_output_get_device_desc_a,
+          index,
+          ctype,
+          cname,
+          chwid
+        )
+      end
+      [cname.read_string, ctype.read_long, chwid.read_string]
+    end
+
+    def get_midi_message
+      cmsg = FFI::MemoryPointer.new(:string, 1024, true)
+      res =
+        CBindings.call(
+          :bind_get_midi_message,
+          cmsg,
+          1024,
+          ok: [-5, -6],
+          exp: ->(x) { x >= 0 }
+        )
+      if (got_midi = res > 0)
+        data = cmsg.read_bytes(res).bytes
+        data.each_slice(3) do |ch, key, velocity|
+          midi.channel = ch
+          midi.current = key
+          midi.cache[key] = velocity
+        end
+      end
+      got_midi
+    end
+
+    def sendtext(script)
+      raise ArgumentError, "script must not exceed 48kB" if script.length > 48000
+      CBindings.call(:bind_set_parameters, script)
+    end
+
+    def apply(data)
+      data.each do |key, hash|
+        case key.to_s.split("-")
+        in [/strip|bus|button/ => kls, /^[0-9]+$/ => index]
+          target = send(kls)
+        in ["vban", /in|instream|out|oustream/ => dir, /^[0-9]+$/ => index]
+          target = vban.send("#{dir.chomp("stream")}stream")
+        else
+          raise KeyError, "invalid config key '#{key}'"
+        end
+        target[index.to_i].apply(hash)
+      end
+    end
+
+    def apply_config(name)
+      apply(configs[name])
+      logger.info "profile #{name} applied!"
+    end
+  end
+end

data/lib/voicemeeter/bus.rb

@@ -0,0 +1,129 @@
+module Voicemeeter
+  module Bus
+    # Base class for Bus
+    class Base
+      include IRemote
+      include Mixins::Fades
+      include Mixins::Return
+
+      attr_reader :eq, :mode, :levels
+
+      def self.make(remote, i)
+        (i < remote.kind.phys_out) ? PhysicalBus.new(remote, i) : VirtualBus.new(remote, i)
+      end
+
+      def initialize(remote, i)
+        super
+        make_accessor_bool :mute, :mono, :sel, :monitor
+        make_accessor_float :gain
+        make_accessor_string :label
+
+        @eq = BusEq.new(remote, i)
+        @mode = BusModes.new(remote, i)
+        @levels = BusLevels.new(remote, i)
+      end
+
+      def identifier
+        "bus[#{@index}]"
+      end
+    end
+
+    # Represents a Physical Bus
+    class PhysicalBus < Base; end
+
+    # Represents a Virtual Bus
+    class VirtualBus < Base; end
+
+    class BusEq
+      include IRemote
+
+      def initialize(remote, i)
+        super
+        make_accessor_bool :on, :ab
+      end
+
+      def identifier
+        "bus[#{@index}].eq"
+      end
+    end
+
+    class BusModes
+      include IRemote
+
+      def initialize(remote, i)
+        super
+        make_accessor_bool :normal,
+          :amix,
+          :bmix,
+          :repeat,
+          :composite,
+          :tvmix,
+          :upmix21,
+          :upmix41,
+          :upmix61,
+          :centeronly,
+          :lfeonly,
+          :rearonly
+      end
+
+      def identifier
+        "bus[#{@index}].mode"
+      end
+
+      def get
+        sleep(@remote.delay)
+        %i[amix bmix repeat composite tvmix upmix21 upmix41 upmix61 centeronly lfeonly rearonly].each do |mode|
+          if send(mode)
+            return mode
+          end
+        end
+        :normal
+      end
+    end
+  end
+
+  class BusLevels
+    include IRemote
+
+    def initialize(remote, i)
+      super
+      @init = i * 8
+      @offset = 8
+    end
+
+    def identifier
+      "bus[#{@index}]"
+    end
+
+    def getter(mode)
+      convert = ->(x) { (x > 0) ? (20 * Math.log(x, 10)).round(1) : -200.0 }
+
+      vals = if @remote.running? && @remote.event.ldirty
+        @remote.cache[:bus_level][@init, @offset]
+      else
+        (@init...@init + @offset).map { |i| @remote.get_level(mode, i) }
+      end
+      vals.map(&convert)
+    end
+
+    def all
+      getter(Mixins::LevelEnum::BUS)
+    end
+
+    def isdirty? = @remote.cache[:bus_comp][@init, @offset].any?
+  end
+
+  class BusDevice
+    include IRemote
+
+    def initialize(remote, i)
+      super
+      make_reader_only :name, :sr
+      make_writer_only :wdm, :ks, :mme, :asio
+    end
+
+    def identifier
+      "bus[#{@index}].device"
+    end
+  end
+end

data/lib/voicemeeter/button.rb

@@ -0,0 +1,70 @@
+module Voicemeeter
+  module Button
+    module ButtonEnum
+      STATE = 1
+      STATEONLY = 2
+      TRIGGER = 3
+
+      def identifier(val)
+        [nil, :state, :stateonly, :trigger][val]
+      end
+
+      module_function :identifier
+    end
+
+    module ButtonColorMixin
+      def identifier
+        "command.button[#{@index}]"
+      end
+
+      def color
+        method(:getter).super_method.call("color").to_i
+      end
+
+      def color=(val)
+        method(:setter).super_method.call("color", val)
+      end
+    end
+
+    # Base class for Button
+    class Base
+      include Logging
+      include IRemote
+      include ButtonColorMixin
+
+      def getter(mode)
+        logger.debug "getter: button[#{@index}].#{ButtonEnum.identifier(mode)}"
+        @remote.get_buttonstatus(@index, mode)
+      end
+
+      def setter(mode, val)
+        logger.debug "setter: button[#{@index}].#{ButtonEnum.identifier(mode)}=#{val}"
+        @remote.set_buttonstatus(@index, mode, val)
+      end
+
+      def state
+        getter(ButtonEnum::STATE) == 1
+      end
+
+      def state=(value)
+        setter(ButtonEnum::STATE, value && 1 || 0)
+      end
+
+      def stateonly
+        getter(ButtonEnum::STATEONLY) == 1
+      end
+
+      def stateonly=(value)
+        setter(ButtonEnum::STATEONLY, value && 1 || 0)
+      end
+
+      def trigger
+        getter(ButtonEnum::TRIGGER) == 1
+      end
+
+      def trigger=(value)
+        setter(ButtonEnum::TRIGGER, value && 1 || 0)
+      end
+    end
+  end
+end

data/lib/voicemeeter/cbindings.rb

@@ -0,0 +1,81 @@
+module Voicemeeter
+  # Ruby bindings for the C-API functions
+  module CBindings
+    extend Logging
+    extend FFI::Library
+    using Util::CoreExtensions
+
+    private
+
+    VM_PATH = Install.get_vmpath
+
+    ffi_lib VM_PATH.join(
+      "VoicemeeterRemote#{(Install::OS_BITS == 64) ? "64" : "32"}.dll"
+    )
+    ffi_convention :stdcall
+
+    private_class_method def self.attach_function(c_name, args, returns)
+      ruby_name = :"bind_#{c_name.to_s.delete_prefix("VBVMR_").snakecase}"
+      super(ruby_name, c_name, args, returns)
+    end
+
+    attach_function :VBVMR_Login, [], :long
+    attach_function :VBVMR_Logout, [], :long
+    attach_function :VBVMR_RunVoicemeeter, [:long], :long
+    attach_function :VBVMR_GetVoicemeeterType, [:pointer], :long
+    attach_function :VBVMR_GetVoicemeeterVersion, [:pointer], :long
+    attach_function :VBVMR_MacroButton_IsDirty, [], :long
+    attach_function :VBVMR_MacroButton_GetStatus, %i[long pointer long], :long
+    attach_function :VBVMR_MacroButton_SetStatus, %i[long float long], :long
+
+    attach_function :VBVMR_IsParametersDirty, [], :long
+    attach_function :VBVMR_GetParameterFloat, %i[string pointer], :long
+    attach_function :VBVMR_SetParameterFloat, %i[string float], :long
+
+    attach_function :VBVMR_GetParameterStringA, %i[string pointer], :long
+    attach_function :VBVMR_SetParameterStringA, %i[string string], :long
+
+    attach_function :VBVMR_SetParameters, [:string], :long
+
+    attach_function :VBVMR_GetLevel, %i[long long pointer], :long
+
+    attach_function :VBVMR_Input_GetDeviceNumber, [], :long
+    attach_function :VBVMR_Input_GetDeviceDescA,
+      %i[long pointer pointer pointer],
+      :long
+
+    attach_function :VBVMR_Output_GetDeviceNumber, [], :long
+    attach_function :VBVMR_Output_GetDeviceDescA,
+      %i[long pointer pointer pointer],
+      :long
+
+    attach_function :VBVMR_GetMidiMessage, %i[pointer long], :long
+
+    def call(fn, *args, ok: [0], exp: nil)
+      to_cname = -> {
+        "VBVMR_#{fn.to_s.delete_prefix("bind_").camelcase.gsub(/(Button|Input|Output)/, '\1_')}"
+      }
+
+      res = send(fn, *args)
+      if exp
+        unless exp.call(res) || ok.include?(res)
+          raise Errors::VMCAPIError.new to_cname.call, res
+        end
+      else
+        unless ok.include?(res)
+          raise Errors::VMCAPIError.new to_cname.call, res
+        end
+      end
+      res
+    rescue Errors::VMCAPIError => e
+      err_msg = [
+        "#{e.class.name}: #{e.message}",
+        *e.backtrace
+      ]
+      logger.error err_msg.join("\n")
+      raise
+    end
+
+    module_function :call
+  end
+end

data/lib/voicemeeter/command.rb

@@ -0,0 +1,35 @@
+module Voicemeeter
+  class Command
+    include IRemote
+
+    def initialize(remote)
+      super
+      make_action_method :show, :restart, :shutdown
+      make_writer_bool :showvbanchat, :lock
+    end
+
+    def identifier
+      :command
+    end
+
+    def hide
+      setter("show", 0)
+    end
+
+    def load(value)
+      raise VMError.new("load got: #{value}, but expected a string") unless value.is_a? String
+      setter("load", value)
+      sleep(0.2)
+    end
+
+    def save(value)
+      raise VMError.new("save got: #{value}, but expected a string") unless value.is_a? String
+      setter("save", value)
+      sleep(0.2)
+    end
+
+    def reset
+      @remote.apply_config(:reset)
+    end
+  end
+end

data/lib/voicemeeter/configs.rb

@@ -0,0 +1,117 @@
+module Voicemeeter
+  module Configs
+    class TOMLConfBuilder
+      def self.run(kind)
+        aouts = (0...kind.phys_out).to_h { |i| [:"A#{i + 1}", false] }
+        bouts = (0...kind.virt_out).to_h { |i| [:"B#{i + 1}", false] }
+        strip_bools = %i[mute mono solo].to_h { |param| [param, false] }
+        gain = [:gain].to_h { |param| [param, 0.0] }
+
+        phys_float =
+          %i[comp gate denoiser].to_h { |param| [param, {knob: 0.0}] }
+        eq = [:eq].to_h { |param| [param, {on: false}] }
+
+        overrides = {B1: true}
+        phys_strip =
+          (0...kind.phys_in).to_h do |i|
+            [
+              "strip-#{i}".to_sym,
+              {**aouts, **bouts, **strip_bools, **gain, **phys_float, **eq, **overrides}
+            ]
+          end
+
+        overrides = {A1: true}
+        virt_strip =
+          (kind.phys_in...kind.phys_in + kind.virt_in).to_h do |i|
+            [
+              :"strip-#{i}",
+              {**aouts, **bouts, **strip_bools, **gain, **overrides}
+            ]
+          end
+
+        bus_bools = %i[mute mono].to_h { |param| [param, false] }
+        bus =
+          (0...kind.num_bus).to_h do |i|
+            [:"bus-#{i}", {**bus_bools, **gain, **eq}]
+          end
+
+        {**phys_strip, **virt_strip, **bus}
+      end
+    end
+
+    class FileReader
+      include Logging
+
+      def initialize(kind)
+        @configpaths = [
+          Pathname.getwd.join("configs", kind.name.to_s),
+          Pathname.new(Dir.home).join(".config", "voicemeeter-rb", kind.name.to_s),
+          Pathname.new(Dir.home).join("Documents", "Voicemeeter", "configs", kind.name.to_s)
+        ]
+      end
+
+      def each
+        @configpaths.each do |configpath|
+          if configpath.exist?
+            logger.debug "checking #{configpath} for configs"
+            filepaths = configpath.glob("*.{yaml,yml}")
+            filepaths.each do |filepath|
+              @filename = (filepath.basename.sub_ext "").to_s.to_sym
+
+              yield @filename, YAML.load_file(
+                filepath,
+                symbolize_names: true
+              )
+            end
+          end
+        end
+      rescue Psych::SyntaxError => e
+        logger.error "#{e.class.name}: #{e.message}"
+      end
+    end
+
+    class Loader
+      include Logging
+
+      attr_reader :configs
+
+      def initialize(kind)
+        @kind = kind
+        @configs = Hash.new do |hash, key|
+          raise Errors::VMError.new "unknown config '#{key}'. known configs: #{hash.keys}"
+        end
+        @filereader = FileReader.new(kind)
+      end
+
+      def to_s
+        "Loader #{@kind}"
+      end
+
+      def run
+        logger.debug "Running #{self}"
+        configs[:reset] = TOMLConfBuilder.run(@kind)
+        @filereader.each(&method(:register))
+        self
+      end
+
+      private def register(identifier, data)
+        if configs.key? identifier
+          logger.debug "config with name '#{identifier}' already in memory, skipping..."
+          return
+        end
+
+        configs[identifier] = data
+        logger.info "#{@kind.name}/#{identifier} loaded into memory"
+      end
+    end
+
+    def get(kind_id)
+      unless defined? @loaders
+        @loaders = Kinds::ALL.to_h { |kind| [kind.name, Loader.new(kind).run] }
+      end
+      @loaders[kind_id].configs
+    end
+
+    module_function :get
+  end
+end

data/lib/voicemeeter/device.rb

@@ -0,0 +1,28 @@
+module Voicemeeter
+  class Device
+    def initialize(remote)
+      @remote = remote
+    end
+
+    def to_s
+      "#{self.class.name.split("::").last}#{@index}#{@remote.kind}"
+    end
+
+    def getter(**kwargs)
+      kwargs => {direction:}
+      return @remote.get_num_devices(direction) unless kwargs.key? :index
+
+      vals = @remote.get_device_description(kwargs[:index], 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