react-native-audio-api 0.11.0-alpha.0 → 0.11.0-alpha.10

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

@@ -1,431 +1,493 @@
-#include <android/log.h>
-#include <cmath>
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+
 extern "C" {
-#include <libavutil/log.h>
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavutil/audio_fifo.h>
+#include <libavutil/opt.h>
+#include <libswresample/swresample.h>
 }
 
 #include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
-#include <audioapi/android/core/utils/ffmpegBackend/FFmpegAudioFileOptions.h>
+#include <audioapi/android/core/utils/FileOptions.h>
 #include <audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h>
+#include <audioapi/android/core/utils/ffmpegBackend/ptrs.hpp>
+#include <audioapi/android/core/utils/ffmpegBackend/utils.h>
+#include <audioapi/utils/AudioFileProperties.h>
+#include <audioapi/utils/UnitConversion.h>
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <utility>
 
-namespace audioapi {
+constexpr int defaultFrameRatio = 4;
+constexpr int fallbackFIFOSize = 8192;
+constexpr int defaultFlushInterval = 100;
+
+namespace audioapi::android::ffmpeg {
 
 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);
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    const std::shared_ptr<AudioFileProperties> &fileProperties)
+    : AndroidFileWriterBackend(audioEventHandlerRegistry, fileProperties) {
+  // Set flush interval from properties, limit minimum to 100ms
+  // to avoid people hurting themselves too much
+  flushIntervalMs_ = std::min(fileProperties_->androidFlushIntervalMs, defaultFlushInterval);
 }
 
 FFmpegAudioFileWriter::~FFmpegAudioFileWriter() {
-  isFileOpen_.store(false);
-  fileOptions_.reset();
+  if (isFileOpen()) {
+    closeFile();
+  }
 }
 
-void FFmpegAudioFileWriter::openFile(
-    int32_t streamSampleRate,
+/// @brief Opens a specified audio file for writing and prepares any necessary resources.
+/// such as codecs, conversion buffers or circular AVIO FIFO.
+/// This method should be called from the JS thread only.
+/// @param streamSampleRate The sample rate of the incoming audio stream (aka microphone).
+/// @param streamChannelCount The number of channels in the incoming audio stream.
+/// @param streamMaxBufferSize The estimated maximum buffer size for the incoming audio stream.
+/// @returns Success status with file path or Error status with message.
+OpenFileResult FFmpegAudioFileWriter::openFile(
+    float streamSampleRate,
     int32_t streamChannelCount,
     int32_t streamMaxBufferSize) {
-  filePath_ = fileOptions_->getFilePath("audio");
-
   streamSampleRate_ = streamSampleRate;
   streamChannelCount_ = streamChannelCount;
   streamMaxBufferSize_ = streamMaxBufferSize;
+  framesWritten_.store(0, std::memory_order_release);
   nextPts_ = 0;
+  Result<NoneType, std::string> result = Result<NoneType, std::string>::Ok(None);
+  Result<std::string, std::string> filePathResult = fileoptions::getFilePath(fileProperties_);
 
-  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;
+  if (!filePathResult.is_ok()) {
+    return OpenFileResult::Err(filePathResult.unwrap_err());
   }
 
-  formatCtx_ = AVFormatContextPtr(rawFormatCtx);
-  stream_ = avformat_new_stream(formatCtx_.get(), codec);
+  filePath_ = filePathResult.unwrap();
 
-  encoderCtx_ = AVCodecContextPtr(avcodec_alloc_context3(codec));
+  const AVCodec *codec = getCodec(fileProperties_);
 
-  if (!encoderCtx_) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FFmpegFileWriter",
-        "Failed to allocate FFmpeg codec context for file");
-    return;
+  if (!codec) {
+    return OpenFileResult::Err("Unsupported codec for the given file format");
   }
 
-  AVDictionary *codecOptions = nullptr;
-  size_t bitRate = fileOptions_->getBitRate();
-  int flacCompressionLevel = fileOptions_->getFlacCompressionLevel();
-  av_channel_layout_default(
-      &encoderCtx_->ch_layout, fileOptions_->getChannelCount());
+  return initializeFormatContext(codec)
+      .and_then([this, codec](auto) { return configureAndOpenCodec(codec); })
+      .and_then([this](auto) { return initializeStream(); })
+      .and_then([this](auto) { return openIOAndWriteHeader(); })
+      .and_then([this, streamSampleRate, streamChannelCount](auto) {
+        return initializeResampler(streamSampleRate, streamChannelCount);
+      })
+      .and_then([this, streamMaxBufferSize, filePath = std::move(filePath_)](auto) {
+        initializeBuffers(streamMaxBufferSize);
+        isFileOpen_.store(true, std::memory_order_release);
+        return OpenFileResult::Ok(filePath);
+      });
+}
 
