feat: audio node options in ctor

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

@@ -19,6 +19,8 @@
 #include <audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h>
 #include <audioapi/core/BaseAudioContext.h>
 
+#include <audioapi/HostObjects/utils/NodeOptionsParser.h>
+
 namespace audioapi {
 
 BaseAudioContextHostObject::BaseAudioContextHostObject(
@@ -184,7 +186,10 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConstantSource) {
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createGain) {
-  auto gain = context_->createGain();
+  auto object = args[0].asObject(runtime);
+  GainOptions options =
+      audioapi::option_parser::parseGainOptions(runtime, object);
+  auto gain = context_->createGain(std::make_shared<GainOptions>(options));
   auto gainHostObject = std::make_shared<GainNodeHostObject>(gain);
   return jsi::Object::createFromHostObject(runtime, gainHostObject);
 }

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

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <audioapi/core/types/ChannelCountMode.h>
+#include <audioapi/core/types/ChannelInterpretation.h>
+
+namespace audioapi {
+struct AudioNodeOptions {
+  int channelCount;
+  ChannelCountMode channelCountMode;
+  ChannelInterpretation channelInterpretation;
+};
+
+struct GainOptions : AudioNodeOptions {
+  float gain;
+  explicit GainOptions(AudioNodeOptions nodeOptions)
+      : AudioNodeOptions(nodeOptions) {}
+};
+} // namespace audioapi

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

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <audioapi/jsi/RuntimeLifecycleMonitor.h>
+#include <jsi/jsi.h>
+#include <memory>
+#include <utility>
+#include <vector>
+#include <cstddef>
+
+#include <audioapi/HostObjects/utils/NodeOptions.h>
+
+namespace audioapi::option_parser {
+  std::shared_ptr<AudioNodeOptions> parseAudioNodeOptions(
+    jsi::Runtime &runtime,
+    const jsi::Object &optionsObject
+  ) {
+    AudioNodeOptions options;
+
+    options.channelCount =
+      static_cast<int>(optionsObject
+                              .getProperty(runtime, "channelCount")
+                              .getNumber());
+
+    auto channelCountModeStr = optionsObject
+                                   .getProperty(runtime, "channelCountMode")
+                                   .asString(runtime)
+                                   .utf8(runtime);
+
+    if (channelCountModeStr == "max") {
+      options.channelCountMode = ChannelCountMode::MAX;
+    } else if (channelCountModeStr == "clamped-max") {
+      options.channelCountMode = ChannelCountMode::CLAMPED_MAX;
+    } else if (channelCountModeStr == "explicit") {
+      options.channelCountMode = ChannelCountMode::EXPLICIT;
+    }
+
+    auto channelInterpretationStr = optionsObject
+                                        .getProperty(runtime, "channelInterpretation")
+                                        .asString(runtime)
+                                        .utf8(runtime);
+
+    if (channelInterpretationStr == "speakers") {
+      options.channelInterpretation = ChannelInterpretation::SPEAKERS;
+    } else if (channelInterpretationStr == "discrete") {
+      options.channelInterpretation = ChannelInterpretation::DISCRETE;
+    }
+
+    return std::make_shared<AudioNodeOptions>(options);
+  }
+
+  GainOptions parseGainOptions(
+      jsi::Runtime &runtime,
+      const jsi::Object &optionsObject) {
+    std::shared_ptr<AudioNodeOptions> nodeOptions = parseAudioNodeOptions(runtime, optionsObject);
+    GainOptions options(*nodeOptions.get());
+    options.gain = static_cast<float>(optionsObject
+                                          .getProperty(runtime, "gain")
+                                          .getNumber());
+    return options;
+  }
+} // namespace audioapi::option_parser
+
+

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

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/AudioParam.h>
 #include <audioapi/core/BaseAudioContext.h>
@@ -7,7 +8,15 @@
 
 namespace audioapi {
 
-AudioNode::AudioNode(BaseAudioContext *context) : context_(context) {
+AudioNode::AudioNode(
+    BaseAudioContext *context,
+    std::shared_ptr<AudioNodeOptions> options)
+    : context_(context) {
+  if (options != nullptr) {
+    channelCount_ = options->channelCount;
+    channelCountMode_ = options->channelCountMode;
+    channelInterpretation_ = options->channelInterpretation;
+  }
   audioBus_ = std::make_shared<AudioBus>(
       RENDER_QUANTUM_SIZE, channelCount_, context->getSampleRate());
 }

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

@@ -16,10 +16,11 @@ namespace audioapi {
 class AudioBus;
 class BaseAudioContext;
 class AudioParam;
+class AudioNodeOptions;
 
 class AudioNode : public std::enable_shared_from_this<AudioNode> {
  public:
-  explicit AudioNode(BaseAudioContext *context);
+  explicit AudioNode(BaseAudioContext *context, std::shared_ptr<AudioNodeOptions> options = nullptr);
   virtual ~AudioNode();
 
   int getNumberOfInputs() const;

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

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/analysis/AnalyserNode.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
@@ -128,8 +129,9 @@ std::shared_ptr<StreamerNode> BaseAudioContext::createStreamer() {
 }
 #endif
 
-std::shared_ptr<GainNode> BaseAudioContext::createGain() {
-  auto gain = std::make_shared<GainNode>(this);
+std::shared_ptr<GainNode> BaseAudioContext::createGain(
+    std::shared_ptr<GainOptions> options) {
+  auto gain = std::make_shared<GainNode>(this, options);
   nodeManager_->addProcessingNode(gain);
   return gain;
 }

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

@@ -35,6 +35,7 @@ class WorkletSourceNode;
 class WorkletNode;
 class WorkletProcessingNode;
 class StreamerNode;
+class GainOptions;
 
 class BaseAudioContext {
  public:
@@ -65,7 +66,7 @@ class BaseAudioContext {
   std::shared_ptr<OscillatorNode> createOscillator();
   std::shared_ptr<ConstantSourceNode> createConstantSource();
   std::shared_ptr<StreamerNode> createStreamer();
-  std::shared_ptr<GainNode> createGain();
+  std::shared_ptr<GainNode> createGain(std::shared_ptr<GainOptions> options);
   std::shared_ptr<StereoPannerNode> createStereoPanner();
   std::shared_ptr<BiquadFilterNode> createBiquadFilter();
   std::shared_ptr<AudioBufferSourceNode> createBufferSource(bool pitchCorrection);

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

@@ -1,3 +1,4 @@
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/GainNode.h>
 #include <audioapi/dsp/VectorMath.h>
@@ -6,9 +7,15 @@
 
 namespace audioapi {
 
-GainNode::GainNode(BaseAudioContext *context) : AudioNode(context) {
+GainNode::GainNode(
+    BaseAudioContext *context,
+    std::shared_ptr<GainOptions> options)
+    : AudioNode(context, std::static_pointer_cast<AudioNodeOptions>(options)) {
   gainParam_ = std::make_shared<AudioParam>(
-      1.0, MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT, context);
+      options->gain,
+      MOST_NEGATIVE_SINGLE_FLOAT,
+      MOST_POSITIVE_SINGLE_FLOAT,
+      context);
   isInitialized_ = true;
 }
 

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

@@ -8,10 +8,11 @@
 namespace audioapi {
 
 class AudioBus;
+class GainOptions;
 
 class GainNode : public AudioNode {
  public:
-  explicit GainNode(BaseAudioContext *context);
+  explicit GainNode(BaseAudioContext *context, std::shared_ptr<GainOptions> options);
 
   [[nodiscard]] std::shared_ptr<AudioParam> getGainParam() const;
 

packages/react-native-audio-api/src/core/BaseAudioContext.ts

@@ -193,7 +193,7 @@ export default class BaseAudioContext {
   }
 
   createGain(): GainNode {
-    return new GainNode(this, this.context.createGain());
+    return new GainNode(this);
   }
 
   createStereoPanner(): StereoPannerNode {

packages/react-native-audio-api/src/core/GainNode.ts

@@ -1,13 +1,20 @@
 import { IGainNode } from '../interfaces';
+import { GainOptions } from '../defaults';
+import { TGainOptions } from '../types';
 import AudioNode from './AudioNode';
 import AudioParam from './AudioParam';
 import BaseAudioContext from './BaseAudioContext';
 
 export default class GainNode extends AudioNode {
   readonly gain: AudioParam;
 
-  constructor(context: BaseAudioContext, gain: IGainNode) {
-    super(context, gain);
-    this.gain = new AudioParam(gain.gain, context);
+  constructor(context: BaseAudioContext, gainOptions?: TGainOptions) {
+    const finalOptions: TGainOptions = {
+      ...GainOptions,
+      ...gainOptions,
+    };
+    const gainNode: IGainNode = context.context.createGain(finalOptions);
+    super(context, gainNode);
+    this.gain = new AudioParam(gainNode.gain, context);
   }
 }

packages/react-native-audio-api/src/defaults.ts

@@ -0,0 +1,12 @@
+import { TAudioNodeOptions, TGainOptions } from './types';
+
+export const AudioNodeOptions: TAudioNodeOptions = {
+  channelCount: 2,
+  channelCountMode: 'max',
+  channelInterpretation: 'speakers',
+};
+
+export const GainOptions: TGainOptions = {
+  ...AudioNodeOptions,
+  gain: 1,
+};

packages/react-native-audio-api/src/interfaces.ts

@@ -6,6 +6,7 @@ import {
   ContextState,
   OscillatorType,
   WindowType,
+  TGainOptions,
 } from './types';
 
 // IMPORTANT: use only IClass, because it is a part of contract between cpp host object and js layer
@@ -59,7 +60,7 @@ export interface IBaseAudioContext {
   ): IWorkletProcessingNode;
   createOscillator(): IOscillatorNode;
   createConstantSource(): IConstantSourceNode;
-  createGain(): IGainNode;
+  createGain(gainOptions: TGainOptions): IGainNode;
   createStereoPanner(): IStereoPannerNode;
   createBiquadFilter: () => IBiquadFilterNode;
   createBufferSource: (pitchCorrection: boolean) => IAudioBufferSourceNode;

packages/react-native-audio-api/src/types.ts

@@ -56,3 +56,13 @@ export interface ConvolverNodeOptions {
   buffer?: AudioBuffer | null;
   disableNormalization?: boolean;
 }
+
+export type TAudioNodeOptions = {
+  channelCount?: number;
+  channelCountMode?: ChannelCountMode;
+  channelInterpretation?: ChannelInterpretation;
+};
+
+export type TGainOptions = TAudioNodeOptions & {
+  gain?: number;
+};