Python rust backend

.gitignore

@@ -18,3 +18,4 @@ py-build-cmake.cross.toml
 Cargo.lock
 target
 .aider*
+.env

src/backend/internal/BasicLoop.cpp

@@ -17,7 +17,7 @@ BasicLoop::BasicLoop() :
         ma_triggering_now(false),
         ma_length(0),
         ma_position(0),
-        ma_maybe_next_planned_mode(LOOP_MODE_INVALID),
+        ma_maybe_next_planned_mode(LoopMode_Unknown),
         ma_maybe_next_planned_delay(-1),
         ma_already_triggered(false)
     {
@@ -211,7 +211,7 @@ shoop_shared_ptr<LoopInterface> BasicLoop::get_sync_source(bool thread_safe) {
 void BasicLoop::PROC_update_planned_transition_cache() {
 
     ma_maybe_next_planned_mode = mp_planned_states.size() > 0 ?
-        (shoop_loop_mode_t) mp_planned_states.front() : LOOP_MODE_INVALID;
+        (shoop_loop_mode_t) mp_planned_states.front() : LoopMode_Unknown;
     ma_maybe_next_planned_delay = mp_planned_state_countdowns.size() > 0 ?
         mp_planned_state_countdowns.front() : -1;
 }
@@ -261,7 +261,7 @@ void BasicLoop::PROC_handle_transition(shoop_loop_mode_t new_state) {
             set_length(0, false);
         }
         ma_mode = new_state;
-        if(ma_mode > LOOP_MODE_INVALID) {
+        if(ma_mode >= LOOP_MODE_INVALID) {
             throw_error<std::runtime_error>("invalid mode");
         }
         if (ma_mode == LoopMode_Stopped) { ma_position = 0; }
@@ -415,11 +415,11 @@ shoop_loop_mode_t BasicLoop::get_mode() const {
 void BasicLoop::get_first_planned_transition(shoop_loop_mode_t &maybe_mode_out, uint32_t &delay_out) {
     shoop_loop_mode_t maybe_mode = ma_maybe_next_planned_mode;
     int maybe_delay = ma_maybe_next_planned_delay;
-    if (maybe_delay >= 0 && maybe_mode != LOOP_MODE_INVALID) {
+    if (maybe_delay >= 0 && maybe_mode != LoopMode_Unknown) {
         maybe_mode_out = maybe_mode;
         delay_out = maybe_delay;
     } else {
-        maybe_mode_out = LOOP_MODE_INVALID;
+        maybe_mode_out = LoopMode_Unknown;
         delay_out = 0;
     }
 }

src/backend/internal/GraphLoopChannel.cpp

@@ -74,6 +74,18 @@ void GraphLoopChannel::disconnect_output_port(shoop_shared_ptr<GraphPort> port,
     get_backend().set_graph_node_changes_pending();
 }
 
+void GraphLoopChannel::disconnect_port(shoop_shared_ptr<GraphPort> port, bool thread_safe) {
+    auto in_locked = mp_input_port_mapping.lock();
+    auto out_locked = mp_output_port_mapping.lock();
+    if (in_locked && in_locked == port) {
+        mp_input_port_mapping.reset();
+    } else if (out_locked && out_locked == port) {
+        mp_output_port_mapping.reset();
+    } else {
+        throw std::runtime_error("Attempting to disconnect unconnected port");
+    }
+}
+
 void GraphLoopChannel::disconnect_output_ports(bool thread_safe) {
     mp_output_port_mapping.reset();
     get_backend().set_graph_node_changes_pending();

src/backend/internal/GraphLoopChannel.h

@@ -26,6 +26,7 @@ class GraphLoopChannel:  public HasTwoGraphNodes,
 
     void connect_output_port(shoop_shared_ptr<GraphPort> port, bool thread_safe=true);
     void connect_input_port(shoop_shared_ptr<GraphPort> port, bool thread_safe=true);
+    void disconnect_port(shoop_shared_ptr<GraphPort> port, bool thread_safe=true);
     void disconnect_output_port(shoop_shared_ptr<GraphPort> port, bool thread_safe=true);
     void disconnect_output_ports(bool thread_safe=true);
     void disconnect_input_port(shoop_shared_ptr<GraphPort> port, bool thread_safe=true);

src/backend/libshoopdaloop_backend.cpp

@@ -630,6 +630,20 @@ void disconnect_audio_output (shoopdaloop_loop_audio_channel_t *channel, shoopda
   });
 }
 
+void disconnect_audio_port (shoopdaloop_loop_audio_channel_t *channel, shoopdaloop_audio_port_t* port) {
+  return api_impl<void>("disconnect_audio_output", [&]() {
+    auto _chan = internal_audio_channel(channel);
+    if (!_chan) { return; }
+    _chan->get_backend().queue_process_thread_command([=]() {
+        auto _port = internal_audio_port(port);
+        auto _channel = internal_audio_channel(channel);
+        if (_port && _channel) {
+          _channel->disconnect_port(_port, false);
+        }
+    });
+  });
+}
+
 void disconnect_midi_output (shoopdaloop_loop_midi_channel_t  *channel, shoopdaloop_midi_port_t* port) {
   return api_impl<void>("disconnect_midi_output", [&]() {
     auto _chan = internal_midi_channel(channel);
@@ -644,6 +658,20 @@ void disconnect_midi_output (shoopdaloop_loop_midi_channel_t  *channel, shoopdal
   });
 }
 
+void disconnect_midi_port (shoopdaloop_loop_midi_channel_t  *channel, shoopdaloop_midi_port_t* port) {
+  return api_impl<void>("disconnect_midi_output", [&]() {
+    auto _chan = internal_midi_channel(channel);
+    if (!_chan) { return; }
+    _chan->get_backend().queue_process_thread_command([=]() {
+        auto _port = internal_midi_port(port);
+        auto _channel = internal_midi_channel(channel);
+        if (_port && _channel) {
+          _channel->disconnect_port(_port, false);
+        }
+    });
+  });
+}
+
 void disconnect_audio_outputs (shoopdaloop_loop_audio_channel_t *channel) {
   return api_impl<void>("disconnect_audio_outputs", [&]() {
     auto _chan = internal_audio_channel(channel);
@@ -1907,7 +1935,7 @@ void destroy_midi_channel(shoopdaloop_loop_midi_channel_t *d) {
 
 void destroy_shoopdaloop_decoupled_midi_port(shoopdaloop_decoupled_midi_port_t *d) {
   return api_impl<void, log_level_debug_trace, log_level_warning>("destroy_shoopdaloop_decoupled_midi_port", [&]() {
-    logging::log<"Backend.API", log_level_error>(std::nullopt, std::nullopt, "destroy_shoopdaloop_decoupled_midi_port");
+    logging::log<"Backend.API", log_level_debug>(std::nullopt, std::nullopt, "destroy_shoopdaloop_decoupled_midi_port");
     throw std::runtime_error("unimplemented");
   });
 }
@@ -2265,6 +2293,15 @@ void destroy_audio_driver_state(shoop_audio_driver_state_t *state) {
   });
 }
 
+void destroy_audio_driver(shoop_audio_driver_t *driver) {
+  return api_impl<void, log_level_debug_trace>("destroy_audio_driver", [&]() {
+      auto _driver = internal_audio_driver(driver);
+      if (!_driver) { return; }
+      _driver->close();
+      g_active_drivers.erase(_driver);
+  });
+}
+
 unsigned get_driver_active(shoop_audio_driver_t *driver) {
   return api_impl<unsigned>("get_driver_active", [&]() {
     auto _driver = internal_audio_driver(driver);

src/backend/libshoopdaloop_backend.h

@@ -79,6 +79,8 @@ SHOOP_EXPORT void                   disconnect_audio_inputs (shoopdaloop_loop_au
 SHOOP_EXPORT void                   disconnect_midi_inputs  (shoopdaloop_loop_midi_channel_t  *channel);
 SHOOP_EXPORT void                   disconnect_audio_input  (shoopdaloop_loop_audio_channel_t *channel, shoopdaloop_audio_port_t* port);
 SHOOP_EXPORT void                   disconnect_midi_input   (shoopdaloop_loop_midi_channel_t  *channel, shoopdaloop_midi_port_t* port);
+SHOOP_EXPORT void                   disconnect_audio_port   (shoopdaloop_loop_audio_channel_t *channel, shoopdaloop_audio_port_t* port);
+SHOOP_EXPORT void                   disconnect_midi_port   (shoopdaloop_loop_midi_channel_t *channel, shoopdaloop_midi_port_t* port);
 SHOOP_EXPORT shoop_audio_channel_data_t  *get_audio_channel_data   (shoopdaloop_loop_audio_channel_t *channel);
 SHOOP_EXPORT shoop_midi_sequence_t   *get_midi_channel_data    (shoopdaloop_loop_midi_channel_t  *channel);
 SHOOP_EXPORT void                   load_audio_channel_data  (shoopdaloop_loop_audio_channel_t *channel, shoop_audio_channel_data_t *data);