Derive Debug for AudioBufferSourceNode and its components

Author: orottier

src/buffer.rs

@@ -364,11 +364,19 @@ impl AudioBuffer {
 /// Single channel audio samples, basically wraps a `Arc<Vec<f32>>`
 ///
 /// ChannelData has copy-on-write semantics, so it is cheap to clone.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, PartialEq)]
 pub(crate) struct ChannelData {
     data: Arc<Vec<f32>>,
 }
 
+impl std::fmt::Debug for ChannelData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ChannelData")
+            .field("len", &self.len())
+            .finish_non_exhaustive()
+    }
+}
+
 impl ChannelData {
     pub fn new(length: usize) -> Self {
         let buffer = vec![0.; length];

src/context/concrete_base.rs

@@ -52,12 +52,11 @@ impl AudioNodeIdProvider {
 /// [`OfflineAudioContext`](crate::context::OfflineAudioContext), and the `context()` method on
 /// `AudioNode`s.
 ///
-/// The `ConcreteBaseAudioContext` allows for cheap cloning (using an `Arc` internally).
+/// The `ConcreteBaseAudioContext` allows for shallow cloning (using an `Arc` internally).
 #[allow(clippy::module_name_repetitions)]
 #[derive(Clone)]
 #[doc(hidden)]
 pub struct ConcreteBaseAudioContext {
-    /// inner makes `ConcreteBaseAudioContext` cheap to clone
     inner: Arc<ConcreteBaseAudioContextInner>,
 }
 
@@ -257,6 +256,10 @@ impl ConcreteBaseAudioContext {
         base
     }
 
+    pub(crate) fn address(&self) -> usize {
+        Arc::as_ptr(&self.inner) as usize
+    }
+
     /// Send a control message to the render thread
     ///
     /// When the render thread is closed or crashed, the message is discarded and a log warning is

src/context/mod.rs

@@ -94,6 +94,18 @@ pub struct AudioContextRegistration {
     id: AudioNodeId,
 }
 
+impl std::fmt::Debug for AudioContextRegistration {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("AudioContextRegistration")
+            .field("id", &self.id)
+            .field(
+                "context",
+                &format!("BaseAudioContext@{}", self.context.address()),
+            )
+            .finish()
+    }
+}
+
 impl AudioContextRegistration {
     /// Get the audio node id of the registration
     #[must_use]

src/lib.rs

@@ -56,12 +56,17 @@ pub use media_element::MediaElement;
 mod resampling;
 pub mod worklet;
 
-#[derive(Debug)]
 #[repr(transparent)]
 pub(crate) struct AtomicF32 {
     bits: AtomicU32,
 }
 
+impl std::fmt::Debug for AtomicF32 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!("{}", self.load(Ordering::Relaxed)))
+    }
+}
+
 impl AtomicF32 {
     #[must_use]
     pub fn new(value: f32) -> Self {
@@ -81,12 +86,17 @@ impl AtomicF32 {
 }
 
 /// Atomic float 64, only `load` and `store` are supported, no arithmetic
-#[derive(Debug)]
 #[repr(transparent)]
 pub(crate) struct AtomicF64 {
     bits: AtomicU64,
 }
 
+impl std::fmt::Debug for AtomicF64 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!("{}", self.load(Ordering::Relaxed)))
+    }
+}
+
 impl AtomicF64 {
     #[must_use]
     pub fn new(value: f64) -> Self {

src/node/audio_buffer_source.rs

@@ -102,6 +102,7 @@ enum ControlMessage {
 /// - `cargo run --release --example trigger_soundfile`
 /// - `cargo run --release --example granular`
 ///
+#[derive(Debug)]
 pub struct AudioBufferSourceNode {
     registration: AudioContextRegistration,
     channel_config: ChannelConfig,

src/node/mod.rs

@@ -151,7 +151,7 @@ impl Default for ChannelConfigOptions {
 ///     interpretation: ChannelInterpretation::Discrete,
 /// };
 /// let _: ChannelConfig = opts.into();
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct ChannelConfig {
     inner: Arc<Mutex<ChannelConfigInner>>,
 }
@@ -169,6 +169,16 @@ impl Default for ChannelConfig {
     }
 }
 
+impl std::fmt::Debug for ChannelConfig {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ChannelConfig")
+            .field("count", &self.count())
+            .field("count_mode", &self.count_mode())
+            .field("interpretation", &self.interpretation())
+            .finish()
+    }
+}
+
 // All methods on this struct are marked `pub(crate)` because we don't want outside users to be
 // able to change the values directly.  These methods are only accessible via the AudioNode
 // interface, so AudioNode's that have channel count/mode constraints should be able to assert

src/param.rs

@@ -261,14 +261,30 @@ impl AudioParamEventTimeline {
 }
 
 /// AudioParam controls an individual aspect of an AudioNode's functionality, such as volume.
-#[derive(Clone)] // for the node bindings, see #378
+#[derive(Clone)] // `Clone` for the node bindings, see #378
 pub struct AudioParam {
     registration: Arc<AudioContextRegistration>,
     raw_parts: AudioParamInner,
 }
 
+impl std::fmt::Debug for AudioParam {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("AudioParam")
+            .field("registration", &self.registration())
+            .field("automation_rate", &self.automation_rate())
+            .field(
+                "automation_rate_constrained",
+                &self.raw_parts.automation_rate_constrained,
+            )
+            .field("default_value", &self.default_value())
+            .field("min_value", &self.min_value())
+            .field("max_value", &self.max_value())
+            .finish()
+    }
+}
+
 // helper struct to attach / detach to context (for borrow reasons)
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub(crate) struct AudioParamInner {
     default_value: f32,                          // immutable
     min_value: f32,                              // immutable