react-native-audio-api 0.12.1 → 0.12.2

package/README.md

@@ -28,9 +28,6 @@ check out the [Getting Started](https://docs.swmansion.com/react-native-audio-ap
 - **DynamicCompressorNode 〽️**<br />
   Reduce the volume of loud sounds and boost quieter nodes to balance the audio signal, avoid clipping or distorted sounds
 
-- **Audio tag 🏷️**<br />
-  Simple ability to play and buffer audio, with all of the most commonly used functions, same as on the web, without the need to create and manipulate an audio graph.
-
 - **MIDI support 🎸**<br />
   Complementary lib for react-native-audio-api, that will allow to communicate with MIDI devices or read/write MIDI files.
 
@@ -40,6 +37,14 @@ check out the [Getting Started](https://docs.swmansion.com/react-native-audio-ap
 - **Noise Cancellation 🦇**<br />
   System-based active noise and echo cancellation support
 
+### <a href="https://github.com/software-mansion/react-native-audio-api/releases/tag/0.12.0"><img src="https://img.shields.io/badge/Released_in-0.12.0-green" /></a>
+
+- **Audio tag 🏷️**<br />
+  Simple ability to play and buffer audio, with all of the most commonly used functions, same as on the web, without the need to create and manipulate an audio graph.
+
+- **Recording rotation 🎤**<br />
+  Ability to chunk your recording into smaller files, increasing resilience to unpredictable events.
+
 ### <a href="https://github.com/software-mansion/react-native-audio-api/releases/tag/0.11.0"><img src="https://img.shields.io/badge/Released_in-0.11.0-green" /></a>
 
 - **Recording to file 📼**<br />

package/RNAudioAPI.podspec

@@ -131,8 +131,6 @@ Pod::Spec.new do |s|
       -force_load #{lib_dir}/libvorbis.a
       -force_load #{lib_dir}/libvorbisenc.a
       -force_load #{lib_dir}/libvorbisfile.a
-      -force_load #{lib_dir}/libssl.a
-      -force_load #{lib_dir}/libcrypto.a
     ].join(" "),
   }
   # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.

package/android/src/main/cpp/audioapi/CMakeLists.txt

@@ -16,6 +16,14 @@ set_source_files_properties(
   COMPILE_FLAGS "-O3"
 )
 
+if(CMAKE_C_COMPILER_ID MATCHES "Clang")
+  set_source_files_properties(
+    "${COMMON_CPP_DIR}/audioapi/dsp/r8brain/fft/pffft_double.c"
+    PROPERTIES
+    COMPILE_FLAGS "-Wno-#pragma-messages"
+  )
+endif()
+
 set(INCLUDE_DIR ${COMMON_CPP_DIR}/audioapi/external/include)
 set(FFMPEG_INCLUDE_DIR ${COMMON_CPP_DIR}/audioapi/external/include_ffmpeg)
 set(EXTERNAL_DIR ${COMMON_CPP_DIR}/audioapi/external/android)
@@ -132,8 +140,6 @@ target_link_libraries(react-native-audio-api
   vorbis
   vorbisenc
   vorbisfile
-  crypto
-  ssl
   z
 )
 

package/android/src/main/cpp/audioapi/android/AudioAPIModule.cpp

@@ -1,7 +1,6 @@
 #include <audioapi/android/AudioAPIModule.h>
+#include <audioapi/android/JniEventPayloadParser.h>
 #include <memory>