-  encoderCtx_->sample_rate = fileOptions_->getSampleRate();
-  encoderCtx_->sample_fmt = fileOptions_->getSampleFormat();
+/// @brief Closes the currently opened audio file, flushing any remaining data and finalizing the file.
+/// This method should called from the JS thread only.
+/// @returns CloseFileStatus indicating success with file path, size and duration, or error with message.
+CloseFileResult FFmpegAudioFileWriter::closeFile() {
+  int result = 0;
 
-  if (bitRate > 0) {
-    encoderCtx_->bit_rate = bitRate;
+  if (!isFileOpen()) {
+    return CloseFileResult::Err("File is not open");
   }
 
-  if (flacCompressionLevel >= 0) {
-    av_dict_set_int(
-        &codecOptions, "compression_level", flacCompressionLevel, 0);
-  }
+  result = processFifo(true);
 
-  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;
+  if (result < 0) {
+    auto finalStatus = finalizeOutput();
+
+    return CloseFileResult::Err(
+        "Failed to flush FIFO to encoder. error code: " + parseErrorCode(result) +
+        ", finalization status: " + (finalStatus.is_ok() ? "success" : finalStatus.unwrap_err()));
   }
 
-  av_dict_free(&codecOptions);
+  result = avcodec_send_frame(encoderCtx_.get(), nullptr);
 
-  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 (result < 0) {
+    return CloseFileResult::Err("Failed to send EOF to encoder");
   }
 
-  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;
-    }
+  if (writeEncodedPackets() < 0) {
+    return CloseFileResult::Err("Failed to drain encoder packets");
   }
 
-  stream_->time_base =
-      AVRational{1, static_cast<int>(encoderCtx_->sample_rate)};
+  return finalizeOutput();
+}
 
-  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;
+/// @brief Writes audio data to the currently opened file.
+/// This method should be called only from the audio thread (or audio side-effect thread in the future).
+/// @param data Pointer to the audio data buffer (interleaved float samples) as returned by Oboe stream.
+/// @param numFrames Number of audio frames in the data buffer.
+/// @returns True if the data was written successfully, false otherwise.
+bool FFmpegAudioFileWriter::writeAudioData(void *data, int numFrames) {
+  if (!isFileOpen()) {
+    return false;
   }
 
-  frame_ = AVFramePtr(av_frame_alloc());
-  packet_ = AVPacketPtr(av_packet_alloc());
+  if (!resampleAndPushToFifo(data, numFrames)) {
+    return false;
+  }
 
-  resampleCtx_ = SwrContextPtr(swr_alloc());
+  framesWritten_.fetch_add(numFrames, std::memory_order_acq_rel);
 
-  AVChannelLayout inChannelLayout;
-  av_channel_layout_default(&inChannelLayout, streamChannelCount_);
+  if (processFifo(false) < 0) {
+    return false;
+  }
 
-  av_opt_set_chlayout(resampleCtx_.get(), "in_chlayout", &inChannelLayout, 0);
+  return true;
+}
 
