voicemeeter 0.0.1

data/lib/voicemeeter/remote.rb

@@ -0,0 +1,102 @@
+module Voicemeeter
+  # Builder module for Remote factories.
+  module Builder
+    private
+
+    def steps(step)
+      case step
+      when :strip then -> { (0...kind.num_strip).map { Strip::Base.make(self, _1) } }
+      when :bus then -> { (0...kind.num_bus).map { Bus::Base.make(self, _1) } }
+      when :button then -> { (0...kind.num_buttons).map { Button::Base.new(self, _1) } }
+      when :vban then -> { Vban::Base.new(self) }
+      when :command then -> { Command.new(self) }
+      when :recorder then -> { Recorder::Base.new(self) }
+      when :device then -> { Device.new(self) }
+      when :fx then -> { Fx.new(self) }
+      when :patch then -> { Patch::Base.new(self) }
+      when :option then -> { Option::Base.new(self) }
+      end
+    end
+
+    def director
+      %i[strip bus button vban command device option]
+    end
+  end
+
+  module Remote
+    extend Logging
+
+    # Concrete class for Remote
+    class Remote < Base
+      include Builder
+
+      public attr_reader :strip, :bus, :button, :vban, :command, :device, :option
+
+      def initialize(...)
+        super
+        director.each { |step| instance_variable_set("@#{step}", steps(step).call) }
+      end
+
+      def configs
+        Configs.get(kind.name)
+      end
+
+      def run
+        login
+        if event.any?
+          init_event_threads
+        end
+
+        yield(self) if block_given?
+      ensure
+        end_event_threads
+        logout
+      end
+    end
+
+    # Represents a RemoteBasic type
+    class RemoteBasic < Remote; end
+
+    # Represents a RemoteBanana type
+    class RemoteBanana < Remote
+      public attr_reader :recorder, :patch
+
+      private def director
+        super | [:recorder, :patch]
+      end
+    end
+
+    # Represents a RemotePotato type
+    class RemotePotato < Remote
+      public attr_reader :recorder, :patch, :fx
+
+      private def director
+        super | [:recorder, :patch, :fx]
+      end
+    end
+
+    # Factory class for Remote. Returns a Remote class of a kind.
+    class RequestRemote
+      def self.for(kind, **)
+        case kind.name
+        when :basic
+          RemoteBasic.new(kind, **)
+        when :banana
+          RemoteBanana.new(kind, **)
+        when :potato
+          RemotePotato.new(kind, **)
+        end
+      end
+    end
+
+    # Interface entry point. Wraps factory class and handles kind errors.
+    def self.new(kind_id, **)
+      kind = Kinds.get(kind_id)
+    rescue KeyError => e
+      logger.error "#{e.class.name}: #{e.message}"
+      raise Errors::VMError.new "unknown Voicemeeter kind '#{kind_id}'"
+    else
+      RequestRemote.for(kind, **)
+    end
+  end
+end

data/lib/voicemeeter/strip.rb

