react-native-audio-api 0.5.5 → 0.6.0-rc.0

package/RNAudioAPI.podspec

@@ -31,7 +31,7 @@ Pod::Spec.new do |s|
     end
   end
 
-  s.ios.frameworks = 'CoreFoundation', 'CoreAudio', 'AudioToolbox', 'Accelerate'
+  s.ios.frameworks = 'CoreFoundation', 'CoreAudio', 'AudioToolbox', 'Accelerate', 'MediaPlayer', 'AVFoundation'
 
   s.compiler_flags = "#{folly_flags}"
 

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

@@ -6,26 +6,6 @@
 
 namespace audioapi {
 
-AudioPlayer::AudioPlayer(
-    const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio)
-    : renderAudio_(renderAudio), channelCount_(2) {
-  AudioStreamBuilder builder;
-
-  builder.setSharingMode(SharingMode::Exclusive)
-      ->setFormat(AudioFormat::Float)
-      ->setFormatConversionAllowed(true)
-      ->setPerformanceMode(PerformanceMode::None)
-      ->setChannelCount(channelCount_)
-      ->setSampleRateConversionQuality(SampleRateConversionQuality::Medium)
-      ->setDataCallback(this)
-      ->openStream(mStream_);
-
-  sampleRate_ = static_cast<float>(mStream_->getSampleRate());
-  mBus_ = std::make_shared<AudioBus>(
-      RENDER_QUANTUM_SIZE, channelCount_, sampleRate_);
-  isInitialized_ = true;
-}
-
 AudioPlayer::AudioPlayer(
     const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio,
     float sampleRate)

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

@@ -14,8 +14,6 @@ class AudioBus;
 
 class AudioPlayer : public AudioStreamDataCallback {
  public:
-  explicit AudioPlayer(
-      const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio);
   AudioPlayer(
       const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio,
       float sampleRate);

package/android/src/main/java/com/swmansion/audioapi/AudioAPIPackage.kt

@@ -10,6 +10,7 @@ import com.facebook.react.module.model.ReactModuleInfoProvider
 @ReactModuleList(
   nativeModules = [
     AudioAPIModule::class,
+    AudioManagerModule::class,
   ],
 )
 class AudioAPIPackage : BaseReactPackage() {
@@ -19,6 +20,7 @@ class AudioAPIPackage : BaseReactPackage() {
   ): NativeModule? {
     when (name) {
       AudioAPIModule.NAME -> return AudioAPIModule(reactContext)
+      AudioManagerModule.NAME -> return AudioManagerModule(reactContext)
     }
     return null
   }
@@ -37,6 +39,17 @@ class AudioAPIPackage : BaseReactPackage() {
           isCxxModule = false,
           isTurboModule = isTurboModule,
         )
+
+      moduleInfos[AudioManagerModule.NAME] =
+        ReactModuleInfo(
+          AudioManagerModule.NAME,
+          AudioManagerModule.NAME,
+          canOverrideExistingModule = true,
+          needsEagerInit = false,
+          hasConstants = true,
+          isCxxModule = false,
+          isTurboModule = false,
+        )
       moduleInfos
     }
 }

package/android/src/main/java/com/swmansion/audioapi/AudioManagerModule.kt

@@ -0,0 +1,59 @@
+package com.swmansion.audioapi
+
+import android.content.Context
+import android.media.AudioManager
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+
+class AudioManagerModule(
+  reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+  companion object {
+    const val NAME = "AudioManagerModule"
+  }
+
+  private val audioManager: AudioManager = reactContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+
+  init {
+    try {
+      System.loadLibrary("react-native-audio-api")
+    } catch (exception: UnsatisfiedLinkError) {
+      throw RuntimeException("Could not load native module AudioAPIModule", exception)
+    }
+  }
+
+  @ReactMethod
+  fun setLockScreenInfo(info: ReadableMap?) {
+  }
+
+  @ReactMethod
+  fun resetLockScreenInfo() {
+  }
+
+  @ReactMethod
+  fun enableRemoteCommand(
+    name: String?,
+    enabled: Boolean,
+  ) {
+  }
+
+  @ReactMethod
+  fun setAudioSessionOptions(
+    category: String?,
+    mode: String?,
+    options: ReadableArray?,
+    active: Boolean,
+  ) {
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun getDevicePreferredSampleRate(): Double {
+    val sampleRate = this.audioManager.getProperty(AudioManager.PROPERTY_OUTPUT_SAMPLE_RATE)
+    return sampleRate.toDouble()
+  }
+
+  override fun getName(): String = NAME
+}

package/android/src/oldarch/NativeAudioManagerModuleSpec.java

@@ -0,0 +1,99 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJavaSpec.js
+ *
+ * @nolint
+ */
+
+package com.swmansion.audioapi;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+
+public abstract class NativeAudioManagerModuleSpec extends ReactContextBaseJavaModule implements TurboModule {
+  public static final String NAME = "AudioManagerModule";
+
+  public NativeAudioManagerModuleSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  protected final void emitOnRemotePlay() {
+    mEventEmitterCallback.invoke("onRemotePlay");
+  }
+
+  protected final void emitOnRemotePause() {
+    mEventEmitterCallback.invoke("onRemotePause");
+  }
+
+  protected final void emitOnStop() {
+    mEventEmitterCallback.invoke("onStop");
+  }
+
+  protected final void emitOnTogglePlayPause() {
+    mEventEmitterCallback.invoke("onTogglePlayPause");
+  }
+
+  protected final void emitOnChangePlaybackRate(double value) {
+    mEventEmitterCallback.invoke("onChangePlaybackRate", value);
+  }
+
+  protected final void emitOnNextTrack() {
+    mEventEmitterCallback.invoke("onNextTrack");
+  }
+
+  protected final void emitOnPreviousTrack() {
+    mEventEmitterCallback.invoke("onPreviousTrack");
+  }
+
+  protected final void emitOnSkipForward(double value) {
+    mEventEmitterCallback.invoke("onSkipForward", value);
+  }
+
+  protected final void emitOnSkipBackward(double value) {
+    mEventEmitterCallback.invoke("onSkipBackward", value);
+  }
+
+  protected final void emitOnSeekForward() {
+    mEventEmitterCallback.invoke("onSeekForward");
+  }
+
+  protected final void emitOnSeekBackward() {
+    mEventEmitterCallback.invoke("onSeekBackward");
+  }
+
+  protected final void emitOnChangePlaybackPosition(double value) {
+    mEventEmitterCallback.invoke("onChangePlaybackPosition", value);
+  }
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void setLockScreenInfo(ReadableMap info);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void resetLockScreenInfo();
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void setSessionOptions(String category, String mode, ReadableArray options);
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract double getDevicePreferredSampleRate();
+}

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -2,7 +2,9 @@
 
 #include <audioapi/jsi/JsiPromise.h>
 #include <audioapi/core/AudioContext.h>
+#include <audioapi/core/OfflineAudioContext.h>
 #include <audioapi/HostObjects/AudioContextHostObject.h>
+#include <audioapi/HostObjects/OfflineAudioContextHostObject.h>
 
 #include <memory>
 
@@ -14,8 +16,11 @@ class AudioAPIModuleInstaller {
  public:
   static void injectJSIBindings(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker) {
     auto createAudioContext = getCreateAudioContextFunction(jsiRuntime, jsCallInvoker);
+    auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(jsiRuntime, jsCallInvoker);
     jsiRuntime->global().setProperty(
         *jsiRuntime, "createAudioContext", createAudioContext);
+    jsiRuntime->global().setProperty(
+        *jsiRuntime, "createOfflineAudioContext", createOfflineAudioContext);
   }
 
  private:
@@ -30,12 +35,8 @@ class AudioAPIModuleInstaller {
             const jsi::Value *args,
             size_t count) -> jsi::Value {
           std::shared_ptr<AudioContext> audioContext;
-          if (args[0].isUndefined()) {
-            audioContext = std::make_shared<AudioContext>();
-          } else {
-            auto sampleRate = static_cast<float>(args[0].getNumber());
-            audioContext = std::make_shared<AudioContext>(sampleRate);
-          }
+          auto sampleRate = static_cast<float>(args[0].getNumber());
+          audioContext = std::make_shared<AudioContext>(sampleRate);
 
           auto audioContextHostObject = std::make_shared<AudioContextHostObject>(
               audioContext, &runtime, jsCallInvoker);
@@ -44,6 +45,29 @@ class AudioAPIModuleInstaller {
               runtime, audioContextHostObject);
         });
   }
+
+  static jsi::Function getCreateOfflineAudioContextFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker) {
+    return jsi::Function::createFromHostFunction(
+        *jsiRuntime,
+        jsi::PropNameID::forAscii(*jsiRuntime, "createOfflineAudioContext"),
+        0,
+        [jsiRuntime, jsCallInvoker](
+            jsi::Runtime &runtime,
+            const jsi::Value &thisValue,
+            const jsi::Value *args,
+            size_t count) -> jsi::Value {
+            auto numberOfChannels = static_cast<int>(args[0].getNumber());
+            auto length = static_cast<size_t>(args[1].getNumber());
+            auto sampleRate = static_cast<float>(args[2].getNumber());
+
+          std::shared_ptr<OfflineAudioContext> offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate);
+          auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
+              offlineAudioContext, jsiRuntime, jsCallInvoker);
+
+          return jsi::Object::createFromHostObject(
+              runtime, audioContextHostObject);
+        });
+  }
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/OfflineAudioContextHostObject.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/HostObjects/BaseAudioContextHostObject.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace audioapi {
+using namespace facebook;
+
+class OfflineAudioContextHostObject : public BaseAudioContextHostObject {
+ public:
+  explicit OfflineAudioContextHostObject(
+          const std::shared_ptr<OfflineAudioContext> &offlineAudioContext,
+          jsi::Runtime *runtime,
+          const std::shared_ptr<react::CallInvoker> &callInvoker)
+      : BaseAudioContextHostObject(offlineAudioContext, runtime, callInvoker) {
+    addFunctions(
+      JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, resume),
+      JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, suspend),
+      JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, startRendering));
+  }
+
+  JSI_HOST_FUNCTION(resume) {
+    auto promise = promiseVendor_->createPromise([this](const std::shared_ptr<Promise>& promise) {
+      auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
+      audioContext->resume();
+    });
+
+    return promise;
+  }
+
+  JSI_HOST_FUNCTION(suspend) {
+    double when = args[0].getNumber();
+
+    auto promise = promiseVendor_->createPromise([this, when](const std::shared_ptr<Promise>& promise) {
+      auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
+      OfflineAudioContextSuspendCallback callback = [promise]() {
+        promise->resolve([](jsi::Runtime &runtime) {
+          return jsi::Value::undefined();
+        });
+      };
+      audioContext->suspend(when, callback);
+    });
+
+    return promise;
+  }
+
+  JSI_HOST_FUNCTION(startRendering) {
+    auto promise = promiseVendor_->createPromise([this](const std::shared_ptr<Promise>& promise) {
+      auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
+
+      OfflineAudioContextResultCallback callback =
+          [promise](const std::shared_ptr<AudioBuffer>& audioBuffer) -> void {
+        auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(audioBuffer);
+        promise->resolve([audioBufferHostObject = std::move(audioBufferHostObject)](jsi::Runtime &runtime) {
+          return jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
+        });
+      };
+
+      audioContext->startRendering(callback);
+    });
+
+    return promise;
+  }
+};
+} // namespace audioapi

