react-native-audio-api 0.11.0-alpha.0 → 0.11.0-nightly-bfab178-20251107

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

@@ -1,112 +0,0 @@
-#pragma once
-
-extern "C" {
-#include <libavutil/opt.h>
-#include <libavcodec/avcodec.h>
-#include <libavutil/audio_fifo.h>
-#include <libavformat/avformat.h>
-#include <libswresample/swresample.h>
-#include <libavutil/channel_layout.h>
-}
-
-#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
-
-#include <string>
-#include <memory>
-
-namespace audioapi {
-
-class FFmpegAudioFileOptions;
-
-struct AVCodecContextDTOR {
-  void operator()(AVCodecContext* ctx) const {
-    if (ctx) {
-      avcodec_free_context(&ctx);
-    }
-  }
-};
-
-struct AVFormatContextDTOR {
-  void operator()(AVFormatContext* ctx) const {
-    if (ctx) {
-      avformat_free_context(ctx);
-    }
-  }
-};
-
-struct AVFrameDTOR {
-  void operator()(AVFrame* frame) const {
-    if (frame) {
-      av_frame_free(&frame);
-    }
-  }
-};
-
-struct AVPacketDTOR {
-  void operator()(AVPacket* packet) const {
-    if (packet) {
-      av_packet_free(&packet);
-    }
-  }
-};
-
-struct SwrContextDTOR {
-  void operator()(SwrContext* ctx) const {
-    if (ctx) {
-      swr_free(&ctx);
-    }
-  }
-};
-
-struct AVAudioFifoDTOR {
-  void operator()(AVAudioFifo* fifo) const {
-    if (fifo) {
-      av_audio_fifo_free(fifo);
-    }
-  }
-};
-
-using AVCodecContextPtr = std::unique_ptr<AVCodecContext, AVCodecContextDTOR>;
-using AVFormatContextPtr = std::unique_ptr<AVFormatContext, AVFormatContextDTOR>;
-using AVFramePtr = std::unique_ptr<AVFrame, AVFrameDTOR>;
-using AVPacketPtr = std::unique_ptr<AVPacket, AVPacketDTOR>;
-using SwrContextPtr = std::unique_ptr<SwrContext, SwrContextDTOR>;
-using AVAudioFifoPtr = std::unique_ptr<AVAudioFifo, AVAudioFifoDTOR>;
-
-class FFmpegAudioFileWriter : public AndroidFileWriterBackend {
- public:
-  FFmpegAudioFileWriter(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t androidFlags);
-  ~FFmpegAudioFileWriter() override;
-
-  void openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) override;
-  std::string closeFile() override;
-
-  bool writeAudioData(void *data, int numFrames) override;
-
- private:
-  std::shared_ptr<FFmpegAudioFileOptions> fileOptions_;
-
-  std::atomic<bool> isFileOpen_{false};
-  std::atomic<bool> isConverterRequired_{false};
-
-  AVCodecContextPtr encoderCtx_{nullptr};
-  AVFormatContextPtr formatCtx_{nullptr};
-  SwrContextPtr resampleCtx_{nullptr};
-  AVPacketPtr packet_{nullptr};
-  AVFramePtr frame_{nullptr};
-  AVStream* stream_{nullptr};
-  AVAudioFifoPtr audioFifo_{nullptr};
-  int64_t nextPts_;
-
-  bool initializeConverterIfNeeded();
-  bool initializeEncoder();
-
-  bool isFileOpen();
-  bool isConverterRequired();
-};
-
-} // namespace audioapi

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