-  av_opt_set_chlayout(
-      resampleCtx_.get(), "out_chlayout", &encoderCtx_->ch_layout, 0);
+/// @brief Initializes the FFmpeg format context for the output file.
+/// @param codec The codec to be used for encoding.
+/// @returns Success status or Error status with message.
+Result<NoneType, std::string> FFmpegAudioFileWriter::initializeFormatContext(const AVCodec *codec) {
+  AVFormatContext *rawFormatCtx = nullptr;
 
-  av_opt_set_int(resampleCtx_.get(), "in_sample_rate", streamSampleRate, 0);
+  int result = avformat_alloc_output_context2(
+      &rawFormatCtx, nullptr, getMuxerName(fileProperties_).c_str(), filePath_.c_str());
 
-  av_opt_set_int(
-      resampleCtx_.get(), "out_sample_rate", encoderCtx_->sample_rate, 0);
+  if (result < 0 || !rawFormatCtx) {
+    return Result<NoneType, std::string>::Err(
+        "Failed to allocate FFmpeg format context with error: " + parseErrorCode(result));
+  }
 
-  av_opt_set_sample_fmt(
-      resampleCtx_.get(), "in_sample_fmt", AV_SAMPLE_FMT_FLT, 0);
+  formatCtx_ = av_unique_ptr<AVFormatContext>(rawFormatCtx);
+  return Result<NoneType, std::string>::Ok(None);
+}
 
-  av_opt_set_sample_fmt(
-      resampleCtx_.get(), "out_sample_fmt", encoderCtx_->sample_fmt, 0);
+/// @brief Configures and opens the codec context for encoding.
+/// @param codec The codec to be used for encoding.
+/// @returns Success status or Error status with message.
+Result<NoneType, std::string> FFmpegAudioFileWriter::configureAndOpenCodec(const AVCodec *codec) {
+  encoderCtx_ = av_unique_ptr<AVCodecContext>(avcodec_alloc_context3(codec));
 
-  if (swr_init(resampleCtx_.get()) < 0) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FFmpegFileWriter",
-        "Failed to initialize resampler for file: %s",
-        filePath_.c_str());
-    return;
+  if (!encoderCtx_) {
+    return Result<NoneType, std::string>::Err("Failed to allocate FFmpeg codec context");
   }
 
-  int contextFrameRatio = 2;
+  av_channel_layout_default(&encoderCtx_->ch_layout, fileProperties_->channelCount);
+  encoderCtx_->sample_rate = static_cast<int>(fileProperties_->sampleRate);
+  encoderCtx_->sample_fmt = getSampleFormat(fileProperties_);
 
-  if (encoderCtx_->frame_size > 0) {
-    contextFrameRatio = static_cast<int>(std::ceil(
-        static_cast<double>(streamMaxBufferSize_) /
-        static_cast<double>(encoderCtx_->frame_size)));
+  if (fileProperties_->bitRate > 0) {
+    encoderCtx_->bit_rate = fileProperties_->bitRate;
   }
 
-  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));
+  AVDictionary *codecOptions = nullptr;
 
-  __android_log_print(
-      ANDROID_LOG_INFO,
-      "FFmpegFileWriter",
-      "Using audio FIFO size of %d frames",
-      fifoSize);
+  if (fileProperties_->flacCompressionLevel >= 0) {
+    av_dict_set_int(&codecOptions, "compression_level", fileProperties_->flacCompressionLevel, 0);
+  }
 
-  isFileOpen_.store(true);
-}
+  int result = avcodec_open2(encoderCtx_.get(), codec, &codecOptions);
+  av_dict_free(&codecOptions);
 
