react-native-audio-api 0.11.0-alpha.1 → 0.11.0-alpha.11

package/android/src/main/cpp/audioapi/android/core/AudioPlayer.cpp

@@ -4,6 +4,10 @@
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <jni.h>
+
+#include <algorithm>
+#include <memory>
 
 namespace audioapi {
 
@@ -11,9 +15,7 @@ AudioPlayer::AudioPlayer(
     const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio,
     float sampleRate,
     int channelCount)
-    : renderAudio_(renderAudio),
-      sampleRate_(sampleRate),
-      channelCount_(channelCount) {
+    : renderAudio_(renderAudio), sampleRate_(sampleRate), channelCount_(channelCount) {
   isInitialized_ = openAudioStream();
 
   nativeAudioPlayer_ = jni::make_global(NativeAudioPlayer::create());
@@ -35,21 +37,17 @@ bool AudioPlayer::openAudioStream() {
   auto result = builder.openStream(mStream_);
   if (result != oboe::Result::OK || mStream_ == nullptr) {
     __android_log_print(
-        ANDROID_LOG_ERROR,
-        "AudioPlayer",
-        "Failed to open stream: %s",
-        oboe::convertToText(result));
+        ANDROID_LOG_ERROR, "AudioPlayer", "Failed to open stream: %s", oboe::convertToText(result));
     return false;
   }
 
-  mBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, sampleRate_);
+  mBus_ = std::make_shared<AudioBus>(RENDER_QUANTUM_SIZE, channelCount_, sampleRate_);
   return true;
 }
 
 bool AudioPlayer::start() {
   if (mStream_) {
-    nativeAudioPlayer_->start();
+    jni::ThreadScope::WithClassLoader([this]() { nativeAudioPlayer_->start(); });
     auto result = mStream_->requestStart();
     return result == oboe::Result::OK;
   }
@@ -59,7 +57,7 @@ bool AudioPlayer::start() {
 
 void AudioPlayer::stop() {
   if (mStream_) {
-    nativeAudioPlayer_->stop();
+    jni::ThreadScope::WithClassLoader([this]() { nativeAudioPlayer_->stop(); });
     mStream_->requestStop();
   }
 }
@@ -92,10 +90,8 @@ bool AudioPlayer::isRunning() const {
   return mStream_ && mStream_->getState() == oboe::StreamState::Started;
 }
 
-DataCallbackResult AudioPlayer::onAudioReady(
-    AudioStream *oboeStream,
-    void *audioData,
-    int32_t numFrames) {
+DataCallbackResult
+AudioPlayer::onAudioReady(AudioStream *oboeStream, void *audioData, int32_t numFrames) {
   if (!isInitialized_) {
     return DataCallbackResult::Continue;
   }
@@ -106,8 +102,7 @@ DataCallbackResult AudioPlayer::onAudioReady(
   assert(buffer != nullptr);
 
   while (processedFrames < numFrames) {
-    int framesToProcess =
-        std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
+    int framesToProcess = std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
     renderAudio_(mBus_, framesToProcess);
 
     // TODO: optimize this with SIMD?
@@ -124,9 +119,7 @@ DataCallbackResult AudioPlayer::onAudioReady(
   return DataCallbackResult::Continue;
 }
 
-void AudioPlayer::onErrorAfterClose(
-    oboe::AudioStream *stream,
-    oboe::Result error) {
+void AudioPlayer::onErrorAfterClose(oboe::AudioStream *stream, oboe::Result error) {
   if (error == oboe::Result::ErrorDisconnected) {
     cleanup();
     if (openAudioStream()) {

package/android/src/main/cpp/audioapi/android/core/utils/AndroidFileWriterBackend.h

@@ -1,37 +1,33 @@
 #pragma once
 
+#include <audioapi/core/utils/AudioFileWriter.h>
 #include <tuple>
 #include <string>
 #include <memory>
+#include <audioapi/utils/Result.hpp>
 
 namespace audioapi {
 
-class AndroidFileWriterBackend {
- public:
-  AndroidFileWriterBackend(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t androidFlags) {}
-
-  virtual ~AndroidFileWriterBackend() = default;
+class AudioFileProperties;
 
-  virtual std::string openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) = 0;
-  virtual std::tuple<double, double> closeFile() = 0;
+class AndroidFileWriterBackend : public AudioFileWriter {
+ public:
+  explicit AndroidFileWriterBackend(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    const std::shared_ptr<AudioFileProperties> &fileProperties)
+      : AudioFileWriter(audioEventHandlerRegistry, fileProperties) {}
 
+  virtual OpenFileResult openFile(float streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) = 0;
   virtual bool writeAudioData(void *data, int numFrames) = 0;
 
-  std::string getFilePath() const { return filePath_; }
-
-  double getCurrentDuration() const { return static_cast<double>(framesWritten_.load()) / streamSampleRate_; }
+  std::string getFilePath() const override { return filePath_; }
+  double getCurrentDuration() const override { return static_cast<double>(framesWritten_.load(std::memory_order_acquire)) / streamSampleRate_; }
 
  protected:
-  std::string filePath_{""};
-  std::atomic<size_t> framesWritten_{0};
-
-  int32_t streamSampleRate_{0};
+  float streamSampleRate_{0};
   int32_t streamChannelCount_{0};
   int32_t streamMaxBufferSize_{0};
+  std::string filePath_{""};
 };
 
 } // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/utils/AndroidRecorderCallback.cpp

@@ -7,38 +7,56 @@
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/utils/CircularAudioArray.h>
 
+#include <algorithm>
 #include <memory>
+#include <string>
+#include <unordered_map>
 
 namespace audioapi {
 
+/// @brief Constructor
+/// Allocates circular buffer (as every property to do so is already known at this point).
+/// @param audioEventHandlerRegistry The audio event handler registry
+/// @param sampleRate The user desired sample rate
+/// @param bufferLength The user desired buffer length
+/// @param channelCount The user desired channel count
+/// @param callbackId The callback identifier
 AndroidRecorderCallback::AndroidRecorderCallback(
     const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
     float sampleRate,
     size_t bufferLength,
-    size_t channelCount,
+    int channelCount,
     uint64_t callbackId)
-    : sampleRate_(sampleRate),
-      bufferLength_(bufferLength),
-      channelCount_(channelCount),
-      callbackId_(callbackId),
-      audioEventHandlerRegistry_(audioEventHandlerRegistry) {
-  ringBufferSize_ = std::max((int)bufferLength * 2, 8192);
-  circularBus_.resize(channelCount_);
-
-  for (size_t i = 0; i < channelCount_; ++i) {
-    auto busArray = std::make_shared<CircularAudioArray>(ringBufferSize_);
-    circularBus_[i] = busArray;
-  }
-}
+    : AudioRecorderCallback(
+          audioEventHandlerRegistry,
+          sampleRate,
+          bufferLength,
+          channelCount,
+          callbackId) {}
 
 AndroidRecorderCallback::~AndroidRecorderCallback() {
+  if (converter_ != nullptr) {
+    ma_data_converter_uninit(converter_.get(), NULL);
+    converter_.reset();
+  }
+
+  if (processingBuffer_ != nullptr) {
+    ma_free(processingBuffer_, NULL);
+    processingBuffer_ = nullptr;
+    processingBufferLength_ = 0;
+  }
+
   for (size_t i = 0; i < circularBus_.size(); ++i) {
-    circularBus_[i].reset();
+    circularBus_[i]->zero();
   }
 }
 
-void AndroidRecorderCallback::prepare(
-    int32_t streamSampleRate,
+/// @brief Prepares the recorder callback by initializing the data converter and allocating necessary buffers.
+/// @param streamSampleRate The sample rate of the incoming audio stream.
+/// @param streamChannelCount The channel count of the incoming audio stream.
+/// @param maxInputBufferLength The maximum buffer length of the incoming audio stream.
+Result<NoneType, std::string> AndroidRecorderCallback::prepare(
+    float streamSampleRate,
     int32_t streamChannelCount,
     size_t maxInputBufferLength) {
   ma_result result;
@@ -59,27 +77,34 @@ void AndroidRecorderCallback::prepare(
   result = ma_data_converter_init(&converterConfig, NULL, converter_.get());
 
   if (result != MA_SUCCESS) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "AndroidRecorderCallback",
-        "Failed to initialize miniaudio data converter");
-    return;
+    return Result<NoneType, std::string>::Err(
+        "Failed to initialize miniaudio data converter" +
+        std::string(ma_result_description(result)));
+  }
+
+  if (streamSampleRate_ <= 0 || streamChannelCount_ <= 0) {
+    return Result<NoneType, std::string>::Err("Invalid stream sample rate or channel count");
+  }
+
+  if (sampleRate_ <= 0 || channelCount_ <= 0) {
+    return Result<NoneType, std::string>::Err("Invalid callback sample rate or channel count");
   }
 
   ma_data_converter_get_expected_output_frame_count(
       converter_.get(), maxInputBufferLength_, &processingBufferLength_);
 
-  processingBufferLength_ =
-      std::max(processingBufferLength_, (ma_uint64)maxInputBufferLength_);
+  processingBufferLength_ = std::max(processingBufferLength_, (ma_uint64)maxInputBufferLength_);
 
   deinterleavingArray_ = std::make_shared<AudioArray>(processingBufferLength_);
   processingBuffer_ = ma_malloc(
-      processingBufferLength_ * channelCount_ *
-          ma_get_bytes_per_sample(ma_format_f32),
-      NULL);
+      processingBufferLength_ * channelCount_ * ma_get_bytes_per_sample(ma_format_f32), NULL);
+
+  return Result<NoneType, std::string>::Ok(None);
 }
 
 void AndroidRecorderCallback::cleanup() {
+  emitAudioData(true);
+
   if (converter_ != nullptr) {
     ma_data_converter_uninit(converter_.get(), NULL);
     converter_.reset();
@@ -92,17 +117,25 @@ void AndroidRecorderCallback::cleanup() {
   }
 
   for (size_t i = 0; i < circularBus_.size(); ++i) {
-    circularBus_[i].reset();
+    circularBus_[i]->zero();
   }
 }
 
+/// @brief Receives audio data from the recorder, processes it (resampling and deinterleaving if necessary),
+/// and pushes it into the circular buffer.
+/// @param data Pointer to the incoming audio data.
+/// @param numFrames Number of frames in the incoming audio data.
 void AndroidRecorderCallback::receiveAudioData(void *data, int numFrames) {
+  if (!isInitialized_.load(std::memory_order_acquire)) {
+    return;
+  }
+
   ma_uint64 inputFrameCount = numFrames;
   ma_uint64 outputFrameCount = 0;
 
-  if ((float)streamSampleRate_ == sampleRate_ ||
+  if (static_cast<float>(streamSampleRate_) == sampleRate_ &&
       streamChannelCount_ == channelCount_) {
-    deinterleaveAndWriteAudioData(data, numFrames);
+    deinterleaveAndPushAudioData(data, numFrames);
     emitAudioData();
     return;
   }
@@ -111,77 +144,27 @@ void AndroidRecorderCallback::receiveAudioData(void *data, int numFrames) {
       converter_.get(), inputFrameCount, &outputFrameCount);
 
   ma_data_converter_process_pcm_frames(
-      converter_.get(),
-      data,
-      &inputFrameCount,
-      processingBuffer_,
-      &outputFrameCount);
-
-  deinterleaveAndWriteAudioData(
-      processingBuffer_, static_cast<int>(outputFrameCount));
+      converter_.get(), data, &inputFrameCount, processingBuffer_, &outputFrameCount);
+
+  deinterleaveAndPushAudioData(processingBuffer_, static_cast<int>(outputFrameCount));
   emitAudioData();
 }
 
-void AndroidRecorderCallback::deinterleaveAndWriteAudioData(
-    void *data,
-    int numFrames) {
+/// @brief Deinterleaves the audio data and pushes it into the circular buffer.
+/// @param data Pointer to the interleaved audio data.
+/// @param numFrames Number of frames in the audio data.
+void AndroidRecorderCallback::deinterleaveAndPushAudioData(void *data, int numFrames) {
   auto *inputData = static_cast<float *>(data);
 
-  for (size_t channel = 0; channel < channelCount_; ++channel) {
+  for (int channel = 0; channel < channelCount_; ++channel) {
     float *channelData = deinterleavingArray_->getData();
 
     for (int frame = 0; frame < numFrames; ++frame) {
-      channelData[frame] = inputData[frame * streamChannelCount_ + channel];
+      channelData[frame] = inputData[frame * channelCount_ + channel];
     }
 
     circularBus_[channel]->push_back(channelData, numFrames);
   }
 }
 
-void AndroidRecorderCallback::emitAudioData() {
-  while (circularBus_[0]->getNumberOfAvailableFrames() >= bufferLength_) {
-    auto bus =
-        std::make_shared<AudioBus>(bufferLength_, channelCount_, sampleRate_);
-
-    for (int i = 0; i < channelCount_; ++i) {
-      auto *outputChannel = bus->getChannel(i)->getData();
-      circularBus_[i]->pop_front(outputChannel, bufferLength_);
-    }
-
-    invokeCallback(bus, (int)bufferLength_);
-  }
-}
-
-void AndroidRecorderCallback::invokeCallback(
-    const std::shared_ptr<AudioBus> &bus,
-    int numFrames) {
-  auto audioBuffer = std::make_shared<AudioBuffer>(bus);
-  auto audioBufferHostObject =
-      std::make_shared<AudioBufferHostObject>(audioBuffer);
-
-  std::unordered_map<std::string, EventValue> eventPayload = {};
-  eventPayload.insert({"buffer", audioBufferHostObject});
-  eventPayload.insert({"numFrames", numFrames});
-
-  if (audioEventHandlerRegistry_) {
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "audioReady", callbackId_, eventPayload);
-  }
-}
-
-void AndroidRecorderCallback::sendRemainingData() {
-  auto numberOfFrames = circularBus_[0]->getNumberOfAvailableFrames();
-  auto bus = std::make_shared<AudioBus>(
-      circularBus_[0]->getNumberOfAvailableFrames(),
-      channelCount_,
-      sampleRate_);
-
-  for (int i = 0; i < channelCount_; ++i) {
-    auto *outputChannel = bus->getChannel(i)->getData();
-    circularBus_[i]->pop_front(outputChannel, numberOfFrames);
-  }
-
-  invokeCallback(bus, (int)numberOfFrames);
-}
-
 } // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/utils/AndroidRecorderCallback.h

@@ -2,8 +2,10 @@
 
 
 #include <audioapi/libs/miniaudio/miniaudio.h>
+#include <audioapi/core/utils/AudioRecorderCallback.h>
 #include <memory>
 #include <vector>
+#include <string>
 
 namespace audioapi {
 
@@ -12,46 +14,33 @@ class AudioArray;
 class CircularAudioArray;
 class AudioEventHandlerRegistry;
 
-class AndroidRecorderCallback {
+class AndroidRecorderCallback : public AudioRecorderCallback {
  public:
   AndroidRecorderCallback(
       const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
       float sampleRate,
       size_t bufferLength,
-      size_t channelCount,
+      int channelCount,
       uint64_t callbackId);
   ~AndroidRecorderCallback();
 
-  void prepare(int32_t streamSampleRate, int32_t streamChannelCount, size_t maxInputBufferLength);
-  void cleanup();
+  Result<NoneType, std::string> prepare(float streamSampleRate, int streamChannelCount, size_t maxInputBufferLength);
+  void cleanup() override;
 
   void receiveAudioData(void *data, int numFrames);
-  void emitAudioData();
 
-  void invokeCallback(const std::shared_ptr<AudioBus> &bus, int numFrames);
-  void sendRemainingData();
+ protected:
+  float streamSampleRate_{0.0};
+  int streamChannelCount_{0};
+  size_t maxInputBufferLength_{0};
 
- private:
-  int32_t streamSampleRate_;
-  int32_t streamChannelCount_;
-  size_t maxInputBufferLength_;
-
-  float sampleRate_;
-  size_t bufferLength_;
-  size_t channelCount_;
-  uint64_t callbackId_;
-  size_t ringBufferSize_;
-
-  ma_uint64 processingBufferLength_{0};
   void *processingBuffer_{nullptr};
-
+  ma_uint64 processingBufferLength_{0};
   std::unique_ptr<ma_data_converter> converter_{nullptr};
 
-  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
-  std::vector<std::shared_ptr<CircularAudioArray>> circularBus_;
   std::shared_ptr<AudioArray> deinterleavingArray_;
 
-  void deinterleaveAndWriteAudioData(void *data, int numFrames);
+  void deinterleaveAndPushAudioData(void *data, int numFrames);
 };
 
 } // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/utils/AudioDecoder.cpp

@@ -9,43 +9,39 @@
 #include <audioapi/libs/miniaudio/decoders/libvorbis/miniaudio_libvorbis.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>
 
-#ifndef AUDIO_API_TEST_SUITE
 #include <android/log.h>
+#if !RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
-#endif
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
+
+#include <memory>
+#include <string>
+#include <vector>
 
 namespace audioapi {
 
 // Decoding audio in fixed-size chunks because total frame count can't be
 // determined in advance. Note: ma_decoder_get_length_in_pcm_frames() always
 // returns 0 for Vorbis decoders.
-std::vector<float> AudioDecoder::readAllPcmFrames(
-    ma_decoder &decoder,
-    int outputChannels) {
+std::vector<float> AudioDecoder::readAllPcmFrames(ma_decoder &decoder, int outputChannels) {
   std::vector<float> buffer;
   std::vector<float> temp(CHUNK_SIZE * outputChannels);
   ma_uint64 outFramesRead = 0;
 
-#ifndef AUDIO_API_TEST_SUITE
   while (true) {
     ma_uint64 tempFramesDecoded = 0;
-    ma_decoder_read_pcm_frames(
-        &decoder, temp.data(), CHUNK_SIZE, &tempFramesDecoded);
+    ma_decoder_read_pcm_frames(&decoder, temp.data(), CHUNK_SIZE, &tempFramesDecoded);
     if (tempFramesDecoded == 0) {
       break;
     }
 
-    buffer.insert(
-        buffer.end(),
-        temp.data(),
-        temp.data() + tempFramesDecoded * outputChannels);
+    buffer.insert(buffer.end(), temp.data(), temp.data() + tempFramesDecoded * outputChannels);
     outFramesRead += tempFramesDecoded;
   }
 
   if (outFramesRead == 0) {
     __android_log_print(ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode");
   }
-#endif
   return buffer;
 }
 
@@ -58,8 +54,7 @@ std::shared_ptr<AudioBuffer> AudioDecoder::makeAudioBufferFromFloatBuffer(
   }
 
   auto outputFrames = buffer.size() / outputChannels;
-  auto audioBus = std::make_shared<AudioBus>(
-      outputFrames, outputChannels, outputSampleRate);
+  auto audioBus = std::make_shared<AudioBus>(outputFrames, outputChannels, outputSampleRate);
 
   for (int ch = 0; ch < outputChannels; ++ch) {
     auto channelData = audioBus->getChannel(ch)->getData();
@@ -73,31 +68,38 @@ std::shared_ptr<AudioBuffer> AudioDecoder::makeAudioBufferFromFloatBuffer(
 std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(
     const std::string &path,
     float sampleRate) {
-#ifndef AUDIO_API_TEST_SUITE
   if (AudioDecoder::pathHasExtension(path, {".mp4", ".m4a", ".aac"})) {
-    auto buffer =
-        ffmpegdecoder::decodeWithFilePath(path, static_cast<int>(sampleRate));
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+    auto buffer = ffmpegdecoder::decodeWithFilePath(path, static_cast<int>(sampleRate));
     if (buffer == nullptr) {
       __android_log_print(
-          ANDROID_LOG_ERROR,
-          "AudioDecoder",
-          "Failed to decode with FFmpeg: %s",
-          path.c_str());
+          ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode with FFmpeg: %s", path.c_str());
       return nullptr;
     }
     return buffer;
+#else
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "AudioDecoder",
+        "FFmpeg is disabled, cannot decode file: %s",
+        path.c_str());
+    return nullptr;
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
   }
   ma_decoder decoder;
-  ma_decoder_config config =
-      ma_decoder_config_init(ma_format_f32, 0, static_cast<int>(sampleRate));
+  ma_decoder_config config = ma_decoder_config_init(ma_format_f32, 0, static_cast<int>(sampleRate));
   ma_decoding_backend_vtable *customBackends[] = {
       ma_decoding_backend_libvorbis, ma_decoding_backend_libopus};
 
   config.ppCustomBackendVTables = customBackends;
-  config.customBackendCount =
-      sizeof(customBackends) / sizeof(customBackends[0]);
+  config.customBackendCount = sizeof(customBackends) / sizeof(customBackends[0]);
 
   if (ma_decoder_init_file(path.c_str(), &config, &decoder) != MA_SUCCESS) {
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "AudioDecoder",
+        "Failed to initialize decoder for file: %s",
+        path.c_str());
     ma_decoder_uninit(&decoder);
     return nullptr;
   }
@@ -107,46 +109,38 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(
 
   std::vector<float> buffer = readAllPcmFrames(decoder, outputChannels);
   ma_decoder_uninit(&decoder);
-  return makeAudioBufferFromFloatBuffer(
-      buffer, outputSampleRate, outputChannels);
-#else
-  return nullptr;
-#endif
+  return makeAudioBufferFromFloatBuffer(buffer, outputSampleRate, outputChannels);
 }
 
-std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithMemoryBlock(
-    const void *data,
-    size_t size,
-    float sampleRate) {
-#ifndef AUDIO_API_TEST_SUITE
+std::shared_ptr<AudioBuffer>
+AudioDecoder::decodeWithMemoryBlock(const void *data, size_t size, float sampleRate) {
   const AudioFormat format = AudioDecoder::detectAudioFormat(data, size);
-  if (format == AudioFormat::MP4 || format == AudioFormat::M4A ||
-      format == AudioFormat::AAC) {
-    auto buffer = ffmpegdecoder::decodeWithMemoryBlock(
-        data, size, static_cast<int>(sampleRate));
+  if (format == AudioFormat::MP4 || format == AudioFormat::M4A || format == AudioFormat::AAC) {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+    auto buffer = ffmpegdecoder::decodeWithMemoryBlock(data, size, static_cast<int>(sampleRate));
     if (buffer == nullptr) {
-      __android_log_print(
-          ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode with FFmpeg");
+      __android_log_print(ANDROID_LOG_ERROR, "AudioDecoder", "Failed to decode with FFmpeg");
       return nullptr;
     }
     return buffer;
+#else
+    __android_log_print(
+        ANDROID_LOG_ERROR, "AudioDecoder", "FFmpeg is disabled, cannot decode memory block");
+    return nullptr;
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
   }
   ma_decoder decoder;
-  ma_decoder_config config =
-      ma_decoder_config_init(ma_format_f32, 0, static_cast<int>(sampleRate));
+  ma_decoder_config config = ma_decoder_config_init(ma_format_f32, 0, static_cast<int>(sampleRate));
 
   ma_decoding_backend_vtable *customBackends[] = {
       ma_decoding_backend_libvorbis, ma_decoding_backend_libopus};
 
   config.ppCustomBackendVTables = customBackends;
-  config.customBackendCount =
-      sizeof(customBackends) / sizeof(customBackends[0]);
+  config.customBackendCount = sizeof(customBackends) / sizeof(customBackends[0]);
 
   if (ma_decoder_init_memory(data, size, &config, &decoder) != MA_SUCCESS) {
     __android_log_print(
-        ANDROID_LOG_ERROR,
-        "AudioDecoder",
-        "Failed to initialize decoder for memory block");
+        ANDROID_LOG_ERROR, "AudioDecoder", "Failed to initialize decoder for memory block");
     ma_decoder_uninit(&decoder);
     return nullptr;
   }
@@ -156,11 +150,7 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithMemoryBlock(
 
   std::vector<float> buffer = readAllPcmFrames(decoder, outputChannels);
   ma_decoder_uninit(&decoder);
-  return makeAudioBufferFromFloatBuffer(
-      buffer, outputSampleRate, outputChannels);
-#else
-  return nullptr;
-#endif
+  return makeAudioBufferFromFloatBuffer(buffer, outputSampleRate, outputChannels);
 }
 
 std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithPCMInBase64(
@@ -170,11 +160,9 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithPCMInBase64(
     bool interleaved) {
   auto decodedData = base64_decode(data, false);
   const auto uint8Data = reinterpret_cast<uint8_t *>(decodedData.data());
-  size_t numFramesDecoded =
-      decodedData.size() / (inputChannelCount * sizeof(int16_t));
+  size_t numFramesDecoded = decodedData.size() / (inputChannelCount * sizeof(int16_t));
 
-  auto audioBus = std::make_shared<AudioBus>(
-      numFramesDecoded, inputChannelCount, inputSampleRate);
+  auto audioBus = std::make_shared<AudioBus>(numFramesDecoded, inputChannelCount, inputSampleRate);
 
   for (int ch = 0; ch < inputChannelCount; ++ch) {
     auto channelData = audioBus->getChannel(ch)->getData();