@@ -1,47 +0,0 @@
-
-#include <audioapi/android/core/utils/FileUtils.h>
-#include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileOptions.h>
-
-namespace audioapi {
-
-MiniAudioFileOptions::MiniAudioFileOptions(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t flags)
-    : sampleRate_(sampleRate), channelCount_(channelCount), flags_(flags) {};
-
-ma_encoding_format MiniAudioFileOptions::getFormat() const {
-  return ma_encoding_format_wav;
-}
-
-std::string MiniAudioFileOptions::getFilePath(
-    const std::string &baseFileName) const {
-  return android::fileutils::getFilePath(
-      android::fileutils::directoryFromFlags(flags_), baseFileName, "wav");
-}
-
-float MiniAudioFileOptions::getSampleRate() const {
-  return sampleRate_;
-}
-
-size_t MiniAudioFileOptions::getChannelCount() const {
-  return channelCount_;
-}
-
-ma_format MiniAudioFileOptions::getDataFormat() const {
-  android::fileutils::BitDepth bitDepth =
-      android::fileutils::bitDepthFromFlags(flags_);
-  switch (bitDepth) {
-    case android::fileutils::BitDepth::BIT_16:
-      return ma_format_s16;
-    case android::fileutils::BitDepth::BIT_24:
-      return ma_format_s24;
-    case android::fileutils::BitDepth::BIT_32:
-      return ma_format_f32;
-    default:
-      return ma_format_f32;
-  }
-}
-
-} // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileOptions.h

@@ -1,28 +0,0 @@
-#pragma once
-
-#include <audioapi/libs/miniaudio/miniaudio.h>
-#include <cstddef>
-#include <cstdint>
-#include <string>
-
-namespace audioapi {
-
-class MiniAudioFileOptions {
- public:
-  MiniAudioFileOptions(float sampleRate, size_t channelCount, size_t bitRate, size_t flags);
-  ~MiniAudioFileOptions() = default;
-
-  ma_encoding_format getFormat() const;
-  std::string getFilePath(const std::string &baseFileName) const;
-
-  float getSampleRate() const;
-  size_t getChannelCount() const;
-  ma_format getDataFormat() const;
-
- private:
-  float sampleRate_;
-  size_t channelCount_;
-  size_t flags_;
-};
-
-} // namespace audioapi

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

