Additional fixes

Author: alan-george-lk

.gitignore

@@ -30,7 +30,7 @@ lib/
 *.dylib
 *.dll
 *.exe
-livekit.log
+*.log
 web/
 *trace.json
 compile_commands.json

src/audio_stream.cpp

@@ -55,7 +55,7 @@ AudioStream::fromParticipant(Participant &participant, TrackSource track_source,
 AudioStream::~AudioStream() { close(); }
 
 AudioStream::AudioStream(AudioStream &&other) noexcept {
-  std::lock_guard<std::mutex> lock(other.mutex_);
+  const std::scoped_lock<std::mutex> lock(other.mutex_);
   queue_ = std::move(other.queue_);
   capacity_ = other.capacity_;
   eof_ = other.eof_;
@@ -76,8 +76,8 @@ AudioStream &AudioStream::operator=(AudioStream &&other) noexcept {
   close();
 
   {
-    std::lock_guard<std::mutex> lock_this(mutex_);
-    std::lock_guard<std::mutex> lock_other(other.mutex_);
+    const std::scoped_lock<std::mutex> lock_this(mutex_);
+    const std::scoped_lock<std::mutex> lock_other(other.mutex_);
 
     queue_ = std::move(other.queue_);
     capacity_ = other.capacity_;
@@ -110,7 +110,7 @@ bool AudioStream::read(AudioFrameEvent &out_event) {
 
 void AudioStream::close() {
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    const std::scoped_lock<std::mutex> lock(mutex_);
     if (closed_) {
       return;
     }
@@ -221,7 +221,7 @@ void AudioStream::onFfiEvent(const FfiEvent &event) {
 
 void AudioStream::pushFrame(AudioFrameEvent &&ev) {
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    const std::scoped_lock<std::mutex> lock(mutex_);
 
     if (closed_ || eof_) {
       return;
@@ -239,7 +239,7 @@ void AudioStream::pushFrame(AudioFrameEvent &&ev) {
 
 void AudioStream::pushEos() {
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    const std::scoped_lock<std::mutex> lock(mutex_);
     if (eof_) {
       return;
     }

src/data_stream.cpp

@@ -109,7 +109,7 @@ TextStreamReader::TextStreamReader(TextStreamInfo info)
 
 void TextStreamReader::onChunkUpdate(const std::string &text) {
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    const std::scoped_lock<std::mutex> lock(mutex_);
     if (closed_)
       return;
     queue_.push_back(text);
@@ -120,7 +120,7 @@ void TextStreamReader::onChunkUpdate(const std::string &text) {
 void TextStreamReader::onStreamClose(
     const std::map<std::string, std::string> &trailer_attrs) {
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    const std::scoped_lock<std::mutex> lock(mutex_);
     for (const auto &kv : trailer_attrs) {
       info_.attributes[kv.first] = kv.second;
     }
@@ -154,7 +154,7 @@ ByteStreamReader::ByteStreamReader(ByteStreamInfo info)
 
 void ByteStreamReader::onChunkUpdate(const std::vector<std::uint8_t> &bytes) {
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    const std::scoped_lock<std::mutex> lock(mutex_);
     if (closed_)
       return;
     queue_.push_back(bytes);
@@ -165,7 +165,7 @@ void ByteStreamReader::onChunkUpdate(const std::vector<std::uint8_t> &bytes) {
 void ByteStreamReader::onStreamClose(
     const std::map<std::string, std::string> &trailer_attrs) {
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    const std::scoped_lock<std::mutex> lock(mutex_);
     for (const auto &kv : trailer_attrs) {
       info_.attributes[kv.first] = kv.second;
     }
@@ -308,7 +308,7 @@ TextStreamWriter::TextStreamWriter(
 }
 
 void TextStreamWriter::write(const std::string &text) {
-  std::lock_guard<std::mutex> lock(write_mutex_);
+  const std::scoped_lock<std::mutex> lock(write_mutex_);
   if (closed_)
     throw std::runtime_error("Cannot write to closed TextStreamWriter");
 
@@ -339,7 +339,7 @@ ByteStreamWriter::ByteStreamWriter(
 }
 
 void ByteStreamWriter::write(const std::vector<std::uint8_t> &data) {
-  std::lock_guard<std::mutex> lock(write_mutex_);
+  const std::scoped_lock<std::mutex> lock(write_mutex_);
   if (closed_)
     throw std::runtime_error("Cannot write to closed ByteStreamWriter");
 

src/data_track_stream.cpp

@@ -38,7 +38,7 @@ void DataTrackStream::init(FfiHandle subscription_handle) {
 
 bool DataTrackStream::read(DataTrackFrame &out) {
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    const std::scoped_lock<std::mutex> lock(mutex_);
     if (closed_ || eof_) {
       return false;
     }
@@ -70,7 +70,7 @@ bool DataTrackStream::read(DataTrackFrame &out) {
 void DataTrackStream::close() {
   std::int32_t listener_id = -1;
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    const std::scoped_lock<std::mutex> lock(mutex_);
     if (closed_) {
       return;
     }
@@ -94,7 +94,7 @@ void DataTrackStream::onFfiEvent(const FfiEvent &event) {
 
   const auto &dts = event.data_track_stream_event();
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    const std::scoped_lock<std::mutex> lock(mutex_);
     if (closed_ || dts.stream_handle() !=
                        static_cast<std::uint64_t>(subscription_handle_.get())) {
       return;
@@ -111,7 +111,7 @@ void DataTrackStream::onFfiEvent(const FfiEvent &event) {
 }
 
 void DataTrackStream::pushFrame(DataTrackFrame &&frame) {
-  std::lock_guard<std::mutex> lock(mutex_);
+  const std::scoped_lock<std::mutex> lock(mutex_);
 
   if (closed_ || eof_) {
     return;
@@ -128,7 +128,7 @@ void DataTrackStream::pushFrame(DataTrackFrame &&frame) {
 
 void DataTrackStream::pushEos() {
   {
-    std::lock_guard<std::mutex> lock(mutex_);
+    const std::scoped_lock<std::mutex> lock(mutex_);
     if (eof_) {
       return;
     }

src/ffi_client.cpp

@@ -172,14 +172,14 @@ bool FfiClient::isInitialized() const noexcept {
 
 FfiClient::ListenerId
 FfiClient::AddListener(const FfiClient::Listener &listener) {
-  std::lock_guard<std::mutex> guard(lock_);
+  const std::scoped_lock<std::mutex> guard(lock_);
   FfiClient::ListenerId id = next_listener_id++;
   listeners_[id] = listener;
   return id;
 }
 
 void FfiClient::RemoveListener(ListenerId id) {
-  std::lock_guard<std::mutex> guard(lock_);
+  const std::scoped_lock<std::mutex> guard(lock_);
   listeners_.erase(id);
 }
 
@@ -216,7 +216,7 @@ void FfiClient::PushEvent(const proto::FfiEvent &event) const {
   std::unique_ptr<PendingBase> to_complete;
   std::vector<Listener> listeners_copy;
   {
-    std::lock_guard<std::mutex> guard(lock_);
+    const std::scoped_lock<std::mutex> guard(lock_);
 
     // Complete pending future if this event is a callback with async_id
     if (auto async_id = ExtractAsyncId(event)) {
@@ -259,7 +259,7 @@ FfiClient::AsyncId FfiClient::generateAsyncId() {
 bool FfiClient::cancelPendingByAsyncId(AsyncId async_id) {
   std::unique_ptr<PendingBase> to_cancel;
   {
-    std::lock_guard<std::mutex> guard(lock_);
+    const std::scoped_lock<std::mutex> guard(lock_);
     auto it = pending_by_id_.find(async_id);
     if (it != pending_by_id_.end()) {
       to_cancel = std::move(it->second);
@@ -283,7 +283,7 @@ std::future<T> FfiClient::registerAsync(
   pending->match = std::move(match);
   pending->handler = std::move(handler);
   {
-    std::lock_guard<std::mutex> guard(lock_);
+    const std::scoped_lock<std::mutex> guard(lock_);
     pending_by_id_.emplace(async_id, std::move(pending));
   }
   return fut;

src/local_participant.cpp

@@ -416,7 +416,7 @@ void LocalParticipant::handleRpcMethodInvocation(
 
   // Track this invocation and check if we're shutting down
   {
-    std::lock_guard<std::mutex> lock(state->mutex);
+    const std::scoped_lock<std::mutex> lock(state->mutex);
     if (state->shutting_down) {
       // Already shutting down, don't process new invocations
       return;
@@ -430,7 +430,7 @@ void LocalParticipant::handleRpcMethodInvocation(
   struct InvocationGuard {
     std::shared_ptr<RpcInvocationState> state;
     ~InvocationGuard() {
-      std::lock_guard<std::mutex> lock(state->mutex);
+      const std::scoped_lock<std::mutex> lock(state->mutex);
       state->active_invocations--;
       if (state->active_invocations == 0) {
         state->cv.notify_all();
@@ -465,7 +465,7 @@ void LocalParticipant::handleRpcMethodInvocation(
 
   // Check again if shutdown started during handler execution
   {
-    std::lock_guard<std::mutex> lock(state->mutex);
+    const std::scoped_lock<std::mutex> lock(state->mutex);
     if (state->shutting_down) {
       // Shutdown started, don't send response - handle may be invalid
       return;

src/logging.cpp

@@ -91,7 +91,7 @@ std::shared_ptr<spdlog::logger> createDefaultLogger() {
 namespace detail {
 
 std::shared_ptr<spdlog::logger> getLogger() {
-  std::lock_guard<std::mutex> lock(loggerMutex());
+  const std::scoped_lock<std::mutex> lock(loggerMutex());
   auto &logger = loggerStorage();
   if (!logger) {
     logger = createDefaultLogger();
@@ -101,7 +101,7 @@ std::shared_ptr<spdlog::logger> getLogger() {
 }
 
 void shutdownLogger() {
-  std::lock_guard<std::mutex> lock(loggerMutex());
+  const std::scoped_lock<std::mutex> lock(loggerMutex());
   auto &logger = loggerStorage();
   if (logger) {
     spdlog::drop(kLoggerName);
@@ -118,7 +118,7 @@ void setLogLevel(LogLevel level) {
 LogLevel getLogLevel() { return fromSpdlogLevel(detail::getLogger()->level()); }
 
 void setLogCallback(LogCallback callback) {
-  std::lock_guard<std::mutex> lock(loggerMutex());
+  const std::scoped_lock<std::mutex> lock(loggerMutex());
   auto &logger = loggerStorage();
   auto current_level = logger ? logger->level() : spdlog::level::info;