@@ -0,0 +1,254 @@
+module Voicemeeter
+  module Strip
+    # Base class for Strip
+    class Base
+      include IRemote
+      include Mixins::Outputs
+      include Mixins::Fades
+
+      attr_reader :gainlayer, :levels
+
+      def self.make(remote, i)
+        (i < remote.kind.phys_in) ? PhysicalStrip.new(remote, i) : VirtualStrip.new(remote, i)
+      end
+
+      def initialize(remote, i)
+        super
+        make_accessor_bool :solo, :mute, :mono
+        make_accessor_float :gain
+        make_accessor_int :limit
+        make_accessor_string :label
+
+        @gainlayer = (0...8).map { GainLayer.new(remote, i, _1) }
+        @levels = StripLevels.new(remote, i)
+      end
+
+      def identifier
+        "strip[#{@index}]"
+      end
+    end
+
+    # Represents a Physical Strip
+    class PhysicalStrip < Base
+      include Mixins::Xy::Pan
+      include Mixins::Xy::Color
+      include Mixins::Xy::Fx
+      include Mixins::Fx
+
+      attr_reader :comp, :gate, :denoiser, :eq, :device
+
+      def initialize(remote, i)
+        super
+        make_accessor_float :audibility
+
+        @comp = StripComp.new(remote, i)
+        @gate = StripGate.new(remote, i)
+        @denoiser = StripDenoiser.new(remote, i)
+        @eq = StripEq.new(remote, i)
+        @device = StripDevice.new(remote, i)
+      end
+    end
+
+    class StripComp
+      include IRemote
+
+      def initialize(remote, i)
+        super
+        make_accessor_float :gainin,
+          :ratio,
+          :threshold,
+          :attack,
+          :release,
+          :knee,
+          :gainout
+        make_accessor_bool :makeup
+      end
+
+      def identifier
+        "strip[#{@index}].comp"
+      end
+
+      def knob
+        getter("")
+      end
+
+      def knob=(val)
+        setter("", val)
+      end
+    end
+
+    class StripGate
+      include IRemote
+
+      def initialize(remote, i)
+        super
+        make_accessor_float :threshold, :damping, :attack, :hold, :release
+        make_accessor_int :bpsidechain
+      end
+
+      def identifier
+        "strip[#{@index}].gate"
+      end
+
+      def knob
+        getter("")
+      end
+
+      def knob=(val)
+        setter("", val)
+      end
+    end
+
+    class StripDenoiser
+      include IRemote
+
+      def identifier
+        "strip[#{@index}].denoiser"
+      end
+
+      def knob
+        getter("")
+      end
+
+      def knob=(val)
+        setter("", val)
+      end
+    end
+
+    class StripEq
+      include IRemote
+
+      def initialize(remote, i)
+        super
+        make_accessor_bool :on, :ab
+      end
+
+      def identifier
+        "strip[#{@index}].eq"
+      end
+    end
+
+    class StripDevice
+      include IRemote
+
+      def initialize(remote, i)
+        super
+        make_reader_int :sr
+        make_reader_string :name
+        make_writer_string :wdm, :ks, :mme, :asio
+      end
+
+      def identifier
+        "strip[#{@index}].device"
+      end
+    end
+
+    # Represents a Virtual Strip
+    class VirtualStrip < Base
+      include Mixins::Xy::Pan
+      include Mixins::Apps
+
+      def initialize(remote, i)
+        super
+        make_accessor_bool :mc
+        make_accessor_int :karaoke
+      end
+
+      def bass
+        round(getter("EQGain1"), 1)
+      end
+
+      def bass=(val)
+        setter("EQGain1", val)
+      end
+
+      def mid
+        round(getter("EQGain2"), 1)
+      end
+
+      def mid=(val)
+        setter("EQGain2", val)
+      end
+
+      def treble
+        round(getter("EQGain3"), 1)
+      end
+
+      def treble=(val)
+        setter("EQGain3", val)
+      end
+
+      alias_method :med, :mid
+      alias_method :med=, :mid=
+      alias_method :high, :treble
+      alias_method :high=, :treble=
+    end
+
+    class GainLayer
+      include IRemote
+
+      def initialize(remote, i, j)
+        super(remote, i)
+        @j = j
+      end
+
+      def identifier
+        "strip[#{@index}]"
+      end
+
+      def gain
+        getter("gainlayer[#{@j}]")
+      end
+
+      def gain=(value)
+        setter("gainlayer[#{@j}]", value)
+      end
+    end
+
+    class StripLevels
+      include IRemote
+
+      def initialize(remote, i)
+        super
+        p_in = remote.kind.phys_in
+        if i < p_in
+          @init = i * 2
+          @offset = 2
+        else
+          @init = (p_in * 2) + ((i - p_in) * 8)
+          @offset = 8
+        end
+      end
+
+      def identifier
+        "strip[#{@index}]"
+      end
+
+      def get_level(mode)
+        convert = ->(x) { (x > 0) ? (20 * Math.log(x, 10)).round(1) : -200.0 }
+
+        @remote.cache[:strip_mode] = mode
+        vals = if @remote.running? && @remote.event.ldirty
+          @remote.cache[:strip_level][@init, @offset]
+        else
+          (@init...@init + @offset).map { |i| @remote.get_level(mode, i) }
+        end
+        vals.map(&convert)
+      end
+
+      def prefader
+        get_level(Mixins::LevelEnum::PREFADER)
+      end
+
+      def postfader
+        get_level(Mixins::LevelEnum::POSTFADER)
+      end
+
+      def postmute
+        get_level(Mixins::LevelEnum::POSTMUTE)
+      end
+
+      def isdirty? = @remote.cache[:strip_comp][@init, @offset].any?
+    end
+  end
+end

