voicemeeter 0.0.1

data/lib/voicemeeter/event.rb

@@ -0,0 +1,82 @@
+module Voicemeeter
+  module Events
+    module Director
+      def observers
+        @observers ||= {}
+      end
+
+      def on(event, method = nil, &block)
+        (observers[event] ||= []) << (block || method)
+      end
+
+      def register(cbs)
+        cbs = Array(cbs) unless cbs.respond_to? :each
+        cbs.each { |cb| on(cb.name[3..].to_sym, cb) }
+      end
+
+      def deregister(cbs)
+        cbs = Array(cbs) unless cbs.respond_to? :each
+        cbs.each { |cb| observers[cb.name[3..].to_sym]&.reject! { |o| cbs.include? o } }
+      end
+
+      def fire(event)
+        observers[event]&.each { |block| block.call }
+      end
+    end
+
+    class Tracker
+      include Logging
+
+      attr_reader :pdirty, :mdirty, :midi, :ldirty
+
+      def initialize(**kwargs)
+        make_writer_methods :pdirty, :mdirty, :midi, :ldirty
+
+        kwargs.each do |key, value|
+          instance_variable_set("@#{key}", value || false)
+        end
+      end
+
+      def to_s
+        self.class.name.split("::").last.to_s
+      end
+
+      def info(msg = nil)
+        info_msg = msg ? ["#{msg} events."] : []
+        info_msg << if any?
+          ["Now listening for #{get.join(", ")} events"]
+        else
+          ["Not listening for any events"]
+        end
+        logger.info info_msg.join(" ")
+      end
+
+      private def make_writer_methods(*params)
+        params.each do |param|
+          define_singleton_method("#{param}=") do |value|
+            instance_variable_set("@#{param}", value)
+            info("#{param} #{value ? "added to" : "removed from"}")
+          end
+        end
+      end
+
+      def get
+        %i[pdirty mdirty midi ldirty].reject { |ev| !send(ev) }
+      end
+
+      def any?
+        [pdirty, mdirty, midi, ldirty].any?
+      end
+
+      def add(events)
+        events = [events] unless events.respond_to? :each
+        events.each { |e| send("#{e}=", true) }
+      end
+
+      def remove(events)
+        events = [events] unless events.respond_to? :each
+        events.each { |e| send("#{e}=", false) }
+      end
+    end
+  end
+end

data/lib/voicemeeter/fx.rb

@@ -0,0 +1,42 @@
+module Voicemeeter
+  class Fx
+    include IRemote
+    attr_reader :reverb, :delay
+
+    def initialize(remote)
+      super
+      @reverb = FxReverb.new(remote)
+      @delay = FxDelay.new(remote)
+    end
+
+    def identifier
+      :fx
+    end
+  end
+
+  class FxReverb
+    include IRemote
+
+    def initialize(remote)
+      super
+      make_accessor_bool :on, :ab
+    end
+
+    def identifier
+      "fx.reverb"
+    end
+  end
+
+  class FxDelay
+    include IRemote
+
+    def initialize(remote)
+      super
+      make_accessor_bool :on, :ab
+    end
+
+    def identifier
+      "fx.delay"
+    end
+  end
+end

data/lib/voicemeeter/install.rb

@@ -0,0 +1,38 @@
+module Voicemeeter
+  private
+
+  module Install
+    extend Logging
+
+    OS_BITS = (FFI::Platform::CPU.downcase == "x64") ? 64 : 32
+
+    def get_vmpath
+      reg_key = [
+        :Software,
+        ((OS_BITS == 64) ? :WOW6432Node : nil),
+        :Microsoft,
+        :Windows,
+        :CurrentVersion,
+        :Uninstall,
+        :"VB:Voicemeeter {17359A74-1236-5467}"
+      ]
+
+      Win32::Registry::HKEY_LOCAL_MACHINE.open(
+        reg_key.compact.join("\\")
+      ) do |reg|
+        value = reg["UninstallString"]
+
+        Pathname.new(value).dirname
+      end
+    rescue Win32::Registry::Error => e
+      err_msg = [
+        "#{e.class.name}: #{e.message}",
+        *e.backtrace
+      ]
+      logger.error err_msg.join("\n")
+      raise Errors::VMInstallError.new "unable to read Voicemeeter path from the registry"
+    end
+
+    module_function :get_vmpath
+  end
+end

data/lib/voicemeeter/iremote.rb

