react-native-audio-api 0.13.0-nightly-51a651d-20260701 → 0.13.1

package/android/build.gradle

@@ -216,6 +216,7 @@ android {
       "**/librrc_root.so",
       "**/libjscexecutor.so",
       "**/libv8executor.so",
+      "**/libworklets.so",
       "**/libreanimated.so"
     ]
   }

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

@@ -1,5 +1,6 @@
 #include <audioapi/android/AudioAPIModule.h>
 #include <audioapi/android/JniEventPayloadParser.h>
+#include <audioapi/android/system/NativeFileInfo.hpp>
 #include <memory>
 
 namespace audioapi {
@@ -53,6 +54,9 @@ void AudioAPIModule::registerNatives() {
 }
 
 void AudioAPIModule::injectJSIBindings() {
+  // cache app directory paths on the attached thread
+  NativeFileInfo::warmCache();
+
 #if RN_AUDIO_API_ENABLE_WORKLETS
   auto uiWorkletRuntime = weakWorkletsModuleProxy_.lock()->getUIWorkletRuntime();
 #else

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

@@ -63,8 +63,8 @@ void AndroidFileWriterBackend::cleanupPreallocatedInputPool() {
 }
 
 void AndroidFileWriterBackend::writeAudioData(void *data, int numFrames) {
-  if (offloader_ == nullptr || freeSlots_ == nullptr || inputBufferBytesPerSlot_ == 0 ||
-      inputBuffers_.empty()) {
+  if (!isFileOpen() || offloader_ == nullptr || freeSlots_ == nullptr ||
+      inputBufferBytesPerSlot_ == 0 || inputBuffers_.empty()) {
     return;
   }
 

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

@@ -28,7 +28,9 @@ OpenFileResult AndroidRotatingFileWriter::openFile(
   streamSampleRate_ = streamSampleRate;
   streamChannelCount_ = streamChannelCount;
   streamMaxBufferSize_ = streamMaxBufferSizeInFrames;
-  fileProperties_->fileNamePrefix = !fileNameOverride.empty() ? fileNameOverride : "recording";
+  if (!fileNameOverride.empty()) {
+    fileProperties_->fileNamePrefix = fileNameOverride + fileProperties_->fileNamePrefix;
+  }
   if (currentWriter_ == nullptr) {
     currentWriter_ = writerFactory_(fileProperties_);
   }

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.cpp

@@ -108,7 +108,9 @@ CloseFileResult FFmpegAudioFileWriter::closeFile() {
     return CloseFileResult::Err("File is not open");
   }
 
-  // Joins the worker before draining/finalizing the encoder below.
+  isFileOpen_.store(false, std::memory_order_release);
+
+  // Drains the worker queue before flushing/finalizing the encoder below.
   cleanupPreallocatedInputPool();
 
   result = processFifo(true);
@@ -466,10 +468,12 @@ CloseFileResult FFmpegAudioFileWriter::finalizeOutput() {
     avio_closep(&formatCtx_->pb);
   }
 
-  double durationInSeconds = getCurrentDuration();
+  double durationInSeconds = 0.0;
+  if (encoderCtx_ != nullptr && encoderCtx_->sample_rate > 0) {
+    durationInSeconds = static_cast<double>(nextPts_) / encoderCtx_->sample_rate;
+  }
 
   filePath_ = "";
-  isFileOpen_.store(false, std::memory_order_release);
 
   return CloseFileResult::Ok({fileSizeInMB, durationInSeconds});
 }

package/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.cpp

@@ -156,11 +156,11 @@ CloseFileResult MiniAudioFileWriter::closeFile() {
     return CloseFileResult ::Err("File is not open");
   }
 
-  // Joins the worker before the encoder teardown below.
-  cleanupPreallocatedInputPool();
-
   isFileOpen_.store(false, std::memory_order_release);
 
+  // Drains the worker queue before the encoder teardown below.
+  cleanupPreallocatedInputPool();
+
   if (encoder_ != nullptr) {
     ma_encoder_uninit(encoder_.get());
     encoder_.reset();

package/android/src/main/cpp/audioapi/android/system/NativeFileInfo.cpp

@@ -0,0 +1,48 @@
+#include <audioapi/android/system/NativeFileInfo.hpp>
+
+#include <atomic>
+#include <string>
+
+namespace audioapi {
+
+namespace {
+
+std::string cachedFilesDir;
+std::string cachedCacheDir;
+std::atomic<bool> cacheReady{false};
+
+std::string fetchFilesDirFromJava() {
+  static const auto method =
+      NativeFileInfo::javaClassStatic()->getStaticMethod<jni::JString()>("getFilesDir");
+  return method(NativeFileInfo::javaClassStatic())->toStdString();
+}
+
+std::string fetchCacheDirFromJava() {
+  static const auto method =
+      NativeFileInfo::javaClassStatic()->getStaticMethod<jni::JString()>("getCacheDir");
+  return method(NativeFileInfo::javaClassStatic())->toStdString();
+}
+
+} // namespace
+
+void NativeFileInfo::warmCache() {
+  cachedFilesDir = fetchFilesDirFromJava();
+  cachedCacheDir = fetchCacheDirFromJava();
+  cacheReady.store(true, std::memory_order_release);
+}
+
+std::string NativeFileInfo::getFilesDir() {
+  if (cacheReady.load(std::memory_order_acquire)) {
+    return cachedFilesDir;
+  }
+  return fetchFilesDirFromJava();
+}
+
+std::string NativeFileInfo::getCacheDir() {
+  if (cacheReady.load(std::memory_order_acquire)) {
+    return cachedCacheDir;
+  }
+  return fetchCacheDirFromJava();
+}
+
+} // namespace audioapi

package/android/src/main/cpp/audioapi/android/system/NativeFileInfo.hpp

@@ -7,19 +7,17 @@ namespace audioapi {
 
 using namespace facebook;
 
+/// @brief JNI bridge to Kotlin paths for recorder file output.
+/// @note Call warmCache() from a JNI-attached thread
 class NativeFileInfo : public jni::JavaClass<NativeFileInfo> {
  public:
   static auto constexpr kJavaDescriptor = "Lcom/swmansion/audioapi/system/NativeFileInfo;";
 
-  static std::string getFilesDir() {
-    static const auto method = javaClassStatic()->getStaticMethod<jni::JString()>("getFilesDir");
-    return method(javaClassStatic())->toStdString();
-  }
+  /// @brief Fetches and caches directory paths via JNI. Must run before recording.
+  static void warmCache();
 
-  static std::string getCacheDir() {
-    static const auto method = javaClassStatic()->getStaticMethod<jni::JString()>("getCacheDir");
-    return method(javaClassStatic())->toStdString();
-  }
+  static std::string getFilesDir();
+  static std::string getCacheDir();
 };
 
 } // namespace audioapi

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

@@ -109,6 +109,8 @@ class AudioAPIModule(
 
   override fun getDevicePreferredSampleRate(): Double = MediaSessionManager.getDevicePreferredSampleRate()
 
+  override fun isFfmpegEnabled(): Boolean = !BuildConfig.RN_AUDIO_API_FFMPEG_DISABLED
+
   override fun setAudioSessionActivity(
     enabled: Boolean,
     promise: Promise?,

package/android/src/oldarch/NativeAudioAPIModuleSpec.java

@@ -43,6 +43,10 @@ public abstract class NativeAudioAPIModuleSpec extends ReactContextBaseJavaModul
   @DoNotStrip
   public abstract double getDevicePreferredSampleRate();
 
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract boolean isFfmpegEnabled();
+
   @ReactMethod
   @DoNotStrip
   public abstract void setAudioSessionActivity(boolean enabled, Promise promise);

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

@@ -23,7 +23,7 @@
 #include <audioapi/HostObjects/utils/JsEnumParser.h>
 #include <audioapi/HostObjects/utils/NodeOptionsParser.h>
 #include <audioapi/core/BaseAudioContext.h>
-#include <audioapi/core/utils/AudioDecoding.hpp>
+#include <audioapi/core/utils/AudioDecoding.h>
 
 #include <memory>
 #include <vector>

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

@@ -1,6 +1,6 @@
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/HostObjects/utils/AudioDecoderHostObject.h>
-#include <audioapi/core/utils/AudioDecoding.hpp>
+#include <audioapi/core/utils/AudioDecoding.h>
 #include <audioapi/jsi/JsiPromise.h>
 
 #include <jsi/jsi.h>
@@ -16,7 +16,6 @@ AudioDecoderHostObject::AudioDecoderHostObject(
   addFunctions(
       JSI_EXPORT_FUNCTION(AudioDecoderHostObject, decodeWithPCMInBase64),
       JSI_EXPORT_FUNCTION(AudioDecoderHostObject, decodeWithFilePath),
-      JSI_EXPORT_FUNCTION(AudioDecoderHostObject, getDurationWithFilePath),
       JSI_EXPORT_FUNCTION(AudioDecoderHostObject, decodeWithMemoryBlock));
 }
 
@@ -77,28 +76,6 @@ JSI_HOST_FUNCTION_IMPL(AudioDecoderHostObject, decodeWithFilePath) {
   return promise;
 }
 
-JSI_HOST_FUNCTION_IMPL(AudioDecoderHostObject, getDurationWithFilePath) {
-  auto sourcePath = args[0].getString(runtime).utf8(runtime);
-
-  auto promise = promiseVendor_->createAsyncPromise([sourcePath]() -> PromiseResolver {
-    auto result = audiodecoding::getDurationWithFilePath(sourcePath);
-
-    if (result.is_err()) {
-      return [result = std::move(result)](
-                 jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
-        return result.unwrap_err();
-      };
-    }
-
-    const auto duration = result.unwrap();
-    return [duration](jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
-      return jsi::Value(duration);
-    };
-  });
-
-  return promise;
-}
-
 JSI_HOST_FUNCTION_IMPL(AudioDecoderHostObject, decodeWithPCMInBase64) {
   auto b64 = args[0].getString(runtime).utf8(runtime);
   auto inputSampleRate = static_cast<float>(args[1].getNumber());

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

@@ -16,7 +16,6 @@ class AudioDecoderHostObject : public JsiHostObject {
       const std::shared_ptr<react::CallInvoker> &callInvoker);
   JSI_HOST_FUNCTION_DECL(decodeWithMemoryBlock);
   JSI_HOST_FUNCTION_DECL(decodeWithFilePath);
-  JSI_HOST_FUNCTION_DECL(getDurationWithFilePath);
   JSI_HOST_FUNCTION_DECL(decodeWithPCMInBase64);
 
  private:

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

@@ -1,40 +1,19 @@
 #include <audioapi/HostObjects/utils/AudioFileUtilsHostObject.h>
+#include <audioapi/HostObjects/utils/NodeOptionsParser.h>
+#include <audioapi/core/utils/AudioDecoding.h>
 #include <audioapi/core/utils/AudioFileConcatenator.h>
-#if !RN_AUDIO_API_FFMPEG_DISABLED
-#include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
-#include <audioapi/core/utils/AudioDecoding.hpp>
 #include <audioapi/jsi/JsiPromise.h>
-#include <audioapi/libs/miniaudio/MiniAudioDecoding.h>
 
 #include <jsi/jsi.h>
 #include <cstdint>
+#include <map>
 #include <memory>
-#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace audioapi {
 
-namespace {
-
-std::optional<double> probeDurationWithDecoder(const uint8_t *data, size_t size, int sampleRate) {
-  auto duration =
-      audiodecoding::probeDuration<miniaudio_decoder::MiniAudioDecoder>(data, size, sampleRate);
-  if (duration.has_value()) {
-    return duration;
-  }
-#if !RN_AUDIO_API_FFMPEG_DISABLED
-  duration = audiodecoding::probeDuration<ffmpeg_decoder::FFmpegDecoder>(data, size, sampleRate);
-  return duration;
-#else
-  return std::nullopt;
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
-}
-
-} // namespace
-
 AudioFileUtilsHostObject::AudioFileUtilsHostObject(
     jsi::Runtime *runtime,
     const std::shared_ptr<react::CallInvoker> &callInvoker) {
@@ -85,38 +64,67 @@ JSI_HOST_FUNCTION_IMPL(AudioFileUtilsHostObject, concatAudioFiles) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioFileUtilsHostObject, probeDuration) {
-  if (count < 1 || !args[0].isObject()) {
-    throw jsi::JSError(runtime, "probeDuration expects an ArrayBuffer.");
+  if (count < 1) {
+    throw jsi::JSError(runtime, "probeDuration expects an ArrayBuffer or URL/path string.");
   }
 
-  auto arrayBufferObject = args[0].asObject(runtime);
-  if (!arrayBufferObject.isArrayBuffer(runtime)) {
-    throw jsi::JSError(runtime, "probeDuration expects an ArrayBuffer.");
+  const auto sampleRate =
+      count > 1 && args[1].isNumber() ? static_cast<int>(args[1].getNumber()) : 0;
+
+  if (args[0].isObject() && args[0].asObject(runtime).isArrayBuffer(runtime)) {
+    auto arrayBuffer = args[0].asObject(runtime).getArrayBuffer(runtime);
+    const auto *data = arrayBuffer.data(runtime);
+    const auto size = arrayBuffer.size(runtime);
+
+    auto promise = promiseVendor_->createAsyncPromise(
+        [bytes = std::vector<uint8_t>(data, data + size), sampleRate]() -> PromiseResolver {
+          auto result =
+              audiodecoding::probeDurationWithMemory(bytes.data(), bytes.size(), sampleRate);
+          if (result.is_err()) {
+            return [](jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
+              return jsi::Value::null();
+            };
+          }
+
+          return [duration = static_cast<double>(result.unwrap())](
+                     jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
+            return jsi::Value(duration);
+          };
+        });
+
+    return promise;
   }
 
-  auto arrayBuffer = arrayBufferObject.getArrayBuffer(runtime);
-  const auto *data = arrayBuffer.data(runtime);
-  const auto size = arrayBuffer.size(runtime);
+  if (args[0].isString()) {
+    const auto pathOrUrl = args[0].asString(runtime).utf8(runtime);
 
-  const auto sampleRate =
-      count > 1 && args[1].isNumber() ? static_cast<int>(args[1].getNumber()) : 0;
+    std::map<std::string, std::string> headers;
+    if (count > 2 && args[2].isObject()) {
+      headers = audioapi::option_parser::parseHttpHeaders(runtime, args[2].asObject(runtime));
+    }
 
-  auto promise = promiseVendor_->createAsyncPromise(
-      [bytes = std::vector<uint8_t>(data, data + size), sampleRate]() -> PromiseResolver {
-        auto duration = probeDurationWithDecoder(bytes.data(), bytes.size(), sampleRate);
-        if (!duration.has_value()) {
-          return [](jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
-            return jsi::Value::null();
+    auto promise = promiseVendor_->createAsyncPromise(
+        [pathOrUrl, sampleRate, headers = std::move(headers)]() -> PromiseResolver {
+          auto result = audiodecoding::isHttpUrl(pathOrUrl)
+              ? audiodecoding::probeDurationWithUrl(pathOrUrl, sampleRate, headers)
+              : audiodecoding::probeDurationWithFilePath(pathOrUrl);
+
+          if (result.is_err()) {
+            return [](jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
+              return jsi::Value::null();
+            };
+          }
+
+          return [duration = static_cast<double>(result.unwrap())](
+                     jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
+            return jsi::Value(duration);
           };
-        }
+        });
 
-        return [duration = duration.value()](
-                   jsi::Runtime &runtime) -> std::variant<jsi::Value, std::string> {
-          return jsi::Value(duration);
-        };
-      });
+    return promise;
+  }
 
-  return promise;
+  throw jsi::JSError(runtime, "probeDuration expects an ArrayBuffer or URL/path string.");
 }
 
 } // namespace audioapi

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

@@ -6,15 +6,46 @@
 #include <cstddef>
 #include <cstdio>
 #include <limits>
+#include <map>
 #include <memory>
+#include <string>
 #include <vector>
 
 #include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
-#include <audioapi/core/utils/AudioDecoding.hpp>
+#include <audioapi/core/utils/AudioDecoding.h>
 #include <audioapi/types/NodeOptions.h>
 
 namespace audioapi::option_parser {
+
+inline std::map<std::string, std::string> parseHttpHeaders(
+    jsi::Runtime &runtime,
+    const jsi::Object &headersObject) {
+  std::map<std::string, std::string> headers;
+  const auto propertyNames = headersObject.getPropertyNames(runtime);
+  const auto count = propertyNames.size(runtime);
+  for (size_t i = 0; i < count; ++i) {
+    const auto keyValue = propertyNames.getValueAtIndex(runtime, i);
+    if (!keyValue.isString()) {
+      continue;
+    }
+    const auto key = keyValue.asString(runtime).utf8(runtime);
+    const auto value = headersObject.getProperty(runtime, key.c_str());
+    if (value.isString()) {
+      headers.emplace(key, value.asString(runtime).utf8(runtime));
+    }
+  }
+  return headers;
+}
+
+inline void mergeHttpHeaders(
+    std::map<std::string, std::string> &target,
+    const std::map<std::string, std::string> &incoming) {
+  for (const auto &[key, value] : incoming) {
+    target[key] = value;
+  }
+}
+
 inline AudioNodeOptions parseAudioNodeOptions(
     jsi::Runtime &runtime,
     const jsi::Object &optionsObject) {
@@ -320,12 +351,29 @@ inline AudioFileSourceOptions parseAudioFileSourceOptions(
 
   auto sourceValue = optionsObject.getProperty(runtime, "source");
   if (sourceValue.isString()) {
-    options.filePath = sourceValue.asString(runtime).utf8(runtime);
-    options.requiresFFmpeg =
-        audiodecoding::pathHasExtension(options.filePath, {".mp4", ".m4a", ".aac", ".m3u8"});
+    const auto path = sourceValue.asString(runtime).utf8(runtime);
+    if (audiodecoding::isHttpUrl(path)) {
+      options.sourceUrl = path;
+      options.requiresFFmpeg = true;
+    } else {
+      options.filePath = path;
+      options.requiresFFmpeg =
+          audiodecoding::pathHasExtension(path, {".mp4", ".m4a", ".aac", ".m3u8"});
+    }
   } else if (sourceValue.isObject()) {
     auto sourceObj = sourceValue.asObject(runtime);
-    if (sourceObj.isArrayBuffer(runtime)) {
+    if (sourceObj.hasProperty(runtime, "uri")) {
+      const auto uriValue = sourceObj.getProperty(runtime, "uri");
+      if (uriValue.isString()) {
+        options.sourceUrl = uriValue.asString(runtime).utf8(runtime);
+        options.requiresFFmpeg = true;
+      }
+      const auto sourceHeadersValue = sourceObj.getProperty(runtime, "headers");
+      if (sourceHeadersValue.isObject()) {
+        mergeHttpHeaders(
+            options.httpHeaders, parseHttpHeaders(runtime, sourceHeadersValue.asObject(runtime)));
+      }
+    } else if (sourceObj.isArrayBuffer(runtime)) {
       auto arrayBuffer = sourceObj.getArrayBuffer(runtime);
       auto *data = arrayBuffer.data(runtime);
       auto size = arrayBuffer.size(runtime);
@@ -336,11 +384,17 @@ inline AudioFileSourceOptions parseAudioFileSourceOptions(
     }
   }
 
+  const auto headersValue = optionsObject.getProperty(runtime, "headers");
+  if (headersValue.isObject()) {
+    mergeHttpHeaders(
+        options.httpHeaders, parseHttpHeaders(runtime, headersValue.asObject(runtime)));
+  }
+
 #if RN_AUDIO_API_FFMPEG_DISABLED
   if (options.requiresFFmpeg) {
     throw jsi::JSError(
         runtime,
-        "AudioFileSourceNode: source format (.mp4, .m4a, .aac, .m3u8) requires FFmpeg, "
+        "AudioFileSourceNode: remote URLs and formats (.mp4, .m4a, .aac, .m3u8) require FFmpeg, "
         "which is disabled in this build.");
   }
 #endif

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

@@ -21,7 +21,7 @@
 #include <audioapi/core/sources/StreamerNode.h>
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/core/sources/WorkletSourceNode.h>
-#include <audioapi/core/utils/AudioDecoding.hpp>
+#include <audioapi/core/utils/AudioDecoding.h>
 #include <audioapi/core/utils/AudioGraphManager.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>

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

@@ -43,9 +43,12 @@ AudioFileSourceNode::AudioFileSourceNode(
 
   const bool useFilePath = !options.filePath.empty();
   const bool useData = !options.data.empty();
+  const bool useUrl = !options.sourceUrl.empty();
 
-  if (!useFilePath && !useData) {
-    assert(false && "AudioFileSourceNode requires either a file path or memory data to initialize");
+  if (!useFilePath && !useData && !useUrl) {
+    assert(
+        false &&
+        "AudioFileSourceNode requires a file path, remote URL, or memory data to initialize");
     return;
   }
 
@@ -103,6 +106,8 @@ bool AudioFileSourceNode::initDecoder(
   SeekDecoderDaemonOptions daemonOptions{
       .requiresFFmpeg = options.requiresFFmpeg,
       .filePath = std::move(options.filePath),
+      .sourceUrl = std::move(options.sourceUrl),
+      .httpHeaders = std::move(options.httpHeaders),
       .memoryData = std::move(options.data),
       .contextSampleRate = context->getSampleRate(),
       .loop = options.loop};