-#include <string>
-#include <unordered_map>
 
 namespace audioapi {
 
@@ -66,34 +65,13 @@ void AudioAPIModule::injectJSIBindings() {
 void AudioAPIModule::invokeHandlerWithEventNameAndEventBody(
     jint eventOrdinal,
     jni::alias_ref<jni::JMap<jstring, jobject>> eventBody) {
-  std::unordered_map<std::string, EventValue> body = {};
-
-  for (const auto &entry : *eventBody) {
-    std::string name = entry.first->toStdString();
-    auto value = entry.second;
-
-    if (value->isInstanceOf(jni::JString::javaClassStatic())) {
-      body[name] = jni::static_ref_cast<jni::JString>(value)->toStdString();
-    } else if (value->isInstanceOf(jni::JInteger::javaClassStatic())) {
-      body[name] = jni::static_ref_cast<jni::JInteger>(value)->value();
-    } else if (value->isInstanceOf(jni::JDouble::javaClassStatic())) {
-      body[name] = jni::static_ref_cast<jni::JDouble>(value)->value();
-    } else if (value->isInstanceOf(jni::JFloat::javaClassStatic())) {
-      body[name] = jni::static_ref_cast<jni::JFloat>(value)->value();
-    } else if (value->isInstanceOf(jni::JBoolean::javaClassStatic())) {
-      auto booleanValue = jni::static_ref_cast<jni::JBoolean>(value)->value();
-
-      if (booleanValue) {
-        body[name] = true;
-      } else {
-        body[name] = false;
-      }
-    }
+  if (audioEventHandlerRegistry_ == nullptr) {
+    return;
   }
 
-  if (audioEventHandlerRegistry_ != nullptr) {
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        static_cast<audioapi::AudioEvent>(eventOrdinal), body);
-  }
+  auto event = static_cast<AudioEvent>(eventOrdinal);
+  audioEventHandlerRegistry_->dispatchEvent(
+      event, kBroadcastListenerId, buildPayloadFromJniMap(event, eventBody));
 }
+
 } // namespace audioapi

package/android/src/main/cpp/audioapi/android/JniEventPayloadParser.cpp

@@ -0,0 +1,83 @@
+#include <audioapi/android/JniEventPayloadParser.h>
+#include <string>
+
+namespace audioapi {
+
+using namespace facebook;
+
+jni::local_ref<jobject> jniMapGet(
+    const jni::alias_ref<jni::JMap<jstring, jobject>> &map,
+    const char *key) {
+  if (!map) {
+    return nullptr;
+  }
+
+  static auto getMethod =
+      jni::JMap<jstring, jobject>::javaClassStatic()->getMethod<jobject(jobject)>("get");
+
+  auto jKey = jni::make_jstring(key);
+  return getMethod(map, jKey.get());
+}
+
+double jniGetDouble(const jni::alias_ref<jni::JMap<jstring, jobject>> &map, const char *key) {
+  auto val = jniMapGet(map, key);
+  if (!val) {
+    return 0.0;
+  }
+
+  if (val->isInstanceOf(jni::JDouble::javaClassStatic())) {
+    return jni::static_ref_cast<jni::JDouble>(val)->value();
+  }
+
+  if (val->isInstanceOf(jni::JFloat::javaClassStatic())) {
+    return static_cast<double>(jni::static_ref_cast<jni::JFloat>(val)->value());
+  }
+
+  if (val->isInstanceOf(jni::JInteger::javaClassStatic())) {
+    return static_cast<double>(jni::static_ref_cast<jni::JInteger>(val)->value());
+  }
+
+  if (val->isInstanceOf(jni::JLong::javaClassStatic())) {
+    return static_cast<double>(jni::static_ref_cast<jni::JLong>(val)->value());
+  }
+
+  return 0.0;
+}
+
+std::string jniGetString(const jni::alias_ref<jni::JMap<jstring, jobject>> &map, const char *key) {
+  auto val = jniMapGet(map, key);
+  if (val && val->isInstanceOf(jni::JString::javaClassStatic())) {
+    return jni::static_ref_cast<jni::JString>(val)->toStdString();
+  }
+
+  return {};
+}
+
+bool jniGetBool(const jni::alias_ref<jni::JMap<jstring, jobject>> &map, const char *key) {
+  auto val = jniMapGet(map, key);
+  if (val && val->isInstanceOf(jni::JBoolean::javaClassStatic())) {
+    return static_cast<bool>(jni::static_ref_cast<jni::JBoolean>(val)->value());
+  }
+  return false;
+}
+
+AudioEventPayload buildPayloadFromJniMap(
+    AudioEvent event,
+    const jni::alias_ref<jni::JMap<jstring, jobject>> &map) {
+  switch (event) {
+    case AudioEvent::INTERRUPTION:
+      return InterruptionPayload{
+          .type = jniGetString(map, "type"), .shouldResume = jniGetBool(map, "shouldResume")};
+
+    case AudioEvent::VOLUME_CHANGE:
+    case AudioEvent::PLAYBACK_NOTIFICATION_SKIP_FORWARD:
+    case AudioEvent::PLAYBACK_NOTIFICATION_SKIP_BACKWARD:
+    case AudioEvent::PLAYBACK_NOTIFICATION_SEEK_TO:
+      return DoubleValuePayload{.value = jniGetDouble(map, "value")};
+
+    default:
+      return EmptyPayload{};
+  }
+}
+
+} // namespace audioapi

package/android/src/main/cpp/audioapi/android/JniEventPayloadParser.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <audioapi/events/AudioEvent.h>
+#include <audioapi/events/AudioEventPayload.h>
+#include <fbjni/fbjni.h>
+
+namespace audioapi {
+
+/// @brief Builds AudioEventPayload from a JNI map passed from Java/Kotlin.
+AudioEventPayload buildPayloadFromJniMap(
+    AudioEvent event,
+    const facebook::jni::alias_ref<facebook::jni::JMap<jstring, jobject>> &map);
+
+} // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp

@@ -575,9 +575,10 @@ void AndroidAudioRecorder::onErrorAfterClose(oboe::AudioStream *stream, oboe::Re
       }
 
       std::string message = "Android recorder error: " + streamResult.unwrap_err();
-      std::unordered_map<std::string, EventValue> eventPayload{{"message", std::move(message)}};
-      audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-          AudioEvent::RECORDER_ERROR, callbackId, eventPayload);
+      audioEventHandlerRegistry_->dispatchEvent(
+          AudioEvent::RECORDER_ERROR,
+          callbackId,
+          StringPayload{.name = "message", .reason = std::move(message)});
       return;
     }
 