@@ -0,0 +1,51 @@
+module Voicemeeter
+  # Common interface with the base Remote class.
+  module IRemote
+    include Logging
+    include MetaFunctions
+
+    def initialize(remote, i = nil)
+      @remote = remote
+      @index = i
+    end
+
+    def to_s
+      "#{self.class.name.split("::").last}#{@index}#{@remote.kind}"
+    end
+
+    private
+
+    def getter(param, is_string = false)
+      logger.debug "getter: #{_cmd(param)}"
+      @remote.get(_cmd(param), is_string)
+    end
+
+    def setter(param, value)
+      logger.debug "setter: #{_cmd(param)}=#{value}"
+      @remote.set(_cmd(param), value)
+    end
+
+    def _cmd(param)
+      param.empty? ? identifier : "#{identifier}.#{param}"
+    end
+
+    def identifier
+      raise "Called abstract method: identifier"
+    end
+
+    public
+
+    def apply(params)
+      params.each do |key, val|
+        if val.is_a? Hash
+          target = send(key)
+          target.apply(val)
+        elsif key == :mode
+          mode.send("#{val}=", true)
+        else
+          send("#{key}=", val)
+        end
+      end
+    end
+  end
+end

data/lib/voicemeeter/kinds.rb

@@ -0,0 +1,51 @@
+module Voicemeeter
+  module Kinds
+    private
+
+    module KindEnum
+      BASIC = 1
+      BANANA = 2
+      POTATO = 3
+      POTATOX64 = 6
+    end
+
+    KindMap =
+      Data.define(:name, :ins, :outs, :vban, :asio, :insert, :num_buttons) do
+        def phys_in = ins.first
+
+        def virt_in = ins.last
+
+        def phys_out = outs.first
+
+        def virt_out = outs.last
+
+        def num_strip = ins.sum
+
+        def num_bus = outs.sum
+
+        def num_strip_levels = 2 * phys_in + 8 * virt_in
+
+        def num_bus_levels = 8 * (phys_out + virt_out)
+
+        def to_s = name.to_s.capitalize
+      end
+
+    basic = KindMap.new(:basic, [2, 1], [1, 1], [4, 4, 1, 1], [0, 0], 0, 80)
+
+    banana = KindMap.new(:banana, [3, 2], [3, 2], [8, 8, 1, 1], [6, 8], 22, 80)
+
+    potato = KindMap.new(:potato, [5, 3], [5, 3], [8, 8, 1, 1], [10, 8], 34, 80)
+
+    KIND_MAPS = [basic, banana, potato].to_h { |kind| [kind.name, kind] }
+
+    public
+
+    def get(kind_id)
+      KIND_MAPS.fetch(kind_id)
+    end
+
+    ALL = KIND_MAPS.values
+
+    module_function :get
+  end
+end

data/lib/voicemeeter/logger.rb

@@ -0,0 +1,9 @@
+module Voicemeeter
+  module Logging
+    def logger
+      @logger ||= Logger.new($stdout, level: ENV.fetch("VM_LOG_LEVEL", "WARN"))
+      @logger.progname = instance_of?(::Module) ? name : self.class.name
+      @logger
+    end
+  end
+end

data/lib/voicemeeter/meta.rb

@@ -0,0 +1,75 @@
+module Voicemeeter
+  module MetaFunctions
+    private
+
+    # Accessor methods
+    def make_accessor_bool(*params)
+      params.each do |param|
+        define_singleton_method(param) { getter(param).to_i == 1 }
+
+        define_singleton_method("#{param}=") do |value|
+          setter(param, value && 1 || 0)
+        end
+      end
+    end
+
+    def make_accessor_string(*params)
+      params.each do |param|
+        define_singleton_method(param) { getter(param, true) }
+
+        define_singleton_method("#{param}=") { |value| setter(param, value) }
+      end
+    end
+
+    def make_accessor_int(*params)
+      params.each do |param|
+        define_singleton_method(param) { getter(param).to_i }
+
+        define_singleton_method("#{param}=") { |value| setter(param, value) }
+      end
+    end
+
+    def make_accessor_float(*params)
+      params.each do |param|
+        define_singleton_method(param) { getter(param) }
+
+        define_singleton_method("#{param}=") { |value| setter(param, value) }
+      end
+    end
+
+    # reader methods
+    def make_reader_string(*params)
+      params.each do |param|
+        define_singleton_method(param) { getter(param, true) }
+      end
+    end
+
+    def make_reader_int(*params)
+      params.each do |param|
+        define_singleton_method(param) { getter(param).to_i }
+      end
+    end
+
+    # writer methods
+    def make_writer_bool(*params)
+      params.each do |param|
+        define_singleton_method("#{param}=") do |value|
+          setter(param, value && 1 || 0)
+        end
+      end
+    end
+
+    def make_writer_string(*params)
+      params.each do |param|
+        define_singleton_method("#{param}=") { |value| setter(param, value) }
+      end
+    end
+
+    # methods for performing certain actions as opposed to setting values
+    def make_action_method(*params)
+      params.each do |param|
+        define_singleton_method(param) { setter(param, 1) }
+      end
+    end
+  end
+end

