react-native-audio-api 0.11.0-nightly-95f9c99-20251215 → 0.11.0-nightly-dd83923-20251216

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

@@ -0,0 +1,493 @@
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+
+extern "C" {
+#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/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>
+
+constexpr int defaultFrameRatio = 4;
+constexpr int fallbackFIFOSize = 8192;
+constexpr int defaultFlushInterval = 100;
+
+namespace audioapi::android::ffmpeg {
+
+FFmpegAudioFileWriter::FFmpegAudioFileWriter(
+    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() {
+  if (isFileOpen()) {
+    closeFile();
+  }
+}
+
+/// @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) {
+  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_);
+
+  if (!filePathResult.is_ok()) {
+    return OpenFileResult::Err(filePathResult.unwrap_err());
+  }
+
+  filePath_ = filePathResult.unwrap();
+
+  const AVCodec *codec = getCodec(fileProperties_);
+
+  if (!codec) {
+    return OpenFileResult::Err("Unsupported codec for the given file format");
+  }
+
+  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);
+      });
+}
+
+/// @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 (!isFileOpen()) {
+    return CloseFileResult::Err("File is not open");
+  }
+
+  result = processFifo(true);
+
+  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()));
+  }
+
+  result = avcodec_send_frame(encoderCtx_.get(), nullptr);
+
+  if (result < 0) {
+    return CloseFileResult::Err("Failed to send EOF to encoder");
+  }
+
+  if (writeEncodedPackets() < 0) {
+    return CloseFileResult::Err("Failed to drain encoder packets");
+  }
+
+  return finalizeOutput();
+}
+
+/// @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;
+  }
+
+  if (!resampleAndPushToFifo(data, numFrames)) {
+    return false;
+  }
+
+  framesWritten_.fetch_add(numFrames, std::memory_order_acq_rel);
+
+  if (processFifo(false) < 0) {
+    return false;
+  }
+
+  return true;
+}
+
+/// @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;
+
+  int result = avformat_alloc_output_context2(
+      &rawFormatCtx, nullptr, getMuxerName(fileProperties_).c_str(), filePath_.c_str());
+
+  if (result < 0 || !rawFormatCtx) {
+    return Result<NoneType, std::string>::Err(
+        "Failed to allocate FFmpeg format context with error: " + parseErrorCode(result));
+  }
+
+  formatCtx_ = av_unique_ptr<AVFormatContext>(rawFormatCtx);
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+/// @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 (!encoderCtx_) {
+    return Result<NoneType, std::string>::Err("Failed to allocate FFmpeg codec context");
+  }
+
+  av_channel_layout_default(&encoderCtx_->ch_layout, fileProperties_->channelCount);
+  encoderCtx_->sample_rate = static_cast<int>(fileProperties_->sampleRate);
+  encoderCtx_->sample_fmt = getSampleFormat(fileProperties_);
+
+  if (fileProperties_->bitRate > 0) {
+    encoderCtx_->bit_rate = fileProperties_->bitRate;
+  }
+
+  AVDictionary *codecOptions = nullptr;
+
+  if (fileProperties_->flacCompressionLevel >= 0) {
+    av_dict_set_int(&codecOptions, "compression_level", fileProperties_->flacCompressionLevel, 0);
+  }
+
+  int result = avcodec_open2(encoderCtx_.get(), codec, &codecOptions);
+  av_dict_free(&codecOptions);
+
+  if (result < 0) {
+    return Result<NoneType, std::string>::Err(
+        "Failed to open FFmpeg codec with error: " + parseErrorCode(result));
+  }
+
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+/// @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);
+
+  if (!stream_) {
+    return Result<NoneType, std::string>::Err("Failed to create new stream in format context");
+  }
+
+  int result = avcodec_parameters_from_context(stream_->codecpar, encoderCtx_.get());
+
+  if (result < 0) {
+    return Result<NoneType, std::string>::Err(
+        "Failed to copy codec parameters to stream with error: " + parseErrorCode(result));
+  }
+
+  stream_->time_base = AVRational{1, static_cast<int>(encoderCtx_->sample_rate)};
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+/// @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;
+
+  if (!(formatCtx_->oformat->flags & AVFMT_NOFILE)) {
+    result = avio_open(&formatCtx_->pb, filePath_.c_str(), AVIO_FLAG_WRITE);
+
+    if (result < 0) {
+      return Result<NoneType, std::string>::Err(
+          "Failed to open output file with error: " + parseErrorCode(result));
+    }
+  }
+
+  result = avformat_write_header(formatCtx_.get(), nullptr);
+
+  if (result < 0) {
+    return Result<NoneType, std::string>::Err("Failed to write header to file: " + filePath_);
+  }
+
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+/// @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");
+  }
+
+  AVChannelLayout inChannelLayout;
+  av_channel_layout_default(&inChannelLayout, inputChannels);
+
+  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);
+
+  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);
+}
+
+/// @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 calculatedSize =
+      (encoderCtx_->frame_size > 0 ? encoderCtx_->frame_size * frameRatio
+                                   : maxBufferSize * frameRatio);
+
+  int fifoSize = std::max(calculatedSize, fallbackFIFOSize);
+
+  audioFifo_ = av_unique_ptr<AVAudioFifo>(
+      av_audio_fifo_alloc(encoderCtx_->sample_fmt, encoderCtx_->ch_layout.nb_channels, fifoSize));
+}
+
+/// @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 *inputs[1] = {reinterpret_cast<const uint8_t *>(inputData)};
+
+  int convertedSamples = swr_convert(
+      resampleCtx_.get(), frame_->data, static_cast<int>(outputLength), inputs, inputFrameCount);
+
+  if (convertedSamples < 0) {
+    invokeOnErrorCallback("Failed to convert audio samples: " + parseErrorCode(convertedSamples));
+    av_frame_unref(frame_.get());
+    return false;
+  }
+
+  int written = av_audio_fifo_write(
+      audioFifo_.get(), reinterpret_cast<void **>(frame_->data), convertedSamples);
+
+  if (written < convertedSamples) {
+    invokeOnErrorCallback("Failed to write all samples to FIFO");
+    av_frame_unref(frame_.get());
+    return false;
+  }
+
+  return true;
+}
+
+/// @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_audio_fifo_read(audioFifo_.get(), reinterpret_cast<void **>(frame_->data), chunkSize) !=
+        chunkSize) {
+      invokeOnErrorCallback("Failed to read data from FIFO");
+      return -1;
+    }
+
+    frame_->pts = nextPts_;
+    nextPts_ += chunkSize;
+
+    result = avcodec_send_frame(encoderCtx_.get(), frame_.get());
+
+    if (result < 0) {
+      invokeOnErrorCallback("Failed to send frame to encoder: " + parseErrorCode(result));
+      return result;
+    }
+
+    result = writeEncodedPackets();
+
+    if (result < 0) {
+      invokeOnErrorCallback("Failed to write encoded packets: " + parseErrorCode(result));
+      return result;
+    }
+  }
+
+  return 0;
+}
+
+/// @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;
+    }
+
+    av_packet_rescale_ts(packet_.get(), encoderCtx_->time_base, stream_->time_base);
+    packet_->stream_index = stream_->index;
+
+    result = av_interleaved_write_frame(formatCtx_.get(), 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 result;
+}
+
+/// @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());
+
+  if (result < 0) {
+    return CloseFileResult::Err("Failed to write trailer: " + parseErrorCode(result));
+  }
+
+  double fileSizeInMB = 0;
+
+  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::android::ffmpeg
+
+#endif // RN_AUDIO_API_FFMPEG_DISABLED

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

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
+#include <audioapi/android/core/utils/ffmpegBackend/utils.h>
+#include <string>
+#include <memory>
+#include <tuple>
+#include <chrono>
+#include <audioapi/utils/Result.hpp>
+
+struct AVCodecContext;
+struct AVFormatContext;
+struct AVFrame;
+struct AVPacket;
+struct AVAudioFifo;
+struct SwrContext;
+struct AVStream;
+
+namespace audioapi {
+
+class AudioFileProperties;
+
+namespace android::ffmpeg {
+
+class FFmpegAudioFileWriter : public AndroidFileWriterBackend {
+ public:
+  explicit FFmpegAudioFileWriter(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioFileProperties> &fileProperties);
+  ~FFmpegAudioFileWriter();
+
+  OpenFileResult openFile(float streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) override;
+  CloseFileResult closeFile() override;
+
+  bool writeAudioData(void *data, int numFrames) override;
+
+ private:
+  av_unique_ptr<AVCodecContext> encoderCtx_{nullptr};
+  av_unique_ptr<AVFormatContext> formatCtx_{nullptr};
+  av_unique_ptr<SwrContext> resampleCtx_{nullptr};
+  av_unique_ptr<AVAudioFifo> audioFifo_{nullptr};
+  av_unique_ptr<AVPacket> packet_{nullptr};
+  av_unique_ptr<AVFrame> frame_{nullptr};
+  AVStream* stream_{nullptr};
+  unsigned int nextPts_{0};
+
+  std::chrono::steady_clock::time_point lastFlushTime_ = std::chrono::steady_clock::now();
+  int flushIntervalMs_;
+
+  // Initialization helper methods
+  Result<NoneType, std::string> initializeFormatContext(const AVCodec* codec);
+  Result<NoneType, std::string> configureAndOpenCodec(const AVCodec* codec);
+  Result<NoneType, std::string> initializeStream();
+  Result<NoneType, std::string> openIOAndWriteHeader();
+  Result<NoneType, std::string> initializeResampler(float inputRate, int inputChannels);
+  void initializeBuffers(int32_t maxBufferSize);
+
+  // Processing helper methods
+  bool resampleAndPushToFifo(void *data, int numFrames);
+  int processFifo(bool flush);
+  int writeEncodedPackets();
+  int prepareFrameForEncoding(int64_t samplesToRead);
+
+  // Finalization helper methods
+  CloseFileResult finalizeOutput();
+};
+
+} // namespace android::ffmpeg
+
+} // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/ptrs.hpp

