refactor: split CI into quality, platforms, sanitizers workflows and fix lints (#1056)

Author: roderickvd

.github/workflows/cpal.yml .github/workflows/platforms.yml.github/workflows/cpal.yml renamed to .github/workflows/platforms.yml

@@ -0,0 +1,147 @@
+name: Code Quality
+
+on:
+  push:
+    branches: [master]
+    paths-ignore:
+      - "**.md"
+      - "docs/**"
+      - "LICENSE*"
+      - ".gitignore"
+  pull_request:
+    branches: [master]
+    paths-ignore:
+      - "**.md"
+      - "docs/**"
+      - "LICENSE*"
+      - ".gitignore"
+
+jobs:
+  formatting:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt
+
+      - name: Check formatting
+        run: cargo fmt --all -- --check
+
+  lints-stable:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Linux - ALSA/JACK backend
+          - target: x86_64-unknown-linux-gnu
+            name: Linux
+            features: --all-features
+            os: ubuntu-latest
+
+          # Windows - WASAPI backend
+          - target: x86_64-pc-windows-msvc
+            name: Windows
+            features: --all-features
+            os: windows-latest
+
+          # macOS - CoreAudio backend
+          - target: aarch64-apple-darwin
+            name: macOS
+            features: --all-features
+            os: ubuntu-latest
+
+          # Android - Oboe backend
+          - target: armv7-linux-androideabi
+            name: Android
+            features: ""
+            os: ubuntu-latest
+
+          # iOS - CoreAudio (iOS) backend
+          - target: aarch64-apple-ios
+            name: iOS
+            features: ""
+            os: ubuntu-latest
+
+          # WASM - wasm-bindgen feature
+          - target: wasm32-unknown-unknown
+            name: WASM-bindgen
+            features: --features wasm-bindgen
+            os: ubuntu-latest
+
+          # WASM - Emscripten
+          - target: wasm32-unknown-emscripten
+            name: WASM-emscripten
+            features: ""
+            os: ubuntu-latest
+
+          # WASM - WASI
+          - target: wasm32-wasip1
+            name: WASI
+            features: ""
+            os: ubuntu-latest
+
+    name: clippy-${{ matrix.name }}
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Cache Linux audio packages
+        if: runner.os == 'Linux'
+        uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: libasound2-dev libjack-jackd2-dev libjack-jackd2-0 libdbus-1-dev
+
+      - name: Setup ASIO SDK
+        if: runner.os == 'Windows'
+        run: |
+          curl -L -o asio.zip https://www.steinberg.net/asiosdk
+          7z x -oasio asio.zip
+          move asio\*\* asio\
+          choco install asio4all
+          choco install llvm
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+          targets: ${{ matrix.target }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          key: clippy-${{ matrix.target }}-${{ matrix.name }}
+
+      - name: Run clippy
+        env:
+          CPAL_ASIO_DIR: ${{ runner.os == 'Windows' && format('{0}/asio', github.workspace) || '' }}
+        run: cargo clippy --all --target ${{ matrix.target }} ${{ matrix.features }} -- -D warnings
+
+  lints-nightly:
+    name: clippy-WASM-worklet
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Cache Linux audio packages
+        uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: libasound2-dev libjack-jackd2-dev libjack-jackd2-0 libdbus-1-dev
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: clippy, rust-src
+          targets: wasm32-unknown-unknown
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          key: clippy-wasm32-worklet
+
+      - name: Run clippy (web_audio_worklet)
+        env:
+          RUSTFLAGS: -C target-feature=+atomics,+bulk-memory,+mutable-globals
+        run: cargo +nightly clippy --all --target wasm32-unknown-unknown --features web_audio_worklet -Z build-std=std,panic_abort -- -D warnings

.github/workflows/quality.yml

@@ -4,5 +4,4 @@ mod definitions;
 mod devices_info;
 mod utils;
 
-pub use self::audio_features::*;
 pub use self::definitions::*;

src/host/aaudio/java_interface.rs

@@ -29,5 +29,5 @@ fn get_frames_per_buffer<'j>(env: &mut JNIEnv<'j>, context: &JObject<'j>) -> JRe
     // TODO: Use jni::errors::Error::ParseFailed instead of jni::errors::Error::JniCall once jni > v0.21.1 is released
     frames_per_buffer_string
         .parse::<i32>()
-        .map_err(|e| jni::errors::Error::JniCall(jni::errors::JniError::Unknown))
+        .map_err(|_| jni::errors::Error::JniCall(jni::errors::JniError::Unknown))
 }

src/host/aaudio/java_interface/audio_manager.rs

@@ -144,9 +144,8 @@ unsafe impl Sync for Stream {}
 crate::assert_stream_send!(Stream);
 crate::assert_stream_sync!(Stream);
 
-pub type SupportedInputConfigs = VecIntoIter<SupportedStreamConfigRange>;
-pub type SupportedOutputConfigs = VecIntoIter<SupportedStreamConfigRange>;
-pub type Devices = VecIntoIter<Device>;
+pub use crate::iter::{SupportedInputConfigs, SupportedOutputConfigs};
+pub type Devices = std::vec::IntoIter<Device>;
 
 impl Host {
     pub fn new() -> Result<Self, crate::HostUnavailable> {
@@ -206,7 +205,7 @@ fn default_supported_configs() -> VecIntoIter<SupportedStreamConfigRange> {
                     channels: *channel_count,
                     min_sample_rate: SampleRate(*sample_rate as u32),
                     max_sample_rate: SampleRate(*sample_rate as u32),
-                    buffer_size: buffer_size.clone(),
+                    buffer_size,
                     sample_format: *sample_format,
                 });
             }
@@ -252,7 +251,7 @@ fn device_supported_configs(device: &AudioDeviceInfo) -> VecIntoIter<SupportedSt
                     channels: cmp::min(*channel_count as u16, 2u16),
                     min_sample_rate: SampleRate(*sample_rate as u32),
                     max_sample_rate: SampleRate(*sample_rate as u32),
-                    buffer_size: buffer_size.clone(),
+                    buffer_size,
                     sample_format: *format,
                 });
             }