package/common/cpp/audioapi/core/AudioContext.cpp

@@ -10,18 +10,6 @@
 #include <audioapi/core/utils/AudioNodeManager.h>
 
 namespace audioapi {
-AudioContext::AudioContext() : BaseAudioContext() {
-#ifdef ANDROID
-  audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio());
-#else
-  audioPlayer_ = std::make_shared<IOSAudioPlayer>(this->renderAudio());
-#endif
-  sampleRate_ = audioPlayer_->getSampleRate();
-  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
-
-  audioPlayer_->start();
-}
-
 AudioContext::AudioContext(float sampleRate) : BaseAudioContext() {
 #ifdef ANDROID
   audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio(), sampleRate);
@@ -29,6 +17,7 @@ AudioContext::AudioContext(float sampleRate) : BaseAudioContext() {
   audioPlayer_ =
       std::make_shared<IOSAudioPlayer>(this->renderAudio(), sampleRate);
 #endif
+
   sampleRate_ = audioPlayer_->getSampleRate();
   audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
 

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

@@ -14,7 +14,6 @@ class IOSAudioPlayer;
 
 class AudioContext : public BaseAudioContext {
  public:
-  AudioContext();
   explicit AudioContext(float sampleRate);
   ~AudioContext() override;
 

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

@@ -0,0 +1,117 @@
+#include "OfflineAudioContext.h"
+
+#include <audioapi/core/AudioContext.h>
+#include <audioapi/core/Constants.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/Locker.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+#include <thread>
+#include <utility>
+
+namespace audioapi {
+
+OfflineAudioContext::OfflineAudioContext(
+    int numberOfChannels,
+    size_t length,
+    float sampleRate)
+    : BaseAudioContext(),
+      length_(length),
+      numberOfChannels_(numberOfChannels),
+      currentSampleFrame_(0) {
+  sampleRate_ = sampleRate;
+  audioDecoder_ = std::make_shared<AudioDecoder>(sampleRate_);
+  resultBus_ = std::make_shared<AudioBus>(
+      static_cast<int>(length_), numberOfChannels_, sampleRate_);
+}
+
+OfflineAudioContext::~OfflineAudioContext() {
+  nodeManager_->cleanup();
+}
+
+void OfflineAudioContext::resume() {
+  Locker locker(mutex_);
+
+  if (state_ == ContextState::RUNNING) {
+    return;
+  }
+
+  renderAudio();
+}
+
+void OfflineAudioContext::suspend(
+    double when,
+    const std::function<void()> &callback) {
+  Locker locker(mutex_);
+
+  // we can only suspend once per render quantum at the end of the quantum
+  // first quantum is [0, RENDER_QUANTUM_SIZE)
+  auto frame = static_cast<size_t>(when * sampleRate_);
+  frame = RENDER_QUANTUM_SIZE *
+      ((frame + RENDER_QUANTUM_SIZE - 1) / RENDER_QUANTUM_SIZE);
+
+  if (scheduledSuspends_.find(frame) != scheduledSuspends_.end()) {
+    throw std::runtime_error(
+        "cannot schedule more than one suspend at frame " +
+        std::to_string(frame) + " (" + std::to_string(when) + " seconds)");
+  }
+
+  scheduledSuspends_.emplace(frame, callback);
+}
+
+void OfflineAudioContext::renderAudio() {
+  state_ = ContextState::RUNNING;
+  std::thread([this]() {
+    auto audioBus = std::make_shared<AudioBus>(
+        RENDER_QUANTUM_SIZE, numberOfChannels_, sampleRate_);
+
+    while (currentSampleFrame_ < length_) {
+      Locker locker(mutex_);
+      int framesToProcess = std::min(
+          static_cast<int>(length_ - currentSampleFrame_), RENDER_QUANTUM_SIZE);
+
+      destination_->renderAudio(audioBus, framesToProcess);
+
+      for (int i = 0; i < framesToProcess; i++) {
+        for (int channel = 0; channel < numberOfChannels_; channel += 1) {
+          resultBus_->getChannel(channel)->getData()[currentSampleFrame_ + i] =
+              audioBus->getChannel(channel)->getData()[i];
+        }
+      }
+
+      currentSampleFrame_ += framesToProcess;
+
+      // Execute scheduled suspend if exists
+      auto suspend = scheduledSuspends_.find(currentSampleFrame_);
+      if (suspend != scheduledSuspends_.end()) {
+        assert(currentSampleFrame_ < length_);
+        auto callback = suspend->second;
+        scheduledSuspends_.erase(currentSampleFrame_);
+        state_ = ContextState::SUSPENDED;
+        callback();
+        return;
+      }
+    }
+
+    // Rendering completed
+    auto buffer = std::make_shared<AudioBuffer>(resultBus_);
+    resultCallback_(buffer);
+  }).detach();
+}
+
+void OfflineAudioContext::startRendering(
+    OfflineAudioContextResultCallback callback) {
+  Locker locker(mutex_);
+
+  resultCallback_ = std::move(callback);
+  renderAudio();
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "BaseAudioContext.h"
+
+#include <mutex>
+#include <map>
+#include <unordered_map>
+#include <memory>
+
+namespace audioapi {
+
+using OfflineAudioContextSuspendCallback = std::function<void()>;
+using OfflineAudioContextResultCallback = std::function<void(std::shared_ptr<AudioBuffer>)>;
+
+class OfflineAudioContext : public BaseAudioContext {
+ public:
+  explicit OfflineAudioContext(int numberOfChannels, size_t length, float sampleRate);
+  ~OfflineAudioContext() override;
+
+  void resume();
+  void suspend(double when, const OfflineAudioContextSuspendCallback& callback);
+
+  void startRendering(OfflineAudioContextResultCallback callback);
+
+ private:
+  std::mutex mutex_;
+
+  std::unordered_map<size_t, OfflineAudioContextSuspendCallback> scheduledSuspends_;
+  OfflineAudioContextResultCallback resultCallback_;
+
+  size_t length_;
+  int numberOfChannels_;
+  size_t currentSampleFrame_;
+
+  std::shared_ptr<AudioBus> resultBus_;
+
+  void renderAudio();
+};
+
+} // namespace audioapi

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

@@ -101,7 +101,7 @@ void AudioBufferSourceNode::setBuffer(
 
   loopEnd_ = buffer_->getDuration();
 
-  stretch_->presetDefault(channelCount_, buffer_->getSampleRate());
+  stretch_->presetDefault(channelCount_, buffer_->getSampleRate(), true);
 }
 
 void AudioBufferSourceNode::start(double when, double offset, double duration) {
@@ -181,7 +181,7 @@ void AudioBufferSourceNode::processWithoutPitchCorrection(
   auto computedPlaybackRate = getComputedPlaybackRateValue();
   updatePlaybackInfo(processingBus, framesToProcess, startOffset, offsetLength);
 
-  if (computedPlaybackRate == 0.0f || !isPlaying()) {
+  if (computedPlaybackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
     processingBus->zero();
     return;
   }
@@ -215,7 +215,7 @@ void AudioBufferSourceNode::processWithPitchCorrection(
   updatePlaybackInfo(
       playbackRateBus_, framesNeededToStretch, startOffset, offsetLength);
 
-  if (playbackRate == 0.0f || !isPlaying()) {
+  if (playbackRate == 0.0f || (!isPlaying() && !isStopScheduled())) {
     processingBus->zero();
     return;
   }

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

@@ -71,7 +71,7 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
       std::max(dsp::timeToSampleFrame(startTime_, sampleRate), firstFrame);
   size_t stopFrame = stopTime_ == -1.0
       ? std::numeric_limits<size_t>::max()
-      : std::max(dsp::timeToSampleFrame(stopTime_, sampleRate), firstFrame);
+      : dsp::timeToSampleFrame(stopTime_, sampleRate);
 
   if (isUnscheduled() || isFinished()) {
     startOffset = 0;
@@ -93,7 +93,18 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
     startOffset = std::max(startFrame, firstFrame) - firstFrame > 0
         ? std::max(startFrame, firstFrame) - firstFrame
         : 0;
-    nonSilentFramesToProcess = std::min(lastFrame, stopFrame) - startFrame;
+    nonSilentFramesToProcess =
+        std::max(std::min(lastFrame, stopFrame), startFrame) - startFrame;
+
+    assert(startOffset <= framesToProcess);
+    assert(nonSilentFramesToProcess <= framesToProcess);
+
+    // stop will happen in the same render quantum
+    if (stopFrame < lastFrame && stopFrame >= firstFrame) {
+      playbackState_ = PlaybackState::STOP_SCHEDULED;
+      processingBus->zero(stopFrame - firstFrame, lastFrame - stopFrame);
+    }
+
     processingBus->zero(0, startOffset);
     return;
   }
@@ -106,10 +117,25 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
     playbackState_ = PlaybackState::STOP_SCHEDULED;
     startOffset = 0;
     nonSilentFramesToProcess = stopFrame - firstFrame;
+
+    assert(startOffset <= framesToProcess);
+    assert(nonSilentFramesToProcess <= framesToProcess);
+
     processingBus->zero(stopFrame - firstFrame, lastFrame - stopFrame);
     return;
   }
 
+  // mark as finished in first silent render quantum
+  if (stopFrame < firstFrame) {
+    startOffset = 0;
+    nonSilentFramesToProcess = 0;
+
+    playbackState_ = PlaybackState::STOP_SCHEDULED;
+    handleStopScheduled();
+    playbackState_ = PlaybackState::FINISHED;
+    return;
+  }
+
   // normal "mid-buffer" playback
   startOffset = 0;
   nonSilentFramesToProcess = framesToProcess;