@@ -0,0 +1,56 @@
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+
+#pragma once
+
+extern "C" {
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavutil/audio_fifo.h>
+#include <libswresample/swresample.h>
+}
+
+#include <audioapi/android/core/utils/ffmpegBackend/utils.h>
+
+namespace audioapi::android::ffmpeg {
+
+template<> inline void AvDtor<AVCodecContext>::operator()(AVCodecContext* ctx) const {
+  if (ctx != nullptr) {
+    avcodec_free_context(&ctx);
+  }
+}
+
+template<> inline void AvDtor<AVFormatContext>::operator()(AVFormatContext* ctx) const {
+  if (ctx != nullptr) {
+    avformat_free_context(ctx);
+  }
+}
+
+template<> inline void AvDtor<AVFrame>::operator()(AVFrame* frame) const {
+  if (frame != nullptr) {
+    av_frame_free(&frame);
+  }
+}
+
+template<> inline void AvDtor<AVPacket>::operator()(AVPacket* packet) const {
+  if (packet != nullptr) {
+    av_packet_free(&packet);
+  }
+}
+
+template<> inline void AvDtor<SwrContext>::operator()(SwrContext* ctx) const {
+  if (ctx != nullptr) {
+    swr_free(&ctx);
+  }
+}
+
+template<> inline void AvDtor<AVAudioFifo>::operator()(AVAudioFifo* fifo) const {
+  if (fifo != nullptr) {
+    av_audio_fifo_free(fifo);
+  }
+}
+
+} // namespace audioapi::android::ffmpeg
+
+#else
+
+#endif // RN_AUDIO_API_FFMPEG_DISABLED