@@ -323,6 +322,10 @@ where
             (error_callback)(StreamError::from(error))
         }))
         .open_stream()?;
+    // SAFETY: Stream implements Send + Sync (see unsafe impl below). Arc<Mutex<AudioStream>>
+    // is safe because the Mutex provides exclusive access and AudioStream's thread safety
+    // is documented in the AAudio C API.
+    #[allow(clippy::arc_with_non_send_sync)]
     Ok(Stream::Input(Arc::new(Mutex::new(stream))))
 }
 
@@ -365,6 +368,10 @@ where
             (error_callback)(StreamError::from(error))
         }))
         .open_stream()?;
+    // SAFETY: Stream implements Send + Sync (see unsafe impl below). Arc<Mutex<AudioStream>>
+    // is safe because the Mutex provides exclusive access and AudioStream's thread safety
+    // is documented in the AAudio C API.
+    #[allow(clippy::arc_with_non_send_sync)]
     Ok(Stream::Output(Arc::new(Mutex::new(stream))))
 }
 

src/host/aaudio/mod.rs

@@ -92,8 +92,7 @@ fn parse_alsa_description(description: &str) -> Vec<String> {
 // (start_threshold = 2 periods), ensuring low latency even with large multi-period ring
 // buffers.
 
-pub type SupportedInputConfigs = VecIntoIter<SupportedStreamConfigRange>;
-pub type SupportedOutputConfigs = VecIntoIter<SupportedStreamConfigRange>;
+pub use crate::iter::{SupportedInputConfigs, SupportedOutputConfigs};
 
 mod enumerate;
 

src/host/alsa/mod.rs

@@ -1,13 +1,11 @@
-pub type SupportedInputConfigs = std::vec::IntoIter<SupportedStreamConfigRange>;
-pub type SupportedOutputConfigs = std::vec::IntoIter<SupportedStreamConfigRange>;
+pub use crate::iter::{SupportedInputConfigs, SupportedOutputConfigs};
 
 use super::sys;
 use crate::BackendSpecificError;
 use crate::ChannelCount;
 use crate::DefaultStreamConfigError;
 use crate::DeviceDescription;
 use crate::DeviceDescriptionBuilder;
-use crate::DeviceDirection;
 use crate::DeviceId;
 use crate::DeviceIdError;
 use crate::DeviceNameError;

src/host/asio/device.rs

@@ -221,7 +221,7 @@ impl Device {
                 }
 
                 (&sys::AsioSampleType::ASIOSTInt24LSB, SampleFormat::I24) => {
-                    process_input_callback_i24::<I24, _>(
+                    process_input_callback_i24(
                         &mut data_callback,
                         &mut interleaved,
                         asio_stream,
@@ -231,7 +231,7 @@ impl Device {
                     );
                 }
                 (&sys::AsioSampleType::ASIOSTInt24MSB, SampleFormat::I24) => {
-                    process_input_callback_i24::<I24, _>(
+                    process_input_callback_i24(
                         &mut data_callback,
                         &mut interleaved,
                         asio_stream,
@@ -326,6 +326,7 @@ impl Device {
             /// 2. If required, silence the ASIO buffer.
             /// 3. Finally, write the interleaved data to the non-interleaved ASIO buffer,
             ///    performing endianness conversions as necessary.
+            #[allow(clippy::too_many_arguments)]
             unsafe fn process_output_callback<A, D, F>(
                 data_callback: &mut D,
                 interleaved: &mut [u8],
@@ -745,7 +746,7 @@ unsafe fn asio_channel_slice<T>(
 ) -> &[T] {
     let channel_length = requested_channel_length.unwrap_or(asio_stream.buffer_size as usize);
     let buff_ptr: *const T =
-        asio_stream.buffer_infos[channel_index].buffers[buffer_index as usize] as *const _;
+        asio_stream.buffer_infos[channel_index].buffers[buffer_index] as *const _;
     std::slice::from_raw_parts(buff_ptr, channel_length)
 }
 
@@ -760,8 +761,7 @@ unsafe fn asio_channel_slice_mut<T>(
     requested_channel_length: Option<usize>,
 ) -> &mut [T] {
     let channel_length = requested_channel_length.unwrap_or(asio_stream.buffer_size as usize);
-    let buff_ptr: *mut T =
-        asio_stream.buffer_infos[channel_index].buffers[buffer_index as usize] as *mut _;
+    let buff_ptr: *mut T = asio_stream.buffer_infos[channel_index].buffers[buffer_index] as *mut _;
     std::slice::from_raw_parts_mut(buff_ptr, channel_length)
 }
 
@@ -862,15 +862,14 @@ unsafe fn process_output_callback_i24<D>(
     }
 }
 
-unsafe fn process_input_callback_i24<A, D>(
+unsafe fn process_input_callback_i24<D>(
     data_callback: &mut D,
     interleaved: &mut [u8],
     asio_stream: &sys::AsioStream,
     asio_info: &sys::CallbackInfo,
     sample_rate: crate::SampleRate,
     little_endian: bool,
 ) where
-    A: Copy,
     D: FnMut(&Data, &InputCallbackInfo) + Send + 'static,
 {
     let format = SampleFormat::I24;

src/host/asio/stream.rs

@@ -1,12 +1,8 @@
 use std::vec::IntoIter as VecIntoIter;
 
-use crate::DevicesError;
-use crate::SupportedStreamConfigRange;
-
 use super::Device;
 
-pub type SupportedInputConfigs = ::std::vec::IntoIter<SupportedStreamConfigRange>;
-pub type SupportedOutputConfigs = ::std::vec::IntoIter<SupportedStreamConfigRange>;
+pub use crate::iter::{SupportedInputConfigs, SupportedOutputConfigs};
 
 // TODO: Support enumerating earpiece vs headset vs speaker etc?
 pub struct Devices(VecIntoIter<Device>);

src/host/coreaudio/ios/enumerate.rs

@@ -5,7 +5,6 @@ use std::sync::Mutex;
 use coreaudio::audio_unit::render_callback::data;
 use coreaudio::audio_unit::{render_callback, AudioUnit, Element, Scope};
 use objc2_audio_toolbox::{kAudioOutputUnitProperty_EnableIO, kAudioUnitProperty_StreamFormat};
-use objc2_core_audio::kAudioDevicePropertyBufferFrameSize;
 use objc2_core_audio_types::AudioBuffer;
 
 use objc2_avf_audio::AVAudioSession;
@@ -106,15 +105,15 @@ impl Device {
         get_supported_stream_configs(true)
             .next()
             .map(|range| range.with_max_sample_rate())
-            .ok_or_else(|| DefaultStreamConfigError::StreamTypeNotSupported)
+            .ok_or(DefaultStreamConfigError::StreamTypeNotSupported)
     }
 
     fn default_output_config(&self) -> Result<SupportedStreamConfig, DefaultStreamConfigError> {
         // Get the maximum channel count config from supported configs
         get_supported_stream_configs(false)
             .last()
             .map(|range| range.with_max_sample_rate())
-            .ok_or_else(|| DefaultStreamConfigError::StreamTypeNotSupported)
+            .ok_or(DefaultStreamConfigError::StreamTypeNotSupported)
     }
 }
 
@@ -380,7 +379,7 @@ fn get_supported_stream_configs(is_input: bool) -> std::vec::IntoIter<SupportedS
             channels,
             min_sample_rate: SampleRate(sample_rate),
             max_sample_rate: SampleRate(sample_rate),
-            buffer_size: buffer_size.clone(),
+            buffer_size,
             sample_format: SUPPORTED_SAMPLE_FORMAT,
         })
         .collect();
@@ -439,7 +438,7 @@ unsafe fn extract_audio_buffer(
 ) -> (AudioBuffer, Data) {
     let buffer = if is_input {
         // Input: access through buffer array
-        let ptr = (*args.data.data).mBuffers.as_ptr() as *const AudioBuffer;
+        let ptr = (*args.data.data).mBuffers.as_ptr();
         let len = (*args.data.data).mNumberBuffers as usize;
         let buffers: &[AudioBuffer] = slice::from_raw_parts(ptr, len);
         buffers[0]
@@ -449,7 +448,7 @@ unsafe fn extract_audio_buffer(
     };
 
     let data = buffer.mData as *mut ();
-    let len = (buffer.mDataByteSize as usize / bytes_per_channel) as usize;
+    let len = buffer.mDataByteSize as usize / bytes_per_channel;
     let data = Data::from_parts(data, len, sample_format);
 
     (buffer, data)