Fix all but the last lint (mostly adds PipeWire backend docstrings)

src/audio_buffer.rs

@@ -351,6 +351,8 @@ where
         Some(Self { storage })
     }
 
+    /// Create an audio buffer reference from non-interleaved data. This does *not* copy the data,
+    /// but creates a view over it, so that it can be accessed as any other audio buffer.
     pub fn from_noninterleaved(data: &'a [T], channels: usize) -> Option<Self> {
         let buffer_size = data.len() / channels;
         let storage = ArrayView2::from_shape((channels, buffer_size), data).ok()?;
@@ -373,6 +375,12 @@ impl<'a, T: 'a> AudioMut<'a, T> {
         Some(Self { storage })
     }
 
+    /// Create an audio buffer mutable reference from interleaved data. This does *not* copy the
+    /// data, but creates a view over it, so that it can be accessed as any other audio buffer.
+    ///
+    /// Writes to the resulting buffer directly map to the provided slice, and asking an
+    /// interleaved view out of the resulting buffer (with [`AudioBufferBase::as_interleaved`])
+    /// means the same slice is returned.
     pub fn from_noninterleaved_mut(data: &'a mut [T], channels: usize) -> Option<Self> {
         let buffer_size = data.len() / channels;
         let storage = ArrayViewMut2::from_shape((channels, buffer_size), data).ok()?;

src/backends/alsa/stream.rs

@@ -49,14 +49,14 @@ impl<Callback: 'static + Send> AlsaStream<Callback> {
                 let mut poll_descriptors = {
                     let mut buf = vec![rx.as_pollfd()];
                     let num_descriptors = device.pcm.count();
-                    buf.extend(
-                        std::iter::repeat(libc::pollfd {
+                    buf.extend(std::iter::repeat_n(
+                        libc::pollfd {
                             fd: 0,
                             events: 0,
                             revents: 0,
-                        })
-                        .take(num_descriptors),
-                    );
+                        },
+                        num_descriptors,
+                    ));
                     buf
                 };
                 let (hwp, _, io) = device.apply_config(&stream_config)?;
@@ -70,7 +70,7 @@ impl<Callback: 'static + Send> AlsaStream<Callback> {
                 let stream_config = StreamConfig {
                     samplerate,
                     channels: ChannelMap32::default()
-                        .with_indices(std::iter::repeat(1).take(num_channels)),
+                        .with_indices(std::iter::repeat_n(1, num_channels)),
                     buffer_size_range: (Some(period_size), Some(period_size)),
                     exclusive: false,
                 };

src/backends/pipewire/device.rs

@@ -1,3 +1,5 @@
+//! PipeWire device abstraction.
+
 use super::stream::StreamHandle;
 use crate::backends::pipewire::error::PipewireError;
 use crate::{
@@ -12,15 +14,21 @@ use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
 use std::rc::Rc;
 
+/// A device (like a sound card) in PipeWire.
 pub struct PipewireDevice {
     pub(super) target_node: Option<u32>,
+    /// Additive flags describing the device (input/output/...)
     pub device_type: DeviceType,
+    /// Serial number of the device node in the PipeWire graph.
     pub object_serial: Option<String>,
+    /// Name to be used for the next created stream.
     pub stream_name: Cow<'static, str>,
+    /// Properties for the next created stream.
     pub stream_properties: HashMap<Vec<u8>, Vec<u8>>,
 }
 
 impl PipewireDevice {
+    /// Get PipeWire properties of the PipeWire device node.
     pub fn properties(&self) -> Result<Option<Properties>, PipewireError> {
         let Some(node_id) = self.target_node else {
             return Ok(None);

src/backends/pipewire/driver.rs

@@ -1,3 +1,5 @@
+//! PipeWire driver abstraction.
+
 use super::error::PipewireError;
 use crate::backends::pipewire::device::PipewireDevice;
 use crate::backends::pipewire::utils;
@@ -6,6 +8,7 @@ use std::borrow::Cow;
 use std::collections::HashMap;
 use std::marker::PhantomData;
 
+/// The Interflow PipeWire backend driver.
 pub struct PipewireDriver {
     __init: PhantomData<()>,
 }

src/backends/pipewire/error.rs

@@ -1,9 +1,14 @@
+//! PipeWire errors.
+
 use thiserror::Error;
 
+/// PipeWire error.
 #[derive(Debug, Error)]
 pub enum PipewireError {
+    /// Error originating in the PipeWire backend.
     #[error("Pipewire error: {0}")]
     BackendError(#[from] pipewire::Error),
+    /// Error creating a pipewire stream (SPA pod serialization problem).
     #[error("Cannot create Pipewire stream: {0}")]
     GenError(#[from] libspa::pod::serialize::GenError),
 }

src/backends/pipewire/mod.rs

@@ -1,3 +1,10 @@
+//! # PipeWire backend
+//!
+//! PipeWire is a modern multimedia server for Linux systems, designed to handle both audio and
+//! video streams. It provides low-latency performance and advanced routing capabilities while
+//! maintaining compatibility with older APIs like ALSA and PulseAudio, making it a flexible and
+//! future-oriented backend.
+
 pub mod device;
 pub mod driver;
 pub mod error;

src/backends/pipewire/stream.rs

@@ -1,3 +1,5 @@
+//! PipeWire streams.
+
 use crate::audio_buffer::{AudioMut, AudioRef};
 use crate::backends::pipewire::error::PipewireError;
 use crate::channel_map::Bitset;
@@ -124,6 +126,7 @@ impl<Callback: AudioInputCallback> StreamInner<Callback> {
     }
 }
 
+/// PipeWire stream handle.
 pub struct StreamHandle<Callback> {
     commands: rtrb::Producer<StreamCommands<Callback>>,
     handle: JoinHandle<Result<(), PipewireError>>,