react-native-audio-api 0.12.0 → 0.12.2

package/common/cpp/audioapi/core/utils/AudioFileConcatenator.h

@@ -0,0 +1,164 @@
+#pragma once
+
+#include <audioapi/libs/miniaudio/miniaudio.h>
+#include <audioapi/utils/Result.hpp>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+struct AVDictionary;
+struct AVFormatContext;
+struct AVStream;
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
+
+namespace audioapi {
+
+using AudioFileConcatResult = Result<std::string, std::string>;
+
+class MiniAudioDecoderGuard {
+ public:
+  MiniAudioDecoderGuard() = default;
+  MiniAudioDecoderGuard(const MiniAudioDecoderGuard &) = delete;
+  MiniAudioDecoderGuard &operator=(const MiniAudioDecoderGuard &) = delete;
+
+  MiniAudioDecoderGuard(MiniAudioDecoderGuard &&other) noexcept;
+  MiniAudioDecoderGuard &operator=(MiniAudioDecoderGuard &&other) noexcept;
+
+  // Closes the owned miniaudio decoder.
+  ~MiniAudioDecoderGuard();
+
+  // Opens an input file for decoded PCM reads.
+  [[nodiscard]] static Result<MiniAudioDecoderGuard, std::string> open(
+      const std::string &filePath,
+      ma_format outputFormat = ma_format_unknown);
+
+  // Returns the owned miniaudio decoder.
+  [[nodiscard]] ma_decoder *get();
+
+  // Returns the normalized file path represented by this input.
+  [[nodiscard]] const std::string &filePath() const;
+
+  // Returns the decoded output sample rate.
+  [[nodiscard]] ma_uint32 sampleRate() const;
+
+  // Returns the decoded output channel count.
+  [[nodiscard]] ma_uint32 channels() const;
+
+  // Returns the decoded output sample format.
+  [[nodiscard]] ma_format format() const;
+
+ private:
+  void close();
+
+  std::string filePath_;
+  std::unique_ptr<ma_decoder> decoder_{nullptr};
+  bool initialized_{false};
+};
+
+class MiniAudioEncoderGuard {
+ public:
+  MiniAudioEncoderGuard() = default;
+  MiniAudioEncoderGuard(const MiniAudioEncoderGuard &) = delete;
+  MiniAudioEncoderGuard &operator=(const MiniAudioEncoderGuard &) = delete;
+
+  // Closes the owned miniaudio encoder.
+  ~MiniAudioEncoderGuard();
+
+  // Opens a WAV output file with the provided PCM parameters.
+  [[nodiscard]] AudioFileConcatResult
+  open(const std::string &outputPath, ma_format format, ma_uint32 sampleRate, ma_uint32 channels);
+
+  // Writes decoded PCM frames into the WAV output file.
+  [[nodiscard]] AudioFileConcatResult
+  write(const std::string &inputPath, const void *frames, ma_uint64 frameCount);
+
+ private:
+  void close();
+
+  ma_encoder encoder_{};
+  bool initialized_{false};
+};
+
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+class AVDictionaryGuard {
+ public:
+  AVDictionaryGuard() = default;
+  AVDictionaryGuard(const AVDictionaryGuard &) = delete;
+  AVDictionaryGuard &operator=(const AVDictionaryGuard &) = delete;
+
+  // Releases the owned FFmpeg dictionary.
+  ~AVDictionaryGuard();
+
+  // Returns the dictionary pointer address expected by FFmpeg option APIs.
+  [[nodiscard]] AVDictionary **ptr();
+
+ private:
+  AVDictionary *dictionary_{nullptr};
+};
+
+class InputFormatContext {
+ public:
+  InputFormatContext() = default;
+
+  // Takes ownership of an opened FFmpeg input context and selected audio stream.
+  InputFormatContext(std::string filePath, AVFormatContext *context, int audioStreamIndex);
+
+  InputFormatContext(const InputFormatContext &) = delete;
+  InputFormatContext &operator=(const InputFormatContext &) = delete;
+
+  // Moves ownership without closing the transferred FFmpeg context.
+  InputFormatContext(InputFormatContext &&other) noexcept;
+  InputFormatContext &operator=(InputFormatContext &&other) noexcept;
+
+  // Closes the owned FFmpeg input context.
+  ~InputFormatContext();
+
+  // Returns the owned FFmpeg input context.
+  [[nodiscard]] AVFormatContext *context() const;
+
+  // Returns the selected audio stream from the input context.
+  [[nodiscard]] AVStream *audioStream() const;
+
+  // Returns the selected audio stream index from the input context.
+  [[nodiscard]] int audioStreamIndex() const;
+
+  // Returns the normalized file path represented by this input.
+  [[nodiscard]] const std::string &filePath() const;
+
+ private:
+  void close();
+
+  std::string filePath_;
+  AVFormatContext *context_{nullptr};
+  int audioStreamIndex_{-1};
+};
+
+class OutputFormatContext {
+ public:
+  // Takes ownership of an allocated FFmpeg output context.
+  explicit OutputFormatContext(AVFormatContext *context);
+  OutputFormatContext(const OutputFormatContext &) = delete;
+  OutputFormatContext &operator=(const OutputFormatContext &) = delete;
+
+  // Closes the output file handle and frees the owned FFmpeg output context.
+  ~OutputFormatContext();
+
+  // Returns the owned FFmpeg output context.
+  [[nodiscard]] AVFormatContext *get() const;
+
+ private:
+  AVFormatContext *context_{nullptr};
+};
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
+
+// Concatenates compatible local audio files into a single output file.
+[[nodiscard]] AudioFileConcatResult concatAudioFiles(
+    const std::vector<std::string> &inputPaths,
+    const std::string &outputPath);
+
+// Converts a local path or file:// URL into a decoded filesystem path.
+[[nodiscard]] std::string normalizeFilePath(const std::string &path);
+
+} // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioFileWriter.cpp

