react-native-audio-api 0.11.0-alpha.0 → 0.11.0-alpha.10

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

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <audioapi/utils/Result.hpp>
+#include <atomic>
+#include <memory>
+#include <string>
+#include <tuple>
+
+namespace audioapi {
+
+class AudioFileProperties;
+class AudioEventHandlerRegistry;
+
+typedef Result<std::string, std::string> OpenFileResult;
+typedef Result<std::tuple<double, double>, std::string> CloseFileResult;
+
+class AudioFileWriter {
+ public:
+  AudioFileWriter(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioFileProperties> &fileProperties);
+  virtual ~AudioFileWriter() = default;
+
+  virtual CloseFileResult closeFile() = 0;
+
+  virtual std::string getFilePath() const = 0;
+  virtual double getCurrentDuration() const = 0;
+
+  void setOnErrorCallback(uint64_t callbackId);
+  void clearOnErrorCallback();
+  void invokeOnErrorCallback(const std::string &message);
+
+ protected:
+  bool isFileOpen();
+
+  std::atomic<bool> isFileOpen_{false};
+  std::atomic<size_t> framesWritten_{0};
+  std::atomic<uint64_t> errorCallbackId_{0};
+
+  std::shared_ptr<AudioFileProperties> fileProperties_;
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+};
+
+} // namespace audioapi

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

@@ -1,6 +1,8 @@
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/utils/AudioNodeDestructor.h>
 #include <audioapi/core/utils/Locker.h>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
@@ -11,8 +13,7 @@ AudioNodeDestructor::AudioNodeDestructor() {
       channels::spsc::OverflowStrategy::WAIT_ON_FULL,
       channels::spsc::WaitStrategy::ATOMIC_WAIT>(kChannelCapacity);
   sender_ = std::move(sender);
-  workerHandle_ =
-      std::thread(&AudioNodeDestructor::process, this, std::move(receiver));
+  workerHandle_ = std::thread(&AudioNodeDestructor::process, this, std::move(receiver));
 }
 
 AudioNodeDestructor::~AudioNodeDestructor() {
@@ -25,10 +26,8 @@ AudioNodeDestructor::~AudioNodeDestructor() {
   }
 }
 
