musalce-server 0.4.10

data/README.md

@@ -0,0 +1,22 @@
+# Musa Live Coding Environment (Server for Ableton Live and Bitwig)
+
+Musa-DSL Live Coding Environment for Ableton Live and Bitwig Studio (Server part)
+
+**TODO: complete README**
+
+## Install
+**TODO**
+
+## Usage
+**TODO**
+
+## Documentation
+**TODO**
+
+## Author
+
+* [Javier Sánchez Yeste](https://github.com/javier-sy)
+
+## License
+
+[MusaLCE-Server](https://github.com/javier-sy/MusaLCE-Server) Copyright (c) 2021-2023 [Javier Sánchez Yeste](https://yeste.studio), licensed under GPL 3.0 License

data/bin/musalce-server

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'musalce-server'
+
+MusaLCEServer.run(ARGV[0])

data/lib/bitwig/bitwig.rb

@@ -0,0 +1,57 @@
+require_relative '../daw'
+
+require_relative 'handler'
+require_relative 'controllers'
+
+module MusaLCEServer
+  module Bitwig
+    class Bitwig < Daw
+      def daw_initialize(midi_devices:, clock:, osc_server:, osc_client:, logger:)
+        super
+
+        controllers = Controllers.new(midi_devices, clock: clock, logger: logger)
+        handler = Handler.new(osc_server, osc_client, controllers, @sequencer, logger: logger)
+
+        logger.info('Loaded Bitwig Studio driver')
+
+        return controllers.tracks, handler
+      end
+
+      def track(name, all: false)
+        if all
+          [@tracks[name]]
+        else
+          @tracks[name]
+        end
+      end
+
+      def play
+        @handler.play
+        super
+      end
+
+      def stop
+        @handler.stop
+        super
+      end
+
+      def continue
+        @handler.continue
+        super
+      end
+
+      def goto(position)
+        @handler.goto(position)
+        super
+      end
+
+      def record
+        @handler.record
+        super
+      end
+    end
+
+    Daw.register :bitwig, Bitwig
+  end
+end
+

data/lib/bitwig/controllers.rb

@@ -0,0 +1,129 @@
+require_relative 'tracks'
+
+module MusaLCEServer
+  module Bitwig
+    class Controllers
+      def initialize(midi_devices, clock:, logger:)
+        @midi_devices = midi_devices
+        @clock = clock
+        @logger = logger
+        @controllers = {}
+        @tracks = Tracks.new(logger: logger)
+      end
+
+      attr_reader :tracks
+
+      def register_controllers(controllers)
+        to_delete = @controllers.keys - controllers
+
+        controllers.each do |controller_name|
+          if @controllers.key?(controller_name)
+            @logger.info "Controller #{controller_name} already exists"
+          else
+            @logger.info "Added controller #{controller_name}"
+            @controllers[controller_name] = Controller.new(controller_name, @midi_devices, @clock, @tracks, logger: @logger)
+          end
+        end
+
+        to_delete.each do |controller_name|
+          @controllers.delete(controller_name)
+          @logger.info "Deleted controller #{controller_name}"
+        end
+      end
+
+      def register_controller(name:, port_name:, is_clock:)
+        controller = @controllers[name]
+        controller.port_name = port_name
+        controller.is_clock = is_clock
+        @logger.info "Controller #{name} defined with port_name #{port_name} clock #{is_clock}"
+      end
+
+      def update_controller(old_name:, new_name:, port_name:, is_clock:)
+        controller = @controllers.delete(old_name)
+        @controllers[new_name] = controller
+        controller.name = new_name
+
+        controller.port_name = port_name
+        controller.is_clock = is_clock
+
+        @logger.info "Controller #{old_name} updated as #{new_name} with port_name #{port_name} clock #{is_clock}"
+      end
+
+      def register_channels(controller_name:, channels:)
+        controller = @controllers[controller_name]
+
+        @logger.info "Channels for controller #{controller_name} named #{channels}"
+
+        channels.each.with_index do |name, i|
+          controller.channels[i].name = name
+        end
+      end
+    end
+
+    class Controller
+      def initialize(name, midi_devices, clock, tracks, logger:)
+        @midi_devices = midi_devices
+        @clock = clock
+        @tracks = tracks
+        @logger = logger
+
+        @midi_device = nil
+
+        self.name = name
+        @channels = Array.new(16) { |channel| Channel.new(self, tracks, channel, logger: logger) }
+      end
+
+      attr_accessor :port_name
+      attr_reader :name, :midi_device, :channels, :is_clock
+
+      def is_clock=(new_is_clock)
+        # TODO when new_is_clock is false look if another controller is true, else leave clock input as nil (the user has not selected any clock!)
+        @is_clock = new_is_clock
+        update_clock
+      end
+
+      def name=(new_name)
+        @name = new_name
+        @midi_device = @midi_devices.find(@name)
+
+        update_clock
+
+        if @midi_device
+          @logger.info "Found midi device #{@midi_device.to_s} for #{@name}"
+        else
+          @logger.warn "Not found midi device for #{@name}"
+        end
+      end
+
+      private def update_clock
+        @clock.input = MIDICommunications::Input.find_by_name(@midi_device.low_level_device.name) if @is_clock
+      end
+    end
+
+    class Channel
+      def initialize(controller, tracks, channel_number, logger:)
+        @controller = controller
+        @tracks = tracks
+        @channel_number = channel_number
+        @logger = logger
+      end
+
+      attr_reader :channel_number, :name
+
+      def name=(new_name)
+        @tracks[@name]&._forget_channel
+        @name = new_name
+        @tracks.create(@name)
+        @tracks[@name]._channel = self
+      end
+
+      def output
+        @controller.midi_device.channels[@channel_number]
+      end
+
+      def to_s
+        "<Channel #{@channel_number} '#{@name}' on port '#{@controller.port_name}' (controller '#{@controller.name}')>"
+      end
+    end
+  end
+end

data/lib/bitwig/handler.rb

@@ -0,0 +1,82 @@
+require_relative '../daw'
+
+module MusaLCEServer
+  module Bitwig
+    class Handler < ::MusaLCEServer::Handler
+      def initialize(osc_server, osc_client, controllers, sequencer, logger:)
+        super()
+
+        @server = osc_server
+        @client = osc_client
+
+        @controllers = controllers
+        @sequencer = sequencer
+
+        @logger = logger
+
+        @server.add_method '/hello' do |message|
+          @logger.info "Received /hello #{message.to_a}!"
+          version
+          sync
+        end
+
+        @server.add_method '/musalce4bitwig/controllers' do |message|
+          @logger.info("Received /musalce4bitwig/controllers #{message.to_a}")
+          @controllers.register_controllers(message.to_a)
+        end
+
+        @server.add_method '/musalce4bitwig/controller' do |message|
+          @logger.info("Received /musalce4bitwig/controller #{message.to_a}")
+          a = message.to_a
+          @controllers.register_controller(name: a[0], port_name: a[1], is_clock: a[2] == 1)
+        end
+
+        @server.add_method '/musalce4bitwig/controller/update' do |message|
+          @logger.info("Received /musalce4bitwig/controller/update #{message.to_a}")
+          a = message.to_a
+          @controllers.update_controller(old_name: a[0], new_name: a[1], port_name: a[2], is_clock: a[3] == 1)
+        end
+
+        @server.add_method '/musalce4bitwig/channels' do |message|
+          @logger.info("Received /musalce4bitwig/channels #{message.to_a}")
+          a = message.to_a
+          @controllers.register_channels(controller_name: a[0], channels: a[1..])
+        end
+      end
+
+      def sync
+        @logger.info 'Asking sync'
+        send_osc '/musalce4bitwig/sync'
+      end
+
+      def play
+        @logger.info 'Asking play'
+        send_osc '/musalce4bitwig/play'
+      end
+
+      def stop
+        @logger.info 'Asking stop'
+        send_osc '/musalce4bitwig/stop'
+      end
+
+      def continue
+        @logger.info 'Asking continue'
+        send_osc '/musalce4bitwig/continue'
+      end
+
+      def goto(position)
+        @logger.info "Asking goto #{position}"
+        send_osc '/musalce4bitwig/goto', OSC::OSCDouble64.new(((position - 1) * @sequencer.beats_per_bar).to_f)
+      end
+
+      def record
+        @logger.info 'Asking record'
+        send_osc '/musalce4bitwig/record'
+      end
+
+      def panic!
+        @controllers.tracks.each(:panic!)
+      end
+    end
+  end
+end

data/lib/bitwig/tracks.rb

@@ -0,0 +1,58 @@
+require 'musa-dsl/core-ext/dynamic-proxy'
+
+module MusaLCEServer
+  module Bitwig
+    class Tracks
+      include Enumerable
+
+      def initialize(logger:)
+        @logger = logger
+        @tracks = {}
+      end
+
+      def create(name)
+        @tracks[name] = Track.new(name, logger: @logger)
+      end
+
+      def each(&block)
+        if block_given?
+          @tracks.values.each(&block)
+        else
+          @tracks.values.each
+        end
+      end
+
+      def [](name)
+        @tracks[name]
+      end
+
+      def []=(name, track)
+        @tracks[name] = track
+      end
+    end
+
+    class Track
+      def initialize(name, logger:)
+        @name = name
+        @logger = logger
+
+        @output = Musa::Extension::DynamicProxy::DynamicProxy.new
+      end
+
+      attr_reader :name
+
+      def _forget_channel
+        @output.receiver = nil
+      end
+
+      def _channel=(new_channel)
+        @logger.info "Assigning #{new_channel} to track '#{@name}'"
+        @output.receiver = new_channel.output
+      end
+
+      def out
+        @output
+      end
+    end
+  end
+end

data/lib/daw.rb

@@ -0,0 +1,114 @@
+require 'midi-communications'
+
+require_relative 'midi-devices'
+
+module MusaLCEServer
+  class Daw
+    def self.register(daw_id, daw_class)
+      @@daws ||= {}
+      @@daws[daw_id] = daw_class
+    end
+
+    def self.daw_controller_for(daw_id)
+      @@daws[daw_id].new
+    end
+
+    def initialize
+      osc_server = OSC::EMServer.new(11_011)
+      osc_client = OSC::Client.new('localhost', 10_001)
+
+      Thread.new { osc_server.run }
+
+      @sequencer = Musa::Sequencer::Sequencer.new 4, 24, dsl_context_class: MusaLCE_Context, do_log: true
+
+      @clock = Musa::Clock::InputMidiClock.new do_log: true, logger: @sequencer.logger
+      transport = Musa::Transport::Transport.new @clock, sequencer: @sequencer
+
+      transport.after_stop do
+        sequencer.reset
+      end
+
+      @midi_devices = MIDIDevices.new(@sequencer)
+
+      @tracks, @handler = daw_initialize(midi_devices: @midi_devices, clock: @clock, osc_server: osc_server, osc_client: osc_client, logger: @sequencer.logger)
+
+      @handler.version
+      @handler.sync
+
+      Thread.new { transport.start }
+    end
+
+    attr_reader :clock, :sequencer, :tracks
+
+    protected def daw_initialize(midi_devices:, clock:, osc_server:, osc_client:, logger:); end
+
+    def track(name, all: false)
+      raise NotImplementedError
+    end
+
+    def play; end
+
+    def stop; end
+
+    def continue; end
+
+    def goto(position); end
+
+    def record; end
+
+    def panic!
+      @tracks.each do |track|
+        track.out.all_notes_off
+      end
+    end
+
+    def sync
+      @handler.sync
+    end
+
+    def reload
+      @handler.reload
+    end
+  end
+
+  class Handler
+    def reload
+      @logger.info 'Asking controller reset and reload'
+      send_osc '/reload'
+    end
+
+    def version
+      @logger.info "Sending version #{VERSION}"
+      send_osc '/version', VERSION
+    end
+
+    def panic!
+      raise NotImplementedError
+    end
+
+    private def send_osc(message, *args)
+      counter = 0
+      begin
+        @client.send OSC::Message.new(message, *args)
+      rescue Errno::ECONNREFUSED
+        counter += 1
+        @logger.warn "Errno::ECONNREFUSED when sending message #{message} #{args}. Retrying... (#{counter})"
+        retry if counter < 3
+      end
+    end
+  end
+
+  class MusaLCE_Context < Musa::Sequencer::Sequencer::DSLContext
+    include Musa::REPL::CustomizableDSLContext
+
+    def binder
+      @__binder ||= binding
+    end
+
+    def import(*modules)
+      modules.each do |m|
+        self.class.include(m)
+      end
+    end
+  end
+end

data/lib/live/handler.rb

@@ -0,0 +1,55 @@
+require_relative '../daw'
+
+module MusaLCEServer
+  module Live
+    class Handler < ::MusaLCEServer::Handler
+      def initialize(osc_server, osc_client, tracks, logger:)
+        super()
+
+        @server = osc_server
+        @client = osc_client
+
+        @tracks = tracks
+
+        @logger = logger
+
+        @server.add_method '/hello' do |message|
+          @logger.info "Received /hello #{message.to_a}!"
+          sync
+        end
+
+        @server.add_method '/musalce4live/tracks' do |message|
+          @tracks.grant_registry_collection(message.to_a.each_slice(10).to_a)
+        end
+
+        @server.add_method '/musalce4live/track/name' do |message|
+          message.to_a.each_slice(2).to_a.each do |track_data|
+            @tracks.grant_registry(track_data[0], track_data[1])
+          end
+        end
+
+        @server.add_method '/musalce4live/track/midi' do |message|
+          message.to_a.each_slice(3).to_a.each do |track_data|
+            @tracks.grant_registry(track_data[0], *([nil] * 1), *track_data[1..])
+          end
+        end
+
+        @server.add_method '/musalce4live/track/audio' do |message|
+          message.to_a.each_slice(3).to_a.each do |track_data|
+            @tracks.grant_registry(track_data[0], *([nil] * 3), *track_data[1..])
+          end
+        end
+
+        @server.add_method '/musalce4live/track/routings' do |message|
+          message.to_a.each_slice(5).to_a.each do |track_data|
+            @tracks.grant_registry(track_data[0], *([nil] * 5), *track_data[1..])
+          end
+        end
+      end
+
+      def sync
+        send_osc '/musalce4live/tracks'
+      end
+    end
+  end
+end

data/lib/live/live.rb

@@ -0,0 +1,40 @@
+require_relative '../daw'
+
+require_relative 'handler'
+require_relative 'tracks'
+
+module MusaLCEServer
+  module Live
+    class Live < Daw
+      def daw_initialize(midi_devices:, clock:, osc_server:, osc_client:, logger:)
+        super
+        tracks = Tracks.new(midi_devices, logger: logger)
+        handler = Handler.new(osc_server, osc_client, tracks, logger: logger)
+
+        logger.info('Loaded Ableton Live driver')
+
+        return tracks, handler
+      end
+
+      def track(name, all: false)
+        if all
+          @tracks.find_by_name(name)
+        else
+          @tracks.find_by_name(name).first
+        end
+      end
+
+      def midi_sync(midi_device_name, manufacturer: nil, model: nil, name: nil)
+        name ||= midi_device_name
+
+        @clock.input = MIDICommunications::Input.all.find do |_|
+          (_.manufacturer == manufacturer || manufacturer.nil?) &&
+            (_.model == model || model.nil?) &&
+            (_.name == name || name.nil?)
+        end
+      end
+    end
+
+    Daw.register :live, Live
+  end
+end

data/lib/live/tracks.rb

@@ -0,0 +1,142 @@
+require 'musa-dsl/core-ext/dynamic-proxy'
+
+module MusaLCEServer
+  module Live
+    class Track
+      def initialize(id, midi_devices, logger:)
+        @id = id
+        @midi_devices = midi_devices
+        @logger = logger
+
+        @output = Musa::Extension::DynamicProxy::DynamicProxy.new
+      end
+
+      attr_reader :id, :name
+
+      def out
+        @output
+      end
+
+      def _update_name(value)
+        @name = value
+        @logger.info "track #{@id} assigned name #{@name}"
+      end
+
+      def _update_has_midi_input(value);
+      @has_midi_input = value == 1;
+      end
+      def _update_has_midi_output(value);
+      @has_midi_output = value == 1;
+      end
+      def _update_has_audio_input(value);
+      @has_audio_input = value == 1;
+      end
+      def _update_has_audio_output(value);
+      @has_audio_output = value == 1;
+      end
+
+      def _update_current_input_routing(value)
+        @current_input_routing = value
+        _update_current_input_sub_routing(@current_input_sub_routing)
+      end
+
+      def _update_current_input_sub_routing(value)
+        @current_input_sub_routing = value
+
+        effective_midi_voice = nil
+
+        if @has_midi_input
+          device = @midi_devices.find(@current_input_routing)
+
+          if device
+            channel = /Ch\. (?<channel>\d+)/.match(@current_input_sub_routing)&.[](:channel)
+            effective_midi_voice = device.channels[channel.to_i - 1] if channel
+
+            @logger.info "track #{@id} assigned new input: device '#{device.name}' #{effective_midi_voice}"
+          end
+        end
+
+        @output.receiver = effective_midi_voice
+      end
+
+      def _update_current_output_routing(value);
+      @current_output_routing = value
+      end
+
+      def _update_current_output_sub_routing(value);
+      @current_output_sub_routing = value
+      end
+    end
+
+    class Tracks
+      include Enumerable
+
+      def initialize(midi_devices, logger:)
+        @midi_devices = midi_devices
+        @logger = logger
+        @tracks = {}
+      end
+
+      def grant_registry_collection(tracks_data)
+        tracks_to_delete = Set[*@tracks.keys]
+
+        tracks_data.each do |track_data|
+          grant_registry(*track_data)
+          tracks_to_delete.delete track_data[0]
+        end
+
+        tracks_to_delete.each do |id|
+          @tracks.delete(id)
+          @logger.info "deleted track #{id}"
+        end
+      end
+
+      def grant_registry(id, name = nil,
+                         has_midi_input = nil, has_midi_output = nil,
+                         has_audio_input = nil, has_audio_output = nil,
+                         current_input_routing = nil, current_input_sub_routing = nil,
+                         current_output_routing = nil, current_output_sub_routing = nil)
+
+        track = @tracks[id]
+
+        unless track
+          track = Track.new(id, @midi_devices, logger: @logger)
+          @tracks[id] = track
+        end
+
+        track._update_name(name) if name
+        track._update_has_midi_input(has_midi_input) if has_midi_input
+        track._update_has_midi_output(has_midi_output) if has_midi_output
+        track._update_has_audio_input(has_audio_input) if has_audio_input
+        track._update_has_audio_output(has_audio_output) if has_audio_output
+        track._update_current_input_routing(parse_device_name(current_input_routing)) if current_input_routing
+        track._update_current_input_sub_routing(current_input_sub_routing) if current_input_sub_routing
+        track._update_current_output_routing(parse_device_name(current_output_routing)) if current_output_routing
+        track._update_current_output_sub_routing(current_output_sub_routing) if current_output_sub_routing
+      end
+
+      def each(&block)
+        if block_given?
+          @tracks.values.each(&block)
+        else
+          @tracks.values.each
+        end
+      end
+
+      def [](id)
+        @tracks[id]
+      end
+
+      # TODO adaptar a contrato y semántica de Bitwig (en bitwig sólo hay un track con un nombre determinado, el id no existe)
+
+      def find_by_name(name)
+        @tracks.values.select { |_| _.name == name }
+      end
+
+      private def parse_device_name(name)
+        match = name.match(/Driver IAC \((?<name>.+)\)/)
+        match ? match[:name] : name
+      end
+    end
+  end
+end