@@ -2,7 +2,6 @@
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <memory>
 #include <string>
-#include <unordered_map>
 
 namespace audioapi {
 
@@ -29,9 +28,8 @@ void AudioFileWriter::invokeOnErrorCallback(const std::string &message) {
     return;
   }
 
-  std::unordered_map<std::string, EventValue> eventPayload = {{"message", message}};
-  audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-      AudioEvent::RECORDER_ERROR, callbackId, eventPayload);
+  audioEventHandlerRegistry_->dispatchEvent(
+      AudioEvent::RECORDER_ERROR, callbackId, StringPayload{.name = "message", .reason = message});
 }
 
 bool AudioFileWriter::isFileOpen() {

package/common/cpp/audioapi/core/utils/AudioRecorderCallback.cpp

@@ -8,7 +8,6 @@
 #include <algorithm>
 #include <memory>
 #include <string>
-#include <unordered_map>
 
 namespace audioapi {
 
@@ -67,15 +66,12 @@ void AudioRecorderCallback::emitAudioData(bool flush) {
 void AudioRecorderCallback::invokeCallback(
     const std::shared_ptr<AudioBuffer> &buffer,
     int numFrames) {
-  auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
-
-  std::unordered_map<std::string, EventValue> eventPayload = {};
-  eventPayload.insert({"buffer", audioBufferHostObject});
-  eventPayload.insert({"numFrames", numFrames});
-
   if (audioEventHandlerRegistry_) {
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        AudioEvent::AUDIO_READY, callbackId_, eventPayload);
+    audioEventHandlerRegistry_->dispatchEvent(
+        AudioEvent::AUDIO_READY,
+        callbackId_,
+        AudioReadyPayload{
+            .buffer = std::make_shared<AudioBufferHostObject>(buffer), .numFrames = numFrames});
   }
 }
 
@@ -96,9 +92,8 @@ void AudioRecorderCallback::invokeOnErrorCallback(const std::string &message) {
     return;
   }
 
-  std::unordered_map<std::string, EventValue> eventPayload = {{"message", message}};
-  audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-      AudioEvent::RECORDER_ERROR, callbackId, eventPayload);
+  audioEventHandlerRegistry_->dispatchEvent(
+      AudioEvent::RECORDER_ERROR, callbackId, StringPayload{.name = "message", .reason = message});
 }
 
 } // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioRecorderCallback.h

@@ -8,6 +8,7 @@
 #include <audioapi/utils/TaskOffloader.hpp>
 #include <atomic>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <vector>
 
