Metadata update issues

ear-production-suite-plugins/lib/include/communication/direct_speakers_metadata_sender.hpp

@@ -38,9 +38,14 @@ class DirectSpeakersMetadataSender {
  private:
   void sendMetadata();
   void startTimer();
-  MessageBuffer getMessage();
+  MessageBuffer prepareMessage();
   void handleTimeout(std::error_code ec);
-
+  template<typename FunctionT>
+  void setData(FunctionT&& set) {
+    std::lock_guard<std::mutex> dataLock{dataMutex_};
+    data_.set_changed(true);
+    set(&data_);
+  }
   std::shared_ptr<spdlog::logger> logger_;
   nng::PushSocket socket_;
   nng::AsyncIO timer_;

ear-production-suite-plugins/lib/include/communication/object_metadata_sender.hpp

@@ -48,8 +48,22 @@ class ObjectMetadataSender {
  private:
   void sendMetadata();
   void startTimer();
-  MessageBuffer getMessage();
+  MessageBuffer prepareMessage();
   void handleTimeout(std::error_code ec);
+  template<typename FunctionT>
+  void setData(FunctionT&& set) {
+    // send as pointer so can't accidentally copy based on FunctionT
+    // and to match setObjectData
+    std::lock_guard<std::mutex> lock(dataMutex_);
+    data_.set_changed(true);
+    set(&data_);
+  }
+  template<typename FunctionT>
+  void setObjectData(FunctionT&& set) {
+    std::lock_guard<std::mutex> lock(dataMutex_);
+    data_.set_changed(true);
+    set(data_.mutable_obj_metadata());
+  }
 
   std::shared_ptr<spdlog::logger> logger_;
   nng::PushSocket socket_;

ear-production-suite-plugins/lib/include/scene_gains_calculator.hpp

@@ -7,6 +7,7 @@
 #include <ear/ear.hpp>
 #include <Eigen/Eigen>
 #include <map>
+#include <string>
 #include <vector>
 
 namespace ear {
@@ -50,6 +51,7 @@ class SceneGainsCalculator {
   ear::GainCalculatorObjects objectCalculator_;
   ear::GainCalculatorDirectSpeakers directSpeakersCalculator_;
   std::map<communication::ConnectionId, Routing> routingCache_;
+  std::vector<std::string> allActiveIds;
 };
 
 }  // namespace plugin

ear-production-suite-plugins/lib/src/communication/direct_speakers_metadata_sender.cpp

@@ -41,15 +41,15 @@ void DirectSpeakersMetadataSender::connect(const std::string& endpoint,
   startTimer();
 }
 
-MessageBuffer DirectSpeakersMetadataSender::getMessage() {
+MessageBuffer DirectSpeakersMetadataSender::prepareMessage() {
   std::lock_guard<std::mutex> lock(dataMutex_);
   MessageBuffer buffer = allocBuffer(data_.ByteSizeLong());
   data_.SerializeToArray(buffer.data(), buffer.size());
+  data_.set_changed(false);
   return buffer;
 }
 
 void DirectSpeakersMetadataSender::disconnect() {
-  std::lock_guard<std::mutex> lock(dataMutex_);
   timer_.cancel();
   timer_.wait();
   socket_.asyncCancel();
@@ -67,15 +67,17 @@ void DirectSpeakersMetadataSender::sendMetadata() {
   if (!connectionId_.isValid()) {
     return;
   }
-  auto msg = getMessage();
-  data_.set_changed(false);
+  auto msg = prepareMessage();
   socket_.asyncSend(
       msg, [this](std::error_code ec, const nng::Message& ignored) {
         if (!ec) {
           std::lock_guard<std::mutex> lock(timeoutMutex_);
           lastSendTimestamp_ = std::chrono::system_clock::now();
         } else {
-          data_.set_changed(true);
+          {
+            std::lock_guard<std::mutex> dataLock(dataMutex_);
+            data_.set_changed(true);
+          }
           EAR_LOGGER_WARN(logger_, "Metadata sending failed: {}", ec.message());
         }
       });
@@ -109,22 +111,19 @@ void DirectSpeakersMetadataSender::handleTimeout(std::error_code ec) {
 }
 
 void DirectSpeakersMetadataSender::routing(int32_t value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.set_changed(true);
-  data_.set_routing(value);
+  setData([value](auto data) { data->set_routing(value); });
 }
 void DirectSpeakersMetadataSender::name(const std::string& value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.set_name(value);
+  setData([&value](auto data) { data->set_name(value); });
 }
 void DirectSpeakersMetadataSender::colour(int value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.set_colour(value);
+  setData([value](auto data) { data->set_colour(value); });
 }
 void DirectSpeakersMetadataSender::speakerSetupIndex(int value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.set_allocated_ds_metadata(
-      proto::convertSpeakerSetupToEpsMetadata(value));
+  setData([value](auto data) {
+    data->set_allocated_ds_metadata(
+        proto::convertSpeakerSetupToEpsMetadata(value));
+  });
 }
 
 }  // namespace communication

ear-production-suite-plugins/lib/src/communication/object_metadata_sender.cpp

@@ -39,15 +39,15 @@ void ObjectMetadataSender::connect(const std::string& endpoint,
   startTimer();
 }
 
-MessageBuffer ObjectMetadataSender::getMessage() {
+MessageBuffer ObjectMetadataSender::prepareMessage() {
   std::lock_guard<std::mutex> lock(dataMutex_);
   MessageBuffer buffer = allocBuffer(data_.ByteSizeLong());
   data_.SerializeToArray(buffer.data(), buffer.size());
+  data_.set_changed(false);
   return buffer;
 }
 
 void ObjectMetadataSender::disconnect() {
-  std::lock_guard<std::mutex> lock(dataMutex_);
   timer_.cancel();
   timer_.wait();
   socket_.asyncCancel();
@@ -65,15 +65,17 @@ void ObjectMetadataSender::sendMetadata() {
   if (!connectionId_.isValid()) {
     return;
   }
-  auto msg = getMessage();
-  data_.set_changed(false);
+  auto msg = prepareMessage();
   socket_.asyncSend(
       msg, [this](std::error_code ec, const nng::Message& ignored) {
         if (!ec) {
           std::lock_guard<std::mutex> lock(timeoutMutex_);
           lastSendTimestamp_ = std::chrono::system_clock::now();
         } else {
-          data_.set_changed(true);
+          {
+            std::lock_guard<std::mutex> dataLock(dataMutex_);
+            data_.set_changed(true);
+          }
           EAR_LOGGER_WARN(logger_, "Metadata sending failed: {}", ec.message());
         }
       });
@@ -107,63 +109,46 @@ void ObjectMetadataSender::handleTimeout(std::error_code ec) {
 }
 
 void ObjectMetadataSender::name(const std::string& value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.set_name(value);
+  setData([value](auto data) { data->set_name(value); });
 }
 void ObjectMetadataSender::colour(int value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.set_colour(value);
+  setData([value](auto data) { data->set_colour(value); });
 }
-
 void ObjectMetadataSender::routing(int32_t value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.set_changed(true);
-  data_.set_routing(value);
+  setData([value](auto data) { data->set_routing(value); });
 }
 void ObjectMetadataSender::gain(float value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.set_changed(true);
-  data_.mutable_obj_metadata()->set_gain(value);
+  setObjectData([value](auto data) { data->set_gain(value); });
 }
-
 void ObjectMetadataSender::azimuth(float value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.set_changed(true);
-  data_.mutable_obj_metadata()->mutable_position()->set_azimuth(value);
+  setObjectData(
+      [value](auto data) { data->mutable_position()->set_azimuth(value); });
 }
 void ObjectMetadataSender::elevation(float value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.set_changed(true);
-  data_.mutable_obj_metadata()->mutable_position()->set_elevation(value);
+  setObjectData(
+      [value](auto data) { data->mutable_position()->set_elevation(value); });
 }
 void ObjectMetadataSender::distance(float value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.mutable_obj_metadata()->mutable_position()->set_distance(value);
+  setObjectData(
+      [value](auto data) { data->mutable_position()->set_distance(value); });
 }
-
 void ObjectMetadataSender::width(float value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.mutable_obj_metadata()->set_width(value);
+  setObjectData([value](auto data) { data->set_width(value); });
 }
 void ObjectMetadataSender::height(float value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.mutable_obj_metadata()->set_height(value);
+  setObjectData([value](auto data) { data->set_height(value); });
 }
 void ObjectMetadataSender::depth(float value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.mutable_obj_metadata()->set_depth(value);
+  setObjectData([value](auto data) { data->set_depth(value); });
 }
 void ObjectMetadataSender::diffuse(float value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.mutable_obj_metadata()->set_diffuse(value);
+  setObjectData([value](auto data) { data->set_diffuse(value); });
 }
 void ObjectMetadataSender::factor(float value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.mutable_obj_metadata()->set_factor(value);
+  setObjectData([value](auto data) { data->set_factor(value); });
 }
 void ObjectMetadataSender::range(float value) {
-  std::lock_guard<std::mutex> lock(dataMutex_);
-  data_.mutable_obj_metadata()->set_range(value);
+  setObjectData([value](auto data) { data->set_range(value); });
 }
 
 }  // namespace communication

ear-production-suite-plugins/lib/src/scene_gains_calculator.cpp

@@ -1,6 +1,7 @@
 #include "scene_gains_calculator.hpp"
 #include "ear/metadata.hpp"
 #include "helper/eps_to_ear_metadata_converter.hpp"
+#include <algorithm>
 
 namespace ear {
 namespace plugin {
@@ -9,6 +10,7 @@ SceneGainsCalculator::SceneGainsCalculator(ear::Layout outputLayout,
                                            int inputChannelCount)
     : objectCalculator_{outputLayout}, directSpeakersCalculator_{outputLayout} {
   resize(outputLayout, static_cast<std::size_t>(inputChannelCount));
+  allActiveIds.reserve(inputChannelCount);
 }
 
 bool SceneGainsCalculator::update(proto::SceneStore store) {
@@ -30,8 +32,10 @@ bool SceneGainsCalculator::update(proto::SceneStore store) {
                 diffuse_[routing.track + i].end(), 0.0f);
     }
   }
+
   for (const auto& item : store.items()) {
-    if (item.changed()) {
+    bool newItem = std::find(allActiveIds.begin(), allActiveIds.end(), item.connection_id()) == allActiveIds.end();
+    if (newItem || item.changed()) {
       if (item.has_ds_metadata()) {
         auto earMetadata =
             EpsToEarMetadataConverter::convert(item.ds_metadata());
@@ -64,6 +68,13 @@ bool SceneGainsCalculator::update(proto::SceneStore store) {
       }
     }
   }
+
+  // Used for setting the newItem flag next time around
+  allActiveIds.clear();
+  for(const auto& item : store.items()) {
+    allActiveIds.push_back(item.connection_id());
+  }
+
   return true;
 }