AudioNode::disconnect, disconnect_dest, disconnect_output and more

All variants of https://webaudio.github.io/web-audio-api/#AudioNode
disconnect methods.

Changed: renamed disconnect_from -> disconnect_dest

Fix: disconnect methods should not return any value

Author: orottier

src/context/concrete_base.rs

@@ -426,24 +426,29 @@ impl ConcreteBaseAudioContext {
         self.inner.queued_messages.lock().unwrap().push(message);
     }
 
-    /// Disconnects all outputs of the audio node that go to a specific destination node.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this node was not connected to the target node
-    pub(crate) fn disconnect_from(&self, from: AudioNodeId, to: AudioNodeId) {
+    /// Disconnects outputs of the audio node, possibly filtered by output node, input, output.
+    pub(crate) fn disconnect(
+        &self,
+        from: AudioNodeId,
+        output: Option<usize>,
+        to: Option<AudioNodeId>,
+        input: Option<usize>,
+    ) {
         // check if the node was connected, otherwise panic
         let mut has_disconnected = false;
         let mut connections = self.inner.connections.lock().unwrap();
-        connections.retain(|&(c_from, output, c_to, input)| {
-            let retain = c_from != from || c_to != to;
+        connections.retain(|&(c_from, c_output, c_to, c_input)| {
+            let retain = c_from != from
+                || c_output != output.unwrap_or(c_output)
+                || c_to != to.unwrap_or(c_to)
+                || c_input != input.unwrap_or(c_input);
             if !retain {
                 has_disconnected = true;
                 let message = ControlMessage::DisconnectNode {
                     from,
-                    to,
-                    input,
-                    output,
+                    to: c_to,
+                    input: c_input,
+                    output: c_output,
                 };
                 self.send_control_msg(message);
             }
@@ -453,53 +458,11 @@ impl ConcreteBaseAudioContext {
         // make sure to drop the MutexGuard before the panic to avoid poisoning
         drop(connections);
 
-        if !has_disconnected {
+        if !has_disconnected && to.is_some() {
             panic!("InvalidAccessError - attempting to disconnect unconnected nodes");
         }
     }
 
-    /// Disconnects all outgoing connections from the audio node.
-    pub(crate) fn disconnect(&self, from: AudioNodeId) {
-        self.inner
-            .connections
-            .lock()
-            .unwrap()
-            .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`
     pub(crate) fn connect_listener_to_panner(&self, panner: AudioNodeId) {
         self.connect(LISTENER_NODE_ID, panner, 0, usize::MAX);
@@ -568,7 +531,7 @@ mod tests {
         node1.disconnect();
 
         node1.connect(&node2);
-        node1.disconnect_from(&node2);
+        node1.disconnect_dest(&node2);
     }
 
     #[test]
@@ -578,6 +541,6 @@ mod tests {
         let node1 = context.create_constant_source();
         let node2 = context.create_gain();
 
-        node1.disconnect_from(&node2);
+        node1.disconnect_dest(&node2);
     }
 }

src/node/audio_node.rs

@@ -288,28 +288,112 @@ pub trait AudioNode {
         dest
     }
 
+    /// Disconnects all outgoing connections from the AudioNode.
+    fn disconnect(&self) {
+        self.context()
+            .disconnect(self.registration().id(), None, None, None);
+    }
+
     /// Disconnects all outputs of the AudioNode that go to a specific destination AudioNode.
-    fn disconnect_from<'a>(&self, dest: &'a dyn AudioNode) -> &'a dyn AudioNode {
+    ///
+    /// # Panics
+    ///
+    /// This function will panic when
+    /// - the AudioContext of the source and destination does not match
+    /// - the source node was not connected to the destination node
+    fn disconnect_dest(&self, dest: &dyn AudioNode) {
         assert!(
             self.context() == dest.context(),
             "InvalidAccessError - Attempting to disconnect nodes from different contexts"
         );
 
-        self.context()
-            .disconnect_from(self.registration().id(), dest.registration().id());
+        self.context().disconnect(
+            self.registration().id(),
+            None,
+            Some(dest.registration().id()),
+            None,
+        );
+    }
 
-        dest
+    /// Disconnects all outgoing connections at the given output port from the AudioNode.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic when
+    /// - if the output port is out of bounds for this node
+    fn disconnect_output(&self, output: usize) {
+        assert!(
+            self.number_of_outputs() > output,
+            "IndexSizeError - output port {} is out of bounds",
+            output
+        );
+
+        self.context()
+            .disconnect(self.registration().id(), Some(output), None, None);
     }
 
-    /// Disconnects all outgoing connections from the AudioNode.
-    fn disconnect(&self) {
-        self.context().disconnect(self.registration().id());
+    /// Disconnects a specific output of the AudioNode to a specific destination AudioNode
+    ///
+    /// # Panics
+    ///
+    /// This function will panic when
+    /// - the AudioContext of the source and destination does not match
+    /// - if the output port is out of bounds for the source node
+    /// - the source node was not connected to the destination node
+    fn disconnect_dest_output(&self, dest: &dyn AudioNode, output: usize) {
+        assert!(
+            self.context() == dest.context(),
+            "InvalidAccessError - Attempting to disconnect nodes from different contexts"
+        );
+
+        assert!(
+            self.number_of_outputs() > output,
+            "IndexSizeError - output port {} is out of bounds",
+            output
+        );
+
+        self.context().disconnect(
+            self.registration().id(),
+            Some(output),
+            Some(dest.registration().id()),
+            None,
+        );
     }
 
-    /// 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);
+    /// Disconnects a specific output of the AudioNode to a specific input of some destination
+    /// AudioNode
+    ///
+    /// # Panics
+    ///
+    /// This function will panic when
+    /// - the AudioContext of the source and destination does not match
+    /// - if the input port is out of bounds for the destination node
+    /// - if the output port is out of bounds for the source node
+    /// - the source node was not connected to the destination node
+    fn disconnect_dest_output_input(&self, dest: &dyn AudioNode, output: usize, input: usize) {
+        assert!(
+            self.context() == dest.context(),
+            "InvalidAccessError - Attempting to disconnect nodes from different contexts"
+        );
+
+        assert!(
+            self.number_of_outputs() > output,
+            "IndexSizeError - output port {} is out of bounds",
+            output
+        );
+
+        assert!(
+            dest.number_of_inputs() > input,
+            "IndexSizeError - input port {} is out of bounds",
+            input
+        );
+
+        self.context().disconnect(
+            self.registration().id(),
+            Some(output),
+            Some(dest.registration().id()),
+            Some(input),
+        );
     }
 
     /// The number of inputs feeding into the AudioNode. For source nodes, this will be 0.

src/node/delay.rs

@@ -160,22 +160,112 @@ impl AudioNode for DelayNode {
         dest
     }
 
+    /// Disconnects all outgoing connections from the AudioNode.
+    fn disconnect(&self) {
+        self.context()
+            .disconnect(self.reader_registration.id(), None, None, None);
+    }
+
     /// Disconnects all outputs of the AudioNode that go to a specific destination AudioNode.
-    fn disconnect_from<'a>(&self, dest: &'a dyn AudioNode) -> &'a dyn AudioNode {
+    ///
+    /// # Panics
+    ///
+    /// This function will panic when
+    /// - the AudioContext of the source and destination does not match
+    /// - the source node was not connected to the destination node
+    fn disconnect_dest(&self, dest: &dyn AudioNode) {
         assert!(
             self.context() == dest.context(),
             "InvalidAccessError - Attempting to disconnect nodes from different contexts"
         );
 
+        self.context().disconnect(
+            self.reader_registration.id(),
+            None,
+            Some(dest.registration().id()),
+            None,
+        );
+    }
+
+    /// Disconnects all outgoing connections at the given output port from the AudioNode.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic when
+    /// - if the output port is out of bounds for this node
+    fn disconnect_output(&self, output: usize) {
+        assert!(
+            self.number_of_outputs() > output,
+            "IndexSizeError - output port {} is out of bounds",
+            output
+        );
+
         self.context()
-            .disconnect_from(self.reader_registration.id(), dest.registration().id());
+            .disconnect(self.reader_registration.id(), Some(output), None, None);
+    }
 
-        dest
+    /// Disconnects a specific output of the AudioNode to a specific destination AudioNode
+    ///
+    /// # Panics
+    ///
+    /// This function will panic when
+    /// - the AudioContext of the source and destination does not match
+    /// - if the output port is out of bounds for the source node
+    /// - the source node was not connected to the destination node
+    fn disconnect_dest_output(&self, dest: &dyn AudioNode, output: usize) {
+        assert!(
+            self.context() == dest.context(),
+            "InvalidAccessError - Attempting to disconnect nodes from different contexts"
+        );
+
+        assert!(
+            self.number_of_outputs() > output,
+            "IndexSizeError - output port {} is out of bounds",
+            output
+        );
+
+        self.context().disconnect(
+            self.reader_registration.id(),
+            Some(output),
+            Some(dest.registration().id()),
+            None,
+        );
     }
 
-    /// Disconnects all outgoing connections from the AudioNode.
-    fn disconnect(&self) {
-        self.context().disconnect(self.reader_registration.id());
+    /// Disconnects a specific output of the AudioNode to a specific input of some destination
+    /// AudioNode
+    ///
+    /// # Panics
+    ///
+    /// This function will panic when
+    /// - the AudioContext of the source and destination does not match
+    /// - if the input port is out of bounds for the destination node
+    /// - if the output port is out of bounds for the source node
+    /// - the source node was not connected to the destination node
+    fn disconnect_dest_output_input(&self, dest: &dyn AudioNode, output: usize, input: usize) {
+        assert!(
+            self.context() == dest.context(),
+            "InvalidAccessError - Attempting to disconnect nodes from different contexts"
+        );
+
+        assert!(
+            self.number_of_outputs() > output,
+            "IndexSizeError - output port {} is out of bounds",
+            output
+        );
+
+        assert!(
+            dest.number_of_inputs() > input,
+            "IndexSizeError - input port {} is out of bounds",
+            input
+        );
+
+        self.context().disconnect(
+            self.reader_registration.id(),
+            Some(output),
+            Some(dest.registration().id()),
+            Some(input),
+        );
     }
 }