refactor: naming, header includes

Author: closetcaiman

packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.cpp

@@ -1,11 +1,11 @@
-#include "audioapi/HostObjects/AudioParamHostObject.h"
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/core/utils/param/ParamEvent.h>
+#include <audioapi/jsi/JsiHostObject.h>
+#include <audioapi/utils/AudioArray.hpp>
 #include <memory>
 #include <string>
 #include <utility>
-#include "audioapi/core/AudioParam.h"
-#include "audioapi/core/utils/automation/AutomationEvent.h"
-#include "audioapi/jsi/JsiHostObject.h"
-#include "audioapi/utils/AudioArray.hpp"
 
 namespace audioapi {
 
@@ -60,7 +60,7 @@ JSI_PROPERTY_SETTER_IMPL(AudioParamHostObject, value) {
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setValueAtTime) {
   auto startTime = args[1].getNumber();
   controlQueue_.purge(param_->getCurrentTime());
-  controlQueue_.push(AutomationEvent(AutomationEventType::SET_VALUE, startTime));
+  controlQueue_.push(ParamEvent(ParamEventType::SET_VALUE, startTime));
 
   auto event = [param = param_, value = static_cast<float>(args[0].getNumber()), startTime](
                    BaseAudioContext &) {
@@ -74,7 +74,7 @@ JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setValueAtTime) {
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, linearRampToValueAtTime) {
   auto endTime = args[1].getNumber();
   controlQueue_.purge(param_->getCurrentTime());
-  controlQueue_.push(AutomationEvent(AutomationEventType::LINEAR_RAMP, endTime));
+  controlQueue_.push(ParamEvent(ParamEventType::LINEAR_RAMP, endTime));
 
   auto event = [param = param_, value = static_cast<float>(args[0].getNumber()), endTime](
                    BaseAudioContext &) {
@@ -88,7 +88,7 @@ JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, linearRampToValueAtTime) {
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, exponentialRampToValueAtTime) {
   auto endTime = args[1].getNumber();
   controlQueue_.purge(param_->getCurrentTime());
-  controlQueue_.push(AutomationEvent(AutomationEventType::EXPONENTIAL_RAMP, endTime));
+  controlQueue_.push(ParamEvent(ParamEventType::EXPONENTIAL_RAMP, endTime));
 
   auto event = [param = param_, value = static_cast<float>(args[0].getNumber()), endTime](
                    BaseAudioContext &) {
@@ -102,7 +102,7 @@ JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, exponentialRampToValueAtTime) {
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setTargetAtTime) {
   auto startTime = args[1].getNumber();
   controlQueue_.purge(param_->getCurrentTime());
-  controlQueue_.push(AutomationEvent(AutomationEventType::SET_TARGET, startTime));
+  controlQueue_.push(ParamEvent(ParamEventType::SET_TARGET, startTime));
 
   auto event = [param = param_,
                 target = static_cast<float>(args[0].getNumber()),
@@ -119,8 +119,7 @@ JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setValueCurveAtTime) {
   auto startTime = args[1].getNumber();
   auto duration = args[2].getNumber();
   controlQueue_.purge(param_->getCurrentTime());
-  controlQueue_.push(
-      AutomationEvent(AutomationEventType::SET_VALUE_CURVE, startTime, startTime + duration));
+  controlQueue_.push(ParamEvent(ParamEventType::SET_VALUE_CURVE, startTime, startTime + duration));
 
   auto arrayBuffer =
       args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
@@ -181,15 +180,15 @@ Result<NoneType, std::string> AudioParamHostObject::checkCurveExclusionFromJSI(
     jsi::Runtime &runtime,
     const jsi::Value *args) {
   auto arg = args[0].getObject(runtime);
-  auto type = static_cast<AutomationEventType>(arg.getProperty(runtime, "type").getNumber());
+  auto type = static_cast<ParamEventType>(arg.getProperty(runtime, "type").getNumber());
   auto automationTime = arg.getProperty(runtime, "automationTime").getNumber();
 
-  AutomationEvent event;
-  if (type == AutomationEventType::SET_VALUE_CURVE) {
+  ParamEvent event;
+  if (type == ParamEventType::SET_VALUE_CURVE) {
     auto duration = arg.getProperty(runtime, "duration").getNumber();
-    event = AutomationEvent(type, automationTime, automationTime + duration);
+    event = ParamEvent(type, automationTime, automationTime + duration);
   } else {
-    event = AutomationEvent(type, automationTime);
+    event = ParamEvent(type, automationTime);
   }
 
   return controlQueue_.checkCurveExclusion(event);

packages/react-native-audio-api/common/cpp/audioapi/HostObjects/AudioParamHostObject.h

@@ -1,12 +1,12 @@
 #pragma once
 
+#include <audioapi/core/utils/param/ParamControlQueue.h>
+#include <audioapi/jsi/JsiHostObject.h>
+#include <audioapi/utils/Result.hpp>
 #include <jsi/jsi.h>
 #include <cstddef>
 #include <memory>
 #include <string>
-#include "audioapi/core/utils/automation/AutomationControlQueue.h"
-#include "audioapi/jsi/JsiHostObject.h"
-#include "audioapi/utils/Result.hpp"
 
 namespace audioapi {
 using namespace facebook;
@@ -37,7 +37,7 @@ class AudioParamHostObject : public JsiHostObject {
   friend class AudioNodeHostObject;
 
   std::shared_ptr<AudioParam> param_;
-  AutomationControlQueue controlQueue_;
+  ParamControlQueue controlQueue_;
   float defaultValue_;
   float minValue_;
   float maxValue_;

packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.cpp

@@ -1,11 +1,11 @@
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/utils/param/ParamRenderEventFactory.hpp>
 #include <audioapi/dsp/AudioUtils.hpp>
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/utils/AudioArray.hpp>
 #include <memory>
 #include <utility>
-#include "audioapi/core/utils/automation/AutomationRenderEventFactory.hpp"
 
 namespace audioapi {
 
@@ -36,20 +36,19 @@ float AudioParam::getValueAtTime(double time) {
 }
 
 void AudioParam::setValueAtTime(float value, double startTime) {
-  this->updateQueue(AutomationRenderEventFactory::createSetValueEvent(value, startTime));
+  this->updateQueue(ParamRenderEventFactory::createSetValueEvent(value, startTime));
 }
 
 void AudioParam::linearRampToValueAtTime(float value, double endTime) {
-  this->updateQueue(AutomationRenderEventFactory::createLinearRampEvent(value, endTime));
+  this->updateQueue(ParamRenderEventFactory::createLinearRampEvent(value, endTime));
 }
 
 void AudioParam::exponentialRampToValueAtTime(float value, double endTime) {
-  this->updateQueue(AutomationRenderEventFactory::createExponentialRampEvent(value, endTime));
+  this->updateQueue(ParamRenderEventFactory::createExponentialRampEvent(value, endTime));
 }
 
 void AudioParam::setTargetAtTime(float target, double startTime, double timeConstant) {
-  this->updateQueue(
-      AutomationRenderEventFactory::createSetTargetEvent(target, startTime, timeConstant));
+  this->updateQueue(ParamRenderEventFactory::createSetTargetEvent(target, startTime, timeConstant));
 }
 
 void AudioParam::setValueCurveAtTime(
@@ -58,7 +57,7 @@ void AudioParam::setValueCurveAtTime(
     double startTime,
     double duration) {
   this->updateQueue(
-      AutomationRenderEventFactory::createSetValueCurveEvent(values, length, startTime, duration));
+      ParamRenderEventFactory::createSetValueCurveEvent(values, length, startTime, duration));
 }
 
 void AudioParam::cancelScheduledValues(double cancelTime) {

packages/react-native-audio-api/common/cpp/audioapi/core/AudioParam.h

@@ -2,9 +2,9 @@
 
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/types/AutomationEventType.h>
-#include <audioapi/core/utils/automation/AutomationRenderQueue.h>
-#include <audioapi/core/utils/automation/RenderAutomationEvent.hpp>
+#include <audioapi/core/types/ParamEventType.h>
+#include <audioapi/core/utils/param/ParamRenderQueue.h>
+#include <audioapi/core/utils/param/RenderParamEvent.h>
 #include <audioapi/utils/AudioBuffer.hpp>
 
 #include <audioapi/utils/CrossThreadEventScheduler.hpp>
@@ -110,7 +110,7 @@ class AudioParam {
   float minValue_;
   float maxValue_;
 
-  AutomationRenderQueue eventRenderQueue_;
+  ParamRenderQueue eventRenderQueue_;
 
   // Input modulation system
   std::vector<AudioNode *> inputNodes_;
@@ -121,7 +121,7 @@ class AudioParam {
   /// @param event The new event to add to the queue.
   /// @note Resolves the event's startValue and startTime based on neighboring events,
   // and adjusts neighboring events to maintain the invariant of non-overlapping events in the queue.
-  void updateQueue(RenderAutomationEvent &&event) {
+  void updateQueue(RenderParamEvent &&event) {
     eventRenderQueue_.push(std::move(event));
   }
 

…udioapi/core/types/AutomationEventType.h …cpp/audioapi/core/types/ParamEventType.hpackages/react-native-audio-api/common/cpp/audioapi/core/types/AutomationEventType.h renamed to packages/react-native-audio-api/common/cpp/audioapi/core/types/ParamEventType.h packages/react-native-audio-api/common/cpp/audioapi/core/types/AutomationEventType.h renamed to packages/react-native-audio-api/common/cpp/audioapi/core/types/ParamEventType.h

@@ -4,25 +4,25 @@
 #include <string_view>
 namespace audioapi {
 
-enum class AutomationEventType : uint8_t {
+enum class ParamEventType : uint8_t {
   LINEAR_RAMP,
   EXPONENTIAL_RAMP,
   SET_VALUE,
   SET_TARGET,
   SET_VALUE_CURVE,
 };
 
-inline std::string_view toString(AutomationEventType type) {
+inline std::string_view toString(ParamEventType type) {
   switch (type) {
-    case AutomationEventType::LINEAR_RAMP:
+    case ParamEventType::LINEAR_RAMP:
       return "LinearRampToValueAtTime";
-    case AutomationEventType::EXPONENTIAL_RAMP:
+    case ParamEventType::EXPONENTIAL_RAMP:
       return "ExponentialRampToValueAtTime";
-    case AutomationEventType::SET_VALUE:
+    case ParamEventType::SET_VALUE:
       return "SetValueAtTime";
-    case AutomationEventType::SET_TARGET:
+    case ParamEventType::SET_TARGET:
       return "SetTargetAtTime";
-    case AutomationEventType::SET_VALUE_CURVE:
+    case ParamEventType::SET_VALUE_CURVE:
       return "SetValueCurveAtTime";
   }
   return "Unknown";

packages/react-native-audio-api/common/cpp/audioapi/core/utils/automation/AutomationControlQueue.h

@@ -1,34 +1,33 @@
-#include "audioapi/core/utils/automation/AutomationControlQueue.h"
+#include <audioapi/core/types/ParamEventType.h>
+#include <audioapi/core/utils/param/ParamControlQueue.h>
+#include <audioapi/core/utils/param/ParamEvent.h>
+#include <audioapi/utils/Result.hpp>
 #include <cstddef>
 #include <sstream>
-#include "audioapi/core/types/AutomationEventType.h"
-#include "audioapi/core/utils/automation/AutomationEvent.h"
-#include "audioapi/utils/Result.hpp"
 
 namespace audioapi {
 
-EventConflictResult AutomationControlQueue::checkCurveExclusion(const AutomationEvent &event) {
-  if (event.getType() == AutomationEventType::SET_VALUE_CURVE) {
+EventConflictResult ParamControlQueue::checkCurveExclusion(const ParamEvent &event) {
+  if (event.getType() == ParamEventType::SET_VALUE_CURVE) {
     // For curve events, check for any event that occurs at or within the curve's time interval
     return isConflictInInterval(event, event.getStartTime(), event.getEndTime());
   }
   // For non-curve events check for curve events that conflict at the event's automationTime
   return isConflictAtTime(event, event.getAutomationTime());
 }
 
-void AutomationControlQueue::purge(double currentTime) {
+void ParamControlQueue::purge(double currentTime) {
   eventQueue_.erase(eventQueue_.begin(), eventQueue_.lowerBound(currentTime));
 }
 
-EventConflictResult AutomationControlQueue::isConflictAtTime(
-    const AutomationEvent &newEvent,
+EventConflictResult ParamControlQueue::isConflictAtTime(
+    const ParamEvent &newEvent,
     double automationTime) {
   // Check if a SET_VALUE_CURVE that starts before automationTime extends into it
   auto it = eventQueue_.upperBound(automationTime);
   if (it != eventQueue_.begin()) {
     const auto &pred = *std::prev(it);
-    if (pred.getType() == AutomationEventType::SET_VALUE_CURVE &&
-        automationTime < pred.getEndTime()) {
+    if (pred.getType() == ParamEventType::SET_VALUE_CURVE && automationTime < pred.getEndTime()) {
       std::stringstream ss;
       ss << "Cannot schedule event of type " << toString(newEvent.getType()) << " at time "
          << newEvent.getAutomationTime()
@@ -40,12 +39,12 @@ EventConflictResult AutomationControlQueue::isConflictAtTime(
   return Ok(None);
 }
 
-EventConflictResult AutomationControlQueue::isConflictInInterval(
-    const AutomationEvent &newEvent,
+EventConflictResult ParamControlQueue::isConflictInInterval(
+    const ParamEvent &newEvent,
     double startTime,
     double endTime) {
   // Non-ramp events have automationTime == startTime, so lowerBound/lowerBound brackets them.
-  // Ramp events have startTime == 0 (unresolved on the control thread), so getStartTime() >= startTime
+  // Ramp events have startTime == 0 (unresolved on the control thread), so getStartTime() > startTime
   // filters them out.
   for (auto it = eventQueue_.lowerBound(startTime), hi = eventQueue_.lowerBound(endTime); it != hi;
        ++it) {

…ls/automation/AutomationControlQueue.cpp …i/core/utils/param/ParamControlQueue.cpppackages/react-native-audio-api/common/cpp/audioapi/core/utils/automation/AutomationControlQueue.cpp renamed to packages/react-native-audio-api/common/cpp/audioapi/core/utils/param/ParamControlQueue.cpp packages/react-native-audio-api/common/cpp/audioapi/core/utils/automation/AutomationControlQueue.cpp renamed to packages/react-native-audio-api/common/cpp/audioapi/core/utils/param/ParamControlQueue.cpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <audioapi/core/utils/param/ParamEvent.h>
+#include <audioapi/core/utils/param/ParamQueueBase.hpp>
+#include <audioapi/utils/Result.hpp>
+#include <string>
+
+namespace audioapi {
+
+using EventConflictResult = Result<NoneType, std::string>;
+
+/// @brief A queue for managing audio parameter change events on the JS/control thread.
+/// @note The invariant of the queue is that its internal buffer always contains non-overlapping events.
+class ParamControlQueue : public ParamQueueBase<ParamEvent> {
+ public:
+  /// @brief Validate if a new event can be added to the queue without violating curve exclusion rules.
+  /// See: https://webaudio.github.io/web-audio-api/#automation-event-time
+  /// @param event The new event to validate.
+  /// @return Ok if the event can be added, Err with a message if it cannot be added.
+  [[nodiscard]] EventConflictResult checkCurveExclusion(const ParamEvent &event);
+
+  /// @brief Remove all events with automationTime strictly before currentTime.
+  /// @note Should be called before push to prevent the queue from filling up with past events.
+  void purge(double currentTime);
+
+ private:
+  /// @brief Check if a non-curve event at the given time conflicts with an existing curve event.
+  /// @param event The new event being scheduled.
+  /// @param time The automationTime of the new event.
+  [[nodiscard]] EventConflictResult isConflictAtTime(const ParamEvent &event, double time);
+
+  /// @brief Check if a curve event over [startTime, endTime) conflicts with any existing event.
+  /// @param event The new curve event being scheduled.
+  /// @param startTime Start of the curve interval.
+  /// @param endTime End of the curve interval.
+  [[nodiscard]] EventConflictResult
+  isConflictInInterval(const ParamEvent &event, double startTime, double endTime);
+};
+
+} // namespace audioapi