react-native-audio-api 0.6.5-rc.0 → 0.6.5

package/common/cpp/audioapi/core/inputs/AudioRecorder.cpp

@@ -36,8 +36,10 @@ void AudioRecorder::invokeOnAudioReadyCallback(
   body.insert({"numFrames", numFrames});
   body.insert({"when", when});
 
-  audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-      "audioReady", onAudioReadyCallbackId_, body);
+  if (audioEventHandlerRegistry_ != nullptr) {
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "audioReady", onAudioReadyCallbackId_, body);
+  }
 }
 
 void AudioRecorder::sendRemainingData() {

package/common/cpp/audioapi/core/inputs/AudioRecorder.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <memory>
+#include <atomic>
 
 namespace audioapi {
 class AudioBus;

package/common/cpp/audioapi/core/sources/AudioBuffer.h

@@ -5,6 +5,7 @@
 #include <string>
 #include <vector>
 #include <cstddef>
+#include <cstring>
 
 namespace audioapi {
 

package/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.cpp

@@ -23,6 +23,15 @@ AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(BaseAudioContext *context)
       std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
 }
 
+AudioBufferBaseSourceNode::~AudioBufferBaseSourceNode() {
+  if (onPositionChangedCallbackId_ != 0 &&
+      context_->audioEventHandlerRegistry_ != nullptr) {
+    context_->audioEventHandlerRegistry_->unregisterHandler(
+        "positionChanged", onPositionChangedCallbackId_);
+    onPositionChangedCallbackId_ = 0;
+  }
+}
+
 std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getDetuneParam() const {
   return detuneParam_;
 }
@@ -32,6 +41,17 @@ std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getPlaybackRateParam()
   return playbackRateParam_;
 }
 
+void AudioBufferBaseSourceNode::clearOnPositionChangedCallback() {
+  if (onPositionChangedCallbackId_ == 0 || context_ == nullptr ||
+      context_->audioEventHandlerRegistry_ == nullptr) {
+    return;
+  }
+
+  context_->audioEventHandlerRegistry_->unregisterHandler(
+      "positionChanged", onPositionChangedCallbackId_);
+  onPositionChangedCallbackId_ = 0;
+}
+
 void AudioBufferBaseSourceNode::setOnPositionChangedCallbackId(
     uint64_t callbackId) {
   onPositionChangedCallbackId_ = callbackId;
@@ -42,13 +62,18 @@ void AudioBufferBaseSourceNode::setOnPositionChangedInterval(int interval) {
       context_->getSampleRate() * static_cast<float>(interval) / 1000);
 }
 
+int AudioBufferBaseSourceNode::getOnPositionChangedInterval() {
+  return onPositionChangedInterval_;
+}
+
 std::mutex &AudioBufferBaseSourceNode::getBufferLock() {
   return bufferLock_;
 }
 
 void AudioBufferBaseSourceNode::sendOnPositionChangedEvent() {
   if (onPositionChangedCallbackId_ != 0 &&
-      onPositionChangedTime_ > onPositionChangedInterval_) {
+      onPositionChangedTime_ > onPositionChangedInterval_ &&
+      context_->audioEventHandlerRegistry_ != nullptr) {
     std::unordered_map<std::string, EventValue> body = {
         {"value", getCurrentPosition()}};
 

package/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.h

@@ -4,6 +4,8 @@
 #include <audioapi/libs/signalsmith-stretch/signalsmith-stretch.h>
 
 #include <memory>
+#include <mutex>
+#include <atomic>
 
 namespace audioapi {
 
@@ -13,12 +15,15 @@ class AudioParam;
 class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
  public:
   explicit AudioBufferBaseSourceNode(BaseAudioContext *context);
+  virtual ~AudioBufferBaseSourceNode();
 
-    [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
-    [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
+  [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;
 
-    void setOnPositionChangedCallbackId(uint64_t callbackId);
-    void setOnPositionChangedInterval(int interval);
+  void clearOnPositionChangedCallback();
+  void setOnPositionChangedCallbackId(uint64_t callbackId);
+  void setOnPositionChangedInterval(int interval);
+  [[nodiscard]] int getOnPositionChangedInterval();
 
  protected:
     std::mutex bufferLock_;
@@ -34,7 +39,7 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
     // internal helper
     double vReadIndex_;
 
-    uint64_t onPositionChangedCallbackId_ = 0; // 0 means no callback
+    std::atomic<uint64_t> onPositionChangedCallbackId_ = 0; // 0 means no callback
     int onPositionChangedInterval_;
     int onPositionChangedTime_ = 0;
 

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp

@@ -16,6 +16,15 @@ AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
   numberOfInputs_ = 0;
 }
 
+AudioScheduledSourceNode::~AudioScheduledSourceNode() {
+  if (onEndedCallbackId_ != 0 &&
+      context_->audioEventHandlerRegistry_ != nullptr) {
+    context_->audioEventHandlerRegistry_->unregisterHandler(
+        "ended", onEndedCallbackId_);
+    onEndedCallbackId_ = 0;
+  }
+}
+
 void AudioScheduledSourceNode::start(double when) {
   playbackState_ = PlaybackState::SCHEDULED;
   startTime_ = when;
@@ -45,6 +54,17 @@ bool AudioScheduledSourceNode::isStopScheduled() {
   return playbackState_ == PlaybackState::STOP_SCHEDULED;
 }
 
+void AudioScheduledSourceNode::clearOnEndedCallback() {
+  if (onEndedCallbackId_ == 0 || context_ == nullptr ||
+      context_->audioEventHandlerRegistry_ == nullptr) {
+    return;
+  }
+
+  context_->audioEventHandlerRegistry_->unregisterHandler(
+      "ended", onEndedCallbackId_);
+  onEndedCallbackId_ = 0;
+}
+
 void AudioScheduledSourceNode::setOnEndedCallbackId(const uint64_t callbackId) {
   onEndedCallbackId_ = callbackId;
 }
@@ -149,8 +169,10 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
 void AudioScheduledSourceNode::disable() {
   AudioNode::disable();
 
-  context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-      "ended", onEndedCallbackId_, {});
+  if (context_->audioEventHandlerRegistry_ != nullptr) {
+    context_->audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "ended", onEndedCallbackId_, {});
+  }
 }
 
 void AudioScheduledSourceNode::handleStopScheduled() {

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h

@@ -27,6 +27,7 @@ class AudioScheduledSourceNode : public AudioNode {
   // FINISHED: The node has finished playing.
   enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, STOP_SCHEDULED, FINISHED };
   explicit AudioScheduledSourceNode(BaseAudioContext *context);
+  virtual ~AudioScheduledSourceNode();
 
   void start(double when);
   virtual void stop(double when);
@@ -37,6 +38,7 @@ class AudioScheduledSourceNode : public AudioNode {
   bool isFinished();
   bool isStopScheduled();
 
+  void clearOnEndedCallback();
   void setOnEndedCallbackId(uint64_t callbackId);
 
   void disable() override;
@@ -47,7 +49,7 @@ class AudioScheduledSourceNode : public AudioNode {
 
   PlaybackState playbackState_;
 
-  uint64_t onEndedCallbackId_ = 0;
+  std::atomic<uint64_t> onEndedCallbackId_ = 0;
 
   void updatePlaybackInfo(
       const std::shared_ptr<AudioBus>& processingBus,

package/common/cpp/audioapi/core/utils/AudioNodeDestructor.h

@@ -4,6 +4,7 @@
 #include <mutex>
 #include <thread>
 #include <atomic>
+#include <functional>
 #include <vector>
 #include <memory>
 

package/common/cpp/audioapi/core/utils/AudioNodeManager.h

@@ -20,8 +20,6 @@ class AudioNodeManager {
   AudioNodeManager() = default;
   ~AudioNodeManager();
 
-  std::mutex &getGraphLock();
-
   void preProcessGraph();
 
   void addPendingNodeConnection(
@@ -62,6 +60,7 @@ class AudioNodeManager {
       ConnectionType>>
       audioParamToConnect_;
 
+  std::mutex &getGraphLock();
   void settlePendingConnections();
   void cleanupNode(const std::shared_ptr<AudioNode> &node);
   void prepareNodesForDestruction();

package/common/cpp/audioapi/dsp/AudioUtils.cpp

@@ -28,6 +28,6 @@ float linearToDecibels(float value) {
 }
 
 float decibelsToLinear(float value) {
-  return powf(10, value / 20);
+  return pow(10, value / 20);
 }
 } // namespace audioapi::dsp

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.cpp

@@ -4,7 +4,8 @@ namespace audioapi {
 
 AudioEventHandlerRegistry::AudioEventHandlerRegistry(
     jsi::Runtime *runtime,
-    const std::shared_ptr<react::CallInvoker> &callInvoker) {
+    const std::shared_ptr<react::CallInvoker> &callInvoker)
+    : IAudioEventHandlerRegistry() {
   runtime_ = runtime;
   callInvoker_ = callInvoker;
 
@@ -24,57 +25,135 @@ AudioEventHandlerRegistry::~AudioEventHandlerRegistry() {
 uint64_t AudioEventHandlerRegistry::registerHandler(
     const std::string &eventName,
     const std::shared_ptr<jsi::Function> &handler) {
-  static uint64_t LISTENER_ID = 1;
+  uint64_t listenerId = listenerIdCounter_++;
 
-  eventHandlers_[eventName][LISTENER_ID] = handler;
+  if (callInvoker_ == nullptr || runtime_ == nullptr) {
+    // If callInvoker or runtime is not valid, we cannot register the handler
+    return 0;
+  }
+
+  // Modify the eventHandlers_ map only on the main RN thread
+  callInvoker_->invokeAsync([this, eventName, listenerId, handler]() {
+    eventHandlers_[eventName][listenerId] = handler;
+  });
 
-  return LISTENER_ID++;
+  return listenerId;
 }
 
 void AudioEventHandlerRegistry::unregisterHandler(
     const std::string &eventName,
     uint64_t listenerId) {
-  auto it = eventHandlers_.find(eventName);
-  if (it != eventHandlers_.end()) {
-    it->second.erase(listenerId);
+  if (callInvoker_ == nullptr || runtime_ == nullptr) {
+    // If callInvoker or runtime is not valid, we cannot unregister the handler
+    return;
   }
+
+  callInvoker_->invokeAsync([this, eventName, listenerId]() {
+    auto it = eventHandlers_.find(eventName);
+
+    if (it == eventHandlers_.end()) {
+      return;
+    }
+
+    auto &handlersMap = it->second;
+    auto handlerIt = handlersMap.find(listenerId);
+
+    if (handlerIt != handlersMap.end()) {
+      handlersMap.erase(handlerIt);
+    }
+  });
 }
 
 void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
     const std::string &eventName,
     const std::unordered_map<std::string, EventValue> &body) {
-  auto it = eventHandlers_.find(eventName);
-  if (it != eventHandlers_.end()) {
-    for (const auto &pair : it->second) {
+  // callInvoker_ and runtime_ must be valid to invoke handlers
+  // this might happen when react-native is reloaded or the app is closed
+  if (callInvoker_ == nullptr || runtime_ == nullptr) {
+    return;
+  }
+
+  // Do any logic regarding triggering the event on the main RN thread
+  callInvoker_->invokeAsync([this, eventName, body]() {
+    auto it = eventHandlers_.find(eventName);
+
+    if (it == eventHandlers_.end()) {
+      // If the event name is not registered, we can skip invoking handlers
+      return;
+    }
+
+    auto handlersMap = it->second;
+
+    for (const auto &pair : handlersMap) {
       auto handler = pair.second;
-      if (handler) {
-        callInvoker_->invokeAsync([this, handler, body]() {
-          auto eventObject = createEventObject(body);
-          handler->call(*runtime_, eventObject);
-        });
+
+      if (!handler || !handler->isFunction(*runtime_)) {
+        // If the handler is not valid, we can skip it
+        continue;
+      }
+
+      try {
+        auto eventObject = createEventObject(body);
+        handler->call(*runtime_, eventObject);
+      } catch (const std::exception &e) {
+        // re-throw the exception to be handled by the caller
+        // std::exception is safe to parse by the rn bridge
+        throw;
+      } catch (...) {
+        printf(
+            "Unknown exception occurred while invoking handler for event: %s\n",
+            eventName.c_str());
       }
     }
-  }
+  });
 }
 
 void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
     const std::string &eventName,
     uint64_t listenerId,
     const std::unordered_map<std::string, EventValue> &body) {
-  auto it = eventHandlers_.find(eventName);
-  if (it != eventHandlers_.end()) {
-    auto handlersMap = it->second;
-    auto handlerIt = handlersMap.find(listenerId);
-    if (handlerIt != handlersMap.end()) {
-      auto handler = handlerIt->second;
-      if (handler) {
-        callInvoker_->invokeAsync([this, handler, body]() {
-          auto eventObject = createEventObject(body);
-          handler->call(*runtime_, eventObject);
-        });
-      }
-    }
+  // callInvoker_ and runtime_ must be valid to invoke handlers
+  // this might happen when react-native is reloaded or the app is closed
+  if (callInvoker_ == nullptr || runtime_ == nullptr) {
+    return;
   }
+
+  callInvoker_->invokeAsync([this, eventName, listenerId, body]() {
+    auto it = eventHandlers_.find(eventName);
+
+    if (it == eventHandlers_.end()) {
+      // If the event name is not registered, we can skip invoking handlers
+      return;
+    }
+
+    auto handlerIt = it->second.find(listenerId);
+
+    if (handlerIt == it->second.end()) {
+      // If the listener ID is not registered, we can skip invoking handlers
+      return;
+    }
+
+    // Depending on how the AudioBufferSourceNode is handled on the JS side,
+    // it sometimes might enter race condition where the ABSN is deleted on JS
+    // side, but it is still processed on the audio thread, leading to a crash
+    // when f.e. `positionChanged` event is triggered.
+
+    // In case of debugging this, please increment the hours spent counter
+
+    // Hours spent on this: 5
+    try {
+      auto eventObject = createEventObject(body);
+      handlerIt->second->call(*runtime_, eventObject);
+    } catch (const std::exception &e) {
+      // re-throw the exception to be handled by the caller
+      // std::exception is safe to parse by the rn bridge
+      throw;
+    } catch (...) {
+      printf(
+          "Unknown exception occurred while invoking handler for event: %s\n",
+          eventName.c_str());
+    }
+  });
 }
 
 jsi::Object AudioEventHandlerRegistry::createEventObject(
@@ -85,19 +164,20 @@ jsi::Object AudioEventHandlerRegistry::createEventObject(
     const auto name = pair.first.data();
     const auto &value = pair.second;
 
-    if (holds_alternative<int>(value)) {
-      eventObject.setProperty(*runtime_, name, get<int>(value));
-    } else if (holds_alternative<double>(value)) {
-      eventObject.setProperty(*runtime_, name, get<double>(value));
-    } else if (holds_alternative<float>(value)) {
-      eventObject.setProperty(*runtime_, name, get<float>(value));
-    } else if (holds_alternative<bool>(value)) {
-      eventObject.setProperty(*runtime_, name, get<bool>(value));
-    } else if (holds_alternative<std::string>(value)) {
-      eventObject.setProperty(*runtime_, name, get<std::string>(value));
-    } else if (holds_alternative<std::shared_ptr<jsi::HostObject>>(value)) {
+    if (std::holds_alternative<int>(value)) {
+      eventObject.setProperty(*runtime_, name, std::get<int>(value));
+    } else if (std::holds_alternative<double>(value)) {
+      eventObject.setProperty(*runtime_, name, std::get<double>(value));
+    } else if (std::holds_alternative<float>(value)) {
+      eventObject.setProperty(*runtime_, name, std::get<float>(value));
+    } else if (std::holds_alternative<bool>(value)) {
+      eventObject.setProperty(*runtime_, name, std::get<bool>(value));
+    } else if (std::holds_alternative<std::string>(value)) {
+      eventObject.setProperty(*runtime_, name, std::get<std::string>(value));
+    } else if (std::holds_alternative<std::shared_ptr<jsi::HostObject>>(
+                   value)) {
       auto hostObject = jsi::Object::createFromHostObject(
-          *runtime_, get<std::shared_ptr<jsi::HostObject>>(value));
+          *runtime_, std::get<std::shared_ptr<jsi::HostObject>>(value));
       eventObject.setProperty(*runtime_, name, hostObject);
     }
   }

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.h

@@ -2,31 +2,35 @@
 
 #include <jsi/jsi.h>
 #include <ReactCommon/CallInvoker.h>
+#include <audioapi/events/IAudioEventHandlerRegistry.h>
 #include <memory>
 #include <unordered_map>
 #include <array>
 #include <string>
 #include <variant>
+#include <atomic>
 
 namespace audioapi {
 using namespace facebook;
 
 using EventValue = std::variant<int, float, double, std::string, bool, std::shared_ptr<jsi::HostObject>>;
 
-class AudioEventHandlerRegistry {
+class AudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
  public:
   explicit AudioEventHandlerRegistry(
       jsi::Runtime *runtime,
       const std::shared_ptr<react::CallInvoker> &callInvoker);
   ~AudioEventHandlerRegistry();
 
-  uint64_t registerHandler(const std::string &eventName, const std::shared_ptr<jsi::Function> &handler);
-  void unregisterHandler(const std::string &eventName, uint64_t listenerId);
+  uint64_t registerHandler(const std::string &eventName, const std::shared_ptr<jsi::Function> &handler) override;
+  void unregisterHandler(const std::string &eventName, uint64_t listenerId) override;
 
-  void invokeHandlerWithEventBody(const std::string &eventName, const std::unordered_map<std::string, EventValue> &body);
-  void invokeHandlerWithEventBody(const std::string &eventName, uint64_t listenerId, const std::unordered_map<std::string, EventValue> &body);
+  void invokeHandlerWithEventBody(const std::string &eventName, const std::unordered_map<std::string, EventValue> &body) override;
+  void invokeHandlerWithEventBody(const std::string &eventName, uint64_t listenerId, const std::unordered_map<std::string, EventValue> &body) override;
 
  private:
+    std::atomic<uint64_t> listenerIdCounter_{1}; // Atomic counter for listener IDs
+
     std::shared_ptr<react::CallInvoker> callInvoker_;
     jsi::Runtime *runtime_;
     std::unordered_map<std::string, std::unordered_map<uint64_t, std::shared_ptr<jsi::Function>>> eventHandlers_;

package/common/cpp/audioapi/events/IAudioEventHandlerRegistry.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <ReactCommon/CallInvoker.h>
+#include <unordered_map>
+#include <variant>
+#include <string>
+#include <memory>
+
+namespace audioapi {
+
+using EventValue = std::variant<int, float, double, std::string, bool, std::shared_ptr<facebook::jsi::HostObject>>;
+
+class IAudioEventHandlerRegistry {
+ public:
+  virtual ~IAudioEventHandlerRegistry() = default;
+
+  virtual uint64_t registerHandler(const std::string &eventName, const std::shared_ptr<facebook::jsi::Function> &handler) = 0;
+  virtual void unregisterHandler(const std::string &eventName, uint64_t listenerId) = 0;
+
+  virtual void invokeHandlerWithEventBody(const std::string &eventName, const std::unordered_map<std::string, EventValue> &body) = 0;
+  virtual void invokeHandlerWithEventBody(const std::string &eventName, uint64_t listenerId, const std::unordered_map<std::string, EventValue> &body) = 0;
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/jsi/JsiPromise.cpp

@@ -1,4 +1,5 @@
 #include <audioapi/jsi/JsiPromise.h>
+#include <stdexcept>
 
 namespace audioapi {
 

package/common/cpp/audioapi/utils/AudioArray.h

@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <memory>
 #include <cstddef>
+#include <cstring>
 
 namespace audioapi {
 

package/common/cpp/audioapi/utils/CircularAudioArray.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <audioapi/utils/AudioArray.h>
+#include <stdexcept>
 
 namespace audioapi {
 

package/common/cpp/test/CMakeLists.txt

@@ -0,0 +1,63 @@
+cmake_minimum_required(VERSION 3.14)
+project(rnaudioapi_test)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(ROOT ${CMAKE_SOURCE_DIR}/../../../../..)
+set(REACT_NATIVE_DIR "${ROOT}/node_modules/react-native")
+set(JSI_DIR "${REACT_NATIVE_DIR}/ReactCommon/jsi")
+
+include(FetchContent)
+FetchContent_Declare(
+  googletest
+  URL https://github.com/google/googletest/archive/3983f67e32fb3e9294487b9d4f9586efa6e5d088.zip
+)
+# For Windows: Prevent overriding the parent project's compiler/linker settings
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(googletest)
+
+enable_testing()
+
+file(GLOB_RECURSE RNAUDIOAPI_SRC
+  CONFIGURE_DEPENDS
+  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/*.cpp"
+  "${ROOT}/node_modules/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioDecoder.cpp"
+)
+
+list(REMOVE_ITEM RNAUDIOAPI_SRC "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp")
+
+file(GLOB_RECURSE RNAUDIOAPI_LIBS
+  CONFIGURE_DEPENDS
+  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/libs/*.c"
+  "${ROOT}/node_modules/react-native-audio-api/common/cpp/audioapi/libs/*.h"
+)
+
+add_library(rnaudioapi STATIC ${RNAUDIOAPI_SRC})
+add_library(rnaudioapi_libs STATIC ${RNAUDIOAPI_LIBS})
+
+target_include_directories(rnaudioapi PUBLIC
+  ${ROOT}/packages/react-native-audio-api/common/cpp
+  ${JSI_DIR}
+  "${REACT_NATIVE_DIR}/ReactCommon"
+  "${REACT_NATIVE_DIR}/ReactCommon/callinvoker"
+)
+
+target_include_directories(rnaudioapi_libs PUBLIC
+  ${ROOT}/packages/react-native-audio-api/common/cpp
+)
+
+add_executable(
+  tests
+  OscillatorTest.cpp
+  GainTest.cpp
+)
+
+target_link_libraries(tests
+  rnaudioapi
+  rnaudioapi_libs
+  GTest::gtest_main
+  GTest::gmock
+)
+
+include(GoogleTest)
+gtest_discover_tests(tests)

package/common/cpp/test/GainTest.cpp

@@ -0,0 +1,78 @@
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/effects/GainNode.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <gtest/gtest.h>
+#include "MockAudioEventHandlerRegistry.h"
+
+class GainTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<audioapi::IAudioEventHandlerRegistry> eventRegistry;
+  std::unique_ptr<audioapi::OfflineAudioContext> context;
+  static constexpr int sampleRate = 44100;
+
+  void SetUp() override {
+    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+    context = std::make_unique<audioapi::OfflineAudioContext>(
+        2, 5 * sampleRate, sampleRate, eventRegistry);
+  }
+};
+
+class TestableGainNode : public audioapi::GainNode {
+ public:
+  explicit TestableGainNode(audioapi::BaseAudioContext *context)
+      : audioapi::GainNode(context) {}
+
+  void setGainParam(float value) {
+    getGainParam()->setValue(value);
+  }
+
+  void processNode(
+      const std::shared_ptr<audioapi::AudioBus> &processingBus,
+      int framesToProcess) override {
+    audioapi::GainNode::processNode(processingBus, framesToProcess);
+  }
+};
+
+TEST_F(GainTest, GainCanBeCreated) {
+  auto gain = context->createGain();
+  ASSERT_NE(gain, nullptr);
+}
+
+TEST_F(GainTest, GainModulatesVolumeCorrectly) {
+  static constexpr float GAIN_VALUE = 0.5f;
+  static constexpr int FRAMES_TO_PROCESS = 4;
+  auto gainNode = std::make_shared<TestableGainNode>(context.get());
+  gainNode->setGainParam(GAIN_VALUE);
+
+  auto bus =
+      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
+  for (size_t i = 0; i < bus->getSize(); ++i) {
+    bus->getChannel(0)->getData()[i] = i + 1;
+  }
+
+  gainNode->processNode(bus, FRAMES_TO_PROCESS);
+  for (size_t i = 0; i < bus->getSize(); ++i) {
+    EXPECT_FLOAT_EQ((*bus->getChannel(0))[i], (i + 1) * GAIN_VALUE);
+  }
+}
+
+TEST_F(GainTest, GainModulatesVolumeCorrectlyMultiChannel) {
+  static constexpr float GAIN_VALUE = 0.5f;
+  static constexpr int FRAMES_TO_PROCESS = 4;
+  auto gainNode = std::make_shared<TestableGainNode>(context.get());
+  gainNode->setGainParam(GAIN_VALUE);
+
+  auto bus =
+      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 2, sampleRate);
+  for (size_t i = 0; i < bus->getSize(); ++i) {
+    bus->getChannel(0)->getData()[i] = i + 1;
+    bus->getChannel(1)->getData()[i] = -i - 1;
+  }
+
+  gainNode->processNode(bus, FRAMES_TO_PROCESS);
+  for (size_t i = 0; i < bus->getSize(); ++i) {
+    EXPECT_FLOAT_EQ((*bus->getChannel(0))[i], (i + 1) * GAIN_VALUE);
+    EXPECT_FLOAT_EQ((*bus->getChannel(1))[i], (-i - 1) * GAIN_VALUE);
+  }
+}