react-native-audio-api 0.8.3-nightly-ea268f4-20251006 → 0.9.0-nightly-96a5bcd-20251007

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

@@ -21,6 +21,9 @@ OscillatorNode::OscillatorNode(BaseAudioContext *context)
   type_ = OscillatorType::SINE;
   periodicWave_ = context_->getBasicWaveForm(type_);
 
+  audioBus_ = std::make_shared<AudioBus>(
+      RENDER_QUANTUM_SIZE, 1, context_->getSampleRate());
+
   isInitialized_ = true;
 }
 
@@ -47,7 +50,7 @@ void OscillatorNode::setPeriodicWave(
   type_ = OscillatorType::CUSTOM;
 }
 
-void OscillatorNode::processNode(
+std::shared_ptr<AudioBus> OscillatorNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   size_t startOffset = 0;
@@ -57,7 +60,7 @@ void OscillatorNode::processNode(
 
   if (!isPlaying() && !isStopScheduled()) {
     processingBus->zero();
-    return;
+    return processingBus;
   }
 
   auto time = context_->getCurrentTime() +
@@ -89,6 +92,8 @@ void OscillatorNode::processNode(
   }
 
   handleStopScheduled();
+
+  return processingBus;
 }
 
 } // namespace audioapi

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

@@ -24,7 +24,7 @@ class OscillatorNode : public AudioScheduledSourceNode {
   void setPeriodicWave(const std::shared_ptr<PeriodicWave> &periodicWave);
 
  protected:
-  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
 
  private:
   std::shared_ptr<AudioParam> frequencyParam_;

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

@@ -23,7 +23,7 @@ void RecorderAdapterNode::init(size_t bufferSize) {
   buff_ = std::make_shared<CircularOverflowableAudioArray>(bufferSize);
 }
 
-void RecorderAdapterNode::processNode(
+std::shared_ptr<AudioBus> RecorderAdapterNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   float *outputChannel = processingBus->getChannel(0)->getData();
@@ -33,6 +33,8 @@ void RecorderAdapterNode::processNode(
     processingBus->getChannel(i)->copy(
         processingBus->getChannel(0), 0, framesToProcess);
   }
+
+  return processingBus;
 }
 
 void RecorderAdapterNode::readFrames(float *output, const size_t framesToRead) {

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

@@ -27,7 +27,7 @@ class RecorderAdapterNode : public AudioNode {
     void init(size_t bufferSize);
 
  protected:
-    void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+    std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
     std::shared_ptr<CircularOverflowableAudioArray> buff_;
 
  private:

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

@@ -147,12 +147,18 @@ void StreamerNode::streamAudio() {
   }
 }
 
-void StreamerNode::processNode(
+std::shared_ptr<AudioBus> StreamerNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   size_t startOffset = 0;
   size_t offsetLength = 0;
   updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
+
+  if (!isPlaying() && !isStopScheduled()) {
+    processingBus->zero();
+    return processingBus;
+  }
+
   // If we have enough buffered data, copy to output bus
   if (bufferedBusIndex_ >= framesToProcess) {
     Locker locker(mutex_);
@@ -169,6 +175,8 @@ void StreamerNode::processNode(
     }
     bufferedBusIndex_ -= offsetLength;
   }
+
+  return processingBus;
 }
 
 bool StreamerNode::processFrameWithResampler(AVFrame *frame) {

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

@@ -44,7 +44,7 @@ class StreamerNode : public AudioScheduledSourceNode {
   void stop(double when) override;
 
  protected:
-  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
 
  private:
   #ifndef AUDIO_API_TEST_SUITE

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

@@ -22,12 +22,12 @@ WorkletSourceNode::WorkletSourceNode(
   }
 }
 
-void WorkletSourceNode::processNode(
+std::shared_ptr<AudioBus> WorkletSourceNode::processNode(
     const std::shared_ptr<AudioBus> &processingBus,
     int framesToProcess) {
   if (isUnscheduled() || isFinished() || !isEnabled()) {
     processingBus->zero();
-    return;
+    return processingBus;
   }
 
   size_t startOffset = 0;
@@ -38,7 +38,7 @@ void WorkletSourceNode::processNode(
 
   if (nonSilentFramesToProcess == 0) {
     processingBus->zero();
-    return;
+    return processingBus;
   }
 
   size_t outputChannelCount = processingBus->getNumberOfChannels();
@@ -64,7 +64,7 @@ void WorkletSourceNode::processNode(
   // It might happen if the runtime is not available
   if (!result.has_value()) {
     processingBus->zero();
-    return;
+    return processingBus;
   }
 
   // Copy the processed data back to the AudioBus
@@ -77,6 +77,8 @@ void WorkletSourceNode::processNode(
   }
 
   handleStopScheduled();
+
+  return processingBus;
 }
 
 } // namespace audioapi

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

@@ -23,7 +23,7 @@ class WorkletSourceNode : public AudioScheduledSourceNode {
   ) : AudioScheduledSourceNode(context) {}
 
  protected:
-  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override {}
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override { return processingBus; }
 };
 #else
 
@@ -36,7 +36,7 @@ class WorkletSourceNode : public AudioScheduledSourceNode {
   );
 
  protected:
-  void processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
+  std::shared_ptr<AudioBus> processNode(const std::shared_ptr<AudioBus>& processingBus, int framesToProcess) override;
  private:
   WorkletsRunner workletRunner_;
   std::shared_ptr<worklets::SerializableWorklet> shareableWorklet_;

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

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace audioapi {
+
+enum class AudioFormat {
+  UNKNOWN,
+  WAV,
+  OGG,
+  FLAC,
+  AAC,
+  MP3,
+  M4A,
+  MP4,
+  MOV
+};
+} // namespace audioapi

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

@@ -1,124 +1,68 @@
 #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 {
 
-enum class AudioFormat {
-  UNKNOWN,
-  WAV,
-  OGG,
-  FLAC,
-  AAC,
-  MP3,
-  M4A,
-  MP4,
-  MOV
-};
-
-class AudioBus;
+class AudioBuffer;
 
 static constexpr int CHUNK_SIZE = 4096;
 
 class AudioDecoder {
  public:
-  explicit AudioDecoder(float sampleRate) : sampleRate_(sampleRate) {}
+  AudioDecoder() = delete;
 
-  [[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;
+  [[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);
 
  private:
-  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 std::vector<float> readAllPcmFrames(ma_decoder &decoder, int outputChannels);
+  static std::shared_ptr<AudioBuffer>
+  makeAudioBufferFromFloatBuffer(const std::vector<float> &buffer, float outputSampleRate, int outputChannels);
 
-    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);
+  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;
   }
@@ -126,19 +70,21 @@ 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 * 32768.0f);
+    return static_cast<int16_t>(sample * INT16_MAX);
   }
   [[nodiscard]] static inline float int16ToFloat(int16_t sample) {
-    return static_cast<float>(sample) / 32768.0f;
+    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;
   }
 };