Fix the fast path in capture_frame function, without buffering (#778)

* fix the fast path in capture_frame function, without buffering
* added a comment

Author: xianshijing-lk

libwebrtc/src/native/audio_source.rs

@@ -27,6 +27,25 @@ pub struct NativeAudioSource {
 }
 
 impl NativeAudioSource {
+    /// Creates a new [`NativeAudioSource`].
+    ///
+    /// # Arguments
+    /// * `options` – Configuration options for the source (e.g. echo cancellation, noise suppression).
+    /// * `sample_rate` – Sampling rate in Hz (for example, `48000`).
+    /// * `num_channels` – Number of audio channels (`1` for mono, `2` for stereo, etc.).
+    /// * `queue_size_ms` – Size of the internal buffering queue, in milliseconds.
+    ///
+    /// # Behavior
+    /// - If `queue_size_ms` is **zero**, buffering is **disabled** and audio frames are
+    ///   delivered directly to webrtc sinks. In this mode, the caller **must provide 10 ms frames**
+    ///   (i.e., `sample_rate / 100` samples per channel) when calling [`capture_frame`].
+    /// - If `queue_size_ms` is **non-zero**, buffering is enabled. The value must be a
+    ///   **multiple of 10**, representing the total buffering duration in milliseconds.
+    ///   Frames will be queued and flushed to sinks asynchronously once the buffer
+    ///   reaches the configured threshold.
+    ///
+    /// # Panics
+    /// assert if `queue_size_ms` is not a multiple of 10.
     pub fn new(
         options: AudioSourceOptions,
         sample_rate: u32,
@@ -78,6 +97,49 @@ impl NativeAudioSource {
             });
         }
 
+        // Fast path: no buffering
+        if self.queue_size_samples == 0 {
+            // frame size must be 10ms for fast path
+            let expected_frames_per_ch = (self.sample_rate / 100) as usize;
+            if frame.data.len() % (self.num_channels as usize) != 0 {
+                return Err(RtcError {
+                    error_type: RtcErrorType::InvalidState,
+                    message: "frame.data length not divisible by channel count".to_owned(),
+                });
+            }
+            let nb_frames = frame.data.len() / (self.num_channels as usize);
+            if nb_frames != expected_frames_per_ch {
+                return Err(RtcError {
+                    error_type: RtcErrorType::InvalidState,
+                    message: format!(
+                        "direct capture requires 10ms frames: got {} frames, expected {}",
+                        nb_frames, expected_frames_per_ch
+                    ),
+                });
+            }
+
+            unsafe {
+                // Pass null ctx + null callback; C++ ignores them in direct mode
+                let data: &[i16] = frame.data.as_ref();
+                let ok = self.sys_handle.capture_frame(
+                    data,
+                    self.sample_rate,
+                    self.num_channels,
+                    nb_frames,
+                    std::ptr::null(),
+                    std::mem::zeroed::<sys_at::CompleteCallback>(),
+                );
+                if !ok {
+                    return Err(RtcError {
+                        error_type: RtcErrorType::InvalidState,
+                        message: "failed to capture frame without buffering".to_owned(),
+                    });
+                }
+            }
+            return Ok(());
+        }
+
+        // Buffered path.
         extern "C" fn lk_audio_source_complete(userdata: *const sys_at::SourceContext) {
             let tx = unsafe { Box::from_raw(userdata as *mut oneshot::Sender<()>) };
             let _ = tx.send(());
@@ -91,6 +153,7 @@ impl NativeAudioSource {
             let ctx_ptr = Box::into_raw(ctx) as *const sys_at::SourceContext;
 
             unsafe {
+                // In the fast path, C++ never store / invoke on_complete / ctx.
                 if !self.sys_handle.capture_frame(
                     chunk,
                     self.sample_rate,