compiling

Author: stephen-derosa

bridge/src/bridge_data_track.cpp

@@ -16,6 +16,8 @@
 
 #include "livekit_bridge/bridge_data_track.h"
 
+#include "lk_log.h"
+
 #include "livekit/data_frame.h"
 #include "livekit/local_data_track.h"
 #include "livekit/local_participant.h"
@@ -44,7 +46,7 @@ bool BridgeDataTrack::pushFrame(const std::vector<std::uint8_t> &payload,
   try {
     return track_->tryPush(frame);
   } catch (const std::exception &e) {
-    LK_LOG_ERROR("[BridgeDataTrack] tryPush error: " << e.what());
+    LK_LOG_ERROR("[BridgeDataTrack] tryPush error: {}", e.what());
     return false;
   }
 }
@@ -63,7 +65,7 @@ bool BridgeDataTrack::pushFrame(const std::uint8_t *data, std::size_t size,
   try {
     return track_->tryPush(frame);
   } catch (const std::exception &e) {
-    LK_LOG_ERROR("[BridgeDataTrack] tryPush error: " << e.what());
+    LK_LOG_ERROR("[BridgeDataTrack] tryPush error: {}", e.what());
     return false;
   }
 }

bridge/src/bridge_room_delegate.cpp

@@ -19,14 +19,14 @@
 
 #include "bridge_room_delegate.h"
 
+#include "lk_log.h"
+
 #include "livekit/remote_data_track.h"
 #include "livekit/remote_participant.h"
 #include "livekit/remote_track_publication.h"
 #include "livekit/track.h"
 #include "livekit_bridge/livekit_bridge.h"
 
-#include <iostream>
-
 namespace livekit_bridge {
 
 void BridgeRoomDelegate::onTrackSubscribed(
@@ -62,9 +62,9 @@ void BridgeRoomDelegate::onRemoteDataTrackPublished(
     return;
   }
 
-  LK_LOG_INFO("[BridgeRoomDelegate] onRemoteDataTrackPublished: \""
-              << ev.track->info().name << "\" from \""
-              << ev.track->publisherIdentity() << "\"");
+  LK_LOG_INFO("[BridgeRoomDelegate] onRemoteDataTrackPublished: \"{}\" from "
+              "\"{}\"",
+              ev.track->info().name, ev.track->publisherIdentity());
   bridge_.onRemoteDataTrackPublished(ev.track);
 }
 

bridge/src/livekit_bridge.cpp

@@ -307,11 +307,10 @@ LiveKitBridge::createDataTrack(const std::string &name) {
         "LiveKitBridge::createDataTrack: not connected to a room");
   }
 
-  LK_LOG_INFO("[LiveKitBridge] Publishing data track \"" << name << "\"...");
+  LK_LOG_INFO("[LiveKitBridge] Publishing data track \"{}\"...", name);
   auto track = room_->localParticipant()->publishDataTrack(name);
-  LK_LOG_INFO("[LiveKitBridge] Data track \"" << name << "\" published "
-                                              << "(sid=" << track->info().sid
-                                              << ").");
+  LK_LOG_INFO("[LiveKitBridge] Data track \"{}\" published (sid={}).", name,
+              track->info().sid);
 
   auto bridge_track = std::shared_ptr<BridgeDataTrack>(
       new BridgeDataTrack(name, std::move(track), room_->localParticipant()));
@@ -358,8 +357,9 @@ void LiveKitBridge::setOnDataFrameCallback(
   std::thread old_thread;
   {
     std::lock_guard<std::mutex> lock(mutex_);
-    LK_LOG_INFO("[LiveKitBridge] Registered data callback for (\""
-                << participant_identity << "\", \"" << track_name << "\").");
+    LK_LOG_INFO(
+        "[LiveKitBridge] Registered data callback for (\"{}\", \"{}\").",
+        participant_identity, track_name);
     DataCallbackKey key{participant_identity, track_name};
     data_callbacks_[key] = std::move(callback);
 
@@ -446,9 +446,9 @@ void LiveKitBridge::onTrackSubscribed(
         old_thread = startVideoReader(key, track, it->second);
       }
     } else {
-      LK_LOG_INFO("[LiveKitBridge] Track subscribed: \""
-                  << track->name() << "\" from \"" << participant_identity
-                  << "\" (sid=" << track->sid() << ")");
+      LK_LOG_INFO(
+          "[LiveKitBridge] Track subscribed: \"{}\" from \"{}\" (sid={})",
+          track->name(), participant_identity, track->sid());
     }
   }
   // If this key already had a reader (e.g. track was re-subscribed), the old