@@ -59,6 +60,7 @@ class AudioRecorderCallback {
   static constexpr auto RECORDER_CALLBACK_SPSC_WAIT_STRATEGY =
       channels::spsc::WaitStrategy::ATOMIC_WAIT;
   static constexpr auto RECORDER_CALLBACK_CHANNEL_CAPACITY = 64;
+  std::mutex destructionAudioGuard_; // eliminates race between deconstruction and audio thread
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/core/utils/buffer/BufferProcessingDirection.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <cstdint>
+namespace audioapi {
+enum class BufferProcessingDirection : std::int8_t { FORWARD = 1, REVERSE = -1 };
+} // namespace audioapi

package/common/cpp/audioapi/core/utils/buffer/BufferProcessorBase.cpp

@@ -0,0 +1,110 @@
+#include <audioapi/core/utils/buffer/BufferProcessingDirection.h>
+#include <audioapi/core/utils/buffer/BufferProcessorBase.h>
+#include <audioapi/dsp/AudioUtils.hpp>
+#include <audioapi/utils/AudioBuffer.hpp>
+#include <audioapi/utils/Macros.h>
+#include <algorithm>
+#include <cstddef>
+#include <memory>
+
+namespace audioapi {
+
+void BufferProcessorBase::process(
+    const std::shared_ptr<DSPAudioBuffer> &output,
+    size_t writeIndex,
+    size_t framesLeft,
+    double rate,
+    bool interpolate) {
+  setProcessingDirection(rate);
+  if (interpolate) {
+    renderInterpolated(output, writeIndex, framesLeft, rate);
+  } else {
+    renderBlock(output, writeIndex, framesLeft, rate);
+  }
+}
+
+void BufferProcessorBase::setProcessingDirection(double rate) {
+  direction_ = rate > 0.0 ? BufferProcessingDirection::FORWARD : BufferProcessingDirection::REVERSE;
+}
+
+bool BufferProcessorBase::shouldProcessFurther() {
+  if (!atBoundary()) {
+    return true; // Keep going
+  }
+
+  handleBoundary();
+
+  // Check if we should loop
+  return !shouldStop();
+}
+
+void BufferProcessorBase::renderBlock(
+    const std::shared_ptr<DSPAudioBuffer> &output,
+    size_t writeIndex,
+    size_t framesLeft,
+    double rate) {
+  while (framesLeft > 0) {
+    const size_t toCopy = std::min(remainingInContiguousBlock(), framesLeft);
+
+    if (toCopy > 0) {
+      const AudioBuffer *buffer = getBuffer().get();
+      const size_t readIndex = currentIndex();
+
+      if (direction_ == BufferProcessingDirection::REVERSE) {
+        for (size_t ch = 0; ch < output->getNumberOfChannels(); ++ch) {
+          output->getChannel(ch)->copyReverse(
+              *buffer->getChannel(ch), readIndex, writeIndex, toCopy);
+        }
+      } else {
+        output->copy(*buffer, readIndex, writeIndex, toCopy);
+      }
+
+      consume(toCopy);
+      writeIndex += toCopy;
+      framesLeft -= toCopy;
+    }
+
+    if (!shouldProcessFurther()) {
+      output->zero(writeIndex, framesLeft);
+      break;
+    }
+  }
+}
+
+void BufferProcessorBase::renderInterpolated(
+    const std::shared_ptr<DSPAudioBuffer> &output,
+    size_t writeIndex,
+    size_t framesLeft,
+    double rate) {
+  const size_t numChannels = output->getNumberOfChannels();
+  for (size_t i = 0; i < framesLeft; ++i) {
+    const CursorState state = advance(rate);
+    if (state.atEndOfBuffer) {
+      output->zero(writeIndex, framesLeft - i);
+      return;
+    }
+
+    const AudioBuffer *currentBuffer = getBuffer().get();
+    for (size_t ch = 0; ch < numChannels; ++ch) {
+      auto destination = output->getChannel(ch)->span();
+      auto source = currentBuffer->getChannel(ch)->span();
+      if (state.isCrossBuffer) {
+        auto nextSource = getNextBuffer()->getChannel(ch)->span();
+        const float currentSample = source[state.index];
+        const float nextSample = nextSource[state.nextIndex];
+        destination[writeIndex] = currentSample + state.factor * (nextSample - currentSample);
+      } else {
+        destination[writeIndex] =
+            dsp::linearInterpolate(source, state.index, state.nextIndex, state.factor);
+      }
+    }
+
+    writeIndex++;
+
+    if (!shouldProcessFurther()) {
+      output->zero(writeIndex, framesLeft - i - 1);
+      return;
+    }
+  }
+}
+}; // namespace audioapi

package/common/cpp/audioapi/core/utils/buffer/BufferProcessorBase.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <audioapi/core/utils/buffer/BufferProcessingDirection.h>
+#include <audioapi/dsp/AudioUtils.hpp>
+#include <audioapi/utils/AudioBuffer.hpp>
+#include <audioapi/utils/Macros.h>
+#include <cstddef>
+#include <memory>
+
+namespace audioapi {
+
+struct CursorState {
+  size_t index = 0;
+  size_t nextIndex = 0;
+  float factor = 0.0f;
+  bool atEndOfBuffer = false;
+  bool isCrossBuffer = false;
+};
+
+class BufferProcessorBase {
+ public:
+  virtual ~BufferProcessorBase() = default;
+  DELETE_COPY_AND_MOVE(BufferProcessorBase);
+
+  void process(
+      const std::shared_ptr<DSPAudioBuffer> &output,
+      size_t writeIndex,
+      size_t framesLeft,
+      double rate,
+      bool interpolate);
+
+  [[nodiscard]] double getPosition() const {
+    return position_;
+  }
+
+  void setPosition(double position) {
+    position_ = position;
+  }
+
+  [[nodiscard]] virtual bool atBoundary() const = 0;
+  [[nodiscard]] virtual bool shouldStop() const = 0;
+
+ protected:
+  BufferProcessorBase() = default;
+
+  virtual CursorState advance(double rate) = 0;
+  virtual void consume(size_t frames) = 0;
+  [[nodiscard]] virtual size_t remainingInContiguousBlock() const = 0;
+  [[nodiscard]] virtual size_t currentIndex() const = 0;
+  [[nodiscard]] virtual std::shared_ptr<const AudioBuffer> getBuffer() const = 0;
+  [[nodiscard]] virtual std::shared_ptr<const AudioBuffer> getNextBuffer() const = 0;
+  virtual void handleBoundary() = 0;
+
+  double position_ = 0;
+  BufferProcessingDirection direction_ = BufferProcessingDirection::FORWARD;
+
+ private:
+  void setProcessingDirection(double rate);
+
+  void renderBlock(
+      const std::shared_ptr<DSPAudioBuffer> &output,
+      size_t writeIndex,
+      size_t framesLeft,
+      double rate);
+
+  void renderInterpolated(
+      const std::shared_ptr<DSPAudioBuffer> &output,
+      size_t writeIndex,
+      size_t framesLeft,
+      double rate);
+
+  [[nodiscard]] bool shouldProcessFurther();
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/core/utils/buffer/QueueBufferProcessor.cpp

@@ -0,0 +1,129 @@
+#include <audioapi/core/utils/buffer/QueueBufferProcessor.h>
+
+#include <cstddef>
+#include <iterator>
+#include <list>
+#include <memory>
+#include <utility>
+
+namespace audioapi {
+
+QueueBufferProcessor::QueueBufferProcessor(
+    std::list<std::pair<size_t, std::shared_ptr<AudioBuffer>>> *buffers,
+    OnBufferConsumed onBufferConsumed)
+    : buffers_(buffers), onBufferConsumed_(std::move(onBufferConsumed)) {}
+
+CursorState QueueBufferProcessor::advance(double rate) {
+  if (buffers_->empty()) {
+    return {.atEndOfBuffer = true};
+  }
+
+  const size_t bufferSize = buffers_->front().second->getSize();
+  const double currentPos = position_;
+  const auto index = static_cast<size_t>(currentPos);
+  const auto factor = static_cast<float>(currentPos - static_cast<double>(index));
+
+  size_t nextIndex = index + 1;
+  bool isCrossBuffer = false;
+  bool atEnd = false;
+
+  if (nextIndex >= bufferSize) {
+    const bool hasFollowUp =
+        std::next(buffers_->begin()) != buffers_->end() || pendingTailBuffer_ != nullptr;
+
+    if (hasFollowUp) {
+      nextIndex = 0;
+      isCrossBuffer = true;
+    } else {
+      nextIndex = index;
+      atEnd = (currentPos + rate) >= static_cast<double>(bufferSize);
+    }
+  }
+
+  position_ += rate;
+
+  return {
+      .index = index,
+      .nextIndex = nextIndex,
+      .factor = factor,
+      .atEndOfBuffer = atEnd,
+      .isCrossBuffer = isCrossBuffer};
+}
+
+void QueueBufferProcessor::consume(size_t frames) {
+  position_ += static_cast<double>(frames);
+}
+
+size_t QueueBufferProcessor::remainingInContiguousBlock() const {
+  if (buffers_->empty()) {
+    return 0;
+  }
+  const size_t size = buffers_->front().second->getSize();
+  const size_t pos = currentIndex();
+  return pos < size ? size - pos : 0;
+}
+
+size_t QueueBufferProcessor::currentIndex() const {
+  return static_cast<size_t>(position_);
+}
+
+std::shared_ptr<const AudioBuffer> QueueBufferProcessor::getBuffer() const {
+  if (buffers_->empty()) {
+    return nullptr;
+  }
+  return buffers_->front().second;
+}
+
+std::shared_ptr<const AudioBuffer> QueueBufferProcessor::getNextBuffer() const {
+  if (buffers_->empty()) {
+    return pendingTailBuffer_;
+  }
+  auto it = std::next(buffers_->begin());
+  if (it != buffers_->end()) {
+    return it->second;
+  }
+  if (pendingTailBuffer_ != nullptr) {
+    return pendingTailBuffer_;
+  }
+  return buffers_->front().second;
+}
+
+bool QueueBufferProcessor::atBoundary() const {
+  if (buffers_->empty()) {
+    return true;
+  }
+  return position_ >= static_cast<double>(buffers_->front().second->getSize());
+}
+
+bool QueueBufferProcessor::shouldStop() const {
+  return buffers_->empty();
+}
+
+void QueueBufferProcessor::handleBoundary() {
+  if (buffers_->empty()) {
+    return;
+  }
+
+  auto bufferId = buffers_->front().first;
+  auto buffer = std::move(buffers_->front().second);
+  const auto consumedSize = static_cast<double>(buffer->getSize());
+  buffers_->pop_front();
+  position_ -= consumedSize;
+
+  bool queueEmptyAfterPop = buffers_->empty();
+  const bool willAppendTail = queueEmptyAfterPop && pendingTailBuffer_ != nullptr;
+  bool fireBufferEndedEvent = !willAppendTail;
+
+  if (onBufferConsumed_) {
+    onBufferConsumed_(bufferId, buffer, queueEmptyAfterPop, fireBufferEndedEvent);
+  }
+
+  if (willAppendTail) {
+    // Tail reuses the last real bufferId so the final onBufferEnded carries it.
+    buffers_->emplace_back(bufferId, std::move(pendingTailBuffer_));
+    pendingTailBuffer_ = nullptr;
+    tailConsumed_ = true;
+  }
+}
+
+} // namespace audioapi

package/common/cpp/audioapi/core/utils/buffer/QueueBufferProcessor.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <audioapi/core/utils/buffer/BufferProcessorBase.h>
+#include <audioapi/utils/AudioBuffer.hpp>
+
+#include <audioapi/utils/FatFunction.hpp>
+#include <cstddef>
+#include <list>
+#include <memory>
+#include <utility>
+
+namespace audioapi {
+
+inline constexpr size_t ON_BUFFER_CONSUMED_CALLBACK_SIZE = 64;
+
+using OnBufferConsumed = FatFunction<
+    ON_BUFFER_CONSUMED_CALLBACK_SIZE,
+    void(size_t &, const std::shared_ptr<AudioBuffer> &, bool &, bool &)>;
+
+class QueueBufferProcessor : public BufferProcessorBase {
+ public:
+  QueueBufferProcessor(
+      std::list<std::pair<size_t, std::shared_ptr<AudioBuffer>>> *buffers,
+      OnBufferConsumed onBufferConsumed = {});
+
+  /// Arm an in-place tail buffer. When the main queue would drain during
+  /// processing, handleBoundary() appends this tail instead of stopping.
+  void setPendingTail(std::shared_ptr<AudioBuffer> tailBuffer) {
+    pendingTailBuffer_ = std::move(tailBuffer);
+  }
+
+  [[nodiscard]] bool didConsumeTail() const {
+    return tailConsumed_;
+  }
+
+  [[nodiscard]] bool atBoundary() const override;
+  [[nodiscard]] bool shouldStop() const override;
+
+ protected:
+  CursorState advance(double rate) override;
+  void consume(size_t frames) override;
+  [[nodiscard]] size_t remainingInContiguousBlock() const override;
+  [[nodiscard]] size_t currentIndex() const override;
+  [[nodiscard]] std::shared_ptr<const AudioBuffer> getBuffer() const override;
+  [[nodiscard]] std::shared_ptr<const AudioBuffer> getNextBuffer() const override;
+  void handleBoundary() override;
+
+ private:
+  std::list<std::pair<size_t, std::shared_ptr<AudioBuffer>>> *buffers_;
+  OnBufferConsumed onBufferConsumed_;
+  std::shared_ptr<AudioBuffer> pendingTailBuffer_ = nullptr;
+  bool tailConsumed_ = false;
+};
+
+} // namespace audioapi