remove the debug logs

Author: xianshijing-lk

examples/simple_room/main.cpp

@@ -3,6 +3,7 @@
 #include <csignal>
 #include <cstdlib>
 #include <iostream>
+#include <random>
 #include <string>
 #include <thread>
 #include <vector>
@@ -28,7 +29,7 @@ void print_usage(const char *prog) {
             << "  LIVEKIT_URL, LIVEKIT_TOKEN\n";
 }
 
-void handle_sigint(int) { g_running = false; }
+void handle_sigint(int) { g_running.store(false); }
 
 bool parse_args(int argc, char *argv[], std::string &url, std::string &token) {
   // 1) --help
@@ -118,6 +119,47 @@ class SimpleRoomDelegate : public livekit::RoomDelegate {
   }
 };
 
+// Test utils to run a capture loop to publish noisy audio frames to the room
+void runNoiseCaptureLoop(const std::shared_ptr<AudioSource> &source) {
+  const int sample_rate = source->sample_rate();
+  const int num_channels = source->num_channels();
+  const int frame_ms = 10;
+  const int samples_per_channel = sample_rate * frame_ms / 1000;
+
+  std::mt19937 rng(std::random_device{}());
+  std::uniform_int_distribution<int16_t> noise_dist(-5000, 5000);
+  using Clock = std::chrono::steady_clock;
+  auto next_deadline = Clock::now();
+  while (g_running.load(std::memory_order_relaxed)) {
+    AudioFrame frame =
+        AudioFrame::create(sample_rate, num_channels, samples_per_channel);
+    const std::size_t total_samples =
+        static_cast<std::size_t>(num_channels) *
+        static_cast<std::size_t>(samples_per_channel);
+    for (std::size_t i = 0; i < total_samples; ++i) {
+      frame.data()[i] = noise_dist(rng);
+    }
+    try {
+      source->captureFrame(frame);
+    } catch (const std::exception &e) {
+      // If something goes wrong, log and break out
+      std::cerr << "Error in captureFrame: " << e.what() << std::endl;
+      break;
+    }
+
+    // Pace the loop to roughly real-time
+    next_deadline += std::chrono::milliseconds(frame_ms);
+    std::this_thread::sleep_until(next_deadline);
+  }
+
+  // Optionally clear queued audio on exit
+  try {
+    source->clearQueue();
+  } catch (...) {
+    // ignore errors on shutdown
+    std::cout << "Error in clearQueue" << std::endl;
+  }
+}
 } // namespace
 
 int main(int argc, char *argv[]) {
@@ -194,12 +236,20 @@ int main(int argc, char *argv[]) {
     std::cerr << "Failed to publish track: " << e.what() << std::endl;
   }
 
+  // TODO, if we have pre-buffering feature, we might consider starting the
+  // thread right after creating the source.
+  std::thread audioThread(runNoiseCaptureLoop, audioSource);
   // Keep the app alive until Ctrl-C so we continue receiving events,
   // similar to asyncio.run(main()) keeping the loop running.
   while (g_running.load()) {
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
   }
 
+  // Shutdown the audio thread.
+  if (audioThread.joinable()) {
+    audioThread.join();
+  }
+
   FfiClient::instance().shutdown();
   std::cout << "Exiting.\n";
   return 0;

include/livekit/audio_source.h

@@ -72,16 +72,36 @@ class AudioSource {
   void clearQueue();
 
   /**
-   * Push an AudioFrame into the audio source.
+   * Push an AudioFrame into the audio source and BLOCK until the FFI callback
+   * confirms that the native side has finished processing (consuming) the
+   * frame. Safe usage: The frame's internal buffer must remain valid only until
+   * this function returns. Because this call blocks until the corresponding FFI
+   * callback arrives, the caller may safely destroy or reuse the frame
+   * afterward.
+   * @param frame       The audio frame to send. No-op if the frame contains
+   * zero samples.
+   * @param timeout_ms  Maximum time to wait for the FFI callback.
+   *                    - If timeout_ms > 0: block up to this duration.
+   *                      A timeout will cause std::runtime_error.
+   *                    - If timeout_ms == 0: wait indefinitely until the
+   * callback arrives (recommended for production unless the caller needs
+   * explicit timeout control).
    *
-   * It sends a capture_audio_frame FFI request and may throw on error
-   * (depending on what the FFI response exposes).
+   * Notes:
+   *   - This is a blocking call.
+   *   - timeout_ms == 0 (infinite wait) is the safest mode because it
+   * guarantees the callback completes before the function returns, which in
+   * turn guarantees that the audio buffer lifetime is fully protected. The
+   * caller does not need to manage or extend the frame lifetime manually.
    *
-   * If the frame has zero samples, this method is a no-op.
+   *   - May throw std::runtime_error if:
+   *       • the FFI reports an error
    *
-   * @throws std::runtime_error on FFI-reported error (if available).
+   *   - The underlying FFI request *must* eventually produce a callback for
+   * each frame. If the FFI layer is misbehaving or the event loop is stalled,
+   *     a timeout may occur in bounded-wait mode.
    */
-  void captureFrame(const AudioFrame &frame);
+  void captureFrame(const AudioFrame &frame, int timeout_ms = 20);
 
   /**
    * Block until the currently queued audio has (roughly) played out.

src/audio_frame.cpp

@@ -1,3 +1,19 @@
+/*
+ * Copyright 2025 LiveKit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an “AS IS” BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #include "livekit/audio_frame.h"
 
 #include <cstddef>

src/audio_source.cpp

@@ -93,7 +93,8 @@ void AudioSource::clearQueue() {
   resetQueueTracking();
 }
 
-void AudioSource::captureFrame(const AudioFrame &frame) {
+void AudioSource::captureFrame(const AudioFrame &frame, int timeout_ms) {
+  using namespace std::chrono_literals;
   if (!handle_) {
     return;
   }
@@ -105,10 +106,8 @@ void AudioSource::captureFrame(const AudioFrame &frame) {
   // Queue tracking, same logic as before
   double now = now_seconds();
   double elapsed = (last_capture_ == 0.0) ? 0.0 : (now - last_capture_);
-
   double frame_duration = static_cast<double>(frame.samples_per_channel()) /
                           static_cast<double>(sample_rate_);
-
   q_size_ += frame_duration - elapsed;
   if (q_size_ < 0.0) {
     q_size_ = 0.0; // clamp
@@ -117,12 +116,21 @@ void AudioSource::captureFrame(const AudioFrame &frame) {
 
   // Build AudioFrameBufferInfo from the wrapper
   proto::AudioFrameBufferInfo buf = frame.toProto();
-
   // Use async FFI API and block until the callback completes
   auto fut = FfiClient::instance().captureAudioFrameAsync(handle_.get(), buf);
-
+  if (timeout_ms == 0) {
+    fut.get(); // may throw std::runtime_error from async layer
+    return;
+  }
   // This will throw std::runtime_error if the callback reported an error
-  fut.get();
+  auto status = fut.wait_for(std::chrono::milliseconds(timeout_ms));
+  if (status == std::future_status::ready ||
+      status == std::future_status::deferred) {
+    fut.get();
+  } else { // std::future_status::timeout
+    std::cerr << "captureAudioFrameAsync timed out after " << timeout_ms
+              << " ms\n";
+  }
 }
 
 void AudioSource::waitForPlayout() const {

src/ffi_client.cpp

@@ -57,8 +57,6 @@ FfiClient::sendRequest(const proto::FfiRequest &request) const {
   FfiHandleId handle =
       livekit_ffi_request(reinterpret_cast<const uint8_t *>(bytes.data()),
                           bytes.size(), &resp_ptr, &resp_len);
-  std::cout << "receive a handle " << handle << std::endl;
-
   if (handle == INVALID_HANDLE) {
     throw std::runtime_error(
         "failed to send request, received an invalid handle");

src/local_audio_track.cpp

@@ -29,9 +29,7 @@ LocalAudioTrack::LocalAudioTrack(FfiHandle handle,
     : Track(std::move(handle), track.info().sid(), track.info().name(),
             fromProto(track.info().kind()),
             fromProto(track.info().stream_state()), track.info().muted(),
-            false) {
-  std::cout << "LocalAudioTrack handle is " << ffi_handle_id() << std::endl;
-}
+            false) {}
 
 std::shared_ptr<LocalAudioTrack> LocalAudioTrack::createLocalAudioTrack(
     const std::string &name, const std::shared_ptr<AudioSource> &source) {
@@ -43,8 +41,6 @@ std::shared_ptr<LocalAudioTrack> LocalAudioTrack::createLocalAudioTrack(
   proto::FfiResponse resp = FfiClient::instance().sendRequest(req);
   const proto::OwnedTrack &owned = resp.create_audio_track().track();
   FfiHandle handle(static_cast<uintptr_t>(owned.handle().id()));
-  std::cout << "createLocalAudioTrack handle is " << owned.handle().id()
-            << std::endl;
   return std::make_shared<LocalAudioTrack>(std::move(handle), owned);
 }
 

src/local_participant.cpp

@@ -204,20 +204,16 @@ LocalParticipant::publishTrack(const std::shared_ptr<Track> &track,
   }
 
   auto participant_handle = ffiHandleId();
-  std::cout << "participant_handle is " << participant_handle << std::endl;
   if (participant_handle == 0) {
     throw std::runtime_error(
         "LocalParticipant::publishTrack: invalid participant FFI handle");
   }
 
   auto track_handle = track->ffi_handle_id();
-  std::cout << "track_handle is " << track_handle << std::endl;
-
   if (track_handle == 0) {
     throw std::runtime_error(
         "LocalParticipant::publishTrack: invalid track FFI handle");
   }
-  std::cout << "calling  publishTrackAsync" << std::endl;
   auto fut = FfiClient::instance().publishTrackAsync(
       static_cast<std::uint64_t>(participant_handle),
       static_cast<std::uint64_t>(track_handle), options);

src/room.cpp

@@ -86,7 +86,6 @@ bool Room::Connect(const std::string &url, const std::string &token) {
       local_participant_ = std::make_unique<LocalParticipant>(
           std::move(participant_handle), pinfo.sid(), pinfo.name(),
           pinfo.identity(), pinfo.metadata(), std::move(attrs), kind, reason);
-      std::cout << "creating local participant " << std::endl;
     }
     // Setup remote particpants
     {