@@ -475,10 +475,10 @@ void LiveKitBridge::onTrackUnsubscribed(const std::string &participant_identity,
 
 void LiveKitBridge::onRemoteDataTrackPublished(
     std::shared_ptr<livekit::RemoteDataTrack> track) {
-  LK_LOG_INFO("[LiveKitBridge] Remote data track published: \""
-              << track->info().name << "\" from \""
-              << track->publisherIdentity() << "\" (sid=" << track->info().sid
-              << ")");
+  LK_LOG_INFO("[LiveKitBridge] Remote data track published: \"{}\" from \"{}\" "
+              "(sid={})",
+              track->info().name, track->publisherIdentity(),
+              track->info().sid);
 
   std::thread old_thread;
   std::string identity;
@@ -493,15 +493,14 @@ void LiveKitBridge::onRemoteDataTrackPublished(
 
     auto it = data_callbacks_.find(key);
     if (it != data_callbacks_.end()) {
-      LK_LOG_INFO("[LiveKitBridge] Found matching callback for ("
-                  << key.identity << ", " << key.track_name
-                  << "), starting data reader.");
+      LK_LOG_INFO("[LiveKitBridge] Found matching callback for ({}, {}), "
+                  "starting data reader.",
+                  key.identity, key.track_name);
       old_thread = startDataReader(key, track, it->second);
     } else {
-      LK_LOG_INFO(
-          "[LiveKitBridge] No callback registered yet for ("
-          << key.identity << ", " << key.track_name
-          << "); storing as pending (will start when callback is set).");
+      LK_LOG_INFO("[LiveKitBridge] No callback registered yet for ({}, {}); "
+                  "storing as pending (will start when callback is set).",
+                  key.identity, key.track_name);
       pending_remote_data_tracks_[key] = track;
     }
   }
@@ -625,21 +624,22 @@ std::thread LiveKitBridge::startDataReader(
     DataFrameCallback cb) {
   auto old_thread = extractDataReaderThread(key);
 
-  LK_LOG_INFO("[LiveKitBridge] Subscribing to data track \""
-              << key.track_name << "\" from \"" << key.identity << "\"...");
+  LK_LOG_INFO("[LiveKitBridge] Subscribing to data track \"{}\" from \"{}\"...",
+              key.track_name, key.identity);
 
   std::shared_ptr<livekit::DataTrackSubscription> subscription;
   try {
     subscription = track->subscribe();
   } catch (const std::exception &e) {
-    LK_LOG_ERROR("[LiveKitBridge] Failed to subscribe to data track \""
-                 << key.track_name << "\" from \"" << key.identity
-                 << "\": " << e.what());
+    LK_LOG_ERROR("[LiveKitBridge] Failed to subscribe to data track \"{}\" "
+                 "from \"{}\": {}",
+                 key.track_name, key.identity, e.what());
     return old_thread;
   }
 
-  LK_LOG_INFO("[LiveKitBridge] Subscribed to data track \""
-              << key.track_name << "\"; starting reader thread.");
+  LK_LOG_INFO("[LiveKitBridge] Subscribed to data track \"{}\"; starting "
+              "reader thread.",
+              key.track_name);
 
   auto sub_copy = subscription;
   auto track_name = key.track_name;
@@ -649,19 +649,20 @@ std::thread LiveKitBridge::startDataReader(
   reader.remote_track = track;
   reader.subscription = std::move(subscription);
   reader.thread = std::thread([sub_copy, cb, track_name, identity]() {
-    LK_LOG_INFO("[LiveKitBridge] Data reader thread running for \""
-                << track_name << "\" from \"" << identity << "\".");
+    LK_LOG_INFO(
+        "[LiveKitBridge] Data reader thread running for \"{}\" from \"{}\".",
+        track_name, identity);
     livekit::DataFrame frame;
     while (sub_copy->read(frame)) {
       try {
         cb(frame.payload, frame.user_timestamp);
       } catch (const std::exception &e) {
-        LK_LOG_ERROR("[LiveKitBridge] Data callback exception: " << e.what()
-                  << ");
+        LK_LOG_ERROR("[LiveKitBridge] Data callback exception: {}", e.what());
       }
     }
-    LK_LOG_INFO("[LiveKitBridge] Data reader thread exiting for \""
-                << track_name << "\" from \"" << identity << "\".");
+    LK_LOG_INFO(
+        "[LiveKitBridge] Data reader thread exiting for \"{}\" from \"{}\".",
+        track_name, identity);
   });
 
   active_data_readers_[key] = std::move(reader);

src/ffi_client.cpp

@@ -324,7 +324,7 @@ FfiClient::connectAsync(const std::string &url, const std::string &token,
   auto *opts = connect->mutable_options();
   opts->set_auto_subscribe(options.auto_subscribe);
   opts->set_dynacast(options.dynacast);
-  opts->set_single_peer_connection(options.single_peer_connection);
+  // opts->set_single_peer_connection(options.single_peer_connection);
   LK_LOG_INFO("[FfiClient] connectAsync: auto_subscribe={}, dynacast={}, "
               "single_peer_connection={}",
               options.auto_subscribe, options.dynacast,

src/room.cpp

@@ -604,10 +604,10 @@ void Room::OnEvent(const FfiEvent &event) {
       const auto &rdtp = re.remote_data_track_published();
       auto remote_track =
           std::shared_ptr<RemoteDataTrack>(new RemoteDataTrack(rdtp.track()));
-      LK_LOG_INFO("[Room] RoomEvent::kRemoteDataTrackPublished: \""
-                  << remote_track->info().name << "\" from \""
-                  << remote_track->publisherIdentity()
-                  << "\" (sid=" << remote_track->info().sid << ")");
+      LK_LOG_INFO("[Room] RoomEvent::kRemoteDataTrackPublished: \"{}\" from "
+                  "\"{}\" (sid={})",
+                  remote_track->info().name, remote_track->publisherIdentity(),
+                  remote_track->info().sid);
       RemoteDataTrackPublishedEvent ev;
       ev.track = remote_track;
       if (delegate_snapshot) {