react-native-audio-api 0.10.0-nightly-c815c40-20251027 → 0.11.0-alpha.0

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

@@ -0,0 +1,154 @@
+
+#include <audioapi/android/core/utils/FileUtils.h>
+#include <audioapi/android/core/utils/ffmpegBackend/FFmpegAudioFileOptions.h>
+
+namespace audioapi {
+
+FFmpegAudioFileOptions::FFmpegAudioFileOptions(
+    float sampleRate,
+    size_t channelCount,
+    size_t bitRate,
+    size_t flags)
+    : sampleRate_(sampleRate),
+      channelCount_(channelCount),
+      bitRate_(bitRate),
+      flags_(flags) {}
+
+std::string FFmpegAudioFileOptions::getFileExtension() const {
+  android::fileutils::FileFormat format =
+      android::fileutils::formatFromFlags(flags_);
+
+  switch (format) {
+    // WAV is encoded using miniaudio, so it is not necessary here
+    // but lets leave it for convenience
+    // when using FFmpeg we will use M4A as default format
+    case android::fileutils::FileFormat::WAV:
+      return "wav";
+    case android::fileutils::FileFormat::CAF:
+      return "caf";
+    case android::fileutils::FileFormat::M4A:
+      return "m4a";
+    case android::fileutils::FileFormat::FLAC:
+      return "flac";
+    default:
+      return "m4a";
+  }
+}
+
+AVCodecID FFmpegAudioFileOptions::getPCMCodecID() const {
+  android::fileutils::BitDepth bitDepth =
+      android::fileutils::bitDepthFromFlags(flags_);
+
+  switch (bitDepth) {
+    case android::fileutils::BitDepth::BIT_16:
+      return AV_CODEC_ID_PCM_S16LE;
+    case android::fileutils::BitDepth::BIT_24:
+      return AV_CODEC_ID_PCM_S24LE;
+    case android::fileutils::BitDepth::BIT_32:
+      return AV_CODEC_ID_PCM_F32LE;
+    default:
+      return AV_CODEC_ID_PCM_F32LE;
+  }
+}
+
+AVCodecID FFmpegAudioFileOptions::getCodecID() const {
+  android::fileutils::FileFormat format =
+      android::fileutils::formatFromFlags(flags_);
+
+  switch (format) {
+    case android::fileutils::FileFormat::WAV:
+    case android::fileutils::FileFormat::CAF:
+      return getPCMCodecID();
+    case android::fileutils::FileFormat::M4A:
+      return AV_CODEC_ID_AAC;
+    case android::fileutils::FileFormat::FLAC:
+      return AV_CODEC_ID_FLAC;
+    default:
+      return AV_CODEC_ID_AAC;
+  }
+}
+
+AVSampleFormat FFmpegAudioFileOptions::getSampleFormat() const {
+  android::fileutils::FileFormat format =
+      android::fileutils::formatFromFlags(flags_);
+  android::fileutils::BitDepth bitDepth =
+      android::fileutils::bitDepthFromFlags(flags_);
+
+  if (format == android::fileutils::FileFormat::M4A) {
+    return AV_SAMPLE_FMT_FLTP;
+  }
+
+  switch (bitDepth) {
+    case android::fileutils::BitDepth::BIT_16:
+      return AV_SAMPLE_FMT_S16;
+    case android::fileutils::BitDepth::BIT_24:
+      return AV_SAMPLE_FMT_S32;
+    case android::fileutils::BitDepth::BIT_32:
+      return AV_SAMPLE_FMT_FLT;
+    default:
+      return AV_SAMPLE_FMT_FLT;
+  }
+}
+
+const AVCodec *FFmpegAudioFileOptions::getCodec() {
+  return avcodec_find_encoder(getCodecID());
+}
+
+std::string FFmpegAudioFileOptions::getFilePath(
+    const std::string &baseFileName) const {
+  std::string extension = getFileExtension();
+
+  return android::fileutils::getFilePath(
+      android::fileutils::directoryFromFlags(flags_), baseFileName, extension);
+}
+
+float FFmpegAudioFileOptions::getSampleRate() const {
+  return sampleRate_;
+}
+
+size_t FFmpegAudioFileOptions::getChannelCount() const {
+  return channelCount_;
+}
+
+size_t FFmpegAudioFileOptions::getBitRate() const {
+  android::fileutils::FileFormat format =
+      android::fileutils::formatFromFlags(flags_);
+
+  if (format != android::fileutils::FileFormat::M4A) {
+    return 0; // bit rate is not used for PCM formats
+  } else
+
+    return bitRate_;
+}
+
+int FFmpegAudioFileOptions::getFlacCompressionLevel() const {
+  android::fileutils::FileFormat format =
+      android::fileutils::formatFromFlags(flags_);
+
+  if (format != android::fileutils::FileFormat::FLAC) {
+    return -1; // compression level is not used for non-FLAC formats
+  }
+
+  // TODO: extract compression level from flags
+  return 5; // default compression level
+}
+
+std::string FFmpegAudioFileOptions::getMuxerName() const {
+  android::fileutils::FileFormat format =
+      android::fileutils::formatFromFlags(flags_);
+
+  switch (format) {
+    case android::fileutils::FileFormat::WAV:
+      return "wav";
+    case android::fileutils::FileFormat::CAF:
+      return "caf";
+    case android::fileutils::FileFormat::M4A:
+      return "mp4";
+    case android::fileutils::FileFormat::FLAC:
+      return "flac";
+    default:
+      return "mp4";
+  }
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,41 @@
+#pragma once
+
+extern "C" {
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libswresample/swresample.h>
+}
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+namespace audioapi {
+
+class FFmpegAudioFileOptions {
+ public:
+  FFmpegAudioFileOptions(float sampleRate, size_t channelCount, size_t bitRate, size_t flags);
+  ~FFmpegAudioFileOptions() = default;
+
+  std::string getFileExtension() const;
+  std::string getFilePath(const std::string &baseFileName) const;
+
+  float getSampleRate() const;
+  size_t getChannelCount() const;
+
+  AVCodecID getPCMCodecID() const;
+  AVCodecID getCodecID() const;
+  AVSampleFormat getSampleFormat() const;
+  const AVCodec* getCodec();
+  size_t getBitRate() const;
+  int getFlacCompressionLevel() const;
+  std::string getMuxerName() const;
+
+ private:
+  float sampleRate_;
+  size_t channelCount_;
+  size_t flags_;
+  size_t bitRate_;
+};
+
+} // namespace audioapi

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

@@ -0,0 +1,431 @@
+#include <android/log.h>
+#include <cmath>
+extern "C" {
+#include <libavutil/log.h>
+}
+
+#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
+#include <audioapi/android/core/utils/ffmpegBackend/FFmpegAudioFileOptions.h>
+#include <audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h>
+
+namespace audioapi {
+
+FFmpegAudioFileWriter::FFmpegAudioFileWriter(
+    float sampleRate,
+    size_t channelCount,
+    size_t bitRate,
+    size_t androidFlags)
+    : AndroidFileWriterBackend(
+          sampleRate,
+          channelCount,
+          bitRate,
+          androidFlags) {
+  av_log_set_level(AV_LOG_DEBUG);
+
+  av_log_set_callback([](void *, int level, const char *fmt, va_list vl) {
+    if (level > av_log_get_level())
+      return;
+    char msg[1024];
+    vsnprintf(msg, sizeof(msg), fmt, vl);
+    __android_log_print(ANDROID_LOG_INFO, "FFmpeg", "%s", msg);
+  });
+
+  fileOptions_ = std::make_shared<FFmpegAudioFileOptions>(
+      sampleRate, channelCount, bitRate, androidFlags);
+}
+
+FFmpegAudioFileWriter::~FFmpegAudioFileWriter() {
+  isFileOpen_.store(false);
+  fileOptions_.reset();
+}
+
+void FFmpegAudioFileWriter::openFile(
+    int32_t streamSampleRate,
+    int32_t streamChannelCount,
+    int32_t streamMaxBufferSize) {
+  filePath_ = fileOptions_->getFilePath("audio");
+
+  streamSampleRate_ = streamSampleRate;
+  streamChannelCount_ = streamChannelCount;
+  streamMaxBufferSize_ = streamMaxBufferSize;
+  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);
+}
+
+std::string FFmpegAudioFileWriter::closeFile() {
+  if (!isFileOpen()) {
+    return "";
+  }
+
+  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());
+  }
+
+  if (formatCtx_ && formatCtx_->pb) {
+    avio_closep(&formatCtx_->pb);
+  }
+
+  resampleCtx_.reset();
+  frame_.reset();
+  packet_.reset();
+  encoderCtx_.reset();
+  formatCtx_.reset();
+  audioFifo_.reset();
+
+  std::string closedFilePath = filePath_;
+  filePath_ = "";
+
+  return closedFilePath;
+}
+
+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());
+  }
+
+  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