data/lib/voicemeeter/midi.rb

@@ -0,0 +1,14 @@
+module Voicemeeter
+  class Midi
+    attr_accessor :current, :channel
+    attr_reader :cache
+
+    def initialize
+      @cache = {}
+    end
+
+    def get(key)
+      cache[key]
+    end
+  end
+end

data/lib/voicemeeter/mixins.rb

@@ -0,0 +1,83 @@
+module Voicemeeter
+  module Mixins
+    module Fades
+      def fadeto(target, time)
+        setter("FadeTo", "(#{target}, #{time})")
+        sleep(@remote.delay)
+      end
+
+      def fadeby(change, time)
+        setter("FadeBy", "(#{change}, #{time})")
+        sleep(@remote.delay)
+      end
+    end
+
+    module Return
+      def initialize(remote, i)
+        super
+        make_accessor_float :returnreverb, :returndelay, :returnfx1, :returnfx2
+      end
+    end
+
+    module Apps
+      def appgain(name, gain)
+        setter("AppGain", "(\"#{name}\", #{gain})")
+      end
+
+      def appmute(name, mute)
+        setter("AppMute", "(\"#{name}\", #{mute ? 1 : 0})")
+      end
+    end
+
+    module Outputs
+      def initialize(*args)
+        super
+        remote, *_ = args
+        num_a, num_b = remote.kind.outs
+        channels =
+          (1..(num_a + num_b)).map do |i|
+            (i <= num_a) ? "A#{i}" : "B#{i - num_a}"
+          end
+        make_accessor_bool(*channels)
+      end
+    end
+
+    module Xy
+      module Pan
+        def initialize(remote, i)
+          super
+          make_accessor_float :pan_x, :pan_y
+        end
+      end
+
+      module Color
+        def initialize(remote, i)
+          super
+          make_accessor_float :color_x, :color_y
+        end
+      end
+
+      module Fx
+        def initialize(remote, i)
+          super
+          make_accessor_float :fx_x, :fx_y
+        end
+      end
+    end
+
+    module Fx
+      def initialize(remote, i)
+        super
+        make_accessor_float :reverb, :delay, :fx1, :fx2
+        make_accessor_bool :postreverb, :postdelay, :postfx1, :postfx2
+      end
+    end
+
+    module LevelEnum
+      PREFADER = 0
+      POSTFADER = 1
+      POSTMUTE = 2
+      BUS = 3
+    end
+  end
+end

data/lib/voicemeeter/option.rb

@@ -0,0 +1,69 @@
+module Voicemeeter
+  module Option
+    class Base
+      include IRemote
+      attr_reader :delay, :buffer, :mode
+
+      def initialize(remote)
+        super
+        make_accessor_int :sr
+        make_accessor_bool :asiosr, :monitoronsel, :slidermode
+
+        @delay = (0...remote.kind.phys_out).map { OptionDelay.new(remote, _1) }
+        @buffer = OptionBuffer.new(remote)
+        @mode = OptionMode.new(remote)
+      end
+
+      def identifier
+        :option
+      end
+    end
+
+    class OptionDelay
+      include IRemote
+
+      def initialize(remote, i)
+        super
+        make_accessor_bool :on, :ab
+      end
+
+      def identifier
+        "option.delay"
+      end
+
+      def get
+        getter("[#{@index}]").to_i
+      end
+
+      def set(val)
+        setter("[#{@index}]", val)
+      end
+    end
+
+    class OptionBuffer
+      include IRemote
+
+      def initialize(remote)
+        super
+        make_accessor_int :mme, :wdm, :ks, :asio
+      end
+
+      def identifier
+        "option.buffer"
+      end
+    end
+
+    class OptionMode
+      include IRemote
+
+      def initialize(remote)
+        super
+        make_accessor_bool :exclusif, :swift
+      end
+
+      def identifier
+        "option.mode"
+      end
+    end
+  end
+end

data/lib/voicemeeter/patch.rb

