fix(asio): FL Studio ASIO quirk (#1077)

Co-authored-by: Sintel <17052580+Sin-tel@users.noreply.github.com>
Co-authored-by: Roderick van Domburg <roderick@vandomburg.net>

Author: Sin-tel

CHANGELOG.md

@@ -72,6 +72,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **ALSA**: Format selection to probe hardware endianness instead of assuming native byte order.
 - **ALSA**: Data race in stream shutdown.
 - **ASIO**: Handling for `kAsioResetRequest` message to prevent driver UI becoming unresponsive.
+- **ASIO**: Buffer silencing logic to work with non-conformant drivers (e.g., FL Studio ASIO).
 - **CoreAudio**: Timestamp accuracy.
 - **CoreAudio**: Segfaults when enumerating devices.
 - **CoreAudio**: Undefined behavior related to null pointers and aligned reads.

asio-sys/CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 - Fixed docs.rs documentation build by generating stub bindings when building for docs.rs
+- Fixed buffer switch detection to work correctly with non-conformant ASIO drivers
 
 ## [0.2.3] - 2025-12-12
 

asio-sys/src/bindings/mod.rs

@@ -9,7 +9,7 @@ use std::ffi::{CStr, CString};
 use std::os::raw::{c_char, c_double, c_void};
 use std::ptr::null_mut;
 use std::sync::{
-    atomic::{AtomicBool, Ordering},
+    atomic::{AtomicBool, AtomicU32, Ordering},
     Arc, Mutex, MutexGuard, Weak,
 };
 
@@ -100,6 +100,7 @@ pub struct SampleRate {
 pub struct CallbackInfo {
     pub buffer_index: i32,
     pub system_time: ai::ASIOTimeStamp,
+    pub callback_flag: u32,
 }
 
 /// Holds the pointer to the callbacks that come from cpal
@@ -319,6 +320,9 @@ pub struct CallbackId(usize);
 /// parameters.
 static BUFFER_CALLBACK: Mutex<Vec<(CallbackId, BufferCallback)>> = Mutex::new(Vec::new());
 
+/// Used to identify when to clear buffers.
+static CALLBACK_FLAG: AtomicU32 = AtomicU32::new(0);
+
 /// Indicates that ASIOOutputReady should be called
 static CALL_OUTPUT_READY: AtomicBool = AtomicBool::new(false);
 
@@ -1047,9 +1051,13 @@ extern "C" fn buffer_switch_time_info(
     // This lock is probably unavoidable, but locks in the audio stream are not great.
     let mut bcs = BUFFER_CALLBACK.lock().unwrap();
     let asio_time: &mut AsioTime = unsafe { &mut *(time as *mut AsioTime) };
+    // Alternates: 0, 1, 0, 1, ...
+    let callback_flag = CALLBACK_FLAG.fetch_xor(1, Ordering::Relaxed);
+
     let callback_info = CallbackInfo {
         buffer_index: double_buffer_index,
         system_time: asio_time.time_info.system_time,
+        callback_flag,
     };
     for &mut (_, ref mut bc) in bcs.iter_mut() {
         bc.run(&callback_info);

src/host/asio/device.rs

@@ -17,7 +17,7 @@ use crate::SupportedStreamConfigRange;
 use crate::SupportedStreamConfigsError;
 
 use std::hash::{Hash, Hasher};
-use std::sync::atomic::AtomicI32;
+use std::sync::atomic::AtomicU32;
 use std::sync::{Arc, Mutex};
 
 /// A ASIO Device
@@ -30,7 +30,7 @@ pub struct Device {
     // A driver can only have one of each.
     // They need to be created at the same time.
     pub asio_streams: Arc<Mutex<sys::AsioStreams>>,
-    pub current_buffer_index: Arc<AtomicI32>,
+    pub current_callback_flag: Arc<AtomicU32>,
 }
 
 /// All available devices.
@@ -215,7 +215,8 @@ impl Iterator for Devices {
                         return Some(Device {
                             driver,
                             asio_streams,
-                            current_buffer_index: Arc::new(AtomicI32::new(-1)),
+                            // Initialize with sentinel value so it never matches global flag state (0 or 1).
+                            current_callback_flag: Arc::new(AtomicU32::new(u32::MAX)),
                         });
                     }
                     Err(_) => continue,

src/host/asio/stream.rs

@@ -299,7 +299,7 @@ impl Device {
         // Create buffers depending on data type.
         let len_bytes = cpal_num_samples * sample_format.sample_size();
         let mut interleaved = vec![0u8; len_bytes];
-        let current_buffer_index = self.current_buffer_index.clone();
+        let current_callback_flag = self.current_callback_flag.clone();
 
         let stream_playing = Arc::new(AtomicBool::new(false));
         let playing = Arc::clone(&stream_playing);
@@ -321,13 +321,13 @@ impl Device {
 
             // Silence the ASIO buffer that is about to be used.
             //
-            // This checks if any other callbacks have already silenced the buffer associated with
-            // the current `buffer_index`.
+            // Check if any other callbacks have already silenced the buffer associated with
+            // the current callback. The flag is updated once per buffer switch.
             let silence =
-                current_buffer_index.load(Ordering::Acquire) != callback_info.buffer_index;
+                current_callback_flag.load(Ordering::Acquire) != callback_info.callback_flag;
 
             if silence {
-                current_buffer_index.store(callback_info.buffer_index, Ordering::Release);
+                current_callback_flag.store(callback_info.callback_flag, Ordering::Release);
             }
 
             /// 1. Render the given callback to the given buffer of interleaved samples.