-bool AudioNodeDestructor::tryAddNodeForDeconstruction(
-    std::shared_ptr<AudioNode> &&node) {
-  return sender_.try_send(std::move(node)) ==
-      channels::spsc::ResponseStatus::SUCCESS;
+bool AudioNodeDestructor::tryAddNodeForDeconstruction(std::shared_ptr<AudioNode> &&node) {
+  return sender_.try_send(std::move(node)) == channels::spsc::ResponseStatus::SUCCESS;
 }
 
 void AudioNodeDestructor::process(

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

@@ -1,19 +1,18 @@
 #pragma once
 
-#include <thread>
+#include <audioapi/utils/SpscChannel.hpp>
 #include <atomic>
-#include <vector>
 #include <memory>
-#include <audioapi/utils/SpscChannel.hpp>
+#include <thread>
+#include <vector>
 
 namespace audioapi {
 
 class AudioNode;
 
 #define AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS \
-  std::shared_ptr<AudioNode>, \
-  channels::spsc::OverflowStrategy::WAIT_ON_FULL, \
-  channels::spsc::WaitStrategy::ATOMIC_WAIT
+  std::shared_ptr<AudioNode>, channels::spsc::OverflowStrategy::WAIT_ON_FULL, \
+      channels::spsc::WaitStrategy::ATOMIC_WAIT
 
 class AudioNodeDestructor {
  public:
@@ -32,13 +31,11 @@ class AudioNodeDestructor {
   std::thread workerHandle_;
   std::atomic<bool> isExiting_;
 
-  channels::spsc::Sender<
-    AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS> sender_;
+  channels::spsc::Sender<AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS> sender_;
 
   /// @brief Processes audio nodes for deconstruction.
   /// @param receiver The receiver channel for incoming audio nodes.
-  void process(channels::spsc::Receiver<
-    AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS> &&receiver);
+  void process(channels::spsc::Receiver<AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS> &&receiver);
 };
 
 #undef AUDIO_NODE_DESTRUCTOR_SPSC_OPTIONS

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

@@ -1,8 +1,13 @@
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/AudioParam.h>
+#include <audioapi/core/effects/ConvolverNode.h>
+#include <audioapi/core/effects/DelayNode.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/core/utils/Locker.h>
+#include <memory>
+#include <utility>
+#include <vector>
 
 namespace audioapi {
 
@@ -116,8 +121,7 @@ void AudioNodeManager::preProcessGraph() {
   prepareNodesForDestruction(processingNodes_);
 }
 
-void AudioNodeManager::addProcessingNode(
-    const std::shared_ptr<AudioNode> &node) {
+void AudioNodeManager::addProcessingNode(const std::shared_ptr<AudioNode> &node) {
   auto event = std::make_unique<Event>();
   event->type = ConnectionType::ADD;
   event->payloadType = EventPayloadType::NODE;
@@ -126,8 +130,7 @@ void AudioNodeManager::addProcessingNode(
   sender_.send(std::move(event));
 }
 
-void AudioNodeManager::addSourceNode(
-    const std::shared_ptr<AudioScheduledSourceNode> &node) {
+void AudioNodeManager::addSourceNode(const std::shared_ptr<AudioScheduledSourceNode> &node) {
   auto event = std::make_unique<Event>();
   event->type = ConnectionType::ADD;
   event->payloadType = EventPayloadType::SOURCE_NODE;
@@ -147,8 +150,7 @@ void AudioNodeManager::addAudioParam(const std::shared_ptr<AudioParam> &param) {
 
 void AudioNodeManager::settlePendingConnections() {
   std::unique_ptr<Event> value;
-  while (receiver_.try_receive(value) !=
-         channels::spsc::ResponseStatus::CHANNEL_EMPTY) {
+  while (receiver_.try_receive(value) != channels::spsc::ResponseStatus::CHANNEL_EMPTY) {
     switch (value->type) {
       case ConnectionType::CONNECT:
         handleConnectEvent(std::move(value));
@@ -196,8 +198,7 @@ void AudioNodeManager::handleDisconnectAllEvent(std::unique_ptr<Event> event) {
   }
 }
 
-void AudioNodeManager::handleAddToDeconstructionEvent(
-    std::unique_ptr<Event> event) {
+void AudioNodeManager::handleAddToDeconstructionEvent(std::unique_ptr<Event> event) {
   switch (event->payloadType) {
     case EventPayloadType::NODE:
       processingNodes_.push_back(event->payload.node);
@@ -214,20 +215,20 @@ void AudioNodeManager::handleAddToDeconstructionEvent(
 }
 
 template <typename U>
-inline bool AudioNodeManager::nodeCanBeDestructed(
-    std::shared_ptr<U> const &node) {
+inline bool AudioNodeManager::nodeCanBeDestructed(std::shared_ptr<U> const &node) {
   // If the node is an AudioScheduledSourceNode, we need to check if it is
   // playing
   if constexpr (std::is_base_of_v<AudioScheduledSourceNode, U>) {
-    return node.use_count() == 1 &&
-        (node->isUnscheduled() || node->isFinished());
+    return node.use_count() == 1 && (node->isUnscheduled() || node->isFinished());
+  } else if (node->requiresTailProcessing()) {
+    // if the node requires tail processing, its own implementation handles disabling it at the right time
+    return node.use_count() == 1 && !node->isEnabled();
   }
   return node.use_count() == 1;
 }
 
 template <typename U>
-void AudioNodeManager::prepareNodesForDestruction(
-    std::vector<std::shared_ptr<U>> &vec) {
+void AudioNodeManager::prepareNodesForDestruction(std::vector<std::shared_ptr<U>> &vec) {
   if (vec.empty()) {
     return;
   }
@@ -279,14 +280,11 @@ void AudioNodeManager::prepareNodesForDestruction(
 }
 
 void AudioNodeManager::cleanup() {
-  for (auto it = sourceNodes_.begin(), end = sourceNodes_.end(); it != end;
-       ++it) {
+  for (auto it = sourceNodes_.begin(), end = sourceNodes_.end(); it != end; ++it) {
     it->get()->cleanup();
   }
 
-  for (auto it = processingNodes_.begin(), end = processingNodes_.end();
-       it != end;
-       ++it) {
+  for (auto it = processingNodes_.begin(), end = processingNodes_.end(); it != end; ++it) {
     it->get()->cleanup();
   }
 

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

@@ -16,9 +16,8 @@ class AudioScheduledSourceNode;
 class AudioParam;
 
 #define AUDIO_NODE_MANAGER_SPSC_OPTIONS \
-  std::unique_ptr<Event>, \
-  channels::spsc::OverflowStrategy::WAIT_ON_FULL, \
-  channels::spsc::WaitStrategy::BUSY_LOOP
+  std::unique_ptr<Event>, channels::spsc::OverflowStrategy::WAIT_ON_FULL, \
+      channels::spsc::WaitStrategy::BUSY_LOOP
 
 class AudioNodeManager {
  public:
@@ -49,8 +48,8 @@ class AudioNodeManager {
     EventPayloadType payloadType;
     EventPayload payload;
 
-    Event(Event&& other);
-    Event& operator=(Event&& other);
+    Event(Event &&other);
+    Event &operator=(Event &&other);
     Event() : type(ConnectionType::CONNECT), payloadType(EventPayloadType::NODES), payload() {}
     ~Event();
   };
@@ -78,7 +77,7 @@ class AudioNodeManager {
   void addPendingParamConnection(
       const std::shared_ptr<AudioNode> &from,
       const std::shared_ptr<AudioParam> &to,
-    ConnectionType type);
+      ConnectionType type);
 
   /// @brief Adds a processing node to the manager.
   /// @param node The processing node to add.
@@ -112,11 +111,9 @@ class AudioNodeManager {
   std::vector<std::shared_ptr<AudioNode>> processingNodes_;
   std::vector<std::shared_ptr<AudioParam>> audioParams_;
 
-  channels::spsc::Receiver<
-    AUDIO_NODE_MANAGER_SPSC_OPTIONS> receiver_;
+  channels::spsc::Receiver<AUDIO_NODE_MANAGER_SPSC_OPTIONS> receiver_;
 
-  channels::spsc::Sender<
-    AUDIO_NODE_MANAGER_SPSC_OPTIONS> sender_;
+  channels::spsc::Sender<AUDIO_NODE_MANAGER_SPSC_OPTIONS> sender_;
 
   void settlePendingConnections();
   void handleConnectEvent(std::unique_ptr<Event> event);
@@ -128,7 +125,7 @@ class AudioNodeManager {
   void prepareNodesForDestruction(std::vector<std::shared_ptr<U>> &vec);
 
   template <typename U>
-  inline static bool nodeCanBeDestructed(std::shared_ptr<U> const& node);
+  inline static bool nodeCanBeDestructed(std::shared_ptr<U> const &node);
 };
 
 #undef AUDIO_NODE_MANAGER_SPSC_OPTIONS

package/common/cpp/audioapi/core/utils/AudioParamEventQueue.cpp

@@ -1,4 +1,6 @@
 #include <audioapi/core/utils/AudioParamEventQueue.h>
+#include <algorithm>
+#include <utility>
 
 namespace audioapi {
 
@@ -42,9 +44,7 @@ void AudioParamEventQueue::cancelScheduledValues(double cancelTime) {
   }
 }
 
-void AudioParamEventQueue::cancelAndHoldAtTime(
-    double cancelTime,
-    double &endTimeCache) {
+void AudioParamEventQueue::cancelAndHoldAtTime(double cancelTime, double &endTimeCache) {
   while (!eventQueue_.isEmpty()) {
     auto &back = eventQueue_.peekBack();
     if (back.getEndTime() < cancelTime || back.getStartTime() <= cancelTime) {

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

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <audioapi/core/utils/ParamChangeEvent.h>
 #include <audioapi/core/types/ParamChangeEventType.h>
+#include <audioapi/core/utils/ParamChangeEvent.h>
 #include <audioapi/utils/RingBiDirectionalBuffer.hpp>
 
 namespace audioapi {
@@ -16,7 +16,7 @@ class AudioParamEventQueue {
 
   /// @brief Push a new event to the back of the queue.
   /// @note Handles connecting the start value of the new event to the end value of the last event in the queue.
-  void pushBack(ParamChangeEvent&& event);
+  void pushBack(ParamChangeEvent &&event);
 
   /// @brief Pop the front event from the queue.
   /// @return The front event in the queue.
@@ -28,17 +28,17 @@ class AudioParamEventQueue {
 
   /// @brief Cancel scheduled parameter changes and hold the current value at the given time.
   /// @param cancelTime The time at which to cancel scheduled changes.
-  void cancelAndHoldAtTime(double cancelTime, double& endTimeCache);
+  void cancelAndHoldAtTime(double cancelTime, double &endTimeCache);
 
   /// @brief Get the first event in the queue.
   /// @return The first event in the queue.
-  inline const ParamChangeEvent& front() const noexcept {
+  inline const ParamChangeEvent &front() const noexcept {
     return eventQueue_.peekFront();
   }
 
   /// @brief Get the last event in the queue.
   /// @return The last event in the queue.
-  inline const ParamChangeEvent& back() const noexcept {
+  inline const ParamChangeEvent &back() const noexcept {
     return eventQueue_.peekBack();
   }
 

package/common/cpp/audioapi/core/utils/AudioRecorderCallback.cpp

@@ -0,0 +1,101 @@
+
+#include <audioapi/core/utils/AudioRecorderCallback.h>
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/CircularAudioArray.h>
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace audioapi {
+
+/// @brief Constructor
+/// Allocates circular buffer (as every property to do so is already known at this point).
+/// @param audioEventHandlerRegistry The audio event handler registry
+/// @param sampleRate The user desired sample rate
+/// @param bufferLength The user desired buffer length
+/// @param channelCount The user desired channel count
+/// @param callbackId The callback identifier
+AudioRecorderCallback::AudioRecorderCallback(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    float sampleRate,
+    size_t bufferLength,
+    int channelCount,
+    uint64_t callbackId)
+    : sampleRate_(sampleRate),
+      bufferLength_(bufferLength),
+      channelCount_(channelCount),
+      callbackId_(callbackId),
+      audioEventHandlerRegistry_(audioEventHandlerRegistry) {
+  ringBufferSize_ = std::max(bufferLength * 2, static_cast<size_t>(8192));
+  circularBus_.resize(channelCount_);
+
+  for (size_t i = 0; i < channelCount_; ++i) {
+    circularBus_[i] = std::make_shared<CircularAudioArray>(ringBufferSize_);
+  }
+
+  isInitialized_.store(true, std::memory_order_release);
+}
+
+AudioRecorderCallback::~AudioRecorderCallback() {
+  isInitialized_.store(false, std::memory_order_release);
+}
+
+/// @brief Emits audio data from the circular buffer when enough frames are available.
+/// @param flush If true, emits all available data regardless of buffer length.
+void AudioRecorderCallback::emitAudioData(bool flush) {
+  size_t sizeLimit = flush ? circularBus_[0]->getNumberOfAvailableFrames() : bufferLength_;
+
+  while (circularBus_[0]->getNumberOfAvailableFrames() >= sizeLimit) {
+    auto bus = std::make_shared<AudioBus>(sizeLimit, channelCount_, sampleRate_);
+
+    for (int i = 0; i < channelCount_; ++i) {
+      auto *outputChannel = bus->getChannel(i)->getData();
+      circularBus_[i]->pop_front(outputChannel, sizeLimit);
+    }
+
+    invokeCallback(bus, static_cast<int>(sizeLimit));
+  }
+}
+
+void AudioRecorderCallback::invokeCallback(const std::shared_ptr<AudioBus> &bus, int numFrames) {
+  auto audioBuffer = std::make_shared<AudioBuffer>(bus);
+  auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(audioBuffer);
+
+  std::unordered_map<std::string, EventValue> eventPayload = {};
+  eventPayload.insert({"buffer", audioBufferHostObject});
+  eventPayload.insert({"numFrames", numFrames});
+
+  if (audioEventHandlerRegistry_) {
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody("audioReady", callbackId_, eventPayload);
+  }
+}
+
+void AudioRecorderCallback::setOnErrorCallback(uint64_t callbackId) {
+  errorCallbackId_.store(callbackId, std::memory_order_release);
+}
+
+void AudioRecorderCallback::clearOnErrorCallback() {
+  errorCallbackId_.store(0, std::memory_order_release);
+}
+
+/// @brief Invokes the error callback with the provided message.
+/// @param message The error message to be sent to the callback.
+void AudioRecorderCallback::invokeOnErrorCallback(const std::string &message) {
+  uint64_t callbackId = errorCallbackId_.load(std::memory_order_acquire);
+
+  if (audioEventHandlerRegistry_ == nullptr || callbackId == 0) {
+    return;
+  }
+
+  std::unordered_map<std::string, EventValue> eventPayload = {};
+  eventPayload.insert({"message", message});
+  audioEventHandlerRegistry_->invokeHandlerWithEventBody("error", callbackId, eventPayload);
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <audioapi/utils/Result.hpp>
+#include <atomic>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+
+class AudioBus;
+class AudioArray;
+class CircularAudioArray;
+class AudioEventHandlerRegistry;
+
+class AudioRecorderCallback {
+ public:
+  AudioRecorderCallback(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      float sampleRate,
+      size_t bufferLength,
+      int channelCount,
+      uint64_t callbackId);
+  virtual ~AudioRecorderCallback();
+
+  virtual void cleanup() = 0;
+
+  void emitAudioData(bool flush = false);
+  void invokeCallback(const std::shared_ptr<AudioBus> &bus, int numFrames);
+
+  void setOnErrorCallback(uint64_t callbackId);
+  void clearOnErrorCallback();
+  void invokeOnErrorCallback(const std::string &message);
+
+ protected:
+  std::atomic<bool> isInitialized_{false};
+
+  float sampleRate_;
+  size_t bufferLength_;
+  int channelCount_;
+  uint64_t callbackId_;
+  size_t ringBufferSize_;
+
+  std::atomic<uint64_t> errorCallbackId_{0};
+
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+
+  // TODO: CircularAudioBus
+  std::vector<std::shared_ptr<CircularAudioArray>> circularBus_;
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioStretcher.cpp

@@ -5,6 +5,8 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <cstdint>
+#include <memory>
+#include <vector>
 
 namespace audioapi {
 
@@ -43,8 +45,8 @@ std::shared_ptr<AudioBuffer> AudioStretcher::changePlaybackSpeed(
       outputChannels,
       0x1);
 
-  int maxOutputFrames = stretch_output_capacity(
-      stretcher, static_cast<int>(numFrames), 1 / playbackSpeed);
+  int maxOutputFrames =
+      stretch_output_capacity(stretcher, static_cast<int>(numFrames), 1 / playbackSpeed);
   std::vector<int16_t> stretchedBuffer(maxOutputFrames * outputChannels);
 
   int outputFrames = stretch_samples(
@@ -54,13 +56,11 @@ std::shared_ptr<AudioBuffer> AudioStretcher::changePlaybackSpeed(
       stretchedBuffer.data(),
       1 / playbackSpeed);
 
-  outputFrames +=
-      stretch_flush(stretcher, stretchedBuffer.data() + (outputFrames));
+  outputFrames += stretch_flush(stretcher, stretchedBuffer.data() + (outputFrames));
   stretchedBuffer.resize(outputFrames * outputChannels);
   stretch_deinit(stretcher);
 
-  auto audioBus =
-      std::make_shared<AudioBus>(outputFrames, outputChannels, sampleRate);
+  auto audioBus = std::make_shared<AudioBus>(outputFrames, outputChannels, sampleRate);
 
   for (int ch = 0; ch < outputChannels; ++ch) {
     auto channelData = audioBus->getChannel(ch)->getData();

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

@@ -2,6 +2,7 @@
 
 #include <cmath>
 #include <limits>
+#include <numbers>
 
 // https://webaudio.github.io/web-audio-api/
 
@@ -9,17 +10,20 @@ namespace audioapi {
 // audio
 static constexpr int RENDER_QUANTUM_SIZE = 128;
 static constexpr size_t MAX_FFT_SIZE = 32768;
+static constexpr int MAX_CHANNEL_COUNT = 32;
 
 // stretcher
 static constexpr float UPPER_FREQUENCY_LIMIT_DETECTION = 333.0f;
 static constexpr float LOWER_FREQUENCY_LIMIT_DETECTION = 55.0f;
 
 // general
-static constexpr float MOST_POSITIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::max());
-static constexpr float MOST_NEGATIVE_SINGLE_FLOAT = static_cast<float>(std::numeric_limits<float>::lowest());
+static constexpr float MOST_POSITIVE_SINGLE_FLOAT =
+    static_cast<float>(std::numeric_limits<float>::max());
+static constexpr float MOST_NEGATIVE_SINGLE_FLOAT =
+    static_cast<float>(std::numeric_limits<float>::lowest());
 static float LOG2_MOST_POSITIVE_SINGLE_FLOAT = std::log2(MOST_POSITIVE_SINGLE_FLOAT);
 static float LOG10_MOST_POSITIVE_SINGLE_FLOAT = std::log10(MOST_POSITIVE_SINGLE_FLOAT);
-static constexpr float PI = static_cast<float>(M_PI);
+static constexpr float PI = std::numbers::pi_v<float>;
 
 // buffer sizes
 static constexpr size_t PROMISE_VENDOR_THREAD_POOL_WORKER_COUNT = 4;

package/common/cpp/audioapi/core/utils/ParamChangeEvent.cpp

@@ -1,4 +1,5 @@
 #include <audioapi/core/utils/ParamChangeEvent.h>
+#include <utility>
 
 namespace audioapi {
 

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

@@ -20,16 +20,16 @@ class ParamChangeEvent {
       ParamChangeEventType type);
 
   ParamChangeEvent(const ParamChangeEvent &other) = delete;
-  ParamChangeEvent& operator=(const ParamChangeEvent &other) = delete;
+  ParamChangeEvent &operator=(const ParamChangeEvent &other) = delete;
 
   explicit ParamChangeEvent(ParamChangeEvent &&other) noexcept
-    : startTime_(other.startTime_),
-      endTime_(other.endTime_),
-      calculateValue_(std::move(other.calculateValue_)),
-      startValue_(other.startValue_),
-      endValue_(other.endValue_),
-      type_(other.type_) {}
-  ParamChangeEvent& operator=(ParamChangeEvent &&other) noexcept {
+      : startTime_(other.startTime_),
+        endTime_(other.endTime_),
+        calculateValue_(std::move(other.calculateValue_)),
+        startValue_(other.startValue_),
+        endValue_(other.endValue_),
+        type_(other.type_) {}
+  ParamChangeEvent &operator=(ParamChangeEvent &&other) noexcept {
     if (this != &other) {
       startTime_ = other.startTime_;
       endTime_ = other.endTime_;
@@ -53,7 +53,7 @@ class ParamChangeEvent {
   [[nodiscard]] inline float getStartValue() const noexcept {
     return startValue_;
   }
-  [[nodiscard]] inline const std::function<float(double, double, float, float, double)>&
+  [[nodiscard]] inline const std::function<float(double, double, float, float, double)> &
   getCalculateValue() const noexcept {
     return calculateValue_;
   }