react-native-audio-api 0.6.2-rc.6 → 0.6.2

package/android/src/main/java/com/swmansion/audioapi/system/LockScreenManager.kt

@@ -13,6 +13,7 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.ReadableType
 import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper.Companion.instance
+import com.swmansion.audioapi.R
 import java.io.IOException
 import java.lang.ref.WeakReference
 import java.net.URL
@@ -182,6 +183,7 @@ class LockScreenManager(
     name: String,
     enabled: Boolean,
   ) {
+    pb = PlaybackStateCompat.Builder()
     var controlValue = 0L
     when (name) {
       "remotePlay" -> controlValue = PlaybackStateCompat.ACTION_PLAY
@@ -203,8 +205,31 @@ class LockScreenManager(
       }
 
     mediaNotificationManager.get()?.updateActions(controls)
+
+    if (hasControl(PlaybackStateCompat.ACTION_REWIND)) {
+      pb.addCustomAction(
+        PlaybackStateCompat.CustomAction
+          .Builder(
+            "SkipBackward",
+            "Skip Backward",
+            R.drawable.skip_backward_10,
+          ).build(),
+      )
+    }
+
     pb.setActions(controls)
 
+    if (hasControl(PlaybackStateCompat.ACTION_FAST_FORWARD)) {
+      pb.addCustomAction(
+        PlaybackStateCompat.CustomAction
+          .Builder(
+            "SkipForward",
+            "Skip Forward",
+            R.drawable.skip_forward_10,
+          ).build(),
+      )
+    }
+
     state = pb.build()
     mediaSession.get()?.setPlaybackState(state)
 

package/android/src/main/java/com/swmansion/audioapi/system/MediaSessionCallback.kt

@@ -2,7 +2,9 @@ package com.swmansion.audioapi.system
 
 import android.content.Intent
 import android.os.Build
+import android.os.Bundle
 import android.support.v4.media.session.MediaSessionCompat
+import android.util.Log
 import androidx.core.app.NotificationManagerCompat
 import com.swmansion.audioapi.AudioAPIModule
 import java.lang.ref.WeakReference
@@ -53,4 +55,15 @@ class MediaSessionCallback(
     val body = HashMap<String, Any>().apply { put("value", (pos.toDouble() / 1000)) }
     audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("remoteChangePlaybackPosition", body)
   }
+
+  override fun onCustomAction(
+    action: String?,
+    extras: Bundle?,
+  ) {
+    when (action) {
+      "SkipForward" -> onFastForward()
+      "SkipBackward" -> onRewind()
+      else -> Log.w("MediaSessionCallback", "Unknown custom action: $action")
+    }
+  }
 }

package/common/cpp/audioapi/HostObjects/AudioBufferBaseSourceNodeHostObject.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <audioapi/core/sources/AudioBufferBaseSourceNode.h>
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/HostObjects/AudioScheduledSourceNodeHostObject.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioBufferBaseSourceNodeHostObject
+        : public AudioScheduledSourceNodeHostObject {
+ public:
+    explicit AudioBufferBaseSourceNodeHostObject(
+            const std::shared_ptr<AudioBufferBaseSourceNode> &node)
+            : AudioScheduledSourceNodeHostObject(node) {
+        addGetters(
+                JSI_EXPORT_PROPERTY_GETTER(AudioBufferBaseSourceNodeHostObject, detune),
+                JSI_EXPORT_PROPERTY_GETTER(AudioBufferBaseSourceNodeHostObject, playbackRate));
+
+        addSetters(
+                JSI_EXPORT_PROPERTY_SETTER(AudioBufferBaseSourceNodeHostObject, onPositionChanged),
+                JSI_EXPORT_PROPERTY_SETTER(AudioBufferBaseSourceNodeHostObject, onPositionChangedInterval));
+    }
+
+    JSI_PROPERTY_GETTER(detune) {
+        auto sourceNode =
+                std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+        auto detune = sourceNode->getDetuneParam();
+        auto detuneHostObject = std::make_shared<AudioParamHostObject>(detune);
+        return jsi::Object::createFromHostObject(runtime, detuneHostObject);
+    }
+
+    JSI_PROPERTY_GETTER(playbackRate) {
+        auto sourceNode =
+                std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+        auto playbackRate = sourceNode->getPlaybackRateParam();
+        auto playbackRateHostObject =
+                std::make_shared<AudioParamHostObject>(playbackRate);
+        return jsi::Object::createFromHostObject(runtime, playbackRateHostObject);
+    }
+
+    JSI_PROPERTY_SETTER(onPositionChanged) {
+        auto sourceNode =
+                std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+
+        sourceNode->setOnPositionChangedCallbackId(std::stoull(value.getString(runtime).utf8(runtime)));
+    }
+
+    JSI_PROPERTY_SETTER(onPositionChangedInterval) {
+        auto sourceNode =
+                std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
+
+        sourceNode->setOnPositionChangedInterval(static_cast<int>(value.getNumber()));
+    }
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/AudioBufferQueueSourceNodeHostObject.h

@@ -2,8 +2,7 @@
 
 #include <audioapi/HostObjects/AudioBufferHostObject.h>
 #include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
-#include <audioapi/HostObjects/AudioParamHostObject.h>
-#include <audioapi/HostObjects/AudioScheduledSourceNodeHostObject.h>
+#include <audioapi/HostObjects/AudioBufferBaseSourceNodeHostObject.h>
 
 #include <memory>
 #include <vector>
@@ -12,76 +11,16 @@ namespace audioapi {
 using namespace facebook;
 
 class AudioBufferQueueSourceNodeHostObject
-            : public AudioScheduledSourceNodeHostObject {
+            : public AudioBufferBaseSourceNodeHostObject {
  public:
     explicit AudioBufferQueueSourceNodeHostObject(
             const std::shared_ptr<AudioBufferQueueSourceNode> &node)
-            : AudioScheduledSourceNodeHostObject(node) {
-        addGetters(
-                JSI_EXPORT_PROPERTY_GETTER(AudioBufferQueueSourceNodeHostObject, detune),
-                JSI_EXPORT_PROPERTY_GETTER(AudioBufferQueueSourceNodeHostObject, playbackRate));
-
-        addSetters(
-                JSI_EXPORT_PROPERTY_SETTER(AudioBufferQueueSourceNodeHostObject, onPositionChanged),
-                JSI_EXPORT_PROPERTY_SETTER(AudioBufferQueueSourceNodeHostObject, onPositionChangedInterval));
-
-        // start method is overridden in this class
-        functions_->erase("start");
-
+            : AudioBufferBaseSourceNodeHostObject(node) {
         addFunctions(
-                JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, start),
                 JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, enqueueBuffer),
                 JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, pause));
     }
 
-    JSI_PROPERTY_GETTER(detune) {
-        auto audioBufferSourceNode =
-                std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
-        auto detune = audioBufferSourceNode->getDetuneParam();
-        auto detuneHostObject = std::make_shared<AudioParamHostObject>(detune);
-        return jsi::Object::createFromHostObject(runtime, detuneHostObject);
-    }
-
-    JSI_PROPERTY_GETTER(playbackRate) {
-        auto audioBufferSourceNode =
-                std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
-        auto playbackRate = audioBufferSourceNode->getPlaybackRateParam();
-        auto playbackRateHostObject =
-                std::make_shared<AudioParamHostObject>(playbackRate);
-        return jsi::Object::createFromHostObject(runtime, playbackRateHostObject);
-    }
-
-    JSI_PROPERTY_SETTER(onPositionChanged) {
-        auto audioBufferQueueSourceNode =
-                std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
-
-        audioBufferQueueSourceNode->setOnPositionChangedCallbackId(std::stoull(value.getString(runtime).utf8(runtime)));
-    }
-
-    JSI_PROPERTY_SETTER(onPositionChangedInterval) {
-        auto audioBufferQueueSourceNode =
-                std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
-
-        audioBufferQueueSourceNode->setOnPositionChangedInterval(value.getNumber());
-    }
-
-    JSI_HOST_FUNCTION(start) {
-        auto when = args[0].getNumber();
-
-        auto audioBufferQueueSourceNode =
-                std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
-
-        double offset = -1.0;
-
-        if (args[1].isNumber()) {
-            offset = args[1].asNumber();
-        }
-
-        audioBufferQueueSourceNode->start(when, offset);
-
-        return jsi::Value::undefined();
-    }
-
     JSI_HOST_FUNCTION(pause) {
         auto audioBufferQueueSourceNode =
                 std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
@@ -97,10 +36,9 @@ class AudioBufferQueueSourceNodeHostObject
 
         auto audioBufferHostObject =
                 args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
-        int bufferId = args[1].asNumber();
-        auto isLastBuffer = args[2].asBool();
+        auto isLastBuffer = args[1].asBool();
 
-        audioBufferQueueSourceNode->enqueueBuffer(audioBufferHostObject->audioBuffer_, bufferId, isLastBuffer);
+        audioBufferQueueSourceNode->enqueueBuffer(audioBufferHostObject->audioBuffer_, isLastBuffer);
 
         return jsi::Value::undefined();
     }

package/common/cpp/audioapi/HostObjects/AudioBufferSourceNodeHostObject.h

@@ -2,8 +2,7 @@
 
 #include <audioapi/HostObjects/AudioBufferHostObject.h>
 #include <audioapi/core/sources/AudioBufferSourceNode.h>
-#include <audioapi/HostObjects/AudioParamHostObject.h>
-#include <audioapi/HostObjects/AudioScheduledSourceNodeHostObject.h>
+#include <audioapi/HostObjects/AudioBufferBaseSourceNodeHostObject.h>
 
 #include <memory>
 #include <vector>
@@ -12,34 +11,30 @@ namespace audioapi {
 using namespace facebook;
 
 class AudioBufferSourceNodeHostObject
-    : public AudioScheduledSourceNodeHostObject {
+    : public AudioBufferBaseSourceNodeHostObject {
  public:
   explicit AudioBufferSourceNodeHostObject(
       const std::shared_ptr<AudioBufferSourceNode> &node)
-      : AudioScheduledSourceNodeHostObject(node) {
+      : AudioBufferBaseSourceNodeHostObject(node) {
     addGetters(
         JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loop),
         JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loopSkip),
         JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, buffer),
         JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loopStart),
-        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loopEnd),
-        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, detune),
-        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, playbackRate));
+        JSI_EXPORT_PROPERTY_GETTER(AudioBufferSourceNodeHostObject, loopEnd));
 
     addSetters(
         JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loop),
         JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loopSkip),