-std::string FFmpegAudioFileWriter::closeFile() {
-  if (!isFileOpen()) {
-    return "";
+  if (result < 0) {
+    return Result<NoneType, std::string>::Err(
+        "Failed to open FFmpeg codec with error: " + parseErrorCode(result));
   }
 
-  isFileOpen_.store(false);
+  return Result<NoneType, std::string>::Ok(None);
+}
 
-  const int frameSize =
-      encoderCtx_->frame_size > 0 ? encoderCtx_->frame_size : 512;
+/// @brief Initializes a new stream in the format context.
+/// @returns Success status or Error status with message.
+Result<NoneType, std::string> FFmpegAudioFileWriter::initializeStream() {
+  stream_ = avformat_new_stream(formatCtx_.get(), nullptr);
 
-  while (av_audio_fifo_size(audioFifo_.get()) > 0) {
-    const int chunkSize =
-        std::min(av_audio_fifo_size(audioFifo_.get()), frameSize);
+  if (!stream_) {
+    return Result<NoneType, std::string>::Err("Failed to create new stream in format context");
+  }
 
-    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;
+  int result = avcodec_parameters_from_context(stream_->codecpar, encoderCtx_.get());
 
-    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;
-    }
+  if (result < 0) {
+    return Result<NoneType, std::string>::Err(
+        "Failed to copy codec parameters to stream with error: " + parseErrorCode(result));
+  }
 
-    int fifoReadFrameCount =
-        av_audio_fifo_read(audioFifo_.get(), (void **)frame_->data, chunkSize);
+  stream_->time_base = AVRational{1, static_cast<int>(encoderCtx_->sample_rate)};
+  return Result<NoneType, std::string>::Ok(None);
+}
 
-    if (fifoReadFrameCount != chunkSize) {
-      __android_log_print(
-          ANDROID_LOG_ERROR,
-          "FFmpegFileWriter",
-          "Failed to read audio samples from FIFO during flushing");
-      break;
-    }
+/// @brief Opens the file and writes the basic header (depends on the codec/format used).
+/// @returns Success status or Error status with message.
+Result<NoneType, std::string> FFmpegAudioFileWriter::openIOAndWriteHeader() {
+  int result = 0;
 
-    frame_->pts = nextPts_;
-    nextPts_ += chunkSize;
+  if (!(formatCtx_->oformat->flags & AVFMT_NOFILE)) {
+    result = avio_open(&formatCtx_->pb, filePath_.c_str(), AVIO_FLAG_WRITE);
 
-    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;
+    if (result < 0) {
+      return Result<NoneType, std::string>::Err(
+          "Failed to open output file with error: " + parseErrorCode(result));
     }
-
-    av_frame_unref(frame_.get());
   }
 
-  avcodec_send_frame(encoderCtx_.get(), nullptr);
+  result = avformat_write_header(formatCtx_.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 (result < 0) {
+    return Result<NoneType, std::string>::Err("Failed to write header to file: " + filePath_);
   }
 
-  if (av_write_trailer(formatCtx_.get()) < 0) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FFmpegFileWriter",
-        "Failed to write trailer to file: %s",
-        filePath_.c_str());
-  }
+  return Result<NoneType, std::string>::Ok(None);
+}
 
