react-native-audio-api 0.11.0-nightly-95f9c99-20251215 → 0.11.0-nightly-dd83923-20251216

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

@@ -0,0 +1,170 @@
+#include <android/log.h>
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/android/core/utils/AndroidRecorderCallback.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/libs/miniaudio/miniaudio.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/CircularAudioArray.h>
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace audioapi {
+
+/// @brief Constructor
+/// Allocates circular buffer (as every property to do so is already known at this point).
+/// @param audioEventHandlerRegistry The audio event handler registry
+/// @param sampleRate The user desired sample rate
+/// @param bufferLength The user desired buffer length
+/// @param channelCount The user desired channel count
+/// @param callbackId The callback identifier
+AndroidRecorderCallback::AndroidRecorderCallback(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    float sampleRate,
+    size_t bufferLength,
+    int channelCount,
+    uint64_t callbackId)
+    : AudioRecorderCallback(
+          audioEventHandlerRegistry,
+          sampleRate,
+          bufferLength,
+          channelCount,
+          callbackId) {}
+
+AndroidRecorderCallback::~AndroidRecorderCallback() {
+  if (converter_ != nullptr) {
+    ma_data_converter_uninit(converter_.get(), NULL);
+    converter_.reset();
+  }
+
+  if (processingBuffer_ != nullptr) {
+    ma_free(processingBuffer_, NULL);
+    processingBuffer_ = nullptr;
+    processingBufferLength_ = 0;
+  }
+
+  for (size_t i = 0; i < circularBus_.size(); ++i) {
+    circularBus_[i]->zero();
+  }
+}
+
+/// @brief Prepares the recorder callback by initializing the data converter and allocating necessary buffers.
+/// @param streamSampleRate The sample rate of the incoming audio stream.
+/// @param streamChannelCount The channel count of the incoming audio stream.
+/// @param maxInputBufferLength The maximum buffer length of the incoming audio stream.
+Result<NoneType, std::string> AndroidRecorderCallback::prepare(
+    float streamSampleRate,
+    int32_t streamChannelCount,
+    size_t maxInputBufferLength) {
+  ma_result result;
+
+  streamSampleRate_ = streamSampleRate;
+  streamChannelCount_ = streamChannelCount;
+  maxInputBufferLength_ = maxInputBufferLength;
+
+  ma_data_converter_config converterConfig = ma_data_converter_config_init(
+      ma_format_f32,
+      ma_format_f32,
+      streamChannelCount_,
+      channelCount_,
+      streamSampleRate_,
+      static_cast<int32_t>(sampleRate_));
+
+  converter_ = std::make_unique<ma_data_converter>();
+  result = ma_data_converter_init(&converterConfig, NULL, converter_.get());
+
+  if (result != MA_SUCCESS) {
+    return Result<NoneType, std::string>::Err(
+        "Failed to initialize miniaudio data converter" +
+        std::string(ma_result_description(result)));
+  }
+
+  if (streamSampleRate_ <= 0 || streamChannelCount_ <= 0) {
+    return Result<NoneType, std::string>::Err("Invalid stream sample rate or channel count");
+  }
+
+  if (sampleRate_ <= 0 || channelCount_ <= 0) {
+    return Result<NoneType, std::string>::Err("Invalid callback sample rate or channel count");
+  }
+
+  ma_data_converter_get_expected_output_frame_count(
+      converter_.get(), maxInputBufferLength_, &processingBufferLength_);
+
+  processingBufferLength_ = std::max(processingBufferLength_, (ma_uint64)maxInputBufferLength_);
+
+  deinterleavingArray_ = std::make_shared<AudioArray>(processingBufferLength_);
+  processingBuffer_ = ma_malloc(
+      processingBufferLength_ * channelCount_ * ma_get_bytes_per_sample(ma_format_f32), NULL);
+
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+void AndroidRecorderCallback::cleanup() {
+  emitAudioData(true);
+
+  if (converter_ != nullptr) {
+    ma_data_converter_uninit(converter_.get(), NULL);
+    converter_.reset();
+  }
+
+  if (processingBuffer_ != nullptr) {
+    ma_free(processingBuffer_, NULL);
+    processingBuffer_ = nullptr;
+    processingBufferLength_ = 0;
+  }
+
+  for (size_t i = 0; i < circularBus_.size(); ++i) {
+    circularBus_[i]->zero();
+  }
+}
+
+/// @brief Receives audio data from the recorder, processes it (resampling and deinterleaving if necessary),
+/// and pushes it into the circular buffer.
+/// @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 (!isInitialized_.load(std::memory_order_acquire)) {
+    return;
+  }
+
+  ma_uint64 inputFrameCount = numFrames;
+  ma_uint64 outputFrameCount = 0;
+
+  if (static_cast<float>(streamSampleRate_) == sampleRate_ &&
+      streamChannelCount_ == channelCount_) {
+    deinterleaveAndPushAudioData(data, numFrames);
+    emitAudioData();
+    return;
+  }
+
+  ma_data_converter_get_expected_output_frame_count(
+      converter_.get(), inputFrameCount, &outputFrameCount);
+
+  ma_data_converter_process_pcm_frames(
+      converter_.get(), data, &inputFrameCount, processingBuffer_, &outputFrameCount);
+
+  deinterleaveAndPushAudioData(processingBuffer_, static_cast<int>(outputFrameCount));
+  emitAudioData();
+}
+
+/// @brief Deinterleaves the audio data and pushes it into the circular buffer.
+/// @param data Pointer to the interleaved audio data.
+/// @param numFrames Number of frames in the audio data.
+void AndroidRecorderCallback::deinterleaveAndPushAudioData(void *data, int numFrames) {
+  auto *inputData = static_cast<float *>(data);
+
+  for (int channel = 0; channel < channelCount_; ++channel) {
+    float *channelData = deinterleavingArray_->getData();
+
+    for (int frame = 0; frame < numFrames; ++frame) {
+      channelData[frame] = inputData[frame * channelCount_ + channel];
+    }
+
+    circularBus_[channel]->push_back(channelData, numFrames);
+  }
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,46 @@
+#pragma once
+
+
+#include <audioapi/libs/miniaudio/miniaudio.h>
+#include <audioapi/core/utils/AudioRecorderCallback.h>
+#include <memory>
+#include <vector>
+#include <string>
+
+namespace audioapi {
+
+class AudioBus;
+class AudioArray;
+class CircularAudioArray;
+class AudioEventHandlerRegistry;
+
+class AndroidRecorderCallback : public AudioRecorderCallback {
+ public:
+  AndroidRecorderCallback(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      float sampleRate,
+      size_t bufferLength,
+      int channelCount,
+      uint64_t callbackId);
+  ~AndroidRecorderCallback();
+
+  Result<NoneType, std::string> prepare(float streamSampleRate, int streamChannelCount, size_t maxInputBufferLength);
+  void cleanup() override;
+
+  void receiveAudioData(void *data, int numFrames);
+
+ protected:
+  float streamSampleRate_{0.0};
+  int streamChannelCount_{0};
+  size_t maxInputBufferLength_{0};
+
+  void *processingBuffer_{nullptr};
+  ma_uint64 processingBufferLength_{0};
+  std::unique_ptr<ma_data_converter> converter_{nullptr};
+
+  std::shared_ptr<AudioArray> deinterleavingArray_;
+
+  void deinterleaveAndPushAudioData(void *data, int numFrames);
+};
+
+} // namespace audioapi

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

@@ -5,7 +5,6 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 
-#define MINIAUDIO_IMPLEMENTATION
 #include <audioapi/libs/miniaudio/decoders/libopus/miniaudio_libopus.h>
 #include <audioapi/libs/miniaudio/decoders/libvorbis/miniaudio_libvorbis.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>

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

@@ -0,0 +1,83 @@
+#include <android/log.h>
+#include <audioapi/android/core/utils/FileOptions.h>
+#include <audioapi/android/system/NativeFileInfo.hpp>
+#include <audioapi/utils/AudioFileProperties.h>
+#include <chrono>
+#include <filesystem>
+#include <format>
+#include <iostream>
+#include <memory>
+#include <string>
+
+namespace audioapi::android::fileoptions {
+
+Result<NoneType, std::string> createDirectoryIfNotExists(const std::string &directoryPath) {
+  std::error_code ec;
+
+  if (std::filesystem::exists(directoryPath, ec)) {
+    return Result<NoneType, std::string>::Ok(None);
+  }
+
+  bool created = std::filesystem::create_directories(directoryPath, ec);
+
+  if (!created) {
+    return Result<NoneType, std::string>::Err("Failed to create directory: " + directoryPath);
+  }
+
+  if (ec) {
+    return Result<NoneType, std::string>::Err(ec.message());
+  }
+
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+std::string getTimestampString() {
+  auto tNow = std::chrono::system_clock::now();
+  return std::format("{:%Y%m%d_%H%M%S}", std::chrono::floor<std::chrono::seconds>(tNow));
+}
+
+std::string getDirectory(const std::shared_ptr<AudioFileProperties> &properties) {
+  switch (properties->directory) {
+    case AudioFileProperties::FileDirectory::Document:
+      return NativeFileInfo::getFilesDir();
+    case AudioFileProperties::FileDirectory::Cache:
+      return NativeFileInfo::getCacheDir();
+    default:
+      return NativeFileInfo::getCacheDir();
+  }
+}
+
+std::string getFileExtension(const std::shared_ptr<AudioFileProperties> &properties) {
+  switch (properties->format) {
+    case AudioFileProperties::Format::WAV:
+      return "wav";
+    case AudioFileProperties::Format::CAF:
+      return "caf";
+    case AudioFileProperties::Format::M4A:
+      return "m4a";
+    case AudioFileProperties::Format::FLAC:
+      return "flac";
+    default:
+      return "m4a";
+  }
+}
+
+Result<std::string, std::string> getFilePath(
+    const std::shared_ptr<AudioFileProperties> &properties) {
+  std::string directory = getDirectory(properties);
+  std::string subDirectory = std::format("{}/{}", directory, properties->subDirectory);
+  std::string fileTimestamp = getTimestampString();
+  std::string extension = getFileExtension(properties);
+
+  auto result = createDirectoryIfNotExists(subDirectory);
+
+  if (!result.is_ok()) {
+    return Result<std::string, std::string>::Err(result.unwrap_err());
+  }
+
+  auto filePath = std::format(
+      "{}/{}_{}.{}", subDirectory, properties->fileNamePrefix, fileTimestamp, extension);
+  return Result<std::string, std::string>::Ok(filePath);
+}
+
+} // namespace audioapi::android::fileoptions

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

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <string>
+#include <memory>
+#include <audioapi/utils/Result.hpp>
+
+namespace audioapi {
+
+class AudioFileProperties;
+
+namespace android::fileoptions {
+
+Result<NoneType, std::string> createDirectoryIfNotExists(const std::string &directoryPath);
+std::string getTimestampString();
+
+std::string getDirectory(const std::shared_ptr<AudioFileProperties> &properties);
+std::string getFileExtension(const std::shared_ptr<AudioFileProperties> &properties);
+Result<std::string, std::string> getFilePath(const std::shared_ptr<AudioFileProperties> &properties);
+
+} // namespace android::fileoptions
+
+} // namespace audioapi

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

@@ -0,0 +1,8 @@
+/// Miniaudio implementation for Android platform.
+/// this define tells the miniaudio to also include the definitions and not only declarations.
+/// Which should be done only once in the whole project.
+/// This make its safe to include the header file in multiple places, without causing multiple definition errors.
+/// TODO: Consider moving this file to common scope to re-use the miniaudio also for iOS platform.
+#define MINIAUDIO_IMPLEMENTATION
+#define MA_DEBUG_OUTPUT
+#include <audioapi/libs/miniaudio/miniaudio.h>