react-native-audio-api 0.9.0-nightly-96a5bcd-20251007 → 0.9.0

package/common/cpp/audioapi/core/BaseAudioContext.h

@@ -3,14 +3,15 @@
 #include <audioapi/core/types/ContextState.h>
 #include <audioapi/core/types/OscillatorType.h>
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
-#include <cassert>
-#include <complex>
-#include <cstddef>
+
 #include <functional>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
+#include <complex>
+#include <cstddef>
+#include <cassert>
 
 namespace audioapi {
 
@@ -26,6 +27,7 @@ class BiquadFilterNode;
 class AudioDestinationNode;
 class AudioBufferSourceNode;
 class AudioBufferQueueSourceNode;
+class AudioDecoder;
 class AnalyserNode;
 class AudioEventHandlerRegistry;
 class IAudioEventHandlerRegistry;
@@ -66,6 +68,10 @@ class BaseAudioContext {
       int length);
   std::shared_ptr<AnalyserNode> createAnalyser();
 
+  std::shared_ptr<AudioBuffer> decodeAudioDataSource(const std::string &path);
+  std::shared_ptr<AudioBuffer> decodeAudioData(const void *data, size_t size);
+  std::shared_ptr<AudioBuffer> decodeWithPCMInBase64(const std::string &data, float playbackSpeed);
+
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   [[nodiscard]] float getNyquistFrequency() const;
   AudioNodeManager *getNodeManager();
@@ -79,7 +85,9 @@ class BaseAudioContext {
 
   std::shared_ptr<AudioDestinationNode> destination_;
   // init in AudioContext or OfflineContext constructor
-  float sampleRate_{};
+  std::shared_ptr<AudioDecoder> audioDecoder_ {};
+  // init in AudioContext or OfflineContext constructor
+  float sampleRate_ {};
   ContextState state_ = ContextState::RUNNING;
   std::shared_ptr<AudioNodeManager> nodeManager_;
 

package/common/cpp/audioapi/core/OfflineAudioContext.cpp

@@ -3,6 +3,7 @@
 #include <audioapi/core/AudioContext.h>
 #include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/AudioNodeManager.h>
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
@@ -29,6 +30,7 @@ OfflineAudioContext::OfflineAudioContext(
       numberOfChannels_(numberOfChannels),
       currentSampleFrame_(0) {
   sampleRate_ = sampleRate;
+  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
   resultBus_ = std::make_shared<AudioBus>(
       static_cast<int>(length_), numberOfChannels_, sampleRate_);
 }

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

@@ -1,68 +1,124 @@
 #pragma once
 
-#include <audioapi/core/types/AudioFormat.h>
 #include <audioapi/libs/audio-stretch/stretch.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>
-#include <algorithm>
-#include <cstring>
 #include <memory>
 #include <string>
 #include <vector>
+#include <cstring>
+#include <algorithm>
 
 namespace audioapi {
 
-class AudioBuffer;
+enum class AudioFormat {
+  UNKNOWN,
+  WAV,
+  OGG,
+  FLAC,
+  AAC,
+  MP3,
+  M4A,
+  MP4,
+  MOV
+};
+
+class AudioBus;
 
 static constexpr int CHUNK_SIZE = 4096;
 
 class AudioDecoder {
  public:
-  AudioDecoder() = delete;
+  explicit AudioDecoder(float sampleRate) : sampleRate_(sampleRate) {}
 
-  [[nodiscard]] static std::shared_ptr<AudioBuffer> decodeWithFilePath(const std::string &path, float sampleRate);
-  [[nodiscard]] static std::shared_ptr<AudioBuffer>
-  decodeWithMemoryBlock(const void *data, size_t size, float sampleRate);
-  [[nodiscard]] static std::shared_ptr<AudioBuffer>
-  decodeWithPCMInBase64(const std::string &data, float inputSampleRate, int inputChannelCount, bool interleaved);
+  [[nodiscard]] std::shared_ptr<AudioBus> decodeWithFilePath(
+      const std::string &path) const;
+  [[nodiscard]] std::shared_ptr<AudioBus> decodeWithMemoryBlock(
+      const void *data,
+      size_t size) const;
+  [[nodiscard]] std::shared_ptr<AudioBus> decodeWithPCMInBase64(
+      const std::string &data,
+      float playbackSpeed) const;
 
  private:
-  static std::vector<float> readAllPcmFrames(ma_decoder &decoder, int outputChannels);
-  static std::shared_ptr<AudioBuffer>
-  makeAudioBufferFromFloatBuffer(const std::vector<float> &buffer, float outputSampleRate, int outputChannels);
+  float sampleRate_;
+  int numChannels_ = 2;
+
+  static std::vector<int16_t> readAllPcmFrames(
+      ma_decoder &decoder,
+      int numChannels,
+      ma_uint64 &outFramesRead);
+  static std::shared_ptr<AudioBus> makeAudioBusFromInt16Buffer(
+      const std::vector<int16_t> &buffer,
+      int numChannels,
+      float sampleRate);
+
+  void changePlaybackSpeedIfNeeded(
+      std::vector<int16_t> &buffer,
+      size_t framesDecoded,
+      int numChannels,
+      float playbackSpeed) const {
+    if (playbackSpeed == 1.0f) {
+      return;
+    }
+
+    auto stretcher = stretch_init(
+        static_cast<int>(sampleRate_ / 333.0f),
+        static_cast<int>(sampleRate_ / 55.0f),
+        numChannels,
+        0x1);
 
-  static AudioFormat detectAudioFormat(const void *data, size_t size) {
-    if (size < 12)
-      return AudioFormat::UNKNOWN;
-    const auto *bytes = static_cast<const unsigned char *>(data);
+    int maxOutputFrames = stretch_output_capacity(
+        stretcher, static_cast<int>(framesDecoded), 1 / playbackSpeed);
+    std::vector<int16_t> stretchedBuffer(maxOutputFrames);
+
+    int outputFrames = stretch_samples(
+        stretcher,
+        buffer.data(),
+        static_cast<int>(framesDecoded),
+        stretchedBuffer.data(),
+        1 / playbackSpeed);
+
+    outputFrames +=
+        stretch_flush(stretcher, stretchedBuffer.data() + (outputFrames));
+    stretchedBuffer.resize(outputFrames);
+
+    buffer = stretchedBuffer;
+
+    stretch_deinit(stretcher);
+  }
+
+  static AudioFormat detectAudioFormat(const void* data, size_t size) {
+    if (size < 12) return AudioFormat::UNKNOWN;
+    const auto* bytes = static_cast<const unsigned char*>(data);
 
     // WAV/RIFF
     if (std::memcmp(bytes, "RIFF", 4) == 0 && std::memcmp(bytes + 8, "WAVE", 4) == 0)
-      return AudioFormat::WAV;
+        return AudioFormat::WAV;
 
     // OGG
     if (std::memcmp(bytes, "OggS", 4) == 0)
-      return AudioFormat::OGG;
+        return AudioFormat::OGG;
 
     // FLAC
     if (std::memcmp(bytes, "fLaC", 4) == 0)
-      return AudioFormat::FLAC;
+        return AudioFormat::FLAC;
 
     // AAC starts with 0xFF 0xF1 or 0xFF 0xF9
     if (bytes[0] == 0xFF && (bytes[1] & 0xF6) == 0xF0)
-      return AudioFormat::AAC;
+        return AudioFormat::AAC;
 
     // MP3: "ID3" or 11-bit frame sync (0xFF 0xE0)
     if (std::memcmp(bytes, "ID3", 3) == 0)
-      return AudioFormat::MP3;
+        return AudioFormat::MP3;
     if (bytes[0] == 0xFF && (bytes[1] & 0xE0) == 0xE0)
-      return AudioFormat::MP3;
+        return AudioFormat::MP3;
 
     if (std::memcmp(bytes + 4, "ftyp", 4) == 0) {
-      if (std::memcmp(bytes + 8, "M4A ", 4) == 0)
-        return AudioFormat::M4A;
-      else if (std::memcmp(bytes + 8, "qt  ", 4) == 0)
-        return AudioFormat::MOV;
-      return AudioFormat::MP4;
+        if (std::memcmp(bytes + 8, "M4A ", 4) == 0)
+            return AudioFormat::M4A;
+        else if (std::memcmp(bytes + 8, "qt  ", 4) == 0)
+            return AudioFormat::MOV;
+        return AudioFormat::MP4;
     }
     return AudioFormat::UNKNOWN;
   }
@@ -70,21 +126,19 @@ class AudioDecoder {
   static inline bool pathHasExtension(const std::string &path, const std::vector<std::string> &extensions) {
     std::string pathLower = path;
     std::transform(pathLower.begin(), pathLower.end(), pathLower.begin(), ::tolower);
-    for (const auto &ext : extensions) {
-      if (pathLower.ends_with(ext))
-        return true;
+    for (const auto& ext : extensions) {
+        if (pathLower.ends_with(ext))
+            return true;
     }
     return false;
   }
 
+
   [[nodiscard]] static inline int16_t floatToInt16(float sample) {
-    return static_cast<int16_t>(sample * INT16_MAX);
+    return static_cast<int16_t>(sample * 32768.0f);
   }
   [[nodiscard]] static inline float int16ToFloat(int16_t sample) {
-    return static_cast<float>(sample) / INT16_MAX;
-  }
-  [[nodiscard]] static inline float uint8ToFloat(uint8_t byte1, uint8_t byte2) {
-    return static_cast<float>(static_cast<int16_t>((byte2 << 8) | byte1)) / INT16_MAX;
+    return static_cast<float>(sample) / 32768.0f;
   }
 };