data/lib/voicemeeter/util.rb

@@ -0,0 +1,35 @@
+module Voicemeeter
+  module Util
+    module CoreExtensions
+      refine String do
+        def snakecase
+          gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .tr("-", "_")
+            .gsub(/\s/, "_")
+            .gsub(/__+/, "_")
+            .downcase
+        end
+
+        def camelcase
+          self if self !~ /_/ && self =~ /[A-Z]+.*/
+          split("_").map(&:capitalize).join
+        end
+      end
+    end
+
+    module Cache
+      def get(name, is_string = false)
+        return cache.delete(name) if cache.key? name
+        clear_dirty if @sync
+        super
+      end
+
+      def get_buttonstatus(id, mode)
+        return cache.delete("mb_#{id}_#{mode}") if cache.key? "mb_#{id}_#{mode}"
+        clear_dirty if @sync
+        super
+      end
+    end
+  end
+end

data/lib/voicemeeter/vban.rb

@@ -0,0 +1,105 @@
+module Voicemeeter
+  module Vban
+    # Base class for Vban In/Out Streams
+    class VbanStream
+      include IRemote
+
+      def initialize(remote, i)
+        super
+        make_accessor_bool :on
+        make_accessor_string :name, :ip
+        make_accessor_int :quality, :route
+      end
+
+      def identifier
+        "vban.#{direction}stream[#{@index}]"
+      end
+
+      def direction
+        raise "Called abstract method: direction"
+      end
+    end
+
+    # Represents a Vban InStream
+    class VbanInstream < VbanStream
+      def initialize(remote, i)
+        super
+        make_reader_int :sr, :channel, :bit
+      end
+
+      def direction
+        :in
+      end
+    end
+
+    # Represents a Vban Audio InStream
+    class VbanAudioInstream < VbanInstream; end
+
+    # Represents a Vban Midi InStream
+    class VbanMidiInstream < VbanInstream; end
+
+    # Represents a Vban Text InStream
+    class VbanTextInstream < VbanInstream; end
+
+    # Represents a Vban OutStream
+    class VbanOutstream < VbanStream
+      def initialize(remote, i)
+        super
+        make_accessor_int :sr, :channel, :bit
+      end
+
+      def direction
+        :out
+      end
+    end
+
+    # Represents a Vban Audio OutStream
+    class VbanAudioOutstream < VbanOutstream; end
+
+    # Represents a Vban Midi OutStream
+    class VbanMidiOutstream < VbanOutstream; end
+
+    class RequestVbanStream
+      def self.for(remote, i, dir)
+        vban_in, vban_out, midi, _ = remote.kind.vban
+        case dir
+        when :in
+          if i < vban_in
+            VbanAudioInstream.new(remote, i)
+          elsif i < vban_in + midi
+            VbanMidiInstream.new(remote, i)
+          else
+            VbanTextInstream.new(remote, i)
+          end
+        when :out
+          if i < vban_out
+            VbanAudioOutstream.new(remote, i)
+          elsif i < vban_out + midi
+            VbanMidiOutstream.new(remote, i)
+          end
+        end
+      end
+    end
+
+    # Base class for Vban
+    class Base
+      attr_reader :instream, :outstream
+
+      def initialize(remote)
+        vban_in, vban_out, midi, text = remote.kind.vban
+        @instream = (0...vban_in + midi + text).map { RequestVbanStream.for(remote, _1, :in) }
+        @outstream = (0...vban_out + midi).map { RequestVbanStream.for(remote, _1, :out) }
+
+        @remote = remote
+      end
+
+      def enable
+        @remote.set("vban.enable", 1)
+      end
+
+      def disable
+        @remote.set("vban.enable", 0)
+      end
+    end
+  end
+end

data/lib/voicemeeter/version.rb