package/android/src/main/cpp/audioapi/android/core/AudioPlayer.cpp

@@ -31,6 +31,7 @@ bool AudioPlayer::openAudioStream() {
       ->setPerformanceMode(PerformanceMode::None)
       ->setChannelCount(channelCount_)
       ->setSampleRateConversionQuality(SampleRateConversionQuality::Medium)
+      ->setFramesPerDataCallback(RENDER_QUANTUM_SIZE)
       ->setDataCallback(this)
       ->setSampleRate(static_cast<int>(sampleRate_))
       ->setErrorCallback(this);

package/android/src/main/cpp/audioapi/android/core/utils/AndroidRecorderCallback.cpp

@@ -7,6 +7,7 @@
 #include <audioapi/utils/CircularArray.hpp>
 
 #include <algorithm>
+#include <cstring>
 #include <memory>
 #include <string>
 #include <unordered_map>
@@ -35,20 +36,7 @@ AndroidRecorderCallback::AndroidRecorderCallback(
           callbackId) {}
 
 AndroidRecorderCallback::~AndroidRecorderCallback() {
-  if (converter_ != nullptr) {
-    ma_data_converter_uninit(converter_.get(), nullptr);
-    converter_.reset();
-  }
-
-  if (processingBuffer_ != nullptr) {
-    ma_free(processingBuffer_, nullptr);
-    processingBuffer_ = nullptr;
-    processingBufferLength_ = 0;
-  }
-
-  for (size_t i = 0; i < circularBuffer_.size(); ++i) {
-    circularBuffer_[i]->zero();
-  }
+  cleanup();
 }
 
 /// @brief Prepares the recorder callback by initializing the data converter and allocating necessary buffers.
@@ -111,6 +99,10 @@ Result<NoneType, std::string> AndroidRecorderCallback::prepare(
 }
 
 void AndroidRecorderCallback::cleanup() {
+  std::scoped_lock audioLock(destructionAudioGuard_);
+  // join the worker
+  offloader_.reset();
+
   if (circularBuffer_[0]->getNumberOfAvailableFrames() > 0) {
     emitAudioData(true);
   }
@@ -126,10 +118,9 @@ void AndroidRecorderCallback::cleanup() {
     processingBufferLength_ = 0;
   }
 
-  for (size_t i = 0; i < circularBuffer_.size(); ++i) {
-    circularBuffer_[i]->zero();
+  for (const auto &arr : circularBuffer_) {
+    arr->zero();
   }
-  offloader_.reset();
 }
 
 /// @brief Receives audio data from the recorder, processes it (resampling and deinterleaving if necessary),
@@ -137,11 +128,27 @@ void AndroidRecorderCallback::cleanup() {
 /// @param data Pointer to the incoming audio data.
 /// @param numFrames Number of frames in the incoming audio data.
 void AndroidRecorderCallback::receiveAudioData(void *data, int numFrames) {
+  // if we wait here, we are in the middle of the destruction
+  std::scoped_lock lock(destructionAudioGuard_);
+  if (offloader_ == nullptr) {
+    return;
+  }
   if (!isInitialized_.load(std::memory_order_acquire)) {
     return;
   }
 
-  offloader_->getSender()->send({data, numFrames});
+  // Oboe owns `data` only for the duration of this synchronous callback.
+  // Copy into an owned buffer before handing off to the worker thread; the
+  // consumer in taskOffloaderFunction frees it.
+  size_t bytes =
+      static_cast<size_t>(numFrames) * streamChannelCount_ * ma_get_bytes_per_sample(ma_format_f32);
+  void *owned = ma_malloc(bytes, nullptr);
+  if (owned == nullptr) {
+    return;
+  }
+  std::memcpy(owned, data, bytes);
+
+  offloader_->getSender()->send({.data = owned, .numFrames = numFrames});
 }
 
 /// @brief Deinterleaves the audio data and pushes it into the circular buffer.
@@ -151,7 +158,7 @@ void AndroidRecorderCallback::deinterleaveAndPushAudioData(void *data, int numFr
   auto *inputData = static_cast<float *>(data);
   deinterleavingBuffer_->deinterleaveFrom(inputData, numFrames);
 
-  for (size_t ch = 0; ch < channelCount_; ++ch) {
+  for (int ch = 0; ch < channelCount_; ++ch) {
     circularBuffer_[ch]->push_back(*deinterleavingBuffer_->getChannel(ch), numFrames);
   }
 }
@@ -160,16 +167,23 @@ void AndroidRecorderCallback::deinterleaveAndPushAudioData(void *data, int numFr
 /// processes it (resampling and deinterleaving if necessary), and pushes it into the circular buffer.
 void AndroidRecorderCallback::taskOffloaderFunction(CallbackData callbackData) {
   auto [data, numFrames] = callbackData;
+
+  // The TaskOffloader destructor sends a default-constructed CallbackData
+  // (data == nullptr) to unblock the receiver; ignore it here.
+  if (data == nullptr) {
+    return;
+  }
+
   ma_uint64 inputFrameCount = numFrames;
   ma_uint64 outputFrameCount = 0;
 
-  if (static_cast<float>(streamSampleRate_) == sampleRate_ &&
-      streamChannelCount_ == channelCount_) {
+  if (streamSampleRate_ == sampleRate_ && streamChannelCount_ == channelCount_) {
     deinterleaveAndPushAudioData(data, numFrames);
 
     if (circularBuffer_[0]->getNumberOfAvailableFrames() >= bufferLength_) {
       emitAudioData();
     }
+    ma_free(data, nullptr);
     return;
   }
 
@@ -184,6 +198,8 @@ void AndroidRecorderCallback::taskOffloaderFunction(CallbackData callbackData) {
   if (circularBuffer_[0]->getNumberOfAvailableFrames() >= bufferLength_) {
     emitAudioData();
   }
+
+  ma_free(data, nullptr);
 }
 
 } // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/utils/AndroidRecorderCallback.h

@@ -29,7 +29,7 @@ class AndroidRecorderCallback : public AudioRecorderCallback {
 
   Result<NoneType, std::string>
   prepare(float streamSampleRate, int streamChannelCount, size_t maxInputBufferLength);
-  void cleanup() override;
+  void cleanup() final;
 
   void receiveAudioData(void *data, int numFrames);
 

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -5,6 +5,7 @@
 #include <audioapi/HostObjects/inputs/AudioRecorderHostObject.h>
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/HostObjects/utils/AudioDecoderHostObject.h>
+#include <audioapi/HostObjects/utils/AudioFileUtilsHostObject.h>
 #include <audioapi/HostObjects/utils/AudioStretcherHostObject.h>
 #include <audioapi/core/AudioContext.h>
 #include <audioapi/core/OfflineAudioContext.h>
@@ -37,6 +38,7 @@ class AudioAPIModuleInstaller {
         jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, uiRuntime);
     auto createAudioBuffer = getCreateAudioBufferFunction(jsiRuntime);
     auto createAudioDecoder = getCreateAudioDecoderFunction(jsiRuntime, jsCallInvoker);
+    auto createAudioFileUtils = getCreateAudioFileUtilsFunction(jsiRuntime, jsCallInvoker);
     auto createAudioStretcher = getCreateAudioStretcherFunction(jsiRuntime, jsCallInvoker);
 
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioContext", createAudioContext);
@@ -45,6 +47,7 @@ class AudioAPIModuleInstaller {
         *jsiRuntime, "createOfflineAudioContext", createOfflineAudioContext);
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioBuffer", createAudioBuffer);
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioDecoder", createAudioDecoder);
+    jsiRuntime->global().setProperty(*jsiRuntime, "createAudioFileUtils", createAudioFileUtils);
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioStretcher", createAudioStretcher);
 
     auto audioEventHandlerRegistryHostObject =
@@ -185,6 +188,24 @@ class AudioAPIModuleInstaller {
         });
   }
 
+  static jsi::Function getCreateAudioFileUtilsFunction(
+      jsi::Runtime *jsiRuntime,
+      const std::shared_ptr<react::CallInvoker> &jsCallInvoker) {
+    return jsi::Function::createFromHostFunction(
+        *jsiRuntime,
+        jsi::PropNameID::forAscii(*jsiRuntime, "createAudioFileUtils"),
+        0,
+        [jsCallInvoker](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+          auto audioFileUtilsHostObject =
+              std::make_shared<AudioFileUtilsHostObject>(&runtime, jsCallInvoker);
+          return jsi::Object::createFromHostObject(runtime, audioFileUtilsHostObject);
+        });
+  }
+
   static jsi::Function getCreateAudioBufferFunction(jsi::Runtime *jsiRuntime) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,

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

@@ -68,9 +68,24 @@ JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, enqueueBuffer) {
   auto audioBufferHostObject =
       args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
   // TODO: add optimized memory management for buffer changes, e.g.
-  //  when the same buffer is reused across threads and
+  // when the same buffer is reused across threads and
   // buffer modification is not allowed on JS thread
-  auto copiedBuffer = std::make_shared<AudioBuffer>(*audioBufferHostObject->audioBuffer_);
+
+  auto swapBuffer = false; // whether to swap internal node buffer with the new buffer
+  if (!channelCountSet_) {
+    channelCount_ = static_cast<int>(audioBufferHostObject->audioBuffer_->getNumberOfChannels());
+    channelCountSet_ = true;
+    swapBuffer = true;
+  }
+
+  // first buffer defines channel count, rest of them is mixed to channel count of the first buffer
+  auto copiedBuffer = std::make_shared<AudioBuffer>(
+      audioBufferHostObject->audioBuffer_->getSize(),
+      channelCount_,
+      audioBufferHostObject->audioBuffer_->getSampleRate());
+
+  copiedBuffer->sum(*audioBufferHostObject->audioBuffer_);
+
   std::shared_ptr<AudioBuffer> tailBuffer = nullptr;
 
   if (pitchCorrection_ && !stretchHasBeenInit_) {
@@ -84,8 +99,15 @@ JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, enqueueBuffer) {
     stretchHasBeenInit_ = true;
   }
 
-  auto event = [audioBufferQueueSourceNode, copiedBuffer, bufferId = bufferId_, tailBuffer](
-                   BaseAudioContext &) {
+  auto event = [audioBufferQueueSourceNode,
+                copiedBuffer,
+                bufferId = bufferId_,
+                tailBuffer,
+                swapBuffer,
+                channelCount = channelCount_](BaseAudioContext &) {
+    if (swapBuffer) {
+      audioBufferQueueSourceNode->setChannelCount(static_cast<int>(channelCount));
+    }
     audioBufferQueueSourceNode->enqueueBuffer(copiedBuffer, bufferId, tailBuffer);
   };
   audioBufferQueueSourceNode->scheduleAudioEvent(std::move(event));

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

@@ -30,6 +30,7 @@ class AudioBufferQueueSourceNodeHostObject : public AudioBufferBaseSourceNodeHos
   size_t bufferId_ = 0;
   uint64_t onBufferEndedCallbackId_ = 0;
   bool stretchHasBeenInit_ = false;
+  bool channelCountSet_ = false;
 
   void setOnBufferEndedCallbackId(uint64_t callbackId);
 };

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

@@ -14,8 +14,8 @@ AudioFileSourceNodeHostObject::AudioFileSourceNodeHostObject(
     const AudioFileSourceOptions &options)
     : AudioScheduledSourceNodeHostObject(context->createFileSource(options), options),
       loop_(options.loop),
-      volume_(options.volume),
-      duration_(std::static_pointer_cast<AudioFileSourceNode>(node_)->getDuration()) {
+      duration_(std::static_pointer_cast<AudioFileSourceNode>(node_)->getDuration()),
+      volume_(options.volume) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AudioFileSourceNodeHostObject, volume),
       JSI_EXPORT_PROPERTY_GETTER(AudioFileSourceNodeHostObject, loop),

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

@@ -28,7 +28,7 @@ JSI_HOST_FUNCTION_IMPL(AudioDecoderHostObject, decodeWithMemoryBlock) {
   auto sampleRate = static_cast<float>(args[1].getNumber());
 
   auto promise = promiseVendor_->createAsyncPromise([data, size, sampleRate]() -> PromiseResolver {
-    auto result = AudioDecoder::decodeWithMemoryBlock(data, size, sampleRate);
+    auto result = audiodecoder::decodeWithMemoryBlock(data, size, sampleRate);
 
     if (result.is_err()) {
       return [result = std::move(result)](
@@ -54,7 +54,7 @@ JSI_HOST_FUNCTION_IMPL(AudioDecoderHostObject, decodeWithFilePath) {
   auto sampleRate = static_cast<float>(args[1].getNumber());
 
   auto promise = promiseVendor_->createAsyncPromise([sourcePath, sampleRate]() -> PromiseResolver {
-    auto result = AudioDecoder::decodeWithFilePath(sourcePath, sampleRate);
+    auto result = audiodecoder::decodeWithFilePath(sourcePath, sampleRate);
 
     if (result.is_err()) {
       return [result = std::move(result)](
@@ -84,7 +84,7 @@ JSI_HOST_FUNCTION_IMPL(AudioDecoderHostObject, decodeWithPCMInBase64) {
 
   auto promise = promiseVendor_->createAsyncPromise(
       [b64, inputSampleRate, inputChannelCount, interleaved]() -> PromiseResolver {
-        auto result = AudioDecoder::decodeWithPCMInBase64(
+        auto result = audiodecoder::decodeWithPCMInBase64(
             b64, inputSampleRate, inputChannelCount, interleaved);
 
         if (result.is_err()) {

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

@@ -0,0 +1,60 @@
+#include <audioapi/HostObjects/utils/AudioFileUtilsHostObject.h>
+#include <audioapi/core/utils/AudioFileConcatenator.h>
+#include <audioapi/jsi/JsiPromise.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace audioapi {
+
+AudioFileUtilsHostObject::AudioFileUtilsHostObject(
+    jsi::Runtime *runtime,
+    const std::shared_ptr<react::CallInvoker> &callInvoker) {
+  promiseVendor_ = std::make_shared<PromiseVendor>(runtime, callInvoker);
+  addFunctions(JSI_EXPORT_FUNCTION(AudioFileUtilsHostObject, concatAudioFiles));
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioFileUtilsHostObject, concatAudioFiles) {
+  if (count < 2 || !args[0].isObject() || !args[1].isString()) {
+    throw jsi::JSError(runtime, "concatAudioFiles expects input paths and an output path.");
+  }
+
+  auto inputPathArray = args[0].asObject(runtime).asArray(runtime);
+  const auto inputPathCount = inputPathArray.size(runtime);
+  std::vector<std::string> inputPaths;
+  inputPaths.reserve(inputPathCount);
+
+  for (size_t i = 0; i < inputPathCount; ++i) {
+    auto value = inputPathArray.getValueAtIndex(runtime, i);
+    if (!value.isString()) {
+      throw jsi::JSError(runtime, "concatAudioFiles input paths must be strings.");
+    }
+    inputPaths.push_back(value.asString(runtime).utf8(runtime));
+  }
+
+  auto outputPath = args[1].asString(runtime).utf8(runtime);
+
+  auto promise = promiseVendor_->createAsyncPromise(
+      [inputPaths = std::move(inputPaths), outputPath]() -> PromiseResolver {
+        auto result = audioapi::concatAudioFiles(inputPaths, outputPath);
+
+        if (result.is_err()) {
+          return [result = std::move(result)](
+                     jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
+            return result.unwrap_err();
+          };
+        }
+
+        return [outputPath = std::move(outputPath)](
+                   jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
+          return jsi::String::createFromUtf8(runtime, outputPath);
+        };
+      });
+
+  return promise;
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <audioapi/jsi/JsiHostObject.h>
+#include <audioapi/jsi/JsiPromise.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioFileUtilsHostObject : public JsiHostObject {
+ public:
+  explicit AudioFileUtilsHostObject(
+      jsi::Runtime *runtime,
+      const std::shared_ptr<react::CallInvoker> &callInvoker);
+
+  JSI_HOST_FUNCTION_DECL(concatAudioFiles);
+
+ private:
+  std::shared_ptr<PromiseVendor> promiseVendor_;
+};
+
+} // namespace audioapi

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

@@ -309,14 +309,14 @@ inline AudioFileSourceOptions parseAudioFileSourceOptions(
   if (sourceValue.isString()) {
     options.filePath = sourceValue.asString(runtime).utf8(runtime);
     options.requiresFFmpeg =
-        AudioDecoder::pathHasExtension(options.filePath, {".mp4", ".m4a", ".aac"});
+        audiodecoder::pathHasExtension(options.filePath, {".mp4", ".m4a", ".aac"});
   } else if (sourceValue.isObject()) {
     auto sourceObj = sourceValue.asObject(runtime);
     if (sourceObj.isArrayBuffer(runtime)) {
       auto arrayBuffer = sourceObj.getArrayBuffer(runtime);
       auto *data = arrayBuffer.data(runtime);
       auto size = arrayBuffer.size(runtime);
-      auto format = AudioDecoder::detectAudioFormat(data, size);
+      auto format = audiodecoder::detectAudioFormat(data, size);
       options.requiresFFmpeg =
           format == AudioFormat::MP4 || format == AudioFormat::M4A || format == AudioFormat::AAC;
       options.data = std::vector<uint8_t>(data, data + size);

package/common/cpp/audioapi/core/OfflineAudioContext.cpp

@@ -23,7 +23,6 @@ OfflineAudioContext::OfflineAudioContext(
     const RuntimeRegistry &runtimeRegistry)
     : BaseAudioContext(sampleRate, audioEventHandlerRegistry, runtimeRegistry),
       length_(length),
-      numberOfChannels_(numberOfChannels),
       currentSampleFrame_(0),
       audioBuffer_(
           std::make_shared<DSPAudioBuffer>(RENDER_QUANTUM_SIZE, numberOfChannels, sampleRate)),

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

@@ -41,7 +41,6 @@ class OfflineAudioContext : public BaseAudioContext {
   OfflineAudioContextResultCallback resultCallback_;
 
   const size_t length_;
-  const int numberOfChannels_;
   size_t currentSampleFrame_;
 
   std::shared_ptr<DSPAudioBuffer> audioBuffer_;

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

@@ -88,21 +88,15 @@ void ConvolverNode::onInputDisabled() {
   }
 }
 
-std::shared_ptr<DSPAudioBuffer> ConvolverNode::processInputs(
-    const std::shared_ptr<DSPAudioBuffer> &outputBuffer,
-    int framesToProcess,
-    bool checkIsAlreadyProcessed) {
-  if (internalBufferIndex_ < framesToProcess) {
-    return AudioNode::processInputs(outputBuffer, RENDER_QUANTUM_SIZE, false);
-  }
-  return AudioNode::processInputs(outputBuffer, 0, false);
-}
-
 // processing pipeline: processingBuffer -> intermediateBuffer_ -> audioBuffer_ (mixing
 // with intermediateBuffer_)
 std::shared_ptr<DSPAudioBuffer> ConvolverNode::processNode(
     const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
     int framesToProcess) {
+  if (processingBuffer->getSize() != RENDER_QUANTUM_SIZE) {
+    printf(
+        "[AUDIOAPI WARN] convolver requires 128 buffer size for each render quantum, otherwise quality of convolution is very poor\n");
+  }
   if (signalledToStop_) {
     if (remainingSegments_ > 0) {
       remainingSegments_--;