@@ -0,0 +1,79 @@
+module Voicemeeter
+  module Patch
+    # Base class for Patch
+    class Base
+      include IRemote
+      attr_reader :asio, :A2, :A3, :A4, :A5, :composite, :insert
+
+      def initialize(remote)
+        super
+        make_accessor_bool :postfadercomposite, :postfxinsert
+
+        asio_in, asio_out = remote.kind.asio
+        @asio = (0...asio_in).map { PatchAsioIn.new(remote, _1) }
+        %i[A2 A3 A4 A5].each do |param|
+          instance_variable_set("@#{param}", (0...asio_out).map { PatchAsioOut.new(remote, _1, param) })
+        end
+        @composite = (0...8).map { PatchComposite.new(remote, _1) }
+        @insert = (0...remote.kind.insert).map { PatchInsert.new(remote, _1) }
+      end
+    end
+
+    class PatchAsio
+      include IRemote
+
+      def identifier
+        :patch
+      end
+    end
+
+    class PatchAsioIn < PatchAsio
+      def get
+        getter("asio[#{@index}]").to_i
+      end
+
+      def set(val)
+        setter("asio[#{@index}]", val)
+      end
+    end
+
+    class PatchAsioOut < PatchAsio
+      def initialize(remote, i, param)
+        super(remote, i)
+        @param = param
+      end
+
+      def get
+        getter("out#{@param}[#{@index}]").to_i
+      end
+
+      def set(val)
+        setter("out#{@param}[#{@index}]", val)
+      end
+    end
+
+    class PatchComposite
+      include IRemote
+
+      def get
+        getter("composite[#{@index}]").to_i
+      end
+
+      def set(val)
+        setter("composite[#{@index}]", val)
+      end
+    end
+
+    class PatchInsert
+      include IRemote
+
+      def get
+        getter("insert[#{@index}]").to_i == 1
+      end
+
+      def set(val)
+        setter("insert[#{@index}]", val && 1 || 0)
+      end
+    end
+  end
+end

data/lib/voicemeeter/recorder.rb

@@ -0,0 +1,90 @@
+module Voicemeeter
+  module Recorder
+    module FileTypeEnum
+      WAV = 1
+      AIFF = 2
+      BWF = 3
+      MP3 = 100
+    end
+
+    # Base class for Recorder
+    class Base
+      include IRemote
+      include Mixins::Outputs
+
+      attr_reader :mode, :armstrip, :armbus
+
+      def initialize(remote)
+        super
+        make_action_method :play, :stop, :pause, :replay, :record, :ff, :rew
+        make_accessor_int :bitresolution, :channel, :kbps
+        make_accessor_float :gain
+
+        @mode = RecorderMode.new(remote)
+        @armstrip = (0...remote.kind.num_strip).map { RecorderArmStrip.new(remote, _1) }
+        @armbus = (0...remote.kind.num_bus).map { RecorderArmBus.new(remote, _1) }
+      end
+
+      def identifier
+        :recorder
+      end
+
+      def load(filepath)
+        setter("load", filepath)
+      end
+
+      def goto(timestr)
+        unless /^(2[0-3]|[01]?[0-9]):([0-5]?[0-9]):([0-5]?[0-9])$/.match?(timestr)
+          logger.error "goto got: '#{timestr}', but expects a time string in the format 'hh:mm:ss'"
+          return
+        end
+        dt = DateTime.parse(timestr)
+        seconds = dt.hour * 3600 + dt.min * 60 + dt.second
+        setter("goto", seconds)
+      end
+
+      def filetype(val)
+        opts = {wav: FileTypeEnum::WAV, aiff: FileTypeEnum::AIFF, bwf: FileTypeEnum::BWF, mp3: FileTypeEnum::MP3}
+        setter("filetype", opts[val])
+      end
+    end
+
+    class RecorderMode
+      include IRemote
+
+      def initialize(remote)
+        super
+        make_accessor_bool :recbus, :playonload, :loop, :multitrack
+      end
+
+      def identifier
+        "recorder.mode"
+      end
+    end
+
+    class RecorderArmChannel
+      include IRemote
+
+      def initialize(remote, j)
+        super(remote)
+        @j = j
+      end
+
+      def set
+        setter("", val && 1 || 0)
+      end
+    end
+
+    class RecorderArmStrip < RecorderArmChannel
+      def identifier
+        "recorder.armstrip[#{@j}]"
+      end
+    end
+
+    class RecorderArmBus < RecorderArmChannel
+      def identifier
+        "recorder.armbus[#{@j}]"
+      end
+    end
+  end
+end