@@ -0,0 +1,25 @@
+module Voicemeeter
+  module VERSION
+    module_function
+
+    def major
+      0
+    end
+
+    def minor
+      0
+    end
+
+    def patch
+      1
+    end
+
+    def to_a
+      [major, minor, patch]
+    end
+
+    def to_s
+      to_a.join(".")
+    end
+  end
+end

data/lib/voicemeeter/worker.rb

@@ -0,0 +1,64 @@
+module Voicemeeter
+  module Worker
+    include Logging
+
+    private
+
+    def init_producer(que)
+      @producer = Thread.new do
+        Thread.current.name = "producer"
+        Thread.current[:running] = true
+        while Thread.current[:running]
+          que << :pdirty if event.pdirty
+          que << :mdirty if event.mdirty
+          que << :midi if event.midi
+          que << :ldirty if event.ldirty
+          sleep(@ratelimit)
+        end
+        logger.debug "closing #{Thread.current.name} thread"
+        que << Thread.current[:running]
+      end
+    end
+
+    def init_worker(que)
+      logger.info "Listening for #{event.get.join(", ")} events"
+      cache[:strip_level], cache[:bus_level] = _get_levels
+      cache[:strip_comp] = Array.new(kind.num_strip_levels, false)
+      cache[:bus_comp] = Array.new(kind.num_bus_levels, false)
+      Thread.new do
+        Thread.current.name = "worker"
+        while (event = que.pop)
+          fire :pdirty if event == :pdirty && pdirty?
+          fire :mdirty if event == :mdirty && mdirty?
+          fire :midi if event == :midi && get_midi_message
+          if event == :ldirty && ldirty?
+            cache[:strip_comp] = cache[:strip_level].zip(cache[:strip_buf]).map { |a, b| a != b }
+            cache[:bus_comp] = cache[:bus_level].zip(cache[:bus_buf]).map { |a, b| a != b }
+            cache[:strip_level] = cache[:strip_buf]
+            cache[:bus_level] = cache[:bus_buf]
+            fire :ldirty
+          end
+        end
+        logger.debug "closing #{Thread.current.name} thread"
+      end
+    end
+
+    public
+
+    def running?
+      @producer&.alive?
+    end
+
+    def init_event_threads
+      que = Queue.new
+      init_worker(que) and init_producer(que)
+    end
+
+    def end_event_threads
+      if running?
+        @producer[:running] = false
+        @producer.join
+      end
+    end
+  end
+end

data/lib/voicemeeter.rb

@@ -0,0 +1,56 @@
+require "yaml"
+require "pathname"
+require "win32/registry"
+require "ffi"
+require "date"
+require "logger"
+
+require_relative "voicemeeter/logger"
+require_relative "voicemeeter/worker"
+require_relative "voicemeeter/event"
+require_relative "voicemeeter/util"
+require_relative "voicemeeter/meta"
+require_relative "voicemeeter/iremote"
+require_relative "voicemeeter/mixins"
+require_relative "voicemeeter/install"
+
+require_relative "voicemeeter/base"
+require_relative "voicemeeter/bus"
+require_relative "voicemeeter/button"
+require_relative "voicemeeter/cbindings"
+require_relative "voicemeeter/command"
+require_relative "voicemeeter/configs"
+require_relative "voicemeeter/device"
+require_relative "voicemeeter/fx"
+require_relative "voicemeeter/kinds"
+require_relative "voicemeeter/midi"
+require_relative "voicemeeter/option"
+require_relative "voicemeeter/patch"
+require_relative "voicemeeter/recorder"
+require_relative "voicemeeter/remote"
+require_relative "voicemeeter/strip"
+require_relative "voicemeeter/vban"
+
+require_relative "voicemeeter/version"
+
+module Voicemeeter
+  module Errors
+    # Base Voicemeeter error class
+    class VMError < StandardError; end
+
+    # Raised when errors occur during installation.
+    class VMInstallError < VMError; end
+
+    # Raised when the C-API returns error codes
+    class VMCAPIError < VMError
+      attr_reader :fn_name, :code
+
+      # create a new VMCAPIError with given C-API function name and error code
+      def initialize(fn_name, code)
+        @fn_name = fn_name
+        @code = code
+        super("#{fn_name} returned #{code}")
+      end
+    end
+  end
+end