Implement AudioNode::disconnect_at and fix disconnect

`disconnect()` would previously clear all connections, but it should
only clear the node's *outgoing* connections.

Author: orottier

src/context/concrete_base.rs

@@ -110,7 +110,7 @@ struct ConcreteBaseAudioContextInner {
     event_loop: EventLoop,
     /// Sender for events that will be handled by the EventLoop
     event_send: Sender<EventDispatch>,
-    /// Current audio graph connections
+    /// Current audio graph connections (from node, output port, to node, input port)
     connections: Mutex<HashSet<(AudioNodeId, usize, AudioNodeId, usize)>>,
 }
 
@@ -433,17 +433,29 @@ impl ConcreteBaseAudioContext {
     /// Panics if this node was not connected to the target node
     pub(crate) fn disconnect_from(&self, from: AudioNodeId, to: AudioNodeId) {
         // check if the node was connected, otherwise panic
+        let mut has_disconnected = false;
         let mut connections = self.inner.connections.lock().unwrap();
-        let prev_len = connections.len();
-        connections.retain(|c| c.0 != from || c.2 != to);
-        let len = connections.len();
+        connections.retain(|&(c_from, output, c_to, input)| {
+            let retain = c_from != from || c_to != to;
+            if !retain {
+                has_disconnected = true;
+                let message = ControlMessage::DisconnectNode {
+                    from,
+                    to,
+                    input,
+                    output,
+                };
+                self.send_control_msg(message);
+            }
+            retain
+        });
+
+        // make sure to drop the MutexGuard before the panic to avoid poisoning
         drop(connections);
-        if prev_len == len {
+
+        if !has_disconnected {
             panic!("InvalidAccessError - attempting to disconnect unconnected nodes");
         }
-
-        let message = ControlMessage::DisconnectNode { from, to };
-        self.send_control_msg(message);
     }
 
     /// Disconnects all outgoing connections from the audio node.
@@ -452,9 +464,40 @@ impl ConcreteBaseAudioContext {
             .connections
             .lock()
             .unwrap()
-            .retain(|c| c.0 != from);
-        let message = ControlMessage::DisconnectAll { from };
-        self.send_control_msg(message);
+            .retain(|&(c_from, output, to, input)| {
+                let retain = c_from != from;
+                if !retain {
+                    let message = ControlMessage::DisconnectNode {
+                        from,
+                        to,
+                        input,
+                        output,
+                    };
+                    self.send_control_msg(message);
+                }
+                retain
+            });
+    }
+
+    /// Disconnects all outgoing connections at the given output port from the audio node.
+    pub(crate) fn disconnect_at(&self, from: AudioNodeId, output: usize) {
+        self.inner
+            .connections
+            .lock()
+            .unwrap()
+            .retain(|&(c_from, c_output, to, input)| {
+                let retain = c_from != from || c_output != output;
+                if !retain {
+                    let message = ControlMessage::DisconnectNode {
+                        from,
+                        to,
+                        input,
+                        output,
+                    };
+                    self.send_control_msg(message);
+                }
+                retain
+            });
     }
 
     /// Connect the `AudioListener` to a `PannerNode`

src/context/offline.rs

@@ -459,21 +459,26 @@ mod tests {
 
     #[test]
     fn test_suspend_sync() {
+        use crate::node::ConstantSourceNode;
+        use std::sync::OnceLock;
+
         let len = RENDER_QUANTUM_SIZE * 4;
         let sample_rate = 48000_f64;
 
         let mut context = OfflineAudioContext::new(1, len, sample_rate as f32);
+        static SOURCE: OnceLock<ConstantSourceNode> = OnceLock::new();
 
         context.suspend_sync(RENDER_QUANTUM_SIZE as f64 / sample_rate, |context| {
             assert_eq!(context.state(), AudioContextState::Suspended);
             let mut src = context.create_constant_source();
             src.connect(&context.destination());
             src.start();
+            SOURCE.set(src).unwrap();
         });
 
         context.suspend_sync((3 * RENDER_QUANTUM_SIZE) as f64 / sample_rate, |context| {
             assert_eq!(context.state(), AudioContextState::Suspended);
-            context.destination().disconnect();
+            SOURCE.get().unwrap().disconnect();
         });
 
         let output = context.start_rendering_sync();

src/message.rs

@@ -28,10 +28,12 @@ pub(crate) enum ControlMessage {
     },
 
     /// Clear the connection between two given nodes in the audio graph
-    DisconnectNode { from: AudioNodeId, to: AudioNodeId },
-
-    /// Disconnect this node from the audio graph (drop all its connections)
-    DisconnectAll { from: AudioNodeId },
+    DisconnectNode {
+        from: AudioNodeId,
+        to: AudioNodeId,
+        input: usize,
+        output: usize,
+    },
 
     /// Notify the render thread this node is dropped in the control thread
     ControlHandleDropped { id: AudioNodeId },

src/node/audio_node.rs

@@ -306,6 +306,12 @@ pub trait AudioNode {
         self.context().disconnect(self.registration().id());
     }
 
+    /// Disconnects all outgoing connections at the given output port from the AudioNode.
+    fn disconnect_at(&self, output: usize) {
+        self.context()
+            .disconnect_at(self.registration().id(), output);
+    }
+
     /// The number of inputs feeding into the AudioNode. For source nodes, this will be 0.
     fn number_of_inputs(&self) -> usize;
 

src/render/graph.rs

@@ -212,28 +212,13 @@ impl Graph {
         self.ordered.clear(); // void current ordering
     }
 
-    pub fn remove_edge(&mut self, source: AudioNodeId, dest: AudioNodeId) {
+    pub fn remove_edge(&mut self, source: (AudioNodeId, usize), dest: (AudioNodeId, usize)) {
         self.nodes
-            .get_unchecked_mut(source)
+            .get_unchecked_mut(source.0)
             .outgoing_edges
-            .retain(|edge| edge.other_id != dest);
-
-        self.ordered.clear(); // void current ordering
-    }
-
-    pub fn remove_edges_from(&mut self, source: AudioNodeId) {
-        // Remove outgoing edges
-        self.nodes.get_unchecked_mut(source).outgoing_edges.clear();
-
-        // Remove incoming edges - we need to traverse all nodes
-        self.nodes.values_mut().for_each(|node| {
-            // Retain edge when
-            // - not connected to this node, or
-            // - when this is an audioparam edge (only disconnect true audio nodes)
-            node.get_mut()
-                .outgoing_edges
-                .retain(|edge| edge.other_id != source || edge.other_index == usize::MAX);
-        });
+            .retain(|edge| {
+                edge.other_id != dest.0 || edge.self_index != source.1 || edge.other_index != dest.1
+            });
 
         self.ordered.clear(); // void current ordering
     }
@@ -635,7 +620,7 @@ mod tests {
         assert!(pos2 < pos1); // node 1 depends on node 2
 
         // Detach node 1 (and thus node 2) from the root node
-        graph.remove_edge(AudioNodeId(1), AudioNodeId(0));
+        graph.remove_edge((AudioNodeId(1), 0), (AudioNodeId(0), 0));
         graph.order_nodes();
 
         // sorting is not deterministic, but this should uphold:
@@ -653,45 +638,6 @@ mod tests {
         assert!(pos2 < pos1); // node 1 depends on node 2
     }
 
-    #[test]
-    fn test_remove_all() {
-        let mut graph = Graph::new(llq::Queue::new().split().0);
-
-        let node = Box::new(TestNode { tail_time: false });
-        add_node(&mut graph, 0, node.clone());
-        add_node(&mut graph, 1, node.clone());
-        add_node(&mut graph, 2, node);
-
-        // link 1->0, 1->2 and 2->0
-        add_edge(&mut graph, 1, 0);
-        add_edge(&mut graph, 1, 2);
-        add_edge(&mut graph, 2, 0);
-
-        graph.order_nodes();
-
-        assert_eq!(
-            graph.ordered,
-            vec![AudioNodeId(1), AudioNodeId(2), AudioNodeId(0)]
-        );
-
-        graph.remove_edges_from(AudioNodeId(1));
-        graph.order_nodes();
-
-        // sorting is not deterministic, but this should uphold:
-        assert_eq!(graph.ordered.len(), 3); // all nodes present
-        let pos0 = graph
-            .ordered
-            .iter()
-            .position(|&n| n == AudioNodeId(0))
-            .unwrap();
-        let pos2 = graph
-            .ordered
-            .iter()
-            .position(|&n| n == AudioNodeId(2))
-            .unwrap();
-        assert!(pos2 < pos0); // node 1 depends on node 0
-    }
-
     #[test]
     fn test_cycle() {
         let mut graph = Graph::new(llq::Queue::new().split().0);

src/render/thread.rs

@@ -151,11 +151,16 @@ impl RenderThread {
                     .unwrap()
                     .add_edge((from, output), (to, input));
             }
-            DisconnectNode { from, to } => {
-                self.graph.as_mut().unwrap().remove_edge(from, to);
-            }
-            DisconnectAll { from } => {
-                self.graph.as_mut().unwrap().remove_edges_from(from);
+            DisconnectNode {
+                from,
+                output,
+                to,
+                input,
+            } => {
+                self.graph
+                    .as_mut()
+                    .unwrap()
+                    .remove_edge((from, output), (to, input));
             }
             ControlHandleDropped { id } => {
                 self.graph.as_mut().unwrap().mark_control_handle_dropped(id);