@@ -1,237 +0,0 @@
-#include <android/log.h>
-#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
-#include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileOptions.h>
-#include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h>
-#include <audioapi/libs/miniaudio/miniaudio.h>
-
-namespace audioapi {
-
-MiniAudioFileWriter::MiniAudioFileWriter(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t androidFlags)
-    : AndroidFileWriterBackend(
-          sampleRate,
-          channelCount,
-          bitRate,
-          androidFlags) {
-  fileOptions_ = std::make_shared<MiniAudioFileOptions>(
-      sampleRate, channelCount, bitRate, androidFlags);
-}
-
-MiniAudioFileWriter::~MiniAudioFileWriter() {
-  isFileOpen_.store(false);
-  fileOptions_.reset();
-
-  if (encoder_ != nullptr) {
-    ma_encoder_uninit(encoder_.get());
-    encoder_.reset();
-  }
-
-  if (converter_ != nullptr) {
-    ma_data_converter_uninit(converter_.get(), NULL);
-    converter_.reset();
-  }
-
-  if (processingBuffer_ != nullptr) {
-    ma_free(processingBuffer_, NULL);
-    processingBuffer_ = nullptr;
-    processingBufferLength_ = 0;
-  }
-}
-
-void MiniAudioFileWriter::openFile(
-    int32_t streamSampleRate,
-    int32_t streamChannelCount,
-    int32_t streamMaxBufferSize) {
-  streamSampleRate_ = streamSampleRate;
-  streamChannelCount_ = streamChannelCount;
-  streamMaxBufferSize_ = streamMaxBufferSize;
-  bool success = false;
-
-  isConverterRequired_.store(
-      (streamSampleRate_ != fileOptions_->getSampleRate()) ||
-      (streamChannelCount_ != fileOptions_->getChannelCount()) ||
-      (fileOptions_->getDataFormat() != ma_format_f32));
-
-  success = initializeConverterIfNeeded();
-
-  if (!success) {
-    return;
-  }
-
-  success = initializeEncoder();
-
-  if (!success) {
-    return;
-  }
-
-  isFileOpen_.store(true);
-}
-
-std::string MiniAudioFileWriter::closeFile() {
-  if (!isFileOpen()) {
-    return "";
-  }
-
-  isFileOpen_.store(false);
-
-  if (encoder_ != nullptr) {
-    ma_encoder_uninit(encoder_.get());
-    encoder_.reset();
-  }
-
-  if (converter_ != nullptr) {
-    ma_data_converter_uninit(converter_.get(), NULL);
-    converter_.reset();
-  }
-
-  if (processingBuffer_ != nullptr) {
-    ma_free(processingBuffer_, NULL);
-    processingBuffer_ = nullptr;
-    processingBufferLength_ = 0;
-  }
-
-  std::string closedFilePath = filePath_;
-  filePath_ = "";
-
-  return closedFilePath;
-}
-
-bool MiniAudioFileWriter::writeAudioData(void *data, int numFrames) {
-  ma_uint64 framesWritten = 0;
-  ma_result result;
-
-  if (!isFileOpen()) {
-    return false;
-  }
-
-  if (!isConverterRequired()) {
-    result = ma_encoder_write_pcm_frames(
-        encoder_.get(), data, numFrames, &framesWritten);
-
-    __android_log_print(
-        ANDROID_LOG_DEBUG,
-        "MiniAudioFileWriter",
-        "Writing %llu frames without conversion to file: %s",
-        framesWritten,
-        filePath_.c_str());
-
-    if (result != MA_SUCCESS) {
-      __android_log_print(
-          ANDROID_LOG_ERROR,
-          "MiniAudioFileWriter",
-          "Failed to write audio data to file: %s",
-          filePath_.c_str());
-    }
-
-    return result == MA_SUCCESS;
-  }
-
-  ma_uint64 convertedFrameCount = convertBuffer(data, numFrames);
-
-  result = ma_encoder_write_pcm_frames(
-      encoder_.get(), processingBuffer_, convertedFrameCount, &framesWritten);
-
-  if (result != MA_SUCCESS) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "MiniAudioFileWriter",
-        "Failed to write converted audio data to file: %s",
-        filePath_.c_str());
-  }
-
-  return result == MA_SUCCESS;
-}
-
-ma_uint64 MiniAudioFileWriter::convertBuffer(void *data, int numFrames) {
-  ma_uint64 inputFrameCount = numFrames;
-  ma_uint64 outputFrameCount = 0;
-
-  ma_data_converter_get_expected_output_frame_count(
-      converter_.get(), inputFrameCount, &outputFrameCount);
-
-  ma_data_converter_process_pcm_frames(
-      converter_.get(),
-      data,
-      &inputFrameCount,
-      processingBuffer_,
-      &outputFrameCount);
-
-  return outputFrameCount;
-}
-
-bool MiniAudioFileWriter::initializeConverterIfNeeded() {
-  if (!isConverterRequired_) {
-    return true;
-  }
-
-  ma_result result;
-
-  ma_data_converter_config converterConfig = ma_data_converter_config_init(
-      ma_format_f32,
-      fileOptions_->getDataFormat(),
-      streamChannelCount_,
-      fileOptions_->getChannelCount(),
-      streamSampleRate_,
-      fileOptions_->getSampleRate());
-
-  converter_ = std::make_unique<ma_data_converter>();
-  result = ma_data_converter_init(&converterConfig, NULL, converter_.get());
-
-  if (result != MA_SUCCESS) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "MiniAudioFileWriter",
-        "Failed to initialize miniaudio data converter for file: %s",
-        filePath_.c_str());
-    return false;
-  }
-
-  ma_data_converter_get_expected_output_frame_count(
-      converter_.get(), streamMaxBufferSize_, &processingBufferLength_);
-
-  processingBuffer_ = ma_malloc(
-      processingBufferLength_ * fileOptions_->getChannelCount() *
-          ma_get_bytes_per_sample(fileOptions_->getDataFormat()),
-      NULL);
-
-  return true;
-}
-
-bool MiniAudioFileWriter::initializeEncoder() {
-  filePath_ = fileOptions_->getFilePath("audio");
-
-  ma_result result;
-
-  ma_encoder_config config = ma_encoder_config_init(
-      fileOptions_->getFormat(),
-      fileOptions_->getDataFormat(),
-      fileOptions_->getChannelCount(),
-      fileOptions_->getSampleRate());
-
-  encoder_ = std::make_unique<ma_encoder>();
-  result = ma_encoder_init_file(filePath_.c_str(), &config, encoder_.get());
-
-  if (result != MA_SUCCESS) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "MiniAudioFileWriter",
-        "Failed to initialize miniaudio encoder for file: %s",
-        filePath_.c_str());
-    return false;
-  }
-
-  return true;
-}
-
-bool MiniAudioFileWriter::isFileOpen() {
-  return isFileOpen_.load();
-}
-
-bool MiniAudioFileWriter::isConverterRequired() {
-  return isConverterRequired_.load();
-}
-
-} // namespace audioapi

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

@@ -1,46 +0,0 @@
-#pragma once
-
-#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
-#include <audioapi/libs/miniaudio/miniaudio.h>
-
-#include <string>
-#include <memory>
-
-namespace audioapi {
-
-class MiniAudioFileOptions;
-
-class MiniAudioFileWriter : public AndroidFileWriterBackend {
- public:
-  MiniAudioFileWriter(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t androidFlags);
-  ~MiniAudioFileWriter() override;
-
-  void openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) override;
-  std::string closeFile() override;
-
-  bool writeAudioData(void *data, int numFrames) override;
-
- private:
-  std::shared_ptr<MiniAudioFileOptions> fileOptions_;
-
-  std::atomic<bool> isFileOpen_{false};
-  std::atomic<bool> isConverterRequired_{false};
-
-  std::unique_ptr<ma_encoder> encoder_{nullptr};
-  std::unique_ptr<ma_data_converter> converter_{nullptr};
-  void *processingBuffer_{nullptr};
-  ma_uint64 processingBufferLength_{0};
-
-  bool initializeConverterIfNeeded();
-  bool initializeEncoder();
-  ma_uint64 convertBuffer(void *data, int numFrames);
-
-  bool isFileOpen();
-  bool isConverterRequired();
-};
-
-} // namespace audioapi

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

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <fbjni/fbjni.h>
-#include <react/jni/CxxModuleWrapper.h>
-#include <react/jni/JMessageQueueThread.h>
-#include <memory>
-#include <utility>
-#include <unordered_map>
-
-namespace audioapi {
-
-using namespace facebook;
-using namespace react;
-
-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();
-  }
-
-  static std::string getCacheDir() {
-    static const auto method = javaClassStatic()->getStaticMethod<jni::JString()>("getCacheDir");
-    return method(javaClassStatic())->toStdString();
-  }
-};
-
-}

package/android/src/main/java/com/swmansion/audioapi/system/NativeFileInfo.kt

@@ -1,18 +0,0 @@
-package com.swmansion.audioapi.system
-
-import com.facebook.react.bridge.ReactApplicationContext
-import java.lang.ref.WeakReference
-
-object NativeFileInfo {
-  private lateinit var reactContext: WeakReference<ReactApplicationContext>
-
-  fun initialize(reactContext: WeakReference<ReactApplicationContext>) {
-    this.reactContext = reactContext
-  }
-
-  @JvmStatic
-  fun getFilesDir(): String = reactContext.get()?.filesDir?.absolutePath ?: ""
-
-  @JvmStatic
-  fun getCacheDir(): String = reactContext.get()?.cacheDir?.absolutePath ?: ""
-}