-        JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, buffer),
         JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loopStart),
-        JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loopEnd),
-        JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, onPositionChanged),
-        JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, onPositionChangedInterval));
+        JSI_EXPORT_PROPERTY_SETTER(AudioBufferSourceNodeHostObject, loopEnd));
 
     // start method is overridden in this class
     functions_->erase("start");
 
     addFunctions(
-        JSI_EXPORT_FUNCTION(AudioBufferSourceNodeHostObject, start));
+        JSI_EXPORT_FUNCTION(AudioBufferSourceNodeHostObject, start),
+        JSI_EXPORT_FUNCTION(AudioBufferSourceNodeHostObject, setBuffer));
     }
 
   JSI_PROPERTY_GETTER(loop) {
@@ -83,23 +78,6 @@ class AudioBufferSourceNodeHostObject
     return {loopEnd};
   }
 
-  JSI_PROPERTY_GETTER(detune) {
-    auto audioBufferSourceNode =
-        std::static_pointer_cast<AudioBufferSourceNode>(node_);
-    auto detune = audioBufferSourceNode->getDetuneParam();
-    auto detuneHostObject = std::make_shared<AudioParamHostObject>(detune);
-    return jsi::Object::createFromHostObject(runtime, detuneHostObject);
-  }
-
-  JSI_PROPERTY_GETTER(playbackRate) {
-    auto audioBufferSourceNode =
-        std::static_pointer_cast<AudioBufferSourceNode>(node_);
-    auto playbackRate = audioBufferSourceNode->getPlaybackRateParam();
-    auto playbackRateHostObject =
-        std::make_shared<AudioParamHostObject>(playbackRate);
-    return jsi::Object::createFromHostObject(runtime, playbackRateHostObject);
-  }
-
   JSI_PROPERTY_SETTER(loop) {
     auto audioBufferSourceNode =
         std::static_pointer_cast<AudioBufferSourceNode>(node_);
@@ -112,19 +90,6 @@ class AudioBufferSourceNodeHostObject
     audioBufferSourceNode->setLoopSkip(value.getBool());
   }
 