-  if (formatCtx_ && formatCtx_->pb) {
-    avio_closep(&formatCtx_->pb);
+/// @brief Initializes the resampler context for audio conversion.
+/// @param inputRate The sample rate of the input audio.
+/// @param inputChannels The number of channels in the input audio.
+/// @returns Success status or Error status with message.
+Result<NoneType, std::string> FFmpegAudioFileWriter::initializeResampler(
+    float inputRate,
+    int inputChannels) {
+  resampleCtx_ = av_unique_ptr<SwrContext>(swr_alloc());
+
+  if (!resampleCtx_) {
+    return Result<NoneType, std::string>::Err("Failed to allocate resampler context");
   }
 
-  resampleCtx_.reset();
-  frame_.reset();
-  packet_.reset();
-  encoderCtx_.reset();
-  formatCtx_.reset();
-  audioFifo_.reset();
+  AVChannelLayout inChannelLayout;
+  av_channel_layout_default(&inChannelLayout, inputChannels);
 
-  std::string closedFilePath = filePath_;
-  filePath_ = "";
+  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", static_cast<int64_t>(inputRate), 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);
 
-  return closedFilePath;
+  int result = swr_init(resampleCtx_.get());
+
+  if (result < 0) {
+    return Result<NoneType, std::string>::Err(
+        "Failed to initialize resampler for file: " + parseErrorCode(result));
+  }
+
+  return Result<NoneType, std::string>::Ok(None);
 }
 
-bool FFmpegAudioFileWriter::writeAudioData(void *data, int numFrames) {
-  if (!isFileOpen()) {
-    return false;
+/// @brief Initializes frame and packet buffers as well as the audio FIFO,
+/// that might be needed for storing intermediate audio data or buffering before encoding.
+/// @param maxBufferSize The maximum buffer size to allocate.
+void FFmpegAudioFileWriter::initializeBuffers(int32_t maxBufferSize) {
+  frame_ = av_unique_ptr<AVFrame>(av_frame_alloc());
+  packet_ = av_unique_ptr<AVPacket>(av_packet_alloc());
+
+  int frameRatio = defaultFrameRatio;
+  if (encoderCtx_->frame_size > 0) {
+    frameRatio = static_cast<int>(std::ceil(
+        static_cast<double>(maxBufferSize) / static_cast<double>(encoderCtx_->frame_size)));
   }
 
-  int outputLength = av_rescale_rnd(
-      numFrames, encoderCtx_->sample_rate, streamSampleRate_, AV_ROUND_UP);
+  int calculatedSize =
+      (encoderCtx_->frame_size > 0 ? encoderCtx_->frame_size * frameRatio
+                                   : maxBufferSize * frameRatio);
 
-  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;
+  int fifoSize = std::max(calculatedSize, fallbackFIFOSize);
+
+  audioFifo_ = av_unique_ptr<AVAudioFifo>(
+      av_audio_fifo_alloc(encoderCtx_->sample_fmt, encoderCtx_->ch_layout.nb_channels, fifoSize));
+}
 
-  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);
+/// @brief Resamples input audio data and pushes it to the audio FIFO.
+/// @param inputData Pointer to the input audio data.
+/// @param inputFrameCount Number of input frames.
+/// @returns True if successful, false otherwise.
+bool FFmpegAudioFileWriter::resampleAndPushToFifo(void *inputData, int inputFrameCount) {
+  int result = 0;
+  int64_t outputLength = av_rescale_rnd(
+      inputFrameCount, encoderCtx_->sample_rate, static_cast<int>(streamSampleRate_), AV_ROUND_UP);
 
+  result = prepareFrameForEncoding(outputLength);
+
+  if (result < 0) {
+    invokeOnErrorCallback("Failed to prepare frame for resampling: " + parseErrorCode(result));
     return false;
   }
 
-  const uint8_t *inputData[1] = {reinterpret_cast<const uint8_t *>(data)};
+  const uint8_t *inputs[1] = {reinterpret_cast<const uint8_t *>(inputData)};
 
   int convertedSamples = swr_convert(
-      resampleCtx_.get(), frame_->data, outputLength, inputData, numFrames);
+      resampleCtx_.get(), frame_->data, static_cast<int>(outputLength), inputs, inputFrameCount);
 
   if (convertedSamples < 0) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FFmpegFileWriter",
-        "Failed to convert audio samples for file: %s",
-        filePath_.c_str());
+    invokeOnErrorCallback("Failed to convert audio samples: " + parseErrorCode(convertedSamples));
     av_frame_unref(frame_.get());
     return false;
   }
 
-  int fifoWrittenFrameCount = av_audio_fifo_write(
-      audioFifo_.get(), (void **)frame_->data, convertedSamples);
+  int written = av_audio_fifo_write(
+      audioFifo_.get(), reinterpret_cast<void **>(frame_->data), convertedSamples);
 
