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/FFmpegAudioFileOptions.cpp

@@ -1,154 +0,0 @@
-
-#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

@@ -1,41 +0,0 @@
-#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

@@ -1,431 +0,0 @@
-#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