feat: macos fixes, dsp fixes

feelfreelinux · Jan 9, 2024 · e9f1b55 · e9f1b55
1 parent 3017f8d
commit e9f1b55
Show file tree

Hide file tree

Showing 7 changed files with 166 additions and 11 deletions.
diff --git a/.clangd b/.clangd
@@ -1,3 +1,2 @@
-
 CompileFlags:
-   CompilationDatabase: build/      # Search build/ directory for compile_commands.json
+   CompilationDatabase: examples/dsp/build      # Search build/ directory for compile_commands.json
diff --git a/main/audio-dsp/Biquad.cpp b/main/audio-dsp/Biquad.cpp
@@ -10,7 +10,7 @@ Biquad::Biquad() {
 
 void Biquad::sampleRateChanged(uint32_t sampleRate) {
   this->sampleRate = sampleRate;
-  //this->configure(this->type, this->currentConfig);
+  this->configure(this->type, this->currentConfig);
 }
 
 void Biquad::configure(Type type, std::map<std::string, float>& newConf) {
@@ -417,11 +417,11 @@ std::unique_ptr<StreamInfo> Biquad::process(
     std::unique_ptr<StreamInfo> stream) {
   std::scoped_lock lock(accessMutex);
 
-  auto input = stream->data->at(this->channel);
+  auto& input = stream->data->at(this->channel);
   auto numSamples = stream->numSamples;
 
 #ifdef ESP_PLATFORM
-  dsps_biquad_f32_ae32(input, input, numSamples, coeffs, w);
+  dsps_biquad_f32_ae32(input.data(), input.data(), numSamples, coeffs, w);
 #else
   // Apply the set coefficients
   for (int i = 0; i < numSamples; i++) {

diff --git a/main/audio-dsp/include/AudioMixer.h b/main/audio-dsp/include/AudioMixer.h
@@ -37,6 +37,8 @@ class AudioMixer : public bell::AudioTransform {
 
   void reconfigure() override {}
 
+  void sampleRateChanged(uint32_t sampleRate) override {}
+
   void fromJSON(cJSON* json) {
     cJSON* mappedChannels = cJSON_GetObjectItem(json, "mapped_channels");
 

diff --git a/main/audio-dsp/include/Biquad.h b/main/audio-dsp/include/Biquad.h
@@ -83,7 +83,10 @@ class Biquad : public bell::AudioTransform {
     float slope = config->getFloat("slope", false, invalid);
     float gain = config->getFloat("gain", false, invalid);
     float frequency = config->getFloat("frequency", false, invalid);
+
     float q = config->getFloat("q", false, invalid);
+    std::cout << type << " " << gain << " " << frequency  << " " << q << std::endl;
+    std::cout << config->getChannels()[0] << std::endl;
 
     if (currentConfig["bandwidth"] == bandwidth &&
         currentConfig["slope"] == slope && currentConfig["gain"] == gain &&
@@ -122,7 +125,7 @@ class Biquad : public bell::AudioTransform {
   float coeffs[5];
   float w[2] = {1.0, 1.0};
 
-  float sampleRate = 44100;
+  float sampleRate = 48000;
 
   // Generator methods for different filter types
   void highPassCoEffs(float f, float q);

diff --git a/main/audio-dsp/include/Gain.h b/main/audio-dsp/include/Gain.h
@@ -23,13 +23,16 @@ class Gain : public bell::AudioTransform {
 
   void configure(std::vector<int> channels, float gainDB);
 
+  void sampleRateChanged(uint32_t sampleRate) override {}
+
   std::unique_ptr<StreamInfo> process(
       std::unique_ptr<StreamInfo> data) override;
 
   void reconfigure() override {
     std::scoped_lock lock(this->accessMutex);
     float gain = config->getFloat("gain");
     this->channels = config->getChannels();
+    std::cout << "the gain " << gain << std::endl;
 
     if (gainDb == gain) {
       return;

diff --git a/main/audio-dsp/include/NlohmannJSONTransformConfig.h b/main/audio-dsp/include/NlohmannJSONTransformConfig.h
@@ -0,0 +1,144 @@
+#pragma once
+
+#include <memory>
+#include "AudioPipeline.h"
+#ifndef BELL_ONLY_CJSON
+
+// dsp filters
+#include "AudioMixer.h"
+#include "Biquad.h"
+#include "BiquadCombo.h"
+#include "Compressor.h"
+#include "Gain.h"
+
+#include <nlohmann/json.hpp>
+#include <nlohmann/json_fwd.hpp>
+#include "TransformConfig.h"
+
+namespace bell {
+class NlohmannJSONTransformConfig : public bell::TransformConfig {
+ private:
+  nlohmann::json json;
+
+ public:
+  NlohmannJSONTransformConfig(nlohmann::json& body) { this->json = body; };
+  ~NlohmannJSONTransformConfig(){};
+
+  static std::shared_ptr<AudioPipeline> parsePipeline(
+      nlohmann::json& dspPipeline) {
+    auto pipeline = std::make_shared<bell::AudioPipeline>();
+
+    for (auto& transform : dspPipeline) {
+      if (!transform.contains("type"))
+        continue;
+
+      std::string type = transform["type"];
+      if (type == "gain") {
+        auto filter = std::make_shared<bell::Gain>();
+        filter->config =
+            std::make_unique<bell::NlohmannJSONTransformConfig>(transform);
+        filter->reconfigure();
+        pipeline->addTransform(filter);
+        std::cout << "got gain" << std::endl;
+      } else if (type == "compressor") {
+        auto filter = std::make_shared<bell::Compressor>();
+        filter->config =
+            std::make_unique<bell::NlohmannJSONTransformConfig>(transform);
+        filter->reconfigure();
+        pipeline->addTransform(filter);
+      } else if (type == "mixer") {
+        auto filter = std::make_shared<bell::AudioMixer>();
+        filter->config =
+            std::make_unique<bell::NlohmannJSONTransformConfig>(transform);
+        filter->reconfigure();
+        pipeline->addTransform(filter);
+      } else if (type == "biquad") {
+        auto filter = std::make_shared<bell::Biquad>();
+        filter->config =
+            std::make_unique<bell::NlohmannJSONTransformConfig>(transform);
+        filter->reconfigure();
+        pipeline->addTransform(filter);
+      } else if (type == "biquad_combo") {
+        auto filter = std::make_shared<bell::BiquadCombo>();
+        filter->config =
+            std::make_unique<bell::NlohmannJSONTransformConfig>(transform);
+        filter->reconfigure();
+        pipeline->addTransform(filter);
+      } else {
+        throw std::invalid_argument(
+            "No filter type found for configuration field " + type);
+      }
+    }
+
+    pipeline->volumeUpdated(50);
+    return pipeline;
+  }
+
+  std::string rawGetString(const std::string& field) override {
+    if (json.contains(field) && json[field].is_string()) {
+      return json[field];
+    }
+
+    return "invalid";
+  }
+
+  std::vector<int> rawGetIntArray(const std::string& field) override {
+    std::vector<int> result;
+
+    if (json.contains(field) && json[field].is_array()) {
+      for (auto& field : json[field]) {
+        if (!field.is_number_integer()) {
+          continue;
+        }
+
+        result.push_back(field);
+      }
+    }
+
+    return result;
+  }
+
+  std::vector<float> rawGetFloatArray(const std::string& field) override {
+    std::vector<float> result;
+
+    if (json.contains(field) && json[field].is_array()) {
+      for (auto& field : json[field]) {
+        if (!field.is_number_float() && !field.is_number()) {
+          continue;
+        }
+
+        result.push_back(field);
+      }
+    }
+
+    return result;
+  }
+
+  int rawGetInt(const std::string& field) override {
+    if (json.contains(field) && json[field].is_number_integer()) {
+      return json[field];
+    }
+
+    return invalidInt;
+  }
+
+  bool isArray(const std::string& field) override {
+    if (json.contains(field) && json[field].is_array()) {
+      return true;
+    }
+
+    return false;
+  }
+
+  float rawGetFloat(const std::string& field) override {
+    if (json.contains(field) &&
+        (json[field].is_number_float() || json[field].is_number())) {
+      return json[field];
+    }
+
+    return invalidInt;
+  }
+};
+}  // namespace bell
+
+#endif
diff --git a/main/platform/apple/MDNSBrowser.cpp b/main/platform/apple/MDNSBrowser.cpp
@@ -18,6 +18,7 @@ class implMDNSBrowser : public MDNSBrowser {
  private:
   DNSServiceRef service;
   std::vector<DNSServiceRef> addrResolveRefs;
+  std::vector<DiscoveredRecord> lastPublishedRecords;
 
   int socketFd = -1;
   std::atomic<bool> runDiscovery = false;
@@ -38,8 +39,9 @@ class implMDNSBrowser : public MDNSBrowser {
       }
     }
 
-    if (fullyDiscovered.size() > 0 && recordsCallback) {
+    if (recordsCallback && (lastPublishedRecords != fullyDiscovered)) {
       recordsCallback(fullyDiscovered);
+      lastPublishedRecords = fullyDiscovered;
     }
   }
 
@@ -81,6 +83,7 @@ class implMDNSBrowser : public MDNSBrowser {
                                              errorCode, hostname, address, ttl);
     }
 
+    DNSServiceRefDeallocate(ref);
     // Not passed anywhere further
     delete ctx;
   }
@@ -120,9 +123,8 @@ class implMDNSBrowser : public MDNSBrowser {
       ctx->parentPtr->handleServiceResolveReply(ctx, ref, flags, interfaceIndex,
                                                 errorCode, fullName, hostTarget,
                                                 opaqueport, txtLen, txtRecord);
-    } else {
-      delete ctx;
     }
+    DNSServiceRefDeallocate(ref);
   }
 
   /// Handle DNS-SD responses
@@ -155,7 +157,6 @@ class implMDNSBrowser : public MDNSBrowser {
         addrResolvCtx->type = record.type;
         addrResolvCtx->name = record.name;
         addrResolvCtx->parentPtr = this;
-
         DNSServiceErrorType err =
             DNSServiceResolve(&refCopy, kDNSServiceFlagsShareConnection,
                               interfaceIndex, serviceName, regType, replyDomain,
@@ -179,7 +180,10 @@ class implMDNSBrowser : public MDNSBrowser {
       publishDiscovered();
     }
 
-    if (!(flags & kDNSServiceFlagsMoreComing) && recordsCallback) {}
+    if (!(flags & kDNSServiceFlagsMoreComing) &&
+        (flags & kDNSServiceFlagsAdd)) {
+      publishDiscovered();
+    }
   }
 
   /// Thin shim passing dns-sd C-style callback to a member function