-  if (fifoWrittenFrameCount < convertedSamples) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FFmpegFileWriter",
-        "Failed to write audio samples to FIFO");
+  if (written < convertedSamples) {
+    invokeOnErrorCallback("Failed to write all 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;
+  return true;
+}
 
-  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;
+/// @brief pushes the audio data from FIFO to the encoder in chunks,
+// defined by the encoder (512 samples by default) or flushes the FIFO if requested.
+/// Note: flush might be called only when writing the final data batch, otherwise
+// the codec will crash (especially in case of defined size frames like AAC).
+/// @param flush Indicates whether to flush the FIFO.
+/// @returns 0 on success, -1 or AV_ERROR code on failure
+int FFmpegAudioFileWriter::processFifo(bool flush) {
+  int result = 0;
+  int frameSize = encoderCtx_->frame_size > 0 ? encoderCtx_->frame_size : 512;
+
+  while (av_audio_fifo_size(audioFifo_.get()) >= (flush ? 1 : frameSize)) {
+    const int chunkSize = std::min(av_audio_fifo_size(audioFifo_.get()), frameSize);
+
+    if (prepareFrameForEncoding(chunkSize) < 0) {
+      invokeOnErrorCallback("Failed to prepare frame for encoding");
+      return -1;
+    }
 
-    if (av_frame_get_buffer(frame_.get(), 0) < 0) {
-      __android_log_print(
-          ANDROID_LOG_ERROR,
-          "FFmpegFileWriter",
-          "Failed to allocate audio frame buffer");
-      return false;
+    if (av_audio_fifo_read(audioFifo_.get(), reinterpret_cast<void **>(frame_->data), chunkSize) !=
+        chunkSize) {
+      invokeOnErrorCallback("Failed to read data from FIFO");
+      return -1;
     }
 
-    int fifoReadFrameCount =
-        av_audio_fifo_read(audioFifo_.get(), (void **)frame_->data, frameSize);
+    frame_->pts = nextPts_;
+    nextPts_ += chunkSize;
+
+    result = avcodec_send_frame(encoderCtx_.get(), frame_.get());
 
-    if (fifoReadFrameCount != frameSize) {
-      __android_log_print(
-          ANDROID_LOG_ERROR,
-          "FFmpegFileWriter",
-          "Failed to read audio samples from FIFO");
-      return false;
+    if (result < 0) {
+      invokeOnErrorCallback("Failed to send frame to encoder: " + parseErrorCode(result));
+      return result;
     }
 
-    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;
+    result = writeEncodedPackets();
+
+    if (result < 0) {
+      invokeOnErrorCallback("Failed to write encoded packets: " + parseErrorCode(result));
+      return result;
     }
+  }
 
-    while (avcodec_receive_packet(encoderCtx_.get(), packet_.get()) == 0) {
-      av_packet_rescale_ts(
-          packet_.get(),
-          AVRational{1, encoderCtx_->sample_rate},
-          stream_->time_base);
+  return 0;
+}
 
-      packet_->stream_index = stream_->index;
+/// @brief Takes ready encoded packets from the encoder and writes them to the output file.
+/// Also in order to optimize file writing vs file resilience from crashes, it periodically
+/// forces the AVIO buffer to flush data to disk, by default every 0,5 second.
+/// @returns 0 on success, AV_ERROR code on failure
+int FFmpegAudioFileWriter::writeEncodedPackets() {
+  int result = 0;
+
+  while (true) {
+    result = avcodec_receive_packet(encoderCtx_.get(), packet_.get());
+
+    if (result == AVERROR(EAGAIN) || result == AVERROR_EOF) {
+      return 0;
+    } else if (result < 0) {
+      invokeOnErrorCallback("Failed to receive packet from encoder: " + parseErrorCode(result));
+      return result;
+    }
 
-      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_rescale_ts(packet_.get(), encoderCtx_->time_base, stream_->time_base);
+    packet_->stream_index = stream_->index;
 
-        av_packet_unref(packet_.get());
-        av_frame_unref(frame_.get());
-        return false;
-      }
+    result = av_interleaved_write_frame(formatCtx_.get(), packet_.get());
 
-      av_packet_unref(packet_.get());
+    auto now = std::chrono::steady_clock::now();
+    auto elapsedMs =
+        std::chrono::duration_cast<std::chrono::milliseconds>(now - lastFlushTime_).count();
+
+    if (formatCtx_->pb && elapsedMs >= flushIntervalMs_) {
+      avio_flush(formatCtx_->pb);
+      lastFlushTime_ = now;
     }
 
+    if (result < 0) {
+      return result;
+    }
+  }
+}
+
+/// @brief Prepares the frame for next encoding phase,
+/// if frame is same size as previously used one (99.9% cases) try to reuse it.
+/// Otherwise resize the frame and in the worst case allocate new frame to use.
+/// @param samplesToRead Number of samples to prepare the frame for.
+/// @returns 0 on success, AV_ERROR code on failure
+int FFmpegAudioFileWriter::prepareFrameForEncoding(int64_t samplesToRead) {
+  int result = 0;
+
+  if (frame_->data[0] && frame_->nb_samples == samplesToRead &&
+      av_frame_is_writable(frame_.get())) {
+    return 0;
+  }
+
+  frame_->nb_samples = static_cast<int>(samplesToRead);
+  frame_->format = encoderCtx_->sample_fmt;
+  frame_->sample_rate = encoderCtx_->sample_rate;
+
+  if (av_channel_layout_compare(&frame_->ch_layout, &encoderCtx_->ch_layout) != 0) {
+    av_channel_layout_uninit(&frame_->ch_layout);
+
+    result = av_channel_layout_copy(&frame_->ch_layout, &encoderCtx_->ch_layout);
+
+    if (result < 0) {
+      invokeOnErrorCallback("Failed to copy channel layout: " + parseErrorCode(result));
+      return result;
+    }
+  }
+
+  result = av_frame_make_writable(frame_.get());
+
+  if (result < 0) {
     av_frame_unref(frame_.get());
+
+    frame_->nb_samples = static_cast<int>(samplesToRead);
+    ;
+    frame_->format = encoderCtx_->sample_fmt;
+    frame_->sample_rate = encoderCtx_->sample_rate;
+    av_channel_layout_copy(&frame_->ch_layout, &encoderCtx_->ch_layout);
+
+    result = av_frame_get_buffer(frame_.get(), 0);
   }
 
-  return true;
+  return result;
 }
 
-bool FFmpegAudioFileWriter::initializeConverterIfNeeded() {
-  return false;
-}
+/// @brief Closes the currently opened audio file, flushing any remaining data and finalizing the file.
+/// Method checks the file size and duration for convenience.
+/// @returns CloseFileResult indicating success or error details
+CloseFileResult FFmpegAudioFileWriter::finalizeOutput() {
+  int result = av_write_trailer(formatCtx_.get());
 
-bool FFmpegAudioFileWriter::initializeEncoder() {
-  return false;
-}
+  if (result < 0) {
+    return CloseFileResult::Err("Failed to write trailer: " + parseErrorCode(result));
+  }
 
-bool FFmpegAudioFileWriter::isFileOpen() {
-  return isFileOpen_.load();
-}
+  double fileSizeInMB = 0;
 
-bool FFmpegAudioFileWriter::isConverterRequired() {
-  return isConverterRequired_.load();
+  if (formatCtx_->pb) {
+    fileSizeInMB = static_cast<double>(avio_size(formatCtx_->pb)) / MB_IN_BYTES;
+    avio_closep(&formatCtx_->pb);
+  }
+
+  double durationInSeconds = getCurrentDuration();
+
+  filePath_ = "";
+  isFileOpen_.store(false, std::memory_order_release);
+
+  return CloseFileResult::Ok({fileSizeInMB, durationInSeconds});
 }
 
-} // namespace audioapi
+} // namespace audioapi::android::ffmpeg
+
+#endif // RN_AUDIO_API_FFMPEG_DISABLED