BEAR TF selection review

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.14)
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)

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

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <vector>
+#include <string>
 #include <../src/dynamic_renderer.hpp>
 #include "variable_block_adapter.hpp"
 #include <chrono>
@@ -9,6 +10,20 @@
 namespace ear {
 namespace plugin {
 
+enum BearStatusStates {
+  NOT_ATTEMPTED = 0,
+  FAILED,
+  SUCCEEDED
+};
+
+struct BearStatus {
+  bear::Config startupConfig;
+  BearStatusStates startupSuccess{NOT_ATTEMPTED};
+  std::string startupErrorDesc;
+  BearStatusStates listenerDataSetSuccess{NOT_ATTEMPTED};
+  std::string listenerDataSetErrorDesc;
+};
+
 /**
  * @brief Binaural monitoring plugin dsp implementation
  *
@@ -47,6 +62,8 @@ class BinauralMonitoringAudioProcessor {
   BinauralMonitoringAudioProcessor& operator=(
       BinauralMonitoringAudioProcessor&&) = delete;
 
+  BearStatus getBearStatus() { return bearStatus; }
+
   template <typename InBuffer, typename OutBuffer>
   void process(const InBuffer& in, OutBuffer& out) {
     using InTraits = BufferTraits<InBuffer>;
@@ -67,7 +84,7 @@ class BinauralMonitoringAudioProcessor {
   void setListenerOrientation(float quatW, float quatX, float quatY,
                               float quatZ);
 
-  bool rendererError() { return !bearRenderer; }
+  bool rendererStarted() { return bearRenderer && bearStatus.startupSuccess == SUCCEEDED; }
 
   void setIsPlaying(bool state) { isPlaying = state; }
   bool getIsPlaying() { return isPlaying; }
@@ -84,6 +101,7 @@ class BinauralMonitoringAudioProcessor {
   std::shared_ptr<bear::DynamicRenderer> bearRenderer;  // TODO - why shared?
   std::mutex bearListenerMutex_;
   bear::Listener bearListener;
+  BearStatus bearStatus;
 
   bool listenerQuatsDirty{false};
   std::array<double, 4> listenerQuats{1.0, 0.0, 0.0, 0.0};

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

@@ -37,19 +37,25 @@ BinauralMonitoringAudioProcessor::BinauralMonitoringAudioProcessor(
 
   bearListener.set_position_cart(std::array<double, 3>{0.0, 0.0, 0.0});
 
+  bearStatus.startupConfig = bearConfig;
   try {
     bearRenderer = std::make_shared<bear::DynamicRenderer>(
         blockSize,
         std::max(std::max(maxObjChannels, maxDsChannels), maxHoaChannels));
+    bearRenderer->set_config_blocking(bearConfig);
+    bearStatus.startupSuccess = BearStatusStates::SUCCEEDED;
     try {
       bearRenderer->set_listener(bearListener);
+      bearStatus.listenerDataSetSuccess = BearStatusStates::SUCCEEDED;
     } catch (std::exception &e) {
+      bearStatus.listenerDataSetSuccess = BearStatusStates::FAILED;
+      bearStatus.listenerDataSetErrorDesc = e.what();
       bearRenderer.reset();
-      assert(false);
     }
   } catch (std::exception &e) {
+    bearStatus.startupSuccess = BearStatusStates::FAILED;
+    bearStatus.startupErrorDesc = e.what();
     bearRenderer.reset();
-    assert(false);
   }
 }
 
@@ -218,6 +224,7 @@ bool BinauralMonitoringAudioProcessor::updateChannelCounts(
     // Do immediate update
     bearRenderer->set_config_blocking(bearConfig);
   }
+  return true;
 }
 
 }  // namespace plugin

ear-production-suite-plugins/plugins/binaural_monitoring/CMakeLists.txt

@@ -1,16 +1,14 @@
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS OFF)
-
 set(SOURCES_BINAURAL_MONITORING
-    ${EPS_SHARED_DIR}/binary_data.cpp
-    ${EPS_SHARED_DIR}/components/look_and_feel/slider.cpp
-    ${EPS_SHARED_DIR}/components/ear_header.cpp
-    ${EPS_SHARED_DIR}/components/ear_slider_label.cpp
-    ${EPS_SHARED_DIR}/components/level_meter_calculator.cpp
+	${EPS_SHARED_DIR}/binary_data.cpp
+	${EPS_SHARED_DIR}/components/look_and_feel/slider.cpp
+	${EPS_SHARED_DIR}/components/ear_combo_box.cpp
+	${EPS_SHARED_DIR}/components/ear_header.cpp
+	${EPS_SHARED_DIR}/components/ear_slider_label.cpp
+	${EPS_SHARED_DIR}/components/level_meter_calculator.cpp
 	src/binaural_monitoring_frontend_connector.cpp
-    src/binaural_monitoring_plugin_editor.cpp
-    src/binaural_monitoring_plugin_processor.cpp
+	src/binaural_monitoring_plugin_editor.cpp
+	src/binaural_monitoring_plugin_processor.cpp
+	src/bear_data_files.cpp
 	src/orientation_osc.cpp
 )
 
@@ -25,6 +23,7 @@ set(HEADERS_BINAURAL_MONITORING
 	${EPS_SHARED_DIR}/binary_data.hpp
 
 	${EPS_SHARED_DIR}/components/ear_button.hpp
+	${EPS_SHARED_DIR}/components/ear_combo_box.hpp
 	${EPS_SHARED_DIR}/components/ear_header.hpp
 	${EPS_SHARED_DIR}/components/ear_inverted_slider.hpp
 	${EPS_SHARED_DIR}/components/ear_slider.hpp
@@ -47,10 +46,11 @@ set(HEADERS_BINAURAL_MONITORING
 	src/binaural_monitoring_frontend_connector.hpp
 	src/binaural_monitoring_plugin_editor.hpp
 	src/binaural_monitoring_plugin_processor.hpp
-	src/error_overlay.hpp
+	src/bear_data_files.hpp
 	src/headphone_channel_meter.hpp
 	src/headphone_channel_meter_box.hpp
 	src/orientation_osc.hpp
+	src/value_box_data_file.hpp
 	src/value_box_orientation.hpp
 	src/value_box_osc.hpp
 )
@@ -60,7 +60,7 @@ source_group("Header Files" FILES ${HEADERS_BINAURAL_MONITORING})
 add_juce_vst3_plugin(
 	ear_binaural_monitoring
 	SOURCES ${SOURCES_BINAURAL_MONITORING} ${HEADERS_BINAURAL_MONITORING}
-    IDE_FOLDER ${IDE_FOLDER_PLUGINS}
+	IDE_FOLDER ${IDE_FOLDER_PLUGINS}
 	CODE_SUFFIX "F0" # Speaker Monitoring suffixes start from A0 and increment. For bin, lets use F0 (Note FF is scene)
 	DISPLAY_NAME "EAR Binaural Monitoring"
 	DESCRIPTION "The binaural monitoring plugin"
@@ -81,7 +81,7 @@ if(APPLE)
 	add_custom_command(TARGET ear_binaural_monitoring_VST3 POST_BUILD
 		COMMAND ${CMAKE_COMMAND} -E copy ${TENSORFILE_FULLPATH} "$<TARGET_FILE_DIR:ear_binaural_monitoring_VST3>/../Resources/${TENSORFILE_FILENAME}"
 	)
-    install(FILES ${TENSORFILE_FULLPATH} DESTINATION "${EPS_PLUGIN_INSTALL_PREFIX}ear-production-suite/EAR Binaural Monitoring.vst3/Contents/Resources")
+	install(FILES ${TENSORFILE_FULLPATH} DESTINATION "${EPS_PLUGIN_INSTALL_PREFIX}ear-production-suite/EAR Binaural Monitoring.vst3/Contents/Resources")
 else()
 	add_custom_command(TARGET ear_binaural_monitoring_VST3 POST_BUILD
 		COMMAND ${CMAKE_COMMAND} -E copy ${TENSORFILE_FULLPATH} "$<TARGET_FILE_DIR:ear_binaural_monitoring_VST3>/${TENSORFILE_FILENAME}"

ear-production-suite-plugins/plugins/binaural_monitoring/src/bear_data_files.cpp

@@ -0,0 +1,181 @@
+#include "bear_data_files.hpp"
+#include <bear/api.hpp>
+
+namespace {
+juce::File getBearDataFileDirectory() {
+  auto vstPath = juce::File::getSpecialLocation(
+      juce::File::SpecialLocationType::currentExecutableFile);
+  vstPath = vstPath.getParentDirectory();
+#ifdef __APPLE__
+  vstPath = vstPath.getParentDirectory();
+  vstPath = vstPath.getChildFile("Resources");
+#endif
+  return vstPath;
+};
+
+juce::File getCustomDataFileDirectory() {
+  auto vstPath = juce::File::getSpecialLocation(
+      juce::File::SpecialLocationType::currentExecutableFile);
+  vstPath = vstPath.getParentDirectory();
+#ifdef __APPLE__
+  // vstPath is `EAR Binaural Monitoring.vst3/Contents/MacOS` - traverse up x3 to get to dir containing vst3 bundle
+  vstPath = vstPath.getParentDirectory();
+  vstPath = vstPath.getParentDirectory();
+  vstPath = vstPath.getParentDirectory();
+#endif
+  return vstPath;
+};
+
+}
+
+namespace ear {
+namespace plugin {
+DataFileManager::DataFileManager() {
+  bearReleaseFiles_.add(
+      getBearDataFileDirectory().getChildFile(BEAR_DATA_FILE));
+  updateAvailableFiles();
+}
+
+namespace {
+void setFromMetadata(DataFileManager::DataFile& dataFile) {
+  try {
+    auto md = bear::DataFileMetadata::read_from_file(
+        dataFile.fullPath.getFullPathName().toStdString());
+    if (md.has_metadata()) {
+      dataFile.label = md.get_label();
+      dataFile.description = md.get_description();
+      dataFile.isBearRelease = md.is_released();
+    }
+  }
+  catch(std::exception const&) {
+    /* 
+    `read_from_file` could throw if;
+     - the file does not exist, or otherwise unreadable
+     - the file is not a valid tensorfile
+     - the metadata within the file is not of the expected structure
+    In all these cases, and any other, silently skip metadata extraction
+
+    Note that a file with bad metadata may still be a usable filter set
+    so we don't want to strike it off yet, nor is it worth doing deeper 
+    checks here... the user can still select it as the processor will 
+    catch unusable files (unreadable/invalid/corrupt etc) anyway when 
+    it tries to start BEAR with it, and will report the actual error.
+    */
+  }
+}
+
+void updateFile(juce::File const& file, DataFileManager::FileMap& file_map,
+                bool mustBeRelease) {
+  DataFileManager::DataFile df{.filename = file.getFileName(),
+                               .fullPath = file};
+  setFromMetadata(df);
+  if (!mustBeRelease || df.isBearRelease) {
+    file_map.insert({file, std::move(df)});
+  }
+}
+}  // namespace
+
+bool DataFileManager::onlyContainsDefault() const {
+  return customDataFiles.empty() && releasedDataFiles.size() == 1u;
+}
+
+bool DataFileManager::defaultIsSelected() const {
+  return selectedDataFile_.has_value() &&
+         releasedDataFiles.contains(selectedDataFile_->fullPath);
+}
+
+void DataFileManager::updateAvailableFiles() {
+  releasedDataFiles.clear();
+  customDataFiles.clear();
+
+  // add our expected released files
+  for (auto const& file : bearReleaseFiles_) {
+    if (file.existsAsFile()) {
+      updateFile(file, releasedDataFiles, true);
+    }
+  }
+
+  auto custom_files = getCustomDataFileDirectory().findChildFiles(
+      juce::File::TypesOfFileToFind::findFiles, false, "*.tf");
+  for (const auto& file : custom_files) {
+    if (!releasedDataFiles.contains(file)) {  // on windows the custom / release
+                                              // dirs are the same
+      updateFile(file, customDataFiles, false);
+    }
+  }
+}
+
+std::optional<DataFileManager::DataFile>
+DataFileManager::getSelectedDataFileInfo() const {
+  return selectedDataFile_;
+}
+
+std::vector<DataFileManager::DataFile>
+DataFileManager::getAvailableDataFiles() const {
+  std::vector<DataFile> files;
+  files.reserve(getAvailableDataFilesCount());
+  auto fileExtractor = [](auto const& file) { return file.second; };
+  std::transform(releasedDataFiles.begin(), releasedDataFiles.end(), std::back_inserter(files), fileExtractor);
+  std::transform(customDataFiles.begin(), customDataFiles.end(), std::back_inserter(files), fileExtractor);
+  return files;
+}
+
+std::size_t DataFileManager::getAvailableDataFilesCount() const {
+  return releasedDataFiles.size() + customDataFiles.size();
+}
+
+void DataFileManager::setSelectedDataFile(DataFile const& file) {
+  if(!selectedDataFile_ || file != *selectedDataFile_) {
+    selectedDataFile_ = file;
+    selectedDataFileChangeCallback_(file);
+  }
+}
+
+bool DataFileManager::setSelectedDataFile(const juce::String& fullPath) {
+  return setSelectedDataFile(juce::File(fullPath));
+}
+
+bool DataFileManager::setSelectedDataFile(const juce::File& fullPath) {
+  auto const found = getDataFileInfo(fullPath);
+  if (found) {
+    setSelectedDataFile(*found);
+  }
+  return static_cast<bool>(found);
+}
+
+bool DataFileManager::setSelectedDataFileDefault() { 
+  updateAvailableFiles();
+  auto found = false;
+  if(!releasedDataFiles.empty()) {
+    setSelectedDataFile(releasedDataFiles.begin()->second);
+    found = true;
+  }
+  return found;
+}
+
+namespace {
+  std::optional<DataFileManager::DataFile> getDataFile(DataFileManager::FileMap const& map, juce::File const& file) {
+    std::optional<DataFileManager::DataFile> dataFile;
+  if(auto it = map.find(file); it != map.end()) {
+    dataFile = it->second;
+  }
+  return dataFile;
+  }
+}
+
+std::optional<DataFileManager::DataFile> DataFileManager::getDataFileInfo(
+    const juce::File& fullPath) const {
+  auto file = getDataFile(releasedDataFiles, fullPath);
+  if(!file) {
+    file = getDataFile(customDataFiles, fullPath);
+  }
+  return file;
+}
+
+void DataFileManager::onSelectedDataFileChange(
+    std::function<void(DataFile const&)> callback) {
+  selectedDataFileChangeCallback_ = std::move(callback);
+}
+
+}  // namespace plugin
+}  // namespace ear