react-native-audio-api 0.11.0-alpha.1 → 0.11.0-nightly-9f40b78-20251108

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

@@ -1,429 +0,0 @@
-#include <android/log.h>
-#include <cmath>
-
-extern "C" {
-#include <libavformat/avio.h>
-}
-
-#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
-#include <audioapi/android/core/utils/ffmpegBackend/FFmpegAudioFileOptions.h>
-#include <audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h>
-
-constexpr double BYTES_TO_MB = 1024.0 * 1024.0;
-
-namespace audioapi {
-
-FFmpegAudioFileWriter::FFmpegAudioFileWriter(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t androidFlags)
-    : AndroidFileWriterBackend(
-          sampleRate,
-          channelCount,
-          bitRate,
-          androidFlags) {
-  fileOptions_ = std::make_shared<FFmpegAudioFileOptions>(
-      sampleRate, channelCount, bitRate, androidFlags);
-}
-
-FFmpegAudioFileWriter::~FFmpegAudioFileWriter() {
-  isFileOpen_.store(false);
-  fileOptions_.reset();
-}
-
-std::string FFmpegAudioFileWriter::openFile(
-    int32_t streamSampleRate,
-    int32_t streamChannelCount,
-    int32_t streamMaxBufferSize) {
-  filePath_ = fileOptions_->getFilePath("audio");
-
-  streamSampleRate_ = streamSampleRate;
-  streamChannelCount_ = streamChannelCount;
-  streamMaxBufferSize_ = streamMaxBufferSize;
-  framesWritten_.store(0);
-  nextPts_ = 0;
-
-  const AVCodec *codec = fileOptions_->getCodec();
-  AVFormatContext *rawFormatCtx = nullptr;
-
-  if (avformat_alloc_output_context2(
-          &rawFormatCtx,
-          nullptr,
-          fileOptions_->getMuxerName().c_str(),
-          filePath_.c_str()) < 0 ||
-      !rawFormatCtx) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FFmpegFileWriter",
-        "Failed to allocate FFmpeg format context for file: %s",
-        filePath_.c_str());
-    return "";
-  }
-
-  formatCtx_ = AVFormatContextPtr(rawFormatCtx);
-  stream_ = avformat_new_stream(formatCtx_.get(), codec);
-
-  encoderCtx_ = AVCodecContextPtr(avcodec_alloc_context3(codec));
-
-  if (!encoderCtx_) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FFmpegFileWriter",
-        "Failed to allocate FFmpeg codec context for file");
-    return "";
-  }
-
-  AVDictionary *codecOptions = nullptr;
-  size_t bitRate = fileOptions_->getBitRate();
-  int flacCompressionLevel = fileOptions_->getFlacCompressionLevel();
-  av_channel_layout_default(
-      &encoderCtx_->ch_layout, fileOptions_->getChannelCount());
-
-  encoderCtx_->sample_rate = fileOptions_->getSampleRate();
-  encoderCtx_->sample_fmt = fileOptions_->getSampleFormat();
-
-  if (bitRate > 0) {
-    encoderCtx_->bit_rate = bitRate;
-  }
-
-  if (flacCompressionLevel >= 0) {
-    av_dict_set_int(
-        &codecOptions, "compression_level", flacCompressionLevel, 0);
-  }
-
-  if (avcodec_open2(encoderCtx_.get(), codec, &codecOptions) < 0) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FFmpegFileWriter",
-        "Failed to open FFmpeg codec for file");
-    av_dict_free(&codecOptions);
-    return "";
-  }
-
-  av_dict_free(&codecOptions);
-
-  if (avcodec_parameters_from_context(stream_->codecpar, encoderCtx_.get()) <
-      0) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FFmpegFileWriter",
-        "Failed to copy codec parameters to stream for file");
-    return "";
-  }
-
-  if (!(formatCtx_->oformat->flags & AVFMT_NOFILE)) {
-    if (avio_open(&formatCtx_->pb, filePath_.c_str(), AVIO_FLAG_WRITE) < 0) {
-      __android_log_print(
-          ANDROID_LOG_ERROR,
-          "FFmpegFileWriter",
-          "Failed to open output file: %s",
-          filePath_.c_str());
-      return "";
-    }
-  }
-
-  stream_->time_base =
-      AVRational{1, static_cast<int>(encoderCtx_->sample_rate)};
-
-  if (avformat_write_header(formatCtx_.get(), nullptr) < 0) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FFmpegFileWriter",
-        "Failed to write header to file: %s",
-        filePath_.c_str());
-    return "";
-  }
-
-  frame_ = AVFramePtr(av_frame_alloc());
-  packet_ = AVPacketPtr(av_packet_alloc());
-
-  resampleCtx_ = SwrContextPtr(swr_alloc());
-
-  AVChannelLayout inChannelLayout;
-  av_channel_layout_default(&inChannelLayout, streamChannelCount_);
-
-  av_opt_set_chlayout(resampleCtx_.get(), "in_chlayout", &inChannelLayout, 0);
-
-  av_opt_set_chlayout(
-      resampleCtx_.get(), "out_chlayout", &encoderCtx_->ch_layout, 0);
-
-  av_opt_set_int(resampleCtx_.get(), "in_sample_rate", streamSampleRate, 0);
-
-  av_opt_set_int(
-      resampleCtx_.get(), "out_sample_rate", encoderCtx_->sample_rate, 0);
-
-  av_opt_set_sample_fmt(
-      resampleCtx_.get(), "in_sample_fmt", AV_SAMPLE_FMT_FLT, 0);
-
-  av_opt_set_sample_fmt(
-      resampleCtx_.get(), "out_sample_fmt", encoderCtx_->sample_fmt, 0);
-
-  if (swr_init(resampleCtx_.get()) < 0) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FFmpegFileWriter",
-        "Failed to initialize resampler for file: %s",
-        filePath_.c_str());
-    return "";
-  }
-
-  int contextFrameRatio = 2;
-
-  if (encoderCtx_->frame_size > 0) {
-    contextFrameRatio = static_cast<int>(std::ceil(
-        static_cast<double>(streamMaxBufferSize_) /
-        static_cast<double>(encoderCtx_->frame_size)));
-  }
-
-  int fifoSize = std::max(
-      encoderCtx_->frame_size > 0
-          ? encoderCtx_->frame_size * contextFrameRatio * 2
-          : streamMaxBufferSize_ * 2,
-      4096);
-
-  audioFifo_ = AVAudioFifoPtr(av_audio_fifo_alloc(
-      encoderCtx_->sample_fmt, encoderCtx_->ch_layout.nb_channels, fifoSize));
-
-  __android_log_print(
-      ANDROID_LOG_INFO,
-      "FFmpegFileWriter",
-      "Using audio FIFO size of %d frames",
-      fifoSize);
-
-  isFileOpen_.store(true);
-
-  return filePath_;
-}
-
-std::tuple<double, double> FFmpegAudioFileWriter::closeFile() {
-  if (!isFileOpen()) {
-    return {0.0, 0.0};
-  }
-
-  isFileOpen_.store(false);
-
-  const int frameSize =
-      encoderCtx_->frame_size > 0 ? encoderCtx_->frame_size : 512;
-
-  while (av_audio_fifo_size(audioFifo_.get()) > 0) {
-    const int chunkSize =
-        std::min(av_audio_fifo_size(audioFifo_.get()), frameSize);
-
-    frame_->nb_samples = chunkSize;
-    av_channel_layout_copy(&frame_->ch_layout, &encoderCtx_->ch_layout);
-    frame_->format = encoderCtx_->sample_fmt;
-    frame_->sample_rate = encoderCtx_->sample_rate;
-
-    if (av_frame_get_buffer(frame_.get(), 0) < 0) {
-      __android_log_print(
-          ANDROID_LOG_ERROR,
-          "FFmpegFileWriter",
-          "Failed to allocate audio frame buffer during flushing");
-      break;
-    }
-
-    int fifoReadFrameCount =
-        av_audio_fifo_read(audioFifo_.get(), (void **)frame_->data, chunkSize);
-
-    if (fifoReadFrameCount != chunkSize) {
-      __android_log_print(
-          ANDROID_LOG_ERROR,
-          "FFmpegFileWriter",
-          "Failed to read audio samples from FIFO during flushing");
-      break;
-    }
-
-    frame_->pts = nextPts_;
-    nextPts_ += chunkSize;
-
-    if (avcodec_send_frame(encoderCtx_.get(), frame_.get()) < 0) {
-      __android_log_print(
-          ANDROID_LOG_ERROR,
-          "FFmpegFileWriter",
-          "Failed to send audio frame to encoder during flushing");
-      av_frame_unref(frame_.get());
-      break;
-    }
-
-    av_frame_unref(frame_.get());
-  }
-
-  avcodec_send_frame(encoderCtx_.get(), nullptr);
-
-  while (avcodec_receive_packet(encoderCtx_.get(), packet_.get()) == 0) {
-    av_packet_rescale_ts(
-        packet_.get(),
-        AVRational{1, encoderCtx_->sample_rate},
-        stream_->time_base);
-    packet_->stream_index = stream_->index;
-    av_interleaved_write_frame(formatCtx_.get(), packet_.get());
-    av_packet_unref(packet_.get());
-  }
-
-  if (av_write_trailer(formatCtx_.get()) < 0) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FFmpegFileWriter",
-        "Failed to write trailer to file: %s",
-        filePath_.c_str());
-  }
-
-  double fileSizeInMB = avio_size(formatCtx_->pb) / BYTES_TO_MB;
-  double durationInSeconds = getCurrentDuration();
-
-  if (formatCtx_ && formatCtx_->pb) {
-    avio_closep(&formatCtx_->pb);
-  }
-
-  resampleCtx_.reset();
-  frame_.reset();
-  packet_.reset();
-  encoderCtx_.reset();
-  formatCtx_.reset();
-  audioFifo_.reset();
-
-  filePath_ = "";
-  return {fileSizeInMB, durationInSeconds};
-}
-
-bool FFmpegAudioFileWriter::writeAudioData(void *data, int numFrames) {
-  if (!isFileOpen()) {
-    return false;
-  }
-
-  int outputLength = av_rescale_rnd(
-      numFrames, encoderCtx_->sample_rate, streamSampleRate_, AV_ROUND_UP);
-
-  frame_->nb_samples = outputLength;
-  av_channel_layout_copy(&frame_->ch_layout, &encoderCtx_->ch_layout);
-  frame_->format = encoderCtx_->sample_fmt;
-  frame_->sample_rate = encoderCtx_->sample_rate;
-
-  if (av_frame_get_buffer(frame_.get(), 0) < 0) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FFmpegFileWriter",
-        "Failed to allocate audio frame buffer, outputLength: %d, format: %d, sample_rate: %d, channels: %d",
-        outputLength,
-        encoderCtx_->sample_fmt,
-        encoderCtx_->sample_rate,
-        encoderCtx_->ch_layout.nb_channels);
-
-    return false;
-  }
-
-  const uint8_t *inputData[1] = {reinterpret_cast<const uint8_t *>(data)};
-
-  int convertedSamples = swr_convert(
-      resampleCtx_.get(), frame_->data, outputLength, inputData, numFrames);
-
-  if (convertedSamples < 0) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FFmpegFileWriter",
-        "Failed to convert audio samples for file: %s",
-        filePath_.c_str());
-    av_frame_unref(frame_.get());
-    return false;
-  }
-
-  int fifoWrittenFrameCount = av_audio_fifo_write(
-      audioFifo_.get(), (void **)frame_->data, convertedSamples);
-
-  if (fifoWrittenFrameCount < convertedSamples) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FFmpegFileWriter",
-        "Failed to write audio samples to FIFO");
-    av_frame_unref(frame_.get());
-    return false;
-  }
-
-  av_frame_unref(frame_.get());
-  const int frameSize =
-      encoderCtx_->frame_size > 0 ? encoderCtx_->frame_size : 512;
-
-  while (av_audio_fifo_size(audioFifo_.get()) >= frameSize) {
-    frame_->nb_samples = frameSize;
-    av_channel_layout_copy(&frame_->ch_layout, &encoderCtx_->ch_layout);
-    frame_->format = encoderCtx_->sample_fmt;
-    frame_->sample_rate = encoderCtx_->sample_rate;
-
-    if (av_frame_get_buffer(frame_.get(), 0) < 0) {
-      __android_log_print(
-          ANDROID_LOG_ERROR,
-          "FFmpegFileWriter",
-          "Failed to allocate audio frame buffer");
-      return false;
-    }
-
-    int fifoReadFrameCount =
-        av_audio_fifo_read(audioFifo_.get(), (void **)frame_->data, frameSize);
-
-    if (fifoReadFrameCount != frameSize) {
-      __android_log_print(
-          ANDROID_LOG_ERROR,
-          "FFmpegFileWriter",
-          "Failed to read audio samples from FIFO");
-      return false;
-    }
-
-    frame_->pts = nextPts_;
-    nextPts_ += frameSize;
-
-    if (avcodec_send_frame(encoderCtx_.get(), frame_.get()) < 0) {
-      __android_log_print(
-          ANDROID_LOG_ERROR,
-          "FFmpegFileWriter",
-          "Failed to send audio frame to encoder");
-      av_frame_unref(frame_.get());
-      return false;
-    }
-
-    while (avcodec_receive_packet(encoderCtx_.get(), packet_.get()) == 0) {
-      av_packet_rescale_ts(
-          packet_.get(),
-          AVRational{1, encoderCtx_->sample_rate},
-          stream_->time_base);
-
-      packet_->stream_index = stream_->index;
-
-      if (av_interleaved_write_frame(formatCtx_.get(), packet_.get()) < 0) {
-        __android_log_print(
-            ANDROID_LOG_ERROR,
-            "FFmpegFileWriter",
-            "Failed to write audio packet to file");
-
-        av_packet_unref(packet_.get());
-        av_frame_unref(frame_.get());
-        return false;
-      }
-
-      av_packet_unref(packet_.get());
-    }
-
-    av_frame_unref(frame_.get());
-  }
-
-  framesWritten_.fetch_add(numFrames);
-  return true;
-}
-
-bool FFmpegAudioFileWriter::initializeConverterIfNeeded() {
-  return false;
-}
-
-bool FFmpegAudioFileWriter::initializeEncoder() {
-  return false;
-}
-
-bool FFmpegAudioFileWriter::isFileOpen() {
-  return isFileOpen_.load();
-}
-
-bool FFmpegAudioFileWriter::isConverterRequired() {
-  return isConverterRequired_.load();
-}
-
-} // namespace audioapi

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

@@ -1,113 +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>
-#include <tuple>
-
-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;
-
-  std::string openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) override;
-  std::tuple<double, double> 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