react-native-audio-api 0.12.1 → 0.12.2

package/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp

@@ -10,8 +10,6 @@
 #include <algorithm>
 #include <cassert>
 #include <memory>
-#include <string>
-#include <unordered_map>
 
 #if !RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
@@ -69,10 +67,10 @@ void AudioFileSourceNode::sendOnPositionChangedEvent(int framesPlayed) {
   if (onPositionChangedCallbackId_ != 0 &&
       (onPositionChangedFlush_.load(std::memory_order_acquire) ||
        onPositionChangedTime_ > onPositionChangedInterval_)) {
-    std::unordered_map<std::string, EventValue> body = {{"value", getCurrentTime()}};
-
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        AudioEvent::POSITION_CHANGED, onPositionChangedCallbackId_, body);
+    audioEventHandlerRegistry_->dispatchEvent(
+        AudioEvent::POSITION_CHANGED,
+        onPositionChangedCallbackId_,
+        DoubleValuePayload{.value = getCurrentTime()});
 
     onPositionChangedTime_ = 0;
     onPositionChangedFlush_.store(false, std::memory_order_release);
@@ -85,7 +83,7 @@ void AudioFileSourceNode::initDecoders(
     bool useFilePath,
     const std::shared_ptr<BaseAudioContext> &context,
     const std::shared_ptr<AudioFileDecoderState> &state) {
-  bool ok = false;
+  decoding::DecoderResult openResult = Ok(None);
   if (requiresFFmpeg_) {
 #if !RN_AUDIO_API_FFMPEG_DISABLED
     decoder_ = std::make_unique<ffmpegdecoder::FFmpegDecoder>();
@@ -94,14 +92,14 @@ void AudioFileSourceNode::initDecoders(
     decoder_ = std::make_unique<miniaudio_decoder::MiniAudioDecoder>();
   }
   if (useFilePath) {
-    ok = decoder_->openFile(static_cast<int>(context->getSampleRate()), state->filePath);
+    openResult = decoder_->openFile(static_cast<int>(context->getSampleRate()), state->filePath);
   } else {
-    ok = decoder_->openMemory(
+    openResult = decoder_->openMemory(
         static_cast<int>(context->getSampleRate()),
         state->memoryData.data(),
         state->memoryData.size());
   }
-  if (ok) {
+  if (openResult.is_ok()) {
     state->channels = decoder_->outputChannels();
     state->sampleRate = static_cast<float>(decoder_->outputSampleRate());
     duration_ = static_cast<double>(decoder_->getDurationInSeconds());
@@ -142,7 +140,7 @@ size_t AudioFileSourceNode::readFrames(float *buf, size_t frameCount) {
 }
 
 bool AudioFileSourceNode::seekDecoderToTime(double seconds) {
-  return decoder_->seekToTime(seconds);
+  return decoder_->seekToTime(seconds).is_ok();
 }
 
 void AudioFileSourceNode::applyPlaybackStateAfterSuccessfulSeek(double seconds) {

package/common/cpp/audioapi/core/sources/AudioFileSourceNode.h

@@ -81,7 +81,7 @@ class AudioFileSourceNode : public AudioScheduledSourceNode {
       const std::shared_ptr<AudioFileDecoderState> &state);
 
   std::shared_ptr<AudioFileDecoderState> decoderState_;
-  std::unique_ptr<decoding::IIncrementalAudioDecoder> decoder_;
+  std::unique_ptr<decoding::IncrementalAudioDecoder> decoder_;
   float volume_;
   bool requiresFFmpeg_;
   bool filePaused_{false};

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp

@@ -159,8 +159,8 @@ void AudioScheduledSourceNode::disable() {
   AudioNode::disable();
 
   if (onEndedCallbackId_ != 0) {
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        AudioEvent::ENDED, onEndedCallbackId_, {});
+    audioEventHandlerRegistry_->dispatchEvent(
+        AudioEvent::ENDED, onEndedCallbackId_, EmptyPayload{});
   }
 }
 

package/common/cpp/audioapi/core/types/AudioFormat.h

@@ -1,6 +1,8 @@
 #pragma once
 
+#include <cstdint>
+
 namespace audioapi {
 
-enum class AudioFormat { UNKNOWN, WAV, OGG, FLAC, AAC, MP3, M4A, MP4, MOV };
+enum class AudioFormat : uint8_t { UNKNOWN, WAV, OGG, FLAC, AAC, MP3, M4A, MP4, MOV };
 } // namespace audioapi

package/common/cpp/audioapi/core/utils/AudioDecoder.cpp

@@ -1,142 +1,171 @@
 #include <audioapi/core/utils/AudioDecoder.h>
-#include <audioapi/dsp/VectorMath.h>
 #include <audioapi/libs/base64/base64.h>
-#include <audioapi/utils/AudioArray.hpp>
-
-#include <audioapi/libs/miniaudio/decoders/libopus/miniaudio_libopus.h>
-#include <audioapi/libs/miniaudio/decoders/libvorbis/miniaudio_libvorbis.h>
-#include <audioapi/libs/miniaudio/miniaudio.h>
+#include <audioapi/libs/decoding/IncrementalAudioDecoder.h>
+#include <audioapi/libs/miniaudio/MiniAudioDecoding.h>
 
 #if !RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
 
+#include <algorithm>
+#include <cctype>
+#include <cstdint>
+#include <cstring>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
-namespace audioapi {
+namespace audioapi::audiodecoder {
+
+// Drains an incremental decoder into an AudioBuffer. Total frame count is not
+// known up front for some formats (e.g. Vorbis), so we read in fixed-size
+// chunks and grow the interleaved accumulator until the decoder reports EOF.
+AudioBufferResult decodeAll(decoding::IncrementalAudioDecoder &decoder) {
+  const int channels = std::max(1, decoder.outputChannels());
+  const auto outputSampleRate = static_cast<float>(decoder.outputSampleRate());
 
-// 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.
-Result<std::vector<float>, std::string> AudioDecoder::readAllPcmFrames(
-    ma_decoder &decoder,
-    int outputChannels) {
-  std::vector<float> buffer;
-  std::vector<float> temp(CHUNK_SIZE * outputChannels);
-  ma_uint64 outFramesRead = 0;
+  std::vector<float> interleaved;
+  std::vector<float> chunk(
+      decoding::IncrementalAudioDecoder::CHUNK_SIZE * static_cast<size_t>(channels));
 
   while (true) {
-    ma_uint64 tempFramesDecoded = 0;
-    ma_decoder_read_pcm_frames(&decoder, temp.data(), CHUNK_SIZE, &tempFramesDecoded);
-    if (tempFramesDecoded == 0) {
+    const size_t framesRead =
+        decoder.readPcmFrames(chunk.data(), decoding::IncrementalAudioDecoder::CHUNK_SIZE);
+    if (framesRead == 0) {
       break;
     }
-
-    buffer.insert(buffer.end(), temp.data(), temp.data() + tempFramesDecoded * outputChannels);
-    outFramesRead += tempFramesDecoded;
+    interleaved.insert(
+        interleaved.end(),
+        chunk.begin(),
+        chunk.begin() + static_cast<std::ptrdiff_t>(framesRead * static_cast<size_t>(channels)));
   }
 
-  if (outFramesRead == 0) {
+  if (interleaved.empty()) {
     return Err("Failed to decode any frames");
   }
 
-  return Ok(std::move(buffer));
+  const size_t outputFrames = interleaved.size() / static_cast<size_t>(channels);
+  auto audioBuffer = std::make_shared<AudioBuffer>(outputFrames, channels, outputSampleRate);
+  audioBuffer->deinterleaveFrom(interleaved.data(), outputFrames);
+  return Ok(std::move(audioBuffer));
 }
 
-AudioBufferResult AudioDecoder::makeAudioBufferFromFloatBuffer(
-    const std::vector<float> &buffer,
-    float outputSampleRate,
-    int outputChannels) {
-  if (buffer.empty()) {
-    return Err("Buffer is empty");
+// NOLINTBEGIN(readability-magic-numbers, cppcoreguidelines-avoid-magic-numbers)
+AudioFormat detectAudioFormat(const void *data, size_t size) {
+  if (size < 12) {
+    return AudioFormat::UNKNOWN;
   }
+  const auto *bytes = static_cast<const unsigned char *>(data);
 
-  auto outputFrames = buffer.size() / outputChannels;
-  auto audioBuffer = std::make_shared<AudioBuffer>(outputFrames, outputChannels, outputSampleRate);
-
-  audioBuffer->deinterleaveFrom(buffer.data(), outputFrames);
-
-  return Ok(std::move(audioBuffer));
-}
+  // WAV/RIFF
+  if (std::memcmp(bytes, "RIFF", 4) == 0 && std::memcmp(bytes + 8, "WAVE", 4) == 0) {
+    return AudioFormat::WAV;
+  }
 
-AudioBufferResult AudioDecoder::decodeWithMiniaudio(float sampleRate, DecoderSource source) {
-  ma_decoder decoder;
-  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]);
-
-  ma_result initResult = std::visit(
-      [&config, &decoder](auto &&arg) -> ma_result {
-        using T = std::decay_t<decltype(arg)>;
-        if constexpr (std::is_same_v<T, MemorySource>) {
-          return ma_decoder_init_memory(arg.data, arg.size, &config, &decoder);
-        } else if constexpr (std::is_same_v<T, std::string>) {
-          return ma_decoder_init_file(arg.c_str(), &config, &decoder);
-        } else {
-          return MA_INVALID_ARGS;
-        }
-      },
-      source);
-
-  if (initResult != MA_SUCCESS) {
-    return Err(
-        "Failed to initialize miniaudio decoder: " +
-        std::string(ma_result_description(initResult)));
+  // OGG
+  if (std::memcmp(bytes, "OggS", 4) == 0) {
+    return AudioFormat::OGG;
   }
 
-  auto outputSampleRate = static_cast<float>(decoder.outputSampleRate);
-  auto outputChannels = static_cast<int>(decoder.outputChannels);
+  // FLAC
+  if (std::memcmp(bytes, "fLaC", 4) == 0) {
+    return AudioFormat::FLAC;
+  }
 
-  auto result = readAllPcmFrames(decoder, outputChannels)
-                    .and_then([outputSampleRate, outputChannels](std::vector<float> &&buffer) {
-                      return makeAudioBufferFromFloatBuffer(
-                          std::move(buffer), outputSampleRate, outputChannels);
-                    });
+  // AAC starts with 0xFF 0xF1 or 0xFF 0xF9
+  if (bytes[0] == 0xFF && (bytes[1] & 0xF6) == 0xF0) {
+    return AudioFormat::AAC;
+  }
 
-  ma_decoder_uninit(&decoder);
+  // MP3: "ID3" or 11-bit frame sync (0xFF 0xE0)
+  if (std::memcmp(bytes, "ID3", 3) == 0) {
+    return AudioFormat::MP3;
+  }
+  if (bytes[0] == 0xFF && (bytes[1] & 0xE0) == 0xE0) {
+    return AudioFormat::MP3;
+  }
 
-  return result;
+  if (std::memcmp(bytes + 4, "ftyp", 4) == 0) {
+    if (std::memcmp(bytes + 8, "M4A ", 4) == 0) {
+      return AudioFormat::M4A;
+    }
+    if (std::memcmp(bytes + 8, "qt  ", 4) == 0) {
+      return AudioFormat::MOV;
+    }
+    return AudioFormat::MP4;
+  }
+  return AudioFormat::UNKNOWN;
 }
+// NOLINTEND(readability-magic-numbers, cppcoreguidelines-avoid-magic-numbers)
+
+bool pathHasExtension(const std::string &path, const std::vector<std::string> &extensions) {
+  std::string pathLower = path;
+  std::ranges::transform(pathLower, pathLower.begin(), [](unsigned char c) {
+    return static_cast<char>(std::tolower(c));
+  });
+  return std::ranges::any_of(
+      extensions, [&pathLower](const std::string &ext) { return pathLower.ends_with(ext); });
+}
+
+AudioBufferResult decodeWithFilePath(const std::string &path, float sampleRate) {
+  const int sr = static_cast<int>(sampleRate);
 
-AudioBufferResult AudioDecoder::decodeWithFilePath(const std::string &path, float sampleRate) {
-  if (AudioDecoder::pathHasExtension(path, {".mp4", ".m4a", ".aac"})) {
+  if (needsFFmpegByPath(path)) {
 #if !RN_AUDIO_API_FFMPEG_DISABLED
-    auto buffer = ffmpegdecoder::decodeWithFilePath(path, static_cast<int>(sampleRate));
-    if (buffer == nullptr) {
-      return Err("Failed to decode with file path using FFmpeg");
+    ffmpegdecoder::FFmpegDecoder decoder;
+    const auto openResult = decoder.openFile(sr, path);
+    if (openResult.is_err()) {
+      return Err("Failed to open file with FFmpeg decoder: " + openResult.unwrap_err());
     }
-    return Ok(std::move(buffer));
+    auto result = decodeAll(decoder);
+    decoder.close();
+    return result;
 #else
     return Err("FFmpeg is disabled, cannot decode with file path");
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
   }
-  return decodeWithMiniaudio(sampleRate, path);
+
+  miniaudio_decoder::MiniAudioDecoder decoder;
+  const auto openResult = decoder.openFile(sr, path);
+  if (openResult.is_err()) {
+    return Err("Failed to open file with miniaudio decoder: " + openResult.unwrap_err());
+  }
+  auto result = decodeAll(decoder);
+  decoder.close();
+  return result;
 }
 
-AudioBufferResult
-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) {
+AudioBufferResult decodeWithMemoryBlock(const void *data, size_t size, float sampleRate) {
+  const int sr = static_cast<int>(sampleRate);
+  const AudioFormat format = detectAudioFormat(data, size);
+
+  if (needsFFmpeg(format)) {
 #if !RN_AUDIO_API_FFMPEG_DISABLED
-    auto buffer = ffmpegdecoder::decodeWithMemoryBlock(data, size, static_cast<int>(sampleRate));
-    if (buffer == nullptr) {
-      return Err("Failed to decode with memory block using FFmpeg");
+    ffmpegdecoder::FFmpegDecoder decoder;
+    const auto openResult = decoder.openMemory(sr, data, size);
+    if (openResult.is_err()) {
+      return Err("Failed to open memory block with FFmpeg decoder: " + openResult.unwrap_err());
     }
-    return Ok(std::move(buffer));
+    auto result = decodeAll(decoder);
+    decoder.close();
+    return result;
 #else
     return Err("FFmpeg is disabled, cannot decode memory block");
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
   }
-  return decodeWithMiniaudio(sampleRate, MemorySource{.data = data, .size = size});
+
+  miniaudio_decoder::MiniAudioDecoder decoder;
+  const auto openResult = decoder.openMemory(sr, data, size);
+  if (openResult.is_err()) {
+    return Err("Failed to open memory block with miniaudio decoder: " + openResult.unwrap_err());
+  }
+  auto result = decodeAll(decoder);
+  decoder.close();
+  return result;
 }
 
-AudioBufferResult AudioDecoder::decodeWithPCMInBase64(
+AudioBufferResult decodeWithPCMInBase64(
     const std::string &data,
     float inputSampleRate,
     int inputChannelCount,
@@ -148,7 +177,7 @@ AudioBufferResult AudioDecoder::decodeWithPCMInBase64(
   auto audioBuffer =
       std::make_shared<AudioBuffer>(numFramesDecoded, inputChannelCount, inputSampleRate);
 
-  for (size_t ch = 0; ch < inputChannelCount; ++ch) {
+  for (int ch = 0; ch < inputChannelCount; ++ch) {
     auto channelData = audioBuffer->getChannel(ch)->span();
 
     for (size_t i = 0; i < numFramesDecoded; ++i) {
@@ -168,4 +197,4 @@ AudioBufferResult AudioDecoder::decodeWithPCMInBase64(
   return Ok(std::move(audioBuffer));
 }
 
-} // namespace audioapi
+} // namespace audioapi::audiodecoder

package/common/cpp/audioapi/core/utils/AudioDecoder.h

@@ -1,119 +1,42 @@
 #pragma once
 
 #include <audioapi/core/types/AudioFormat.h>
-#include <audioapi/libs/miniaudio/miniaudio.h>
 #include <audioapi/utils/AudioBuffer.hpp>
 #include <audioapi/utils/Result.hpp>
-#include <algorithm>
-#include <cstring>
+#include <cstddef>
 #include <memory>
 #include <string>
-#include <variant>
 #include <vector>
 
-namespace audioapi {
+namespace audioapi::audiodecoder {
 
 using AudioBufferResult = Result<std::shared_ptr<AudioBuffer>, std::string>;
 
-struct MemorySource {
-  const void *data;
-  size_t size;
-};
+[[nodiscard]] AudioBufferResult decodeWithFilePath(const std::string &path, float sampleRate);
+[[nodiscard]] AudioBufferResult
+decodeWithMemoryBlock(const void *data, size_t size, float sampleRate);
+[[nodiscard]] AudioBufferResult decodeWithPCMInBase64(
+    const std::string &data,
+    float inputSampleRate,
+    int inputChannelCount,
+    bool interleaved);
 
-using DecoderSource = std::variant<MemorySource, std::string>;
+[[nodiscard]] AudioFormat detectAudioFormat(const void *data, size_t size);
 
-static constexpr int CHUNK_SIZE = 4096;
+[[nodiscard]] bool pathHasExtension(
+    const std::string &path,
+    const std::vector<std::string> &extensions);
 
-class AudioDecoder {
- public:
-  AudioDecoder() = delete;
+[[nodiscard]] inline bool needsFFmpeg(AudioFormat format) {
+  return format == AudioFormat::MP4 || format == AudioFormat::M4A || format == AudioFormat::AAC;
+}
 
-  [[nodiscard]] static AudioBufferResult decodeWithFilePath(
-      const std::string &path,
-      float sampleRate);
-  [[nodiscard]] static AudioBufferResult
-  decodeWithMemoryBlock(const void *data, size_t size, float sampleRate);
-  [[nodiscard]] static AudioBufferResult decodeWithPCMInBase64(
-      const std::string &data,
-      float inputSampleRate,
-      int inputChannelCount,
-      bool interleaved);
+[[nodiscard]] inline bool needsFFmpegByPath(const std::string &path) {
+  return pathHasExtension(path, {".mp4", ".m4a", ".aac"});
+}
 
-  // NOLINTBEGIN(readability-magic-numbers, cppcoreguidelines-avoid-magic-numbers)
-  static AudioFormat detectAudioFormat(const void *data, size_t size) {
-    if (size < 12) {
-      return AudioFormat::UNKNOWN;
-    }
-    const auto *bytes = static_cast<const unsigned char *>(data);
+[[nodiscard]] inline float uint8ToFloat(uint8_t byte1, uint8_t byte2) {
+  return static_cast<float>(static_cast<int16_t>((byte2 << CHAR_BIT) | byte1)) / INT16_MAX;
+}
 
-    // WAV/RIFF
-    if (std::memcmp(bytes, "RIFF", 4) == 0 && std::memcmp(bytes + 8, "WAVE", 4) == 0) {
-      return AudioFormat::WAV;
-    }
-
-    // OGG
-    if (std::memcmp(bytes, "OggS", 4) == 0) {
-      return AudioFormat::OGG;
-    }
-
-    // FLAC
-    if (std::memcmp(bytes, "fLaC", 4) == 0) {
-      return AudioFormat::FLAC;
-    }
-
-    // AAC starts with 0xFF 0xF1 or 0xFF 0xF9
-    if (bytes[0] == 0xFF && (bytes[1] & 0xF6) == 0xF0) {
-      return AudioFormat::AAC;
-    }
-
-    // MP3: "ID3" or 11-bit frame sync (0xFF 0xE0)
-    if (std::memcmp(bytes, "ID3", 3) == 0) {
-      return AudioFormat::MP3;
-    }
-    if (bytes[0] == 0xFF && (bytes[1] & 0xE0) == 0xE0) {
-      return AudioFormat::MP3;
-    }
-
-    if (std::memcmp(bytes + 4, "ftyp", 4) == 0) {
-      if (std::memcmp(bytes + 8, "M4A ", 4) == 0) {
-        return AudioFormat::M4A;
-      }
-      if (std::memcmp(bytes + 8, "qt  ", 4) == 0) {
-        return AudioFormat::MOV;
-      }
-      return AudioFormat::MP4;
-    }
-    return AudioFormat::UNKNOWN;
-  }
-
-  // NOLINTEND(readability-magic-numbers, cppcoreguidelines-avoid-magic-numbers)
-  static bool pathHasExtension(
-      const std::string &path,
-      const std::vector<std::string> &extensions) {
-    std::string pathLower = path;
-    std::ranges::transform(pathLower, pathLower.begin(), ::tolower);
-    return std::ranges::any_of(
-        extensions, [&pathLower](const std::string &ext) { return pathLower.ends_with(ext); });
-  }
-
- private:
-  static AudioBufferResult decodeWithMiniaudio(float sampleRate, DecoderSource source);
-  static Result<std::vector<float>, std::string> readAllPcmFrames(
-      ma_decoder &decoder,
-      int outputChannels);
-  static AudioBufferResult makeAudioBufferFromFloatBuffer(
-      const std::vector<float> &buffer,
-      float outputSampleRate,
-      int outputChannels);
-  [[nodiscard]] static int16_t floatToInt16(float sample) {
-    return static_cast<int16_t>(sample * INT16_MAX);
-  }
-  [[nodiscard]] static float int16ToFloat(int16_t sample) {
-    return static_cast<float>(sample) / INT16_MAX;
-  }
-  [[nodiscard]] static float uint8ToFloat(uint8_t byte1, uint8_t byte2) {
-    return static_cast<float>(static_cast<int16_t>((byte2 << CHAR_BIT) | byte1)) / INT16_MAX;
-  }
-};
-
-} // namespace audioapi
+} // namespace audioapi::audiodecoder