-  JSI_PROPERTY_SETTER(buffer) {
-    auto audioBufferSourceNode =
-        std::static_pointer_cast<AudioBufferSourceNode>(node_);
-    if (value.isNull()) {
-      audioBufferSourceNode->setBuffer(std::shared_ptr<AudioBuffer>(nullptr));
-      return;
-    }
-
-    auto bufferHostObject =
-        value.getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
-    audioBufferSourceNode->setBuffer(bufferHostObject->audioBuffer_);
-  }
-
   JSI_PROPERTY_SETTER(loopStart) {
     auto audioBufferSourceNode =
         std::static_pointer_cast<AudioBufferSourceNode>(node_);
@@ -137,20 +102,6 @@ class AudioBufferSourceNodeHostObject
     audioBufferSourceNode->setLoopEnd(value.getNumber());
   }
 
-  JSI_PROPERTY_SETTER(onPositionChanged) {
-    auto audioBufferSourceNode =
-            std::static_pointer_cast<AudioBufferSourceNode>(node_);
-
-    audioBufferSourceNode->setOnPositionChangedCallbackId(std::stoull(value.getString(runtime).utf8(runtime)));
-  }
-
-  JSI_PROPERTY_SETTER(onPositionChangedInterval) {
-      auto audioBufferSourceNode =
-              std::static_pointer_cast<AudioBufferSourceNode>(node_);
-
-      audioBufferSourceNode->setOnPositionChangedInterval(value.getNumber());
-  }
-
   JSI_HOST_FUNCTION(start) {
     auto when = args[0].getNumber();
     auto offset = args[1].getNumber();
@@ -169,6 +120,25 @@ class AudioBufferSourceNodeHostObject
 
     return jsi::Value::undefined();
   }
+
+  JSI_HOST_FUNCTION(setBuffer) {
+    auto audioBufferSourceNode =
+        std::static_pointer_cast<AudioBufferSourceNode>(node_);
+
+    auto audioBufferSourceNodeJsiObject = args[0].getObject(runtime);
+
+    if (args[1].isNull()) {
+      audioBufferSourceNode->setBuffer(std::shared_ptr<AudioBuffer>(nullptr));
+      return jsi::Value::undefined();
+    }
+
+    auto bufferHostObject =
+        args[1].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+    audioBufferSourceNodeJsiObject.setExternalMemoryPressure(runtime,
+        bufferHostObject->getSizeInBytes() + 16);
+    audioBufferSourceNode->setBuffer(bufferHostObject->audioBuffer_);
+    return jsi::Value::undefined();
+  }
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h

@@ -8,6 +8,7 @@
 #include <audioapi/HostObjects/AudioDestinationNodeHostObject.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/HostObjects/BiquadFilterNodeHostObject.h>
+#include <audioapi/HostObjects/CustomProcessorNodeHostObject.h>
 #include <audioapi/HostObjects/GainNodeHostObject.h>
 #include <audioapi/HostObjects/OscillatorNodeHostObject.h>
 #include <audioapi/HostObjects/PeriodicWaveHostObject.h>
@@ -40,6 +41,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
 
     addFunctions(
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createOscillator),
+        JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createCustomProcessor),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createGain),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createStereoPanner),
         JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBiquadFilter),
@@ -78,6 +80,13 @@ class BaseAudioContextHostObject : public JsiHostObject {
     return jsi::Object::createFromHostObject(runtime, oscillatorHostObject);
   }
 
+  JSI_HOST_FUNCTION(createCustomProcessor) {
+    auto identifier = args[0].getString(runtime).utf8(runtime);
+    auto customProcessor = context_->createCustomProcessor(identifier);
+    auto customProcessorHostObject = std::make_shared<CustomProcessorNodeHostObject>(customProcessor);
+    return jsi::Object::createFromHostObject(runtime, customProcessorHostObject);
+  }
+
   JSI_HOST_FUNCTION(createGain) {
     auto gain = context_->createGain();
     auto gainHostObject = std::make_shared<GainNodeHostObject>(gain);

package/common/cpp/audioapi/HostObjects/CustomProcessorNodeHostObject.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/core/effects/CustomProcessorNode.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class CustomProcessorNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit CustomProcessorNodeHostObject(const std::shared_ptr<CustomProcessorNode> &node)
+      : AudioNodeHostObject(node) {
+    addGetters(
+        JSI_EXPORT_PROPERTY_GETTER(CustomProcessorNodeHostObject, customProcessor),
+        JSI_EXPORT_PROPERTY_GETTER(CustomProcessorNodeHostObject, processorMode));
+
+    addSetters(
+        JSI_EXPORT_PROPERTY_SETTER(CustomProcessorNodeHostObject, processorMode));
+  }
+
+  JSI_PROPERTY_GETTER(customProcessor) {
+    auto customProcessorNode = std::static_pointer_cast<CustomProcessorNode>(node_);
+    auto customProcessorParam =
+        std::make_shared<AudioParamHostObject>(customProcessorNode->getCustomProcessorParam());
+    return jsi::Object::createFromHostObject(runtime, customProcessorParam);
+  }
+
+  JSI_PROPERTY_GETTER(processorMode) {
+    auto customProcessorNode = std::static_pointer_cast<CustomProcessorNode>(node_);
+    auto mode = customProcessorNode->getProcessorMode();
+    std::string modeStr = (mode == CustomProcessorNode::ProcessorMode::ProcessThrough)
+                            ? "processThrough"
+                            : "processInPlace";
+    return jsi::String::createFromUtf8(runtime, modeStr);
+  }
+
+  JSI_PROPERTY_SETTER(processorMode) {
+    auto customProcessorNode = std::static_pointer_cast<CustomProcessorNode>(node_);
+    std::string modeStr = value.getString(runtime).utf8(runtime);
+
+    if (modeStr == "processThrough") {
+      customProcessorNode->setProcessorMode(CustomProcessorNode::ProcessorMode::ProcessThrough);
+    } else {
+      customProcessorNode->setProcessorMode(CustomProcessorNode::ProcessorMode::ProcessInPlace);
+    }
+  }
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/core/BaseAudioContext.cpp

@@ -2,6 +2,7 @@
 #include <audioapi/core/analysis/AnalyserNode.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/effects/BiquadFilterNode.h>
+#include <audioapi/core/effects/CustomProcessorNode.h>
 #include <audioapi/core/effects/GainNode.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
 #include <audioapi/core/sources/AudioBuffer.h>
@@ -54,6 +55,14 @@ std::shared_ptr<OscillatorNode> BaseAudioContext::createOscillator() {
   return oscillator;
 }
 
+std::shared_ptr<CustomProcessorNode> BaseAudioContext::createCustomProcessor(
+    const std::string &identifier) {
+  auto customProcessor =
+      std::make_shared<CustomProcessorNode>(this, identifier);
+  nodeManager_->addProcessingNode(customProcessor);
+  return customProcessor;
+}
+
 std::shared_ptr<GainNode> BaseAudioContext::createGain() {
   auto gain = std::make_shared<GainNode>(this);
   nodeManager_->addProcessingNode(gain);

package/common/cpp/audioapi/core/BaseAudioContext.h

@@ -15,6 +15,7 @@
 namespace audioapi {
 
 class AudioBus;
+class CustomProcessorNode;
 class GainNode;
 class AudioBuffer;
 class PeriodicWave;
@@ -41,6 +42,7 @@ class BaseAudioContext {
   std::shared_ptr<AudioDestinationNode> getDestination();
 
   std::shared_ptr<OscillatorNode> createOscillator();
+  std::shared_ptr<CustomProcessorNode> createCustomProcessor(const std::string& identifier);
   std::shared_ptr<GainNode> createGain();
   std::shared_ptr<StereoPannerNode> createStereoPanner();
   std::shared_ptr<BiquadFilterNode> createBiquadFilter();

package/common/cpp/audioapi/core/effects/CustomProcessorNode.cpp

@@ -0,0 +1,173 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/CustomProcessorNode.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+
+#include <algorithm>
+#include <cstring>
+#include <iostream>
+
+namespace audioapi {
+
+// Static registries and active node tracking
+std::map<std::string, std::function<std::shared_ptr<CustomAudioProcessor>()>>
+    CustomProcessorNode::s_processorFactoriesByIdentifier;
+std::unordered_map<std::string, CustomProcessorNode::GenericControlHandler>
+    CustomProcessorNode::s_controlHandlersByIdentifier;
+std::unordered_map<std::string, std::vector<CustomProcessorNode *>>
+    CustomProcessorNode::s_activeNodes;
+
+// Constructor: initializes processor, tracking, and preallocated buffers
+CustomProcessorNode::CustomProcessorNode(
+    BaseAudioContext *context,
+    const std::string &identifier)
+    : AudioNode(context), processorMode_(ProcessorMode::ProcessInPlace) {
+  customProcessorParam_ = std::make_shared<AudioParam>(
+      1.0f, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
+  isInitialized_ = true;
+
+  auto it = s_processorFactoriesByIdentifier.find(identifier);
+  processor_ =
+      (it != s_processorFactoriesByIdentifier.end()) ? it->second() : nullptr;
+
+  s_activeNodes[identifier].push_back(this);
+}
+
+// Destructor: cleans up tracking for this instance
+CustomProcessorNode::~CustomProcessorNode() {
+  for (auto &pair : s_activeNodes) {
+    auto &vec = pair.second;
+    vec.erase(std::remove(vec.begin(), vec.end(), this), vec.end());
+  }
+}
+
+// Gets the modifiable parameter
+std::shared_ptr<AudioParam> CustomProcessorNode::getCustomProcessorParam()
+    const {
+  return customProcessorParam_;
+}
+
+// Returns the current processing mode
+CustomProcessorNode::ProcessorMode CustomProcessorNode::getProcessorMode()
+    const {
+  return processorMode_;
+}
+
+// Updates the processing mode
+void CustomProcessorNode::setProcessorMode(ProcessorMode mode) {
+  processorMode_ = mode;
+}
+
+// Registers a factory for dynamic processor instantiation
+void CustomProcessorNode::registerProcessorFactory(
+    const std::string &identifier,
+    std::function<std::shared_ptr<CustomAudioProcessor>()> factory) {
+  s_processorFactoriesByIdentifier[identifier] = std::move(factory);
+  notifyProcessorChanged(identifier);
+}
+
+// Removes a processor factory from registry
+void CustomProcessorNode::unregisterProcessorFactory(
+    const std::string &identifier) {
+  s_processorFactoriesByIdentifier.erase(identifier);
+  notifyProcessorChanged(identifier);
+}
+
+// Updates processor instances for all nodes using given identifier
+void CustomProcessorNode::notifyProcessorChanged(
+    const std::string &identifier) {
+  auto it = s_activeNodes.find(identifier);
+  if (it != s_activeNodes.end()) {
+    for (CustomProcessorNode *node : it->second) {
+      auto f = s_processorFactoriesByIdentifier.find(identifier);
+      node->processor_ =
+          (f != s_processorFactoriesByIdentifier.end()) ? f->second() : nullptr;
+    }
+  }
+}
+
+// Registers control handler for runtime automation
+void CustomProcessorNode::registerControlHandler(
+    const std::string &identifier,
+    GenericControlHandler handler) {
+  s_controlHandlersByIdentifier[identifier] = std::move(handler);
+}
+
+// Removes a control handler
+void CustomProcessorNode::unregisterControlHandler(
+    const std::string &identifier) {
+  s_controlHandlersByIdentifier.erase(identifier);
+}
+
+// Core processing method routed by selected mode
+void CustomProcessorNode::processNode(
+    const std::shared_ptr<AudioBus> &processingBus,
+    int framesToProcess) {
+  if (!processor_)
+    return;
+
+  int numChannels = processingBus->getNumberOfChannels();
+  if (preallocatedOutputBuffers_.size() != static_cast<size_t>(numChannels)) {
+    preallocatedOutputBuffers_.resize(numChannels);
+  }
+
+  for (int ch = 0; ch < numChannels; ++ch) {
+    if (preallocatedOutputBuffers_[ch].size() !=
+        static_cast<size_t>(framesToProcess)) {
+      preallocatedOutputBuffers_[ch].resize(framesToProcess);
+    }
+  }
+
+  switch (processorMode_) {
+    case ProcessorMode::ProcessThrough:
+      processThrough(processingBus, framesToProcess);
+      break;
+    case ProcessorMode::ProcessInPlace:
+    default:
+      processInPlace(processingBus, framesToProcess);
+      break;
+  }
+}
+
+// Executes in-place processing on the shared audio buffer
+void CustomProcessorNode::processInPlace(
+    const std::shared_ptr<AudioBus> &bus,
+    int frames) {
+  if (!processor_)
+    return;
+
+  int numChannels = bus->getNumberOfChannels();
+  std::vector<float *> channelData(numChannels);
+  for (int ch = 0; ch < numChannels; ++ch) {
+    channelData[ch] = bus->getChannel(ch)->getData();
+  }
+
+  processor_->processInPlace(channelData.data(), numChannels, frames);
+}
+
+// Executes processing using separate input and output buffers with
+// preallocation
+void CustomProcessorNode::processThrough(
+    const std::shared_ptr<AudioBus> &bus,
+    int frames) {
+  if (!processor_)
+    return;
+
+  int numChannels = bus->getNumberOfChannels();
+  std::vector<float *> input(numChannels);
+  std::vector<float *> output(numChannels);
+
+  for (int ch = 0; ch < numChannels; ++ch) {
+    input[ch] = bus->getChannel(ch)->getData();
+    output[ch] = preallocatedOutputBuffers_[ch].data();
+  }
+
+  processor_->processThrough(input.data(), output.data(), numChannels, frames);
+
+  for (int ch = 0; ch < numChannels; ++ch) {
+    std::memcpy(
+        bus->getChannel(ch)->getData(), output[ch], sizeof(float) * frames);
+  }
+}
+
+} // namespace audioapi