diff --git a/.claude/skills/host-objects/SKILL.md b/.claude/skills/host-objects/SKILL.md index 27d27bd66..7b56606f4 100644 --- a/.claude/skills/host-objects/SKILL.md +++ b/.claude/skills/host-objects/SKILL.md @@ -353,6 +353,8 @@ JSI_HOST_FUNCTION_IMPL(AudioBufferHostObject, getChannelData) { } ``` +The view aliases native memory for as long as JS keeps it, and the `shared_ptr` inside the `jsi::ArrayBuffer` keeps that memory alive on its own. When the native side later needs the view to stop aliasing (Web Audio's "acquire the content" on `AudioBufferSourceNode.start()`), it must retain the returned object and neutralise it afterwards — see `detachReturnedChannelData` in the real `AudioBufferHostObject`. + ### External memory pressure Call `setExternalMemoryPressure` whenever returning a HostObject or typed array that wraps a large native buffer. This lets the JS GC schedule collection correctly: diff --git a/packages/audiodocs/docs/fundamentals/best-practices.mdx b/packages/audiodocs/docs/fundamentals/best-practices.mdx index 273c64896..fb9eda409 100644 --- a/packages/audiodocs/docs/fundamentals/best-practices.mdx +++ b/packages/audiodocs/docs/fundamentals/best-practices.mdx @@ -53,6 +53,8 @@ user experience, and maintainability. Here are some key best practices to consid - **Scheduled source nodes are single-use**: [`AudioBufferSourceNode`](../sources/audio-buffer-source-node.mdx), [`OscillatorNode`](../sources/oscillator-node.mdx), and other [`AudioScheduledSourceNode`](../sources/audio-scheduled-source-node.mdx) subclasses can be [`start()`](../sources/audio-scheduled-source-node.mdx#start)ed only once. Create a new node to replay a sound, but reuse the same [`AudioBuffer`](../sources/audio-buffer.mdx) — nodes are inexpensive to create. +- **Seeking**: since a started `AudioBufferSourceNode` can't be repositioned, seeking means stopping/disconnecting it and creating a fresh node with the same `AudioBuffer` at a new `start()` offset. Reassigning the same buffer this way is cheap. The underlying PCM data is copied once per `AudioBuffer`, not once per node, so recreating the source node on every seek doesn't re-copy it. + - **Use [`AudioBufferQueueSourceNode`](../sources/audio-buffer-queue-source-node.mdx) for chunked playback**: When audio arrives in segments (streaming TTS, progressive download), enqueue buffers into a queue source node rather than recreating the entire graph per chunk. ## [**AudioParam**](../core/audio-param.mdx) changes @@ -87,4 +89,5 @@ Prefer logging plain values instead: ```tsx console.log({ channelCount: node.channelCount, numberOfInputs: node.numberOfInputs }); ``` + ::: diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferHostObject.cpp index a2276c050..787838d37 100644 --- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferHostObject.cpp +++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferHostObject.cpp @@ -6,6 +6,7 @@ #include #include #include +#include namespace audioapi { @@ -24,7 +25,43 @@ AudioBufferHostObject::AudioBufferHostObject(const std::shared_ptr } AudioBufferHostObject::AudioBufferHostObject(AudioBufferHostObject &&other) noexcept - : HostObject(std::move(other)), audioBuffer_(std::move(other.audioBuffer_)) {} + : HostObject(std::move(other)), + audioBuffer_(std::move(other.audioBuffer_)), + immutableCopyCache_(std::move(other.immutableCopyCache_)), + returnedChannelDataArrays_(std::move(other.returnedChannelDataArrays_)) {} + +void AudioBufferHostObject::detachReturnedChannelData(jsi::Runtime &runtime) { + if (returnedChannelDataArrays_.empty()) { + return; + } + + auto defineProperty = runtime.global() + .getPropertyAsObject(runtime, "Object") + .getPropertyAsFunction(runtime, "defineProperty"); + auto zeroDescriptor = jsi::Object(runtime); + zeroDescriptor.setProperty(runtime, "value", 0); + + std::vector channelDetached(audioBuffer_->getNumberOfChannels(), false); + + for (const auto &returned : returnedChannelDataArrays_) { + auto array = returned.array.lock(runtime); + if (array.isObject()) { + for (const auto *sizeProperty : {"length", "byteLength", "byteOffset"}) { + defineProperty.call(runtime, array, sizeProperty, zeroDescriptor); + } + } + + if (!channelDetached[returned.channel]) { + audioBuffer_->detachSharedChannel(returned.channel); + channelDetached[returned.channel] = true; + } + } + + returnedChannelDataArrays_.clear(); + // A view could have been written through right up until now, i.e. after the cached + // copy was taken. + immutableCopyCache_.invalidate(); +} JSI_PROPERTY_GETTER_IMPL(AudioBufferHostObject, sampleRate) { return {audioBuffer_->getSampleRate()}; @@ -43,7 +80,12 @@ JSI_PROPERTY_GETTER_IMPL(AudioBufferHostObject, numberOfChannels) { } JSI_HOST_FUNCTION_IMPL(AudioBufferHostObject, getChannelData) { - auto channel = static_cast(args[0].getNumber()); + // The returned Float32Array is a live, JS-writable view straight into + // audioBuffer_'s storage, so a copy cached before now can no longer be trusted. + // Caching resumes once the view is neutralised by detachReturnedChannelData(). + immutableCopyCache_.invalidate(); + + auto channel = static_cast(args[0].getNumber()); auto audioArrayBuffer = audioBuffer_->getSharedChannel(channel); auto arrayBuffer = jsi::ArrayBuffer(runtime, audioArrayBuffer); @@ -51,6 +93,8 @@ JSI_HOST_FUNCTION_IMPL(AudioBufferHostObject, getChannelData) { auto float32Array = float32ArrayCtor.callAsConstructor(runtime, arrayBuffer).getObject(runtime); float32Array.setExternalMemoryPressure(runtime, audioArrayBuffer->size()); + returnedChannelDataArrays_.push_back( + {.channel = channel, .array = jsi::WeakObject(runtime, float32Array)}); return float32Array; } @@ -76,6 +120,9 @@ JSI_HOST_FUNCTION_IMPL(AudioBufferHostObject, copyFromChannel) { } JSI_HOST_FUNCTION_IMPL(AudioBufferHostObject, copyToChannel) { + // Mutates audioBuffer_ in place, so any previously cached copy is now stale. + immutableCopyCache_.invalidate(); + auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime); auto *source = reinterpret_cast(arrayBuffer.data(runtime)); diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferHostObject.h index 04a463fb0..bcaaa36b2 100644 --- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferHostObject.h +++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferHostObject.h @@ -2,11 +2,13 @@ #include #include +#include #include #include #include #include +#include namespace audioapi { using namespace facebook; @@ -23,6 +25,8 @@ class AudioBufferHostObject : public HostObject { if (this != &other) { HostObject::operator=(std::move(other)); audioBuffer_ = std::move(other.audioBuffer_); + immutableCopyCache_ = std::move(other.immutableCopyCache_); + returnedChannelDataArrays_ = std::move(other.returnedChannelDataArrays_); } return *this; } @@ -34,6 +38,33 @@ class AudioBufferHostObject : public HostObject { return audioBuffer_->getSize() * audioBuffer_->getNumberOfChannels() * sizeof(float) * 2; } + /// @brief Returns a defensive copy of `audioBuffer_` suitable for handing to an + /// `AudioBufferSourceNode`, reusing a cached copy across repeated `.buffer = x` + /// reassignments of this same JS-visible buffer (e.g. seeking, which recreates the + /// source node but keeps reusing the already-decoded buffer). Without this, every + /// reassignment allocated a brand-new full-size copy, which is where + /// https://github.com/software-mansion/react-native-audio-api/issues/1263 came from. + /// @note The cache is dropped whenever `audioBuffer_` may have diverged from it: + /// `copyToChannel` mutates in place, `getChannelData` hands out a live JS-writable + /// view, and `detachReturnedChannelData` is the last moment such a view could have + /// been written through. + [[nodiscard]] std::shared_ptr getOrCreateImmutableCopy() { + return immutableCopyCache_.getOrCreate(audioBuffer_); + } + + /// @brief Web Audio's "acquire the content" step for the views handed out by + /// `getChannelData`. Call once playback of this buffer has been scheduled. Every + /// previously returned Float32Array stops aliasing `audioBuffer_` and, if JS still + /// holds it, reads as zero-length; the next `getChannelData` call hands out a fresh + /// view, mirroring what a browser does when it detaches those ArrayBuffers. + void detachReturnedChannelData(jsi::Runtime &runtime); + + /// @brief Whether any `getChannelData` view is live, i.e. handed out since the last + /// `detachReturnedChannelData`. + [[nodiscard]] bool hasReturnedChannelData() const { + return !returnedChannelDataArrays_.empty(); + } + JSI_PROPERTY_GETTER_DECL(sampleRate); JSI_PROPERTY_GETTER_DECL(length); JSI_PROPERTY_GETTER_DECL(duration); @@ -42,5 +73,16 @@ class AudioBufferHostObject : public HostObject { JSI_HOST_FUNCTION_DECL(getChannelData); JSI_HOST_FUNCTION_DECL(copyFromChannel); JSI_HOST_FUNCTION_DECL(copyToChannel); + + private: + struct ReturnedChannelDataArray { + size_t channel; + jsi::WeakObject array; + }; + + utils::ImmutableBufferCache immutableCopyCache_; + /// Float32Array views handed out by `getChannelData` since the last + /// `detachReturnedChannelData`, kept so they can be neutralised then. + std::vector returnedChannelDataArrays_; }; } // namespace audioapi diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.cpp index 4bd5826c6..eb2de3581 100644 --- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.cpp +++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.cpp @@ -126,6 +126,9 @@ JSI_PROPERTY_SETTER_IMPL(AudioBufferSourceNodeHostObject, onLoopEnded) { } JSI_HOST_FUNCTION_IMPL(AudioBufferSourceNodeHostObject, start) { + hasBeenStarted_ = true; + acquireBufferContent(runtime); + auto handle = node_->handle; auto event = [handle, node = audioBufferSourceNode_, @@ -139,6 +142,22 @@ JSI_HOST_FUNCTION_IMPL(AudioBufferSourceNodeHostObject, start) { return jsi::Value::undefined(); } +void AudioBufferSourceNodeHostObject::acquireBufferContent(jsi::Runtime &runtime) { + if (bufferHostObject_ == nullptr || !bufferHostObject_->hasReturnedChannelData()) { + return; + } + + bufferHostObject_->detachReturnedChannelData(runtime); + // The copy handed to the node in setBuffer() predates any writes made through those + // views since, so hand it the post-write content that has now been fenced off. + auto buffers = prepareNodeBuffers(bufferHostObject_->audioBuffer_, bufferHostObject_); + auto event = + [handle = node_->handle, node = audioBufferSourceNode_, buffers](BaseAudioContext &) { + node->replaceBufferContent(buffers.copiedBuffer, buffers.audioBuffer); + }; + audioBufferSourceNode_->scheduleAudioEvent(std::move(event)); +} + JSI_HOST_FUNCTION_IMPL(AudioBufferSourceNodeHostObject, setBuffer) { if (args[0].isNull()) { setBuffer(nullptr); @@ -147,56 +166,76 @@ JSI_HOST_FUNCTION_IMPL(AudioBufferSourceNodeHostObject, setBuffer) { thisValue.asObject(runtime).setExternalMemoryPressure( runtime, getMemoryPressure() + bufferHostObject->getSizeInBytes()); - setBuffer(bufferHostObject->audioBuffer_); + setBuffer(bufferHostObject->audioBuffer_, bufferHostObject); + } + + // Per Web Audio, assigning a buffer to an already-started source acquires its + // content right away, because start() had nothing to acquire back then. + if (hasBeenStarted_) { + acquireBufferContent(runtime); } return jsi::Value::undefined(); } -void AudioBufferSourceNodeHostObject::setBuffer(const std::shared_ptr &buffer) { +AudioBufferSourceNodeHostObject::NodeBuffers AudioBufferSourceNodeHostObject::prepareNodeBuffers( + const std::shared_ptr &buffer, + const std::shared_ptr &bufferHostObject) { // TODO: add optimized memory management for buffer changes, e.g. // when the same buffer is reused across threads and // buffer modification is not allowed on JS thread - auto handle = node_->handle; - - std::shared_ptr copiedBuffer; - std::shared_ptr audioBuffer; - const size_t newChannelCount = buffer == nullptr ? AudioBufferSourceOptions::kDefaultChannelCount - : buffer->getNumberOfChannels(); + NodeBuffers buffers; if (buffer == nullptr) { - copiedBuffer = nullptr; - audioBuffer = std::make_shared( + buffers.copiedBuffer = nullptr; + buffers.audioBuffer = std::make_shared( RENDER_QUANTUM_SIZE, AudioBufferSourceOptions::kDefaultChannelCount, audioBufferSourceNode_->getContextSampleRate()); + return buffers; + } + + if (pitchCorrection_) { + initStretch(static_cast(buffer->getNumberOfChannels()), buffer->getSampleRate()); + auto extraTailFrames = + static_cast((inputLatency_ + outputLatency_) * buffer->getSampleRate()); + size_t totalSize = buffer->getSize() + extraTailFrames; + buffers.copiedBuffer = std::make_shared( + totalSize, buffer->getNumberOfChannels(), buffer->getSampleRate()); + buffers.copiedBuffer->copy(*buffer, 0, 0, buffer->getSize()); + buffers.copiedBuffer->zero(buffer->getSize(), extraTailFrames); + } else if (bufferHostObject != nullptr) { + // Reuse a cached copy across repeated `.buffer = x` reassignments of the same + // JS-visible buffer (e.g. seeking, which recreates the source node but keeps + // reusing the already-decoded buffer) instead of deep-copying every time. + // See https://github.com/software-mansion/react-native-audio-api/issues/1263. + buffers.copiedBuffer = bufferHostObject->getOrCreateImmutableCopy(); } else { - if (pitchCorrection_) { - initStretch(static_cast(buffer->getNumberOfChannels()), buffer->getSampleRate()); - auto extraTailFrames = - static_cast((inputLatency_ + outputLatency_) * buffer->getSampleRate()); - size_t totalSize = buffer->getSize() + extraTailFrames; - copiedBuffer = std::make_shared( - totalSize, buffer->getNumberOfChannels(), buffer->getSampleRate()); - copiedBuffer->copy(*buffer, 0, 0, buffer->getSize()); - copiedBuffer->zero(buffer->getSize(), extraTailFrames); - } else { - copiedBuffer = std::make_shared(*buffer); - } - - audioBuffer = std::make_shared( - RENDER_QUANTUM_SIZE, - copiedBuffer->getNumberOfChannels(), - audioBufferSourceNode_->getContextSampleRate()); + buffers.copiedBuffer = std::make_shared(*buffer); } + buffers.audioBuffer = std::make_shared( + RENDER_QUANTUM_SIZE, + buffers.copiedBuffer->getNumberOfChannels(), + audioBufferSourceNode_->getContextSampleRate()); + return buffers; +} + +void AudioBufferSourceNodeHostObject::setBuffer( + const std::shared_ptr &buffer, + const std::shared_ptr &bufferHostObject) { + bufferHostObject_ = bufferHostObject; + auto buffers = prepareNodeBuffers(buffer, bufferHostObject); + // Update channelCount on the host thread before renegotiation so MAX / // CLAMPED_MAX downstream nodes see the new width immediately. + const size_t newChannelCount = buffer == nullptr ? AudioBufferSourceOptions::kDefaultChannelCount + : buffer->getNumberOfChannels(); updateChannelCount(newChannelCount); auto event = - [handle, node = audioBufferSourceNode_, copiedBuffer, audioBuffer](BaseAudioContext &) { - node->setBuffer(copiedBuffer, audioBuffer); + [handle = node_->handle, node = audioBufferSourceNode_, buffers](BaseAudioContext &) { + node->setBuffer(buffers.copiedBuffer, buffers.audioBuffer); }; audioBufferSourceNode_->scheduleAudioEvent(std::move(event)); } diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.h index b3b480576..a4d2fec5f 100644 --- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.h +++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.h @@ -51,7 +51,29 @@ class AudioBufferSourceNodeHostObject : public AudioBufferBaseSourceNodeHostObje double loopStart_; double loopEnd_; - void setBuffer(const std::shared_ptr &buffer); + /// The JS-visible buffer behind the last `setBuffer`, kept so the "acquire the + /// content" step can run on it. Null when the buffer came from options or was cleared. + std::shared_ptr bufferHostObject_; + bool hasBeenStarted_ = false; + + struct NodeBuffers { + std::shared_ptr copiedBuffer; + std::shared_ptr audioBuffer; + }; + + NodeBuffers prepareNodeBuffers( + const std::shared_ptr &buffer, + const std::shared_ptr &bufferHostObject); + + void setBuffer( + const std::shared_ptr &buffer, + const std::shared_ptr &bufferHostObject = nullptr); + + /// Web Audio's "acquire the content" step: runs on start() when a buffer is set, and on + /// setBuffer() once already started. Cuts off every live getChannelData() view and + /// re-hands the node the fenced-off content. + /// https://webaudio.github.io/web-audio-api/#acquire-the-content + void acquireBufferContent(jsi::Runtime &runtime); }; } // namespace audioapi diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp index 24dbf20f6..978eeeb21 100644 --- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp +++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp @@ -55,10 +55,33 @@ void AudioBufferSourceNode::setLoopEnd(double loopEnd) { void AudioBufferSourceNode::setBuffer( const std::shared_ptr &buffer, const std::shared_ptr &audioBuffer) { + if (!swapBuffers(buffer, audioBuffer)) { + return; + } + + if (buffer_ == nullptr) { + loopEnd_ = 0; + channelCount_ = AudioBufferSourceOptions::kDefaultChannelCount; + return; + } + + channelCount_ = static_cast(buffer_->getNumberOfChannels()); + loopEnd_ = buffer_->getDuration(); +} + +void AudioBufferSourceNode::replaceBufferContent( + const std::shared_ptr &buffer, + const std::shared_ptr &audioBuffer) { + swapBuffers(buffer, audioBuffer); +} + +bool AudioBufferSourceNode::swapBuffers( + const std::shared_ptr &buffer, + const std::shared_ptr &audioBuffer) { std::shared_ptr context = context_.lock(); if (context == nullptr) { - return; + return false; } if (buffer_ != nullptr) { @@ -69,21 +92,10 @@ void AudioBufferSourceNode::setBuffer( context->getDisposer()->dispose(std::move(audioBuffer_)); } - if (buffer == nullptr) { - loopEnd_ = 0; - channelCount_ = AudioBufferSourceOptions::kDefaultChannelCount; - - buffer_ = nullptr; - processor_->setBuffer(nullptr); - audioBuffer_ = audioBuffer; - return; - } - buffer_ = buffer; audioBuffer_ = audioBuffer; - channelCount_ = static_cast(buffer_->getNumberOfChannels()); - loopEnd_ = buffer_->getDuration(); processor_->setBuffer(buffer_); + return true; } void AudioBufferSourceNode::start(double when, double offset, double duration) { diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.h index 37ae6c803..380c853cd 100644 --- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.h +++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.h @@ -29,12 +29,22 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode { /// @note Audio Thread only void setLoopEnd(double loopEnd); + [[nodiscard]] double getLoopEnd() const { + return loopEnd_; + } /// @note Audio Thread only void setBuffer( const std::shared_ptr &buffer, const std::shared_ptr &audioBuffer); + /// @brief Swaps in a buffer holding the same frames, channels and sample rate as the + /// current one, keeping loop bounds and channel count untouched. This is the "acquire + /// the content" refresh: the samples may have changed since setBuffer(), the shape has not. + void replaceBufferContent( + const std::shared_ptr &buffer, + const std::shared_ptr &audioBuffer); + using AudioScheduledSourceNode::start; /// @note Audio Thread only void start(double when, double offset, double duration = -1); @@ -73,6 +83,12 @@ class AudioBufferSourceNode : public AudioBufferBaseSourceNode { double getVirtualEndFrame(float sampleRate); std::unique_ptr processor_; + + /// Hands the old buffers to the disposer and installs the new ones. Returns false when + /// the context is already gone. + bool swapBuffers( + const std::shared_ptr &buffer, + const std::shared_ptr &audioBuffer); }; } // namespace audioapi diff --git a/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioBuffer.hpp b/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioBuffer.hpp index 8f32141fa..95279272b 100644 --- a/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioBuffer.hpp +++ b/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioBuffer.hpp @@ -141,6 +141,14 @@ class AlignedAudioBuffer { return channels_[index]; } + /// @brief Gives channel @p index fresh storage holding a copy of its current samples. + /// Every handle previously obtained through getSharedChannel() keeps the old storage + /// alive but no longer aliases this buffer, so writes through it can't reach us anymore. + /// This is how a JS `getChannelData` view gets cut off once playback acquires the buffer. + void detachSharedChannel(size_t index) { + channels_[index] = std::make_shared>(*channels_[index]); + } + AlignedAudioArray &operator[](size_t index) { return *channels_[index]; } diff --git a/packages/react-native-audio-api/common/cpp/audioapi/utils/ImmutableBufferCache.h b/packages/react-native-audio-api/common/cpp/audioapi/utils/ImmutableBufferCache.h new file mode 100644 index 000000000..b6207fcf5 --- /dev/null +++ b/packages/react-native-audio-api/common/cpp/audioapi/utils/ImmutableBufferCache.h @@ -0,0 +1,44 @@ +#pragma once + +#include + +#include + +namespace audioapi::utils { + +/// @brief Caches a defensive copy of an `AudioBuffer` so repeated requests for +/// "an immutable copy suitable for handing to a source node" reuse the same +/// copy instead of allocating a fresh one every time. Used by +/// `AudioBufferHostObject` to avoid deep-copying the entire buffer on every +/// `.buffer = x` reassignment of the same underlying buffer. That reassignment +/// is what seeking requires, since a live `AudioBufferSourceNode` can't be +/// repositioned. See https://github.com/software-mansion/react-native-audio-api/issues/1263. +/// @note `invalidate()` must be called whenever the source buffer's data could +/// have diverged from the cached copy. This class has no way to observe that on +/// its own. +class ImmutableBufferCache { + public: + /// @brief Returns a defensive copy of `source`, reusing the last copy + /// produced as long as `invalidate()` has not been called since. + [[nodiscard]] std::shared_ptr getOrCreate( + const std::shared_ptr &source) { + if (cached_ == nullptr) { + cached_ = std::make_shared(*source); + } + return cached_; + } + + /// @brief Call when the source buffer's data may no longer match the cached + /// copy: it was mutated in place (`copyToChannel`), a live JS-writable view + /// into it was handed out (`getChannelData`), or such a view has just been + /// cut off after possibly being written through. The next `getOrCreate` + /// produces a fresh copy and caching resumes from there. + void invalidate() { + cached_ = nullptr; + } + + private: + std::shared_ptr cached_; +}; + +} // namespace audioapi::utils diff --git a/packages/react-native-audio-api/common/cpp/test/src/utils/AudioBufferTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/utils/AudioBufferTest.cpp index 6f458af68..300ff9ca7 100644 --- a/packages/react-native-audio-api/common/cpp/test/src/utils/AudioBufferTest.cpp +++ b/packages/react-native-audio-api/common/cpp/test/src/utils/AudioBufferTest.cpp @@ -634,4 +634,25 @@ TEST_F(AudioBufferTest, DeinterleaveZeroFramesIsNoop) { expectChannel(buf, 0, 42.0f); } +TEST_F(AudioBufferTest, DetachSharedChannelCutsOffEscapedHandleAndKeepsSamples) { + AudioBuffer buf(BUF_SIZE, 2, SR); + fillChannel(buf, 0, 0.5f); + fillChannel(buf, 1, 0.25f); + auto escapedHandle = buf.getSharedChannel(0); + auto untouchedHandle = buf.getSharedChannel(1); + + buf.detachSharedChannel(0); + + EXPECT_NE(buf.getSharedChannel(0), escapedHandle) << "Detached channel must get fresh storage."; + EXPECT_EQ(buf.getSharedChannel(1), untouchedHandle) + << "Other channels keep their storage; only the escaped one is replaced."; + expectChannel(buf, 0, 0.5f); + + (*escapedHandle)[3] = 1.0f; + + expectChannel(buf, 0, 0.5f); + EXPECT_FLOAT_EQ((*escapedHandle)[3], 1.0f) + << "The old handle stays alive and writable, it just no longer reaches the buffer."; +} + // NOLINTEND diff --git a/packages/react-native-audio-api/common/cpp/test/src/utils/ImmutableBufferCacheTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/utils/ImmutableBufferCacheTest.cpp new file mode 100644 index 000000000..070f89763 --- /dev/null +++ b/packages/react-native-audio-api/common/cpp/test/src/utils/ImmutableBufferCacheTest.cpp @@ -0,0 +1,64 @@ +#include +#include +#include +#include + +using namespace audioapi; +using namespace audioapi::utils; + +// NOLINTBEGIN + +namespace { + +constexpr size_t FRAME_COUNT = 1024; +constexpr int CHANNELS = 2; +constexpr float SAMPLE_RATE = 44100.0f; + +std::shared_ptr makeBuffer() { + return std::make_shared(FRAME_COUNT, CHANNELS, SAMPLE_RATE); +} + +} // namespace + +// The core of https://github.com/software-mansion/react-native-audio-api/issues/1263: +// repeated `.buffer = x` reassignment of the same underlying buffer (the seek pattern) +// must not allocate a fresh full-size copy every time. +TEST(ImmutableBufferCacheTest, ReusesCachedCopyAcrossRepeatedCalls) { + ImmutableBufferCache cache; + auto source = makeBuffer(); + + auto first = cache.getOrCreate(source); + auto second = cache.getOrCreate(source); + auto third = cache.getOrCreate(source); + + EXPECT_EQ(first, second) << "Second call should reuse the cached copy, not allocate a new one."; + EXPECT_EQ(second, third) << "Third call should reuse the same cached copy as well."; +} + +TEST(ImmutableBufferCacheTest, CachedCopyIsAnActualCopyNotTheOriginal) { + ImmutableBufferCache cache; + auto source = makeBuffer(); + + auto copy = cache.getOrCreate(source); + + EXPECT_NE(copy, source) << "The cached copy must be a distinct AudioBuffer instance. Sharing " + "the original directly would let a future mutation of it race with " + "a node concurrently reading the \"copy\"."; +} + +TEST(ImmutableBufferCacheTest, InvalidateForcesAFreshCopyOnce) { + ImmutableBufferCache cache; + auto source = makeBuffer(); + + auto first = cache.getOrCreate(source); + cache.invalidate(); + auto second = cache.getOrCreate(source); + auto third = cache.getOrCreate(source); + + EXPECT_NE(first, second) << "invalidate() means the source was just mutated in place, so the " + "previously cached copy is stale and must not be reused."; + EXPECT_EQ(second, third) << "After producing one fresh copy, subsequent calls should resume " + "caching normally rather than copying every time."; +} + +// NOLINTEND diff --git a/packages/react-native-audio-api/src/core/AudioBuffer.ts b/packages/react-native-audio-api/src/core/AudioBuffer.ts index b73fcf441..385d61ee2 100644 --- a/packages/react-native-audio-api/src/core/AudioBuffer.ts +++ b/packages/react-native-audio-api/src/core/AudioBuffer.ts @@ -56,6 +56,18 @@ export default class AudioBuffer implements AudioBufferLike { return data; } + /** + * Forgets the cached channel views once the native side has cut them off from + * the buffer (a source node acquired this buffer's content), so the next + * `getChannelData` hands out a fresh view the way a browser does after it + * detaches the old ones. + * + * @internal + */ + public invalidateChannelDataCache(): void { + this.channelDataCache.length = 0; + } + public copyFromChannel( destination: Float32Array, channelNumber: number, diff --git a/packages/react-native-audio-api/src/core/AudioBufferSourceNode.ts b/packages/react-native-audio-api/src/core/AudioBufferSourceNode.ts index e855e7a5b..b70699b7a 100644 --- a/packages/react-native-audio-api/src/core/AudioBufferSourceNode.ts +++ b/packages/react-native-audio-api/src/core/AudioBufferSourceNode.ts @@ -53,6 +53,12 @@ export default class AudioBufferSourceNode extends AudioBufferBaseSourceNode { (this.node as IAudioBufferSourceNode).setBuffer(buffer.buffer); this._buffer = buffer; this.bufferHasBeenSet = true; + + if (this.hasBeenStarted) { + // Assigning a buffer to an already-started source acquires its content right + // away, so native has just cut off the views this buffer handed out. + buffer.invalidateChannelDataCache(); + } } public get loopSkip(): boolean { @@ -112,6 +118,9 @@ export default class AudioBufferSourceNode extends AudioBufferBaseSourceNode { this.hasBeenStarted = true; (this.node as IAudioBufferSourceNode).start(when, offset, duration); + // Native cut off every view handed out by getChannelData() while acquiring the + // buffer's content, so the wrapper must stop returning those dead views. + this._buffer?.invalidateChannelDataCache(); this.context.markRunningOnSourceStart(); }