react-native-audio-api 0.9.0 → 0.9.1

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

@@ -1,6 +1,7 @@
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 
 #include <audioapi/jsi/AudioArrayBuffer.h>
+#include <audioapi/utils/AudioBus.h>
 
 namespace audioapi {
 
@@ -42,14 +43,8 @@ JSI_PROPERTY_GETTER_IMPL(AudioBufferHostObject, numberOfChannels) {
 
 JSI_HOST_FUNCTION_IMPL(AudioBufferHostObject, getChannelData) {
   auto channel = static_cast<int>(args[0].getNumber());
-  auto channelData =
-      reinterpret_cast<uint8_t *>(audioBuffer_->getChannelData(channel));
-  auto length = static_cast<int>(audioBuffer_->getLength());
-  auto size = static_cast<int>(length * sizeof(float));
-
-  // reading or writing from this ArrayBuffer could cause a crash
-  // if underlying channelData is deallocated
-  auto audioArrayBuffer = std::make_shared<AudioArrayBuffer>(channelData, size);
+  auto audioArrayBuffer = std::make_shared<AudioArrayBuffer>(
+      audioBuffer_->bus_->getSharedChannel(channel));
   auto arrayBuffer = jsi::ArrayBuffer(runtime, audioArrayBuffer);
 
   auto float32ArrayCtor =

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

@@ -9,25 +9,16 @@ WorkletNode::WorkletNode(
     size_t bufferLength,
     size_t inputChannelCount)
     : AudioNode(context),
-      buffRealLength_(bufferLength * sizeof(float)),
-      bufferLength_(bufferLength),
       workletRunner_(runtime),
       shareableWorklet_(worklet),
+      bufferLength_(bufferLength),
       inputChannelCount_(inputChannelCount),
       curBuffIndex_(0) {
-  buffs_.reserve(inputChannelCount_);
-  for (size_t i = 0; i < inputChannelCount_; ++i) {
-    buffs_.emplace_back(new uint8_t[buffRealLength_]);
-  }
+  bus_ = std::make_shared<AudioBus>(
+      bufferLength, inputChannelCount, context->getSampleRate());
   isInitialized_ = true;
 }
 
-WorkletNode::~WorkletNode() {
-  for (auto &buff : buffs_) {
-    delete[] buff;
-  }
-}
-
 std::shared_ptr<AudioBus> WorkletNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
@@ -40,17 +31,11 @@ std::shared_ptr<AudioBus> WorkletNode::processNode(
     size_t needsToProcess = framesToProcess - processed;
     size_t shouldProcess = std::min(framesToWorkletInvoke, needsToProcess);
 
-    for (size_t ch = 0; ch < channelCount_; ch++) {
-      /// here we copy
-      /// to   uint8_t* [curBuffIndex_, curBuffIndex_ + shouldProcess]
-      /// from float* [processed, processed + shouldProcess]
-      /// so as the we need to copy shouldProcess * sizeof(float) bytes
-      auto channelData = processingBus->getChannel(ch)->getData();
-      std::memcpy(
-          /* dest */ buffs_[ch] + curBuffIndex_ * sizeof(float),
-          /* src */ reinterpret_cast<const uint8_t *>(channelData + processed),
-          /* size */ shouldProcess * sizeof(float));
-    }
+    /// here we copy
+    /// to [curBuffIndex_, curBuffIndex_ + shouldProcess]
+    /// from [processed, processed + shouldProcess]
+    bus_->copy(processingBus.get(), processed, curBuffIndex_, shouldProcess);
+
     processed += shouldProcess;
     curBuffIndex_ += shouldProcess;
 
@@ -63,16 +48,19 @@ std::shared_ptr<AudioBus> WorkletNode::processNode(
             /// Arguments preparation
             auto jsArray = jsi::Array(uiRuntimeRaw, channelCount_);
             for (size_t ch = 0; ch < channelCount_; ch++) {
-              uint8_t *buffPtr = buffs_[ch];
-              buffs_[ch] = new uint8_t[buffRealLength_];
+              auto audioArray = std::make_shared<AudioArray>(bufferLength_);
+              audioArray->copy(bus_->getChannel(ch));
               auto sharedAudioArray =
-                  std::make_shared<AudioArrayBuffer>(buffPtr, buffRealLength_);
+                  std::make_shared<AudioArrayBuffer>(audioArray);
+              auto sharedAudioArraySize = sharedAudioArray->size();
               auto arrayBuffer =
                   jsi::ArrayBuffer(uiRuntimeRaw, std::move(sharedAudioArray));
+              arrayBuffer.setExternalMemoryPressure(
+                  uiRuntimeRaw, sharedAudioArraySize);
               jsArray.setValueAtIndex(uiRuntimeRaw, ch, std::move(arrayBuffer));
             }
-            jsArray.setExternalMemoryPressure(
-                uiRuntimeRaw, channelCount_ * buffRealLength_);
+
+            bus_->zero();
 
             workletRunner_.executeWorklet(
                 shareableWorklet_,

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

@@ -42,7 +42,7 @@ class WorkletNode : public AudioNode {
       size_t inputChannelCount
   );
 
-  ~WorkletNode() override;
+  ~WorkletNode() override = default;
 
  protected:
   std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
@@ -51,10 +51,9 @@ class WorkletNode : public AudioNode {
  private:
   WorkletsRunner workletRunner_;
   std::shared_ptr<worklets::SerializableWorklet> shareableWorklet_;
-  std::vector<uint8_t*> buffs_;
+  std::shared_ptr<AudioBus> bus_;
 
   /// @brief Length of the byte buffer that will be passed to the AudioArrayBuffer
-  size_t buffRealLength_;
   size_t bufferLength_;
   size_t inputChannelCount_;
   size_t curBuffIndex_;

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

@@ -16,13 +16,12 @@ WorkletProcessingNode::WorkletProcessingNode(
   outputBuffsHandles_.resize(maxChannelCount);
 
   for (size_t i = 0; i < maxChannelCount; ++i) {
-    auto inputBuff = new uint8_t[RENDER_QUANTUM_SIZE * sizeof(float)];
-    inputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(
-        inputBuff, RENDER_QUANTUM_SIZE * sizeof(float));
+    auto inputAudioArray = std::make_shared<AudioArray>(RENDER_QUANTUM_SIZE);
+    inputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(inputAudioArray);
 
-    auto outputBuff = new uint8_t[RENDER_QUANTUM_SIZE * sizeof(float)];
-    outputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(
-        outputBuff, RENDER_QUANTUM_SIZE * sizeof(float));
+    auto outputAudioArray = std::make_shared<AudioArray>(RENDER_QUANTUM_SIZE);
+    outputBuffsHandles_[i] =
+        std::make_shared<AudioArrayBuffer>(outputAudioArray);
   }
 }
 

package/common/cpp/audioapi/core/sources/AudioBuffer.h

@@ -37,6 +37,7 @@ class AudioBuffer : public std::enable_shared_from_this<AudioBuffer> {
  private:
   friend class AudioBufferSourceNode;
   friend class AudioBufferQueueSourceNode;
+  friend class AudioBufferHostObject;
 
   std::shared_ptr<AudioBus> bus_;
 };

package/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.cpp

@@ -27,10 +27,6 @@ AudioBufferBaseSourceNode::AudioBufferBaseSourceNode(
       std::make_shared<signalsmith::stretch::SignalsmithStretch<float>>();
 }
 
-AudioBufferBaseSourceNode::~AudioBufferBaseSourceNode() {
-  clearOnPositionChangedCallback();
-}
-
 std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getDetuneParam() const {
   return detuneParam_;
 }

package/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.h

@@ -15,7 +15,6 @@ class AudioParam;
 class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
  public:
   explicit AudioBufferBaseSourceNode(BaseAudioContext *context, bool pitchCorrection);
-  ~AudioBufferBaseSourceNode() override;
 
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;

package/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp

@@ -29,8 +29,6 @@ AudioBufferSourceNode::~AudioBufferSourceNode() {
 
   buffer_.reset();
   alignedBus_.reset();
-
-  clearOnLoopEndedCallback();
 }
 
 bool AudioBufferSourceNode::getLoop() const {

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp

@@ -16,10 +16,6 @@ AudioScheduledSourceNode::AudioScheduledSourceNode(BaseAudioContext *context)
   numberOfInputs_ = 0;
 }
 
-AudioScheduledSourceNode::~AudioScheduledSourceNode() {
-  clearOnEndedCallback();
-}
-
 void AudioScheduledSourceNode::start(double when) {
   playbackState_ = PlaybackState::SCHEDULED;
   startTime_ = when;

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h

@@ -27,7 +27,6 @@ class AudioScheduledSourceNode : public AudioNode {
   // FINISHED: The node has finished playing.
   enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, STOP_SCHEDULED, FINISHED };
   explicit AudioScheduledSourceNode(BaseAudioContext *context);
-  ~AudioScheduledSourceNode() override;
 
   void start(double when);
   virtual void stop(double when);

package/common/cpp/audioapi/core/sources/StreamerNode.cpp

@@ -44,10 +44,14 @@ bool StreamerNode::initialize(const std::string &input_url) {
   }
 
   if (!openInput(input_url)) {
+    if (VERBOSE)
+      printf("Failed to open input\n");
     return false;
   }
 
   if (!findAudioStream() || !setupDecoder() || !setupResampler()) {
+    if (VERBOSE)
+      printf("Failed to find/setup audio stream\n");
     cleanup();
     return false;
   }
@@ -56,6 +60,8 @@ bool StreamerNode::initialize(const std::string &input_url) {
   frame_ = av_frame_alloc();
 
   if (pkt_ == nullptr || frame_ == nullptr) {
+    if (VERBOSE)
+      printf("Failed to allocate packet or frame\n");
     cleanup();
     return false;
   }
@@ -119,29 +125,24 @@ void StreamerNode::streamAudio() {
   while (streamFlag.load()) {
     if (pendingFrame_ != nullptr) {
       if (!processFrameWithResampler(pendingFrame_)) {
-        cleanup();
         return;
       }
     } else {
       if (av_read_frame(fmtCtx_, pkt_) < 0) {
-        cleanup();
         return;
       }
       if (pkt_->stream_index == audio_stream_index_) {
         if (avcodec_send_packet(codecCtx_, pkt_) != 0) {
-          cleanup();
           return;
         }
         if (avcodec_receive_frame(codecCtx_, frame_) != 0) {
-          cleanup();
           return;
         }
         if (!processFrameWithResampler(frame_)) {
-          cleanup();
           return;
         }
-        av_packet_unref(pkt_);
       }
+      av_packet_unref(pkt_);
     }
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
   }
@@ -174,6 +175,13 @@ std::shared_ptr<AudioBus> StreamerNode::processNode(
           (maxBufferSize_ - offsetLength) * sizeof(float));
     }
     bufferedBusIndex_ -= offsetLength;
+  } else {
+    if (VERBOSE)
+      printf(
+          "Buffer underrun: have %zu, need %zu\n",
+          bufferedBusIndex_,
+          (size_t)framesToProcess);
+    processingBus->zero();
   }
 
   return processingBus;
@@ -273,6 +281,8 @@ bool StreamerNode::setupDecoder() {
 
 void StreamerNode::cleanup() {
   streamFlag.store(false);
+  // cleanup cannot be called from the streaming thread so there is no need to
+  // check if we are in the same thread
   streamingThread_.join();
   if (swrCtx_ != nullptr) {
     swr_free(&swrCtx_);

package/common/cpp/audioapi/core/sources/StreamerNode.h

@@ -28,6 +28,8 @@ extern "C" {
 #include <string>
 #include <atomic>
 
+static bool constexpr VERBOSE = false;
+
 namespace audioapi {
 
 class AudioBus;
@@ -94,7 +96,7 @@ class StreamerNode : public AudioScheduledSourceNode {
 
   /**
    * @brief Open the input stream
-   * @param input_url The URL of the input stream
+   * @param inputUrl The URL of the input stream
    * @return true if successful, false otherwise
    * @note This function initializes the FFmpeg libraries and opens the input stream
    */

package/common/cpp/audioapi/core/sources/WorkletSourceNode.cpp

@@ -16,9 +16,8 @@ WorkletSourceNode::WorkletSourceNode(
   size_t outputChannelCount = this->getChannelCount();
   outputBuffsHandles_.resize(outputChannelCount);
   for (size_t i = 0; i < outputChannelCount; ++i) {
-    auto buff = new uint8_t[RENDER_QUANTUM_SIZE * sizeof(float)];
-    outputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(
-        buff, RENDER_QUANTUM_SIZE * sizeof(float));
+    auto audioArray = std::make_shared<AudioArray>(RENDER_QUANTUM_SIZE);
+    outputBuffsHandles_[i] = std::make_shared<AudioArrayBuffer>(audioArray);
   }
 }
 

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.cpp

@@ -156,8 +156,12 @@ void AudioEventHandlerRegistry::invokeHandlerWithEventBody(
 
     // In case of debugging this, please increment the hours spent counter
 
-    // Hours spent on this: 5
+    // Hours spent on this: 8
     try {
+      if (!handlerIt->second || !handlerIt->second->isFunction(*runtime_)) {
+        // If the handler is not valid, we can skip it
+        return;
+      }
       jsi::Object eventObject(*runtime_);
       // handle special logic for microphone, because we pass audio buffer which
       // has significant size

package/common/cpp/audioapi/external/libavformat.xcframework/Info.plist

@@ -8,32 +8,32 @@
 			<key>BinaryPath</key>
 			<string>libavformat.framework/libavformat</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libavformat.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>libavformat.framework/libavformat</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>libavformat.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/common/cpp/audioapi/external/libswresample.xcframework/Info.plist

@@ -8,32 +8,32 @@
 			<key>BinaryPath</key>
 			<string>libswresample.framework/libswresample</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>libswresample.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>libswresample.framework/libswresample</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libswresample.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/common/cpp/audioapi/jsi/AudioArrayBuffer.cpp

@@ -3,11 +3,11 @@
 namespace audioapi {
 
 size_t AudioArrayBuffer::size() const {
-  return size_;
+  return audioArray_->getSize() * sizeof(float);
 }
 
 uint8_t *AudioArrayBuffer::data() {
-  return data_;
+  return reinterpret_cast<uint8_t *>(audioArray_->getData());
 }
 
 } // namespace audioapi

package/common/cpp/audioapi/jsi/AudioArrayBuffer.h

@@ -1,6 +1,10 @@
 #pragma once
 
 #include <jsi/jsi.h>
+#include <audioapi/utils/AudioArray.h>
+
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
@@ -8,16 +12,12 @@ using namespace facebook;
 
 class AudioArrayBuffer : public jsi::MutableBuffer {
  public:
-  AudioArrayBuffer(uint8_t *data, size_t size): data_(data), size_(size) {}
-  ~AudioArrayBuffer() override {
-    if (data_ == nullptr) {
-      return;
-    }
-    delete[] data_;
-  }
+  explicit AudioArrayBuffer(const std::shared_ptr<AudioArray> &audioArray): audioArray_(audioArray) {}
+  ~AudioArrayBuffer() override = default;
+
   AudioArrayBuffer(AudioArrayBuffer &&other) noexcept
-      : data_(other.data_), size_(other.size_) {
-    other.data_ = nullptr;
+      : audioArray_(std::move(other.audioArray_)) {
+    other.audioArray_ = nullptr;
   }
 
   AudioArrayBuffer(const AudioArrayBuffer &) = delete;
@@ -28,8 +28,7 @@ class AudioArrayBuffer : public jsi::MutableBuffer {
   uint8_t *data() override;
 
  private:
-  uint8_t *data_;
-  const size_t size_;
+  std::shared_ptr<AudioArray> audioArray_;
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/libs/ffmpeg/ffmpeg_setup.sh

@@ -42,7 +42,7 @@ COMMON_CONFIG="
 --disable-audiotoolbox
 --disable-videotoolbox
 --disable-hwaccels
---enable-protocol=https,tls,tcp
+--enable-protocol=https,tls,tcp,http
 --enable-demuxer=hls
 --enable-demuxer=mov
 --enable-demuxer=mp3

package/common/cpp/audioapi/utils/AudioBus.cpp

@@ -128,6 +128,10 @@ AudioArray *AudioBus::getChannelByType(int channelType) const {
   }
 }
 
+std::shared_ptr<AudioArray> AudioBus::getSharedChannel(int index) const {
+  return channels_[index];
+}
+
 AudioArray &AudioBus::operator[](size_t index) {
   return *channels_[index];
 }

package/common/cpp/audioapi/utils/AudioBus.h

@@ -34,6 +34,7 @@ class AudioBus {
   [[nodiscard]] size_t getSize() const;
   [[nodiscard]] AudioArray *getChannel(int index) const;
   [[nodiscard]] AudioArray *getChannelByType(int channelType) const;
+  [[nodiscard]] std::shared_ptr<AudioArray> getSharedChannel(int index) const;
 
   AudioArray &operator[](size_t index);
   const AudioArray &operator[](size_t index) const;

package/common/cpp/test/CMakeLists.txt

@@ -62,12 +62,15 @@ target_include_directories(rnaudioapi PUBLIC
 target_include_directories(rnaudioapi_libs PUBLIC
   ${ROOT}/packages/react-native-audio-api/common/cpp
 )
+
+file(GLOB_RECURSE test_src
+  CONFIGURE_DEPENDS
+  "src/*.cpp"
+)
+
 add_executable(
   tests
-  OscillatorTest.cpp
-  GainTest.cpp
-  AudioParamTest.cpp
-  StereoPannerTest.cpp
+  ${test_src}
 )
 
 add_compile_definitions(AUDIO_API_TEST_SUITE)

package/common/cpp/test/RunTests.sh

@@ -11,10 +11,10 @@ trap cleanup EXIT
 
 cd packages/react-native-audio-api/common/cpp/test
 
-cmake -S . -B build
+cmake -S . -B build -Wno-dev
 
 cd build
-make -j4
+make -j10
 ./tests
 cd ..
 

package/common/cpp/test/{AudioParamTest.cpp → src/AudioParamTest.cpp}

@@ -2,7 +2,7 @@
 #include <audioapi/core/OfflineAudioContext.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <gtest/gtest.h>
-#include "MockAudioEventHandlerRegistry.h"
+#include <test/src/MockAudioEventHandlerRegistry.h>
 
 using namespace audioapi;
 

package/common/cpp/test/src/ConstantSourceTest.cpp

@@ -0,0 +1,64 @@
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/sources/ConstantSourceNode.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <gtest/gtest.h>
+#include <test/src/MockAudioEventHandlerRegistry.h>
+
+using namespace audioapi;
+
+class ConstantSourceTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::unique_ptr<OfflineAudioContext> context;
+  static constexpr int sampleRate = 44100;
+
+  void SetUp() override {
+    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+    context = std::make_unique<OfflineAudioContext>(
+        2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
+  }
+};
+
+class TestableConstantSourceNode : public ConstantSourceNode {
+ public:
+  explicit TestableConstantSourceNode(BaseAudioContext *context)
+      : ConstantSourceNode(context) {}
+
+  void setOffsetParam(float value) {
+    getOffsetParam()->setValue(value);
+  }
+
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
+      int framesToProcess) override {
+    return ConstantSourceNode::processNode(processingBus, framesToProcess);
+  }
+};
+
+TEST_F(ConstantSourceTest, ConstantSourceCanBeCreated) {
+  auto constantSource = context->createConstantSource();
+  ASSERT_NE(constantSource, nullptr);
+}
+
+TEST_F(ConstantSourceTest, ConstantSourceOutputsConstantValue) {
+  static constexpr int FRAMES_TO_PROCESS = 4;
+
+  auto bus =
+      std::make_shared<audioapi::AudioBus>(FRAMES_TO_PROCESS, 1, sampleRate);
+  auto constantSource =
+      std::make_shared<TestableConstantSourceNode>(context.get());
+  constantSource->start(context->getCurrentTime());
+  auto resultBus = constantSource->processNode(bus, FRAMES_TO_PROCESS);
+
+  for (int i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    EXPECT_FLOAT_EQ((*resultBus->getChannel(0))[i], 1.0f);
+  }
+
+  constantSource->setOffsetParam(0.5f);
+  resultBus = constantSource->processNode(bus, FRAMES_TO_PROCESS);
+  for (int i = 0; i < FRAMES_TO_PROCESS; ++i) {
+    EXPECT_FLOAT_EQ((*resultBus->getChannel(0))[i], 0.5f);
+  }
+}

package/common/cpp/test/{GainTest.cpp → src/GainTest.cpp}

@@ -4,34 +4,35 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <gtest/gtest.h>
-#include "MockAudioEventHandlerRegistry.h"
+#include <test/src/MockAudioEventHandlerRegistry.h>
+
+using namespace audioapi;
 
 class GainTest : public ::testing::Test {
  protected:
-  std::shared_ptr<audioapi::IAudioEventHandlerRegistry> eventRegistry;
-  std::unique_ptr<audioapi::OfflineAudioContext> context;
+  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::unique_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
 
   void SetUp() override {
     eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
-    context = std::make_unique<audioapi::OfflineAudioContext>(
+    context = std::make_unique<OfflineAudioContext>(
         2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
   }
 };
 
-class TestableGainNode : public audioapi::GainNode {
+class TestableGainNode : public GainNode {
  public:
-  explicit TestableGainNode(audioapi::BaseAudioContext *context)
-      : audioapi::GainNode(context) {}
+  explicit TestableGainNode(BaseAudioContext *context) : GainNode(context) {}
 
   void setGainParam(float value) {
     getGainParam()->setValue(value);
   }
 
-  std::shared_ptr<audioapi::AudioBus> processNode(
-      const std::shared_ptr<audioapi::AudioBus> &processingBus,
+  std::shared_ptr<AudioBus> processNode(
+      const std::shared_ptr<AudioBus> &processingBus,
       int framesToProcess) override {
-    return audioapi::GainNode::processNode(processingBus, framesToProcess);
+    return GainNode::processNode(processingBus, framesToProcess);
   }
 };
 

package/common/cpp/test/{MockAudioEventHandlerRegistry.h → src/MockAudioEventHandlerRegistry.h}

@@ -6,9 +6,11 @@
 #include <string>
 #include <memory>
 
-using EventMap = std::unordered_map<std::string, audioapi::EventValue>;
+using namespace audioapi;
 
-class MockAudioEventHandlerRegistry : public audioapi::IAudioEventHandlerRegistry {
+using EventMap = std::unordered_map<std::string, EventValue>;
+
+class MockAudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
  public:
   MOCK_METHOD(uint64_t, registerHandler,
               (const std::string &eventName, const std::shared_ptr<facebook::jsi::Function> &handler), (override));

package/common/cpp/test/{OscillatorTest.cpp → src/OscillatorTest.cpp}

@@ -2,17 +2,19 @@
 #include <audioapi/core/sources/OscillatorNode.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <gtest/gtest.h>
-#include "MockAudioEventHandlerRegistry.h"
+#include <test/src/MockAudioEventHandlerRegistry.h>
+
+using namespace audioapi;
 
 class OscillatorTest : public ::testing::Test {
  protected:
-  std::shared_ptr<audioapi::IAudioEventHandlerRegistry> eventRegistry;
-  std::unique_ptr<audioapi::OfflineAudioContext> context;
+  std::shared_ptr<IAudioEventHandlerRegistry> eventRegistry;
+  std::unique_ptr<OfflineAudioContext> context;
   static constexpr int sampleRate = 44100;
 
   void SetUp() override {
     eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
-    context = std::make_unique<audioapi::OfflineAudioContext>(
+    context = std::make_unique<OfflineAudioContext>(
         2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
   }
 };

package/common/cpp/test/{StereoPannerTest.cpp → src/StereoPannerTest.cpp}

@@ -4,7 +4,7 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <gtest/gtest.h>
-#include "MockAudioEventHandlerRegistry.h"
+#include <test/src/MockAudioEventHandlerRegistry.h>
 
 using namespace audioapi;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-api",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification",
   "bin": {
     "setup-rn-audio-api-web": "./scripts/setup-rn-audio-api-web.js"