react-native-audio-api 0.12.0-nightly-75589dc-20260121 → 0.12.0-nightly-6a44b58-20260123

package/android/src/main/java/com/swmansion/audioapi/AudioAPIModule.kt

@@ -1,5 +1,6 @@
 package com.swmansion.audioapi
 
+import android.media.AudioManager
 import androidx.annotation.RequiresPermission
 import com.facebook.jni.HybridData
 import com.facebook.react.bridge.Arguments
@@ -115,8 +116,21 @@ class AudioAPIModule(
     // nothing to do here
   }
 
-  override fun observeAudioInterruptions(enabled: Boolean) {
-    MediaSessionManager.observeAudioInterruptions(enabled)
+  override fun observeAudioInterruptions(
+    focusType: String?,
+    enabled: Boolean,
+  ) {
+    if (!enabled) {
+      MediaSessionManager.abandonAudioFocus()
+      return
+    }
+    when (focusType) {
+      "gain" -> MediaSessionManager.requestAudioFocus(AudioManager.AUDIOFOCUS_GAIN)
+      "gainTransient" -> MediaSessionManager.requestAudioFocus(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT)
+      "gainTransientMayDuck" -> MediaSessionManager.requestAudioFocus(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK)
+      "gainTransientExclusive" -> MediaSessionManager.requestAudioFocus(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE)
+      else -> MediaSessionManager.requestAudioFocus(AudioManager.AUDIOFOCUS_GAIN)
+    }
   }
 
   override fun activelyReclaimSession(enabled: Boolean) {

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

@@ -47,20 +47,24 @@ class AudioFocusListener(
           }
         audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
+
+      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+        audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("duck", emptyMap())
+      }
     }
   }
 
-  fun requestAudioFocus() {
+  fun requestAudioFocus(focus: Int) {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
       this.focusRequest =
         AudioFocusRequest
-          .Builder(AudioManager.AUDIOFOCUS_GAIN)
+          .Builder(focus)
           .setOnAudioFocusChangeListener(this)
           .build()
 
       audioManager.get()?.requestAudioFocus(focusRequest!!)
     } else {
-      audioManager.get()?.requestAudioFocus(this, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN)
+      audioManager.get()?.requestAudioFocus(this, AudioManager.STREAM_MUSIC, focus)
     }
   }
 

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

@@ -88,12 +88,12 @@ object MediaSessionManager {
     return sampleRate.toDouble()
   }
 
-  fun observeAudioInterruptions(observe: Boolean) {
-    if (observe) {
-      audioFocusListener.requestAudioFocus()
-    } else {
-      audioFocusListener.abandonAudioFocus()
-    }
+  fun requestAudioFocus(focus: Int) {
+    audioFocusListener.requestAudioFocus(focus)
+  }
+
+  fun abandonAudioFocus() {
+    audioFocusListener.abandonAudioFocus()
   }
 
   fun activelyReclaimSession(enabled: Boolean) {

package/common/cpp/audioapi/HostObjects/analysis/AnalyserNodeHostObject.cpp

@@ -1,6 +1,7 @@
 #include <audioapi/HostObjects/analysis/AnalyserNodeHostObject.h>
 
 #include <audioapi/core/analysis/AnalyserNode.h>
+#include <audioapi/HostObjects/utils/JsEnumParser.h>
 #include <memory>
 
 namespace audioapi {
@@ -57,7 +58,7 @@ JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, smoothingTimeConstant) {
 JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, window) {
   auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
   auto windowType = analyserNode->getWindowType();
-  return jsi::String::createFromUtf8(runtime, windowType);
+  return jsi::String::createFromUtf8(runtime, js_enum_parser::windowTypeToString(windowType));
 }
 
 JSI_PROPERTY_SETTER_IMPL(AnalyserNodeHostObject, fftSize) {
@@ -86,7 +87,8 @@ JSI_PROPERTY_SETTER_IMPL(AnalyserNodeHostObject, smoothingTimeConstant) {
 
 JSI_PROPERTY_SETTER_IMPL(AnalyserNodeHostObject, window) {
   auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-  analyserNode->setWindowType(value.getString(runtime).utf8(runtime));
+  auto type = value.asString(runtime).utf8(runtime);
+  analyserNode->setWindowType(js_enum_parser::windowTypeFromString(type));
 }
 
 JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getFloatFrequencyData) {

package/common/cpp/audioapi/HostObjects/analysis/AnalyserNodeHostObject.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/core/analysis/AnalyserNode.h>
 
 #include <memory>
 #include <string>
@@ -9,8 +10,6 @@
 namespace audioapi {
 using namespace facebook;
 
-class AnalyserNode;
-
 class AnalyserNodeHostObject : public AudioNodeHostObject {
  public:
   explicit AnalyserNodeHostObject(const std::shared_ptr<AnalyserNode> &node);

package/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.cpp

@@ -2,6 +2,7 @@
 
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/core/effects/BiquadFilterNode.h>
+#include <audioapi/HostObjects/utils/JsEnumParser.h>
 #include <memory>
 
 namespace audioapi {
@@ -49,12 +50,13 @@ JSI_PROPERTY_GETTER_IMPL(BiquadFilterNodeHostObject, gain) {
 JSI_PROPERTY_GETTER_IMPL(BiquadFilterNodeHostObject, type) {
   auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
   auto type = biquadFilterNode->getType();
-  return jsi::String::createFromUtf8(runtime, type);
+  return jsi::String::createFromUtf8(runtime, js_enum_parser::filterTypeToString(type));
 }
 
 JSI_PROPERTY_SETTER_IMPL(BiquadFilterNodeHostObject, type) {
   auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
-  biquadFilterNode->setType(value.getString(runtime).utf8(runtime));
+  auto type = value.asString(runtime).utf8(runtime);
+  biquadFilterNode->setType(js_enum_parser::filterTypeFromString(type));
 }
 
 JSI_HOST_FUNCTION_IMPL(BiquadFilterNodeHostObject, getFrequencyResponse) {

package/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/core/types/BiquadFilterType.h>
 
 #include <memory>
 #include <string>

package/common/cpp/audioapi/HostObjects/effects/WaveShaperNodeHostObject.cpp

@@ -1,6 +1,7 @@
 #include <audioapi/HostObjects/effects/WaveShaperNodeHostObject.h>
 #include <audioapi/core/effects/WaveShaperNode.h>
 #include <audioapi/jsi/AudioArrayBuffer.h>
+#include <audioapi/HostObjects/utils/JsEnumParser.h>
 
 #include <memory>
 #include <string>
@@ -19,7 +20,7 @@ WaveShaperNodeHostObject::WaveShaperNodeHostObject(const std::shared_ptr<WaveSha
 
 JSI_PROPERTY_GETTER_IMPL(WaveShaperNodeHostObject, oversample) {
   auto waveShaperNode = std::static_pointer_cast<WaveShaperNode>(node_);
-  return jsi::String::createFromUtf8(runtime, waveShaperNode->getOversample());
+  return jsi::String::createFromUtf8(runtime, js_enum_parser::overSampleTypeToString(waveShaperNode->getOversample()));
 }
 
 JSI_PROPERTY_GETTER_IMPL(WaveShaperNodeHostObject, curve) {
@@ -44,8 +45,8 @@ JSI_PROPERTY_GETTER_IMPL(WaveShaperNodeHostObject, curve) {
 
 JSI_PROPERTY_SETTER_IMPL(WaveShaperNodeHostObject, oversample) {
   auto waveShaperNode = std::static_pointer_cast<WaveShaperNode>(node_);
-  std::string type = value.asString(runtime).utf8(runtime);
-  waveShaperNode->setOversample(type);
+  auto type = value.asString(runtime).utf8(runtime);
+  waveShaperNode->setOversample(js_enum_parser::overSampleTypeFromString(type));
 }
 
 JSI_HOST_FUNCTION_IMPL(WaveShaperNodeHostObject, setCurve) {

package/common/cpp/audioapi/HostObjects/effects/WaveShaperNodeHostObject.h

@@ -1,8 +1,10 @@
 #pragma once
 
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/core/types/OverSampleType.h>
 
 #include <memory>
+#include <string>
 #include <vector>
 
 namespace audioapi {

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

@@ -11,6 +11,9 @@ AudioBufferQueueSourceNodeHostObject::AudioBufferQueueSourceNodeHostObject(
     : AudioBufferBaseSourceNodeHostObject(node) {
   functions_->erase("start");
 
+  addSetters(
+  JSI_EXPORT_PROPERTY_SETTER(AudioBufferQueueSourceNodeHostObject, onBufferEnded));
+
   addFunctions(
       JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, start),
       JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, enqueueBuffer),
@@ -19,6 +22,21 @@ AudioBufferQueueSourceNodeHostObject::AudioBufferQueueSourceNodeHostObject(
       JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, pause));
 }
 
+AudioBufferQueueSourceNodeHostObject::~AudioBufferQueueSourceNodeHostObject() {
+  auto audioBufferQueueSourceNode = std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+
+  // When JSI object is garbage collected (together with the eventual callback),
+  // underlying source node might still be active and try to call the
+  // non-existing callback.
+  audioBufferQueueSourceNode->setOnBufferEndedCallbackId(0);
+}
+
+JSI_PROPERTY_SETTER_IMPL(AudioBufferQueueSourceNodeHostObject, onBufferEnded) {
+    auto audioBufferQueueSourceNode = std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+
+    audioBufferQueueSourceNode->setOnBufferEndedCallbackId(std::stoull(value.getString(runtime).utf8(runtime)));
+}
+
 JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, start) {
   auto when = args[0].getNumber();
 

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

@@ -15,6 +15,10 @@ class AudioBufferQueueSourceNodeHostObject : public AudioBufferBaseSourceNodeHos
   explicit AudioBufferQueueSourceNodeHostObject(
       const std::shared_ptr<AudioBufferQueueSourceNode> &node);
 
+  ~AudioBufferQueueSourceNodeHostObject() override;
+
+  JSI_PROPERTY_SETTER_DECL(onBufferEnded);
+
   JSI_HOST_FUNCTION_DECL(start);
   JSI_HOST_FUNCTION_DECL(pause);
   JSI_HOST_FUNCTION_DECL(enqueueBuffer);

package/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.cpp

@@ -3,6 +3,7 @@
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
 #include <audioapi/core/sources/OscillatorNode.h>
+#include <audioapi/HostObjects/utils/JsEnumParser.h>
 #include <memory>
 
 namespace audioapi {
@@ -35,7 +36,7 @@ JSI_PROPERTY_GETTER_IMPL(OscillatorNodeHostObject, detune) {
 JSI_PROPERTY_GETTER_IMPL(OscillatorNodeHostObject, type) {
   auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
   auto waveType = oscillatorNode->getType();
-  return jsi::String::createFromUtf8(runtime, waveType);
+  return jsi::String::createFromUtf8(runtime, js_enum_parser::oscillatorTypeToString(waveType));
 }
 
 JSI_HOST_FUNCTION_IMPL(OscillatorNodeHostObject, setPeriodicWave) {
@@ -47,7 +48,8 @@ JSI_HOST_FUNCTION_IMPL(OscillatorNodeHostObject, setPeriodicWave) {
 
 JSI_PROPERTY_SETTER_IMPL(OscillatorNodeHostObject, type) {
   auto oscillatorNode = std::static_pointer_cast<OscillatorNode>(node_);
-  oscillatorNode->setType(value.getString(runtime).utf8(runtime));
+  auto type = value.asString(runtime).utf8(runtime);
+  oscillatorNode->setType(js_enum_parser::oscillatorTypeFromString(type));
 }
 
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/sources/OscillatorNodeHostObject.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h>
+#include <audioapi/core/types/OscillatorType.h>
 
 #include <memory>
 #include <string>

package/common/cpp/audioapi/HostObjects/utils/JsEnumParser.cpp

@@ -0,0 +1,127 @@
+#include <audioapi/HostObjects/utils/JsEnumParser.h>
+#include <string>
+
+using WindowType = audioapi::AnalyserNode::WindowType;
+
+namespace audioapi::js_enum_parser {
+
+  WindowType windowTypeFromString(const std::string &type) {
+    if (type == "blackman") {
+      return WindowType::BLACKMAN;
+    }
+    if (type == "hann") {
+      return WindowType::HANN;
+    }
+
+    throw std::invalid_argument("Unknown window type");
+  }
+
+
+  std::string windowTypeToString(WindowType type) {
+    switch (type) {
+      case WindowType::BLACKMAN:
+        return "blackman";
+      case WindowType::HANN:
+        return "hann";
+      default:
+        throw std::invalid_argument("Unknown window type");
+    }
+  }
+
+  BiquadFilterType filterTypeFromString(const std::string &type) {
+    if (type == "lowpass")
+      return BiquadFilterType::LOWPASS;
+    if (type == "highpass")
+      return BiquadFilterType::HIGHPASS;
+    if (type == "bandpass")
+      return BiquadFilterType::BANDPASS;
+    if (type == "lowshelf")
+      return BiquadFilterType::LOWSHELF;
+    if (type == "highshelf")
+      return BiquadFilterType::HIGHSHELF;
+    if (type == "peaking")
+      return BiquadFilterType::PEAKING;
+    if (type == "notch")
+      return BiquadFilterType::NOTCH;
+    if (type == "allpass")
+      return BiquadFilterType::ALLPASS;
+
+    throw std::invalid_argument("Invalid filter type: " + type);
+  }
+
+  std::string filterTypeToString(BiquadFilterType type) {
+    switch (type) {
+      case BiquadFilterType::LOWPASS:
+        return "lowpass";
+      case BiquadFilterType::HIGHPASS:
+        return "highpass";
+      case BiquadFilterType::BANDPASS:
+        return "bandpass";
+      case BiquadFilterType::LOWSHELF:
+        return "lowshelf";
+      case BiquadFilterType::HIGHSHELF:
+        return "highshelf";
+      case BiquadFilterType::PEAKING:
+        return "peaking";
+      case BiquadFilterType::NOTCH:
+        return "notch";
+      case BiquadFilterType::ALLPASS:
+        return "allpass";
+      default:
+        throw std::invalid_argument("Unknown filter type");
+    }
+  }
+
+  OverSampleType overSampleTypeFromString(const std::string &type) {
+    if (type == "2x")
+      return OverSampleType::OVERSAMPLE_2X;
+    if (type == "4x")
+      return OverSampleType::OVERSAMPLE_4X;
+
+    return OverSampleType::OVERSAMPLE_NONE;
+  }
+
+  std::string overSampleTypeToString(OverSampleType type) {
+    switch (type) {
+      case OverSampleType::OVERSAMPLE_2X:
+        return "2x";
+      case OverSampleType::OVERSAMPLE_4X:
+        return "4x";
+      default:
+        return "none";
+    }
+  }
+
+  OscillatorType oscillatorTypeFromString(const std::string &type) {
+    if (type == "sine")
+      return OscillatorType::SINE;
+    if (type == "square")
+      return OscillatorType::SQUARE;
+    if (type == "sawtooth")
+      return OscillatorType::SAWTOOTH;
+    if (type == "triangle")
+      return OscillatorType::TRIANGLE;
+    if (type == "custom")
+      return OscillatorType::CUSTOM;
+
+    throw std::invalid_argument("Unknown oscillator type: " + type);
+  }
+
+  std::string oscillatorTypeToString(OscillatorType type) {
+    switch (type) {
+      case OscillatorType::SINE:
+        return "sine";
+      case OscillatorType::SQUARE:
+        return "square";
+      case OscillatorType::SAWTOOTH:
+        return "sawtooth";
+      case OscillatorType::TRIANGLE:
+        return "triangle";
+      case OscillatorType::CUSTOM:
+        return "custom";
+      default:
+        throw std::invalid_argument("Unknown oscillator type");
+    }
+  }
+
+} // namespace audioapi::js_enum_parser

package/common/cpp/audioapi/HostObjects/utils/JsEnumParser.h

@@ -0,0 +1,17 @@
+#pragma once
+#include <audioapi/core/analysis/AnalyserNode.h>
+#include <audioapi/core/types/BiquadFilterType.h>
+#include <audioapi/core/types/OscillatorType.h>
+#include <audioapi/core/types/OverSampleType.h>
+#include <string>
+
+namespace audioapi::js_enum_parser {
+std::string windowTypeToString(AnalyserNode::WindowType type);
+AnalyserNode::WindowType windowTypeFromString(const std::string &type);
+std::string overSampleTypeToString(OverSampleType type);
+OverSampleType overSampleTypeFromString(const std::string &type);
+std::string oscillatorTypeToString(OscillatorType type);
+OscillatorType oscillatorTypeFromString(const std::string &type);
+std::string filterTypeToString(BiquadFilterType type);
+BiquadFilterType filterTypeFromString(const std::string &type);
+} // namespace audioapi::js_enum_parser

package/common/cpp/audioapi/core/analysis/AnalyserNode.cpp

@@ -51,8 +51,8 @@ float AnalyserNode::getSmoothingTimeConstant() const {
   return smoothingTimeConstant_;
 }
 
-std::string AnalyserNode::getWindowType() const {
-  return AnalyserNode::toString(windowType_);
+AnalyserNode::WindowType AnalyserNode::getWindowType() const {
+  return windowType_;
 }
 
 void AnalyserNode::setFftSize(int fftSize) {
@@ -80,9 +80,8 @@ void AnalyserNode::setSmoothingTimeConstant(float smoothingTimeConstant) {
   smoothingTimeConstant_ = smoothingTimeConstant;
 }
 
-void AnalyserNode::setWindowType(const std::string &type) {
-  setWindowData(windowType_, fftSize_);
-  windowType_ = AnalyserNode::fromString(type);
+void AnalyserNode::setWindowType(AnalyserNode::WindowType type) {
+  setWindowData(type, fftSize_);
 }
 
 void AnalyserNode::getFloatFrequencyData(float *data, int length) {
@@ -189,12 +188,13 @@ void AnalyserNode::doFFTAnalysis() {
   }
 }
 
-void AnalyserNode::setWindowData(audioapi::AnalyserNode::WindowType type, int size) {
-  if (windowType_ == type && windowData_ && windowData_->getSize() == size) {
+void AnalyserNode::setWindowData(AnalyserNode::WindowType type, int size) {
+  if (windowType_ == type && windowData_ != nullptr && windowData_->getSize() == size) {
     return;
   }
 
-  if (!windowData_ || windowData_->getSize() != size) {
+  windowType_ = type;
+  if (windowData_ == nullptr|| windowData_->getSize() != size) {
     windowData_ = std::make_shared<AudioArray>(size);
   }
 

package/common/cpp/audioapi/core/analysis/AnalyserNode.h

@@ -27,13 +27,13 @@ class AnalyserNode : public AudioNode {
   float getMinDecibels() const;
   float getMaxDecibels() const;
   float getSmoothingTimeConstant() const;
-  std::string getWindowType() const;
+  AnalyserNode::WindowType getWindowType() const;
 
   void setFftSize(int fftSize);
   void setMinDecibels(float minDecibels);
   void setMaxDecibels(float maxDecibels);
   void setSmoothingTimeConstant(float smoothingTimeConstant);
-  void setWindowType(const std::string &type);
+  void setWindowType(AnalyserNode::WindowType);
 
   void getFloatFrequencyData(float *data, int length);
   void getByteFrequencyData(uint8_t *data, int length);
@@ -63,30 +63,6 @@ class AnalyserNode : public AudioNode {
   std::unique_ptr<AudioArray> magnitudeBuffer_;
   bool shouldDoFFTAnalysis_{true};
 
-  static WindowType fromString(const std::string &type) {
-    std::string lowerType = type;
-    std::transform(lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
-    if (lowerType == "blackman") {
-      return WindowType::BLACKMAN;
-    }
-    if (lowerType == "hann") {
-      return WindowType::HANN;
-    }
-
-    throw std::invalid_argument("Unknown window type");
-  }
-
-  static std::string toString(WindowType type) {
-    switch (type) {
-      case WindowType::BLACKMAN:
-        return "blackman";
-      case WindowType::HANN:
-        return "hann";
-      default:
-        throw std::invalid_argument("Unknown window type");
-    }
-  }
-
   void doFFTAnalysis();
 
   void setWindowData(WindowType type, int size);

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

@@ -59,12 +59,12 @@ BiquadFilterNode::BiquadFilterNode(std::shared_ptr<BaseAudioContext> context, co
   isInitialized_ = true;
 }
 
-std::string BiquadFilterNode::getType() {
-  return BiquadFilterNode::toString(type_);
+BiquadFilterType BiquadFilterNode::getType() {
+  return type_;
 }
 
-void BiquadFilterNode::setType(const std::string &type) {
-  type_ = BiquadFilterNode::fromString(type);
+void BiquadFilterNode::setType(BiquadFilterType type) {
+  type_ = type;
 }
 
 std::shared_ptr<AudioParam> BiquadFilterNode::getFrequencyParam() const {

package/common/cpp/audioapi/core/effects/BiquadFilterNode.h

@@ -59,8 +59,8 @@ class BiquadFilterNode : public AudioNode {
       std::shared_ptr<BaseAudioContext> context,
       const BiquadFilterOptions &options);
 
-  [[nodiscard]] std::string getType();
-  void setType(const std::string &type);
+  [[nodiscard]] BiquadFilterType getType();
+  void setType(BiquadFilterType);
   [[nodiscard]] std::shared_ptr<AudioParam> getFrequencyParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getQParam() const;
@@ -81,7 +81,7 @@ class BiquadFilterNode : public AudioNode {
   std::shared_ptr<AudioParam> detuneParam_;
   std::shared_ptr<AudioParam> QParam_;
   std::shared_ptr<AudioParam> gainParam_;
-  audioapi::BiquadFilterType type_;
+  BiquadFilterType type_;
 
   // delayed samples, one per channel
   std::vector<float> x1_;
@@ -96,53 +96,6 @@ class BiquadFilterNode : public AudioNode {
   float a1_ = 0;
   float a2_ = 0;
 
-  static BiquadFilterType fromString(const std::string &type) {
-    std::string lowerType = type;
-    std::transform(lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
-
-    if (lowerType == "lowpass")
-      return BiquadFilterType::LOWPASS;
-    if (lowerType == "highpass")
-      return BiquadFilterType::HIGHPASS;
-    if (lowerType == "bandpass")
-      return BiquadFilterType::BANDPASS;
-    if (lowerType == "lowshelf")
-      return BiquadFilterType::LOWSHELF;
-    if (lowerType == "highshelf")
-      return BiquadFilterType::HIGHSHELF;
-    if (lowerType == "peaking")
-      return BiquadFilterType::PEAKING;
-    if (lowerType == "notch")
-      return BiquadFilterType::NOTCH;
-    if (lowerType == "allpass")
-      return BiquadFilterType::ALLPASS;
-
-    throw std::invalid_argument("Invalid filter type: " + type);
-  }
-
-  static std::string toString(BiquadFilterType type) {
-    switch (type) {
-      case BiquadFilterType::LOWPASS:
-        return "lowpass";
-      case BiquadFilterType::HIGHPASS:
-        return "highpass";
-      case BiquadFilterType::BANDPASS:
-        return "bandpass";
-      case BiquadFilterType::LOWSHELF:
-        return "lowshelf";
-      case BiquadFilterType::HIGHSHELF:
-        return "highshelf";
-      case BiquadFilterType::PEAKING:
-        return "peaking";
-      case BiquadFilterType::NOTCH:
-        return "notch";
-      case BiquadFilterType::ALLPASS:
-        return "allpass";
-      default:
-        throw std::invalid_argument("Unknown filter type");
-    }
-  }
-
   void setNormalizedCoefficients(float b0, float b1, float b2, float a0, float a1, float a2);
   void setLowpassCoefficients(float frequency, float Q);
   void setHighpassCoefficients(float frequency, float Q);

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

@@ -24,16 +24,16 @@ WaveShaperNode::WaveShaperNode(std::shared_ptr<BaseAudioContext> context, const
   isInitialized_ = true;
 }
 
-std::string WaveShaperNode::getOversample() const {
-  return overSampleTypeToString(oversample_.load(std::memory_order_acquire));
+OverSampleType WaveShaperNode::getOversample() const {
+  return oversample_.load(std::memory_order_acquire);
 }
 
-void WaveShaperNode::setOversample(const std::string &type) {
+void WaveShaperNode::setOversample(OverSampleType type) {
   std::scoped_lock<std::mutex> lock(mutex_);
-  oversample_.store(overSampleTypeFromString(type), std::memory_order_release);
+  oversample_.store(type, std::memory_order_release);
 
   for (int i = 0; i < waveShapers_.size(); i++) {
-    waveShapers_[i]->setOversample(overSampleTypeFromString(type));
+    waveShapers_[i]->setOversample(type);
   }
 }
 

package/common/cpp/audioapi/core/effects/WaveShaperNode.h

@@ -24,10 +24,10 @@ class WaveShaperNode : public AudioNode {
       std::shared_ptr<BaseAudioContext> context,
       const WaveShaperOptions &options);
 
-  [[nodiscard]] std::string getOversample() const;
+  [[nodiscard]] OverSampleType getOversample() const;
   [[nodiscard]] std::shared_ptr<AudioArray> getCurve() const;
 
-  void setOversample(const std::string &type);
+  void setOversample(OverSampleType);
   void setCurve(const std::shared_ptr<AudioArray> &curve);
 
  protected:
@@ -41,29 +41,6 @@ class WaveShaperNode : public AudioNode {
   mutable std::mutex mutex_;
 
   std::vector<std::unique_ptr<WaveShaper>> waveShapers_{};
-
-  static OverSampleType overSampleTypeFromString(const std::string &type) {
-    std::string lowerType = type;
-    std::transform(lowerType.begin(), lowerType.end(), lowerType.begin(), ::tolower);
-
-    if (lowerType == "2x")
-      return OverSampleType::OVERSAMPLE_2X;
-    if (lowerType == "4x")
-      return OverSampleType::OVERSAMPLE_4X;
-
-    return OverSampleType::OVERSAMPLE_NONE;
-  }
-
-  static std::string overSampleTypeToString(OverSampleType type) {
-    switch (type) {
-      case OverSampleType::OVERSAMPLE_2X:
-        return "2x";
-      case OverSampleType::OVERSAMPLE_4X:
-        return "4x";
-      default:
-        return "none";
-    }
-  }
 };
 
 } // namespace audioapi