From 56f0f58911152880941427fbfce20512fee16bd9 Mon Sep 17 00:00:00 2001
From: maciejmakowski2003 <maciejmakowski2003@users.noreply.github.com>
Date: Tue, 17 Mar 2026 16:52:51 +0100
Subject: [PATCH 1/8] feat: ai slop long files playback node

---
 .../AudioVisualizer/AudioVisualizer.tsx       | 113 +++++++-----------
 .../BaseAudioContextHostObject.cpp            |  18 +++
 .../HostObjects/BaseAudioContextHostObject.h  |   1 +
 .../sources/AudioFileSourceNodeHostObject.cpp |  15 +++
 .../sources/AudioFileSourceNodeHostObject.h   |  22 ++++
 .../cpp/audioapi/core/BaseAudioContext.cpp    |   8 ++
 .../cpp/audioapi/core/BaseAudioContext.h      |   3 +
 .../core/sources/AudioFileSourceNode.cpp      | 108 +++++++++++++++++
 .../core/sources/AudioFileSourceNode.h        |  46 +++++++
 .../common/cpp/audioapi/types/NodeOptions.h   |   4 +
 packages/react-native-audio-api/src/api.ts    |   1 +
 .../src/core/AudioFileSourceNode.ts           |   9 ++
 .../src/core/BaseAudioContext.ts              |   5 +
 .../react-native-audio-api/src/interfaces.ts  |   3 +
 14 files changed, 289 insertions(+), 67 deletions(-)
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
 create mode 100644 packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
 create mode 100644 packages/react-native-audio-api/src/core/AudioFileSourceNode.ts

diff --git a/apps/common-app/src/examples/AudioVisualizer/AudioVisualizer.tsx b/apps/common-app/src/examples/AudioVisualizer/AudioVisualizer.tsx
index 731aba9c9..8e6960e88 100644
--- a/apps/common-app/src/examples/AudioVisualizer/AudioVisualizer.tsx
+++ b/apps/common-app/src/examples/AudioVisualizer/AudioVisualizer.tsx
@@ -2,9 +2,8 @@ import React, { useEffect, useRef, useState } from 'react';
 import { ActivityIndicator, View } from 'react-native';
 import {
   AnalyserNode,
-  AudioBuffer,
-  AudioBufferSourceNode,
   AudioContext,
+  AudioFileSourceNode,
 } from 'react-native-audio-api';
 
 import { Button, Container } from '../../components';
@@ -13,13 +12,13 @@ import FreqTimeChart from './FreqTimeChart';
 
 const FFT_SIZE = 512;
 
-const URL =
-  'https://software-mansion.github.io/react-native-audio-api/audio/music/example-music-02.mp3';
+const AUDIO_URL =
+  'https://upload.wikimedia.org/wikipedia/commons/9/91/Dl1bajkiwisdr.ddns.net_2026-02-02T18_39_07Z_4625.00_usb.wav';
 
 const AudioVisualizer: React.FC = () => {
   const [isPlaying, setIsPlaying] = useState(false);
   const [isLoading, setIsLoading] = useState(false);
-  const [audioBuffer, setAudioBuffer] = useState<AudioBuffer | null>(null);
+  const [arrayBuffer, setArrayBuffer] = useState<ArrayBuffer | null>(null);
 
   const [times, setTimes] = useState<Uint8Array>(
     new Uint8Array(FFT_SIZE).fill(127)
@@ -28,90 +27,70 @@ const AudioVisualizer: React.FC = () => {
     new Uint8Array(FFT_SIZE / 2).fill(0)
   );
 
-  const [startTime, setStartTime] = useState(0);
-  const [offset, setOffset] = useState(0);
-
   const audioContextRef = useRef<AudioContext | null>(null);
   const analyserRef = useRef<AnalyserNode | null>(null);
-  const bufferSourceRef = useRef<AudioBufferSourceNode | null>(null);
-
-  const handlePlayPause = () => {
-    if (isPlaying) {
-      const stopTime = audioContextRef.current!.currentTime;
-      bufferSourceRef.current?.stop(stopTime);
-      setOffset((prev) => prev + stopTime - startTime);
-    } else {
-      if (!audioContextRef.current || !analyserRef.current) {
-        return;
-      }
-
-      if (!audioBuffer) {
-        fetchAudioBuffer();
-      }
-
-      bufferSourceRef.current = audioContextRef.current.createBufferSource();
-      bufferSourceRef.current.buffer = audioBuffer;
-      bufferSourceRef.current.connect(analyserRef.current);
-
-      setStartTime(audioContextRef.current.currentTime);
-      bufferSourceRef.current.start(startTime, offset);
-
-      requestAnimationFrame(draw);
-    }
-
-    setIsPlaying((prev) => !prev);
-  };
+  const fileSourceRef = useRef<AudioFileSourceNode | null>(null);
+  const animFrameRef = useRef<number>(0);
 
   const draw = () => {
     if (!analyserRef.current) {
       return;
     }
 
-    const timesArrayLength = analyserRef.current.fftSize;
-    const frequencyArrayLength = analyserRef.current.frequencyBinCount;
-
-    const timesArray = new Uint8Array(timesArrayLength);
+    const timesArray = new Uint8Array(analyserRef.current.fftSize);
     analyserRef.current.getByteTimeDomainData(timesArray);
     setTimes(timesArray);
 
-    const freqsArray = new Uint8Array(frequencyArrayLength);
+    const freqsArray = new Uint8Array(analyserRef.current.frequencyBinCount);
     analyserRef.current.getByteFrequencyData(freqsArray);
     setFreqs(freqsArray);
 
-    requestAnimationFrame(draw);
+    // animFrameRef.current = requestAnimationFrame(draw);
   };
 
-  const fetchAudioBuffer = async () => {
-    setIsLoading(true);
-
-    const buffer = await fetch(URL)
-      .then((response) => response.arrayBuffer())
-      .then((arrayBuffer) =>
-        audioContextRef.current!.decodeAudioData(arrayBuffer)
-      )
-      .catch((error) => {
-        console.error('Error decoding audio data source:', error);
-        return null;
-      });
+  const handlePlayPause = () => {
+    if (!audioContextRef.current || !analyserRef.current || !arrayBuffer) {
+      return;
+    }
 
-    setAudioBuffer(buffer);
+    if (isPlaying) {
+      fileSourceRef.current?.stop(audioContextRef.current.currentTime);
+      fileSourceRef.current = null;
+      cancelAnimationFrame(animFrameRef.current);
+    } else {
+      fileSourceRef.current = audioContextRef.current.createAudioFileSource(
+        arrayBuffer
+      );
+      fileSourceRef.current.connect(audioContextRef.current.destination);
+      fileSourceRef.current.start(audioContextRef.current.currentTime);
+      // animFrameRef.current = requestAnimationFrame(draw);
+    }
 
-    setIsLoading(false);
+    setIsPlaying((prev) => !prev);
   };
 
   useEffect(() => {
-    if (!audioContextRef.current) {
-      audioContextRef.current = new AudioContext();
-    }
-
-    if (!analyserRef.current) {
-      analyserRef.current = new AnalyserNode(audioContextRef.current, { fftSize: FFT_SIZE, smoothingTimeConstant: 0.2 });
-      analyserRef.current.connect(audioContextRef.current.destination);
-    }
+    audioContextRef.current = new AudioContext();
+    analyserRef.current = new AnalyserNode(audioContextRef.current, {
+      fftSize: FFT_SIZE,
+      smoothingTimeConstant: 0.2,
+    });
+    // analyserRef.current.connect(audioContextRef.current.destination);
 
-    fetchAudioBuffer();
+    setIsLoading(true);
+    fetch(AUDIO_URL)
+      .then((response) => response.arrayBuffer())
+      .then((buffer) => {
+        setArrayBuffer(buffer);
+        setIsLoading(false);
+      })
+      .catch((error) => {
+        console.error('Error fetching audio:', error);
+        setIsLoading(false);
+      });
 
     return () => {
+      cancelAnimationFrame(animFrameRef.current);
       audioContextRef.current?.close();
     };
   }, []);
@@ -138,8 +117,8 @@ const AudioVisualizer: React.FC = () => {
           }}>
           <Button
             onPress={handlePlayPause}
-            title={isPlaying ? 'Pause' : 'Play'}
-            disabled={!audioBuffer}
+            title={isPlaying ? 'Stop' : 'Play'}
+            disabled={!arrayBuffer}
           />
         </View>
       </View>
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
index f4c22c8b2..7eae2ab14 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
@@ -14,6 +14,7 @@
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.h>
 #include <audioapi/HostObjects/sources/AudioBufferSourceNodeHostObject.h>
+#include <audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h>
 #include <audioapi/HostObjects/sources/ConstantSourceNodeHostObject.h>
 #include <audioapi/HostObjects/sources/OscillatorNodeHostObject.h>
 #include <audioapi/HostObjects/sources/RecorderAdapterNodeHostObject.h>
@@ -58,6 +59,7 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBiquadFilter),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createIIRFilter),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBufferSource),
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createFileSource),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBufferQueueSource),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createPeriodicWave),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createConvolver),
@@ -250,6 +252,22 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferSource) {
   return jsi::Object::createFromHostObject(runtime, bufferSourceHostObject);
 }
 
+JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createFileSource) {
+  AudioFileSourceOptions options;
+  if (count > 0 && !args[0].isUndefined() && !args[0].isNull()) {
+    auto obj = args[0].asObject(runtime);
+    if (obj.isArrayBuffer(runtime)) {
+      auto arrayBuffer = obj.getArrayBuffer(runtime);
+      auto *data = arrayBuffer.data(runtime);
+      auto size = arrayBuffer.size(runtime);
+      options.data = std::vector<uint8_t>(data, data + size);
+    }
+  }
+  const auto fileSourceHostObject =
+      std::make_shared<AudioFileSourceNodeHostObject>(context_, options);
+  return jsi::Object::createFromHostObject(runtime, fileSourceHostObject);
+}
+
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferQueueSource) {
   const auto options = args[0].asObject(runtime);
   const auto baseAudioBufferSourceOptions =
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h
index 052538058..4041f8f51 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.h
@@ -39,6 +39,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION_DECL(createBiquadFilter);
   JSI_HOST_FUNCTION_DECL(createIIRFilter);
   JSI_HOST_FUNCTION_DECL(createBufferSource);
+  JSI_HOST_FUNCTION_DECL(createFileSource);
   JSI_HOST_FUNCTION_DECL(createBufferQueueSource);
   JSI_HOST_FUNCTION_DECL(createPeriodicWave);
   JSI_HOST_FUNCTION_DECL(createAnalyser);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
new file mode 100644
index 000000000..374f6e5ea
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
@@ -0,0 +1,15 @@
+#include <audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h>
+
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/sources/AudioFileSourceNode.h>
+#include <audioapi/types/NodeOptions.h>
+#include <memory>
+
+namespace audioapi {
+
+AudioFileSourceNodeHostObject::AudioFileSourceNodeHostObject(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const AudioFileSourceOptions &options)
+    : AudioScheduledSourceNodeHostObject(context->createFileSource(options), options) {}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h
new file mode 100644
index 000000000..28c8b8771
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h>
+
+#include <memory>
+
+namespace audioapi {
+using namespace facebook;
+
+struct AudioFileSourceOptions;
+class BaseAudioContext;
+
+class AudioFileSourceNodeHostObject : public AudioScheduledSourceNodeHostObject {
+ public:
+  explicit AudioFileSourceNodeHostObject(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const AudioFileSourceOptions &options);
+
+  ~AudioFileSourceNodeHostObject() override = default;
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
index 67e4013e0..98ea980d4 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
@@ -12,6 +12,7 @@
 #include <audioapi/core/effects/WorkletProcessingNode.h>
 #include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
 #include <audioapi/core/sources/AudioBufferSourceNode.h>
+#include <audioapi/core/sources/AudioFileSourceNode.h>
 #include <audioapi/core/sources/ConstantSourceNode.h>
 #include <audioapi/core/sources/OscillatorNode.h>
 #include <audioapi/core/sources/RecorderAdapterNode.h>
@@ -177,6 +178,13 @@ std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource(
   return bufferSource;
 }
 
+std::shared_ptr<AudioFileSourceNode> BaseAudioContext::createFileSource(
+    const AudioFileSourceOptions &options) {
+  auto fileSource = std::make_shared<AudioFileSourceNode>(shared_from_this(), options);
+  graphManager_->addSourceNode(fileSource);
+  return fileSource;
+}
+
 std::shared_ptr<IIRFilterNode> BaseAudioContext::createIIRFilter(const IIRFilterOptions &options) {
   auto iirFilter = std::make_shared<IIRFilterNode>(shared_from_this(), options);
   graphManager_->addProcessingNode(iirFilter);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
index e3f52fd28..dd2c9c74e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
@@ -28,6 +28,7 @@ class IIRFilterNode;
 class AudioDestinationNode;
 class AudioBufferSourceNode;
 class AudioBufferQueueSourceNode;
+class AudioFileSourceNode;
 class AnalyserNode;
 class AudioEventHandlerRegistry;
 class ConvolverNode;
@@ -47,6 +48,7 @@ struct BiquadFilterOptions;
 struct OscillatorOptions;
 struct BaseAudioBufferSourceOptions;
 struct AudioBufferSourceOptions;
+struct AudioFileSourceOptions;
 struct StreamerOptions;
 struct DelayOptions;
 struct IIRFilterOptions;
@@ -93,6 +95,7 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
   std::shared_ptr<BiquadFilterNode> createBiquadFilter(const BiquadFilterOptions &options);
   std::shared_ptr<AudioBufferSourceNode> createBufferSource(
       const AudioBufferSourceOptions &options);
+  std::shared_ptr<AudioFileSourceNode> createFileSource(const AudioFileSourceOptions &options);
   std::shared_ptr<AudioBufferQueueSourceNode> createBufferQueueSource(
       const BaseAudioBufferSourceOptions &options);
   std::shared_ptr<PeriodicWave> createPeriodicWave(
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
new file mode 100644
index 000000000..a54a28dc9
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
@@ -0,0 +1,108 @@
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/sources/AudioFileSourceNode.h>
+#include <audioapi/core/utils/Constants.h>
+#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/types/NodeOptions.h>
+
+#include <memory>
+#include <utility>
+
+namespace audioapi {
+
+AudioFileSourceNode::AudioFileSourceNode(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const AudioFileSourceOptions &options)
+    : AudioScheduledSourceNode(context, options) {
+  if (!options.data.empty()) {
+    auto state = std::make_shared<AudioFileDecoderState>();
+    state->memoryData = options.data;
+
+    ma_decoder_config config =
+        ma_decoder_config_init(ma_format_f32, 0, static_cast<ma_uint32>(context->getSampleRate()));
+    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 result = ma_decoder_init_memory(
+        state->memoryData.data(), state->memoryData.size(), &config, &state->decoder);
+    if (result == MA_SUCCESS) {
+      state->channels = static_cast<int>(state->decoder.outputChannels);
+      state->sampleRate = static_cast<float>(state->decoder.outputSampleRate);
+      state->interleavedBuffer.resize(RENDER_QUANTUM_SIZE * state->channels);
+      decoderState_ = std::move(state);
+      channelCount_ = decoderState_->channels;
+    }
+  }
+
+  isInitialized_.store(true, std::memory_order_release);
+}
+
+void AudioFileSourceNode::setDecoderState(const std::shared_ptr<AudioFileDecoderState> &state) {
+  decoderState_ = state;
+  channelCount_ = state != nullptr ? state->channels : 1;
+}
+
+void AudioFileSourceNode::disable() {
+  AudioScheduledSourceNode::disable();
+}
+
+std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processNode(
+    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
+    int framesToProcess) {
+  if (decoderState_ == nullptr) {
+    processingBuffer->zero();
+    return processingBuffer;
+  }
+
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr) {
+    processingBuffer->zero();
+    return processingBuffer;
+  }
+
+  size_t startOffset = 0;
+  size_t nonSilentFrames = 0;
+  updatePlaybackInfo(
+      processingBuffer,
+      framesToProcess,
+      startOffset,
+      nonSilentFrames,
+      context->getSampleRate(),
+      context->getCurrentSampleFrame());
+
+  if (!isPlaying() && !isStopScheduled()) {
+    processingBuffer->zero();
+    return processingBuffer;
+  }
+
+  if (startOffset > 0) {
+    processingBuffer->zero(0, startOffset);
+  }
+
+  auto &state = *decoderState_;
+  ma_uint64 framesRead = 0;
+  ma_decoder_read_pcm_frames(
+      &state.decoder, state.interleavedBuffer.data(), nonSilentFrames, &framesRead);
+
+  int numOutputChannels = processingBuffer->getNumberOfChannels();
+  for (size_t i = 0; i < framesRead; i++) {
+    for (int ch = 0; ch < numOutputChannels; ch++) {
+      int srcCh = ch < state.channels ? ch : state.channels - 1;
+      processingBuffer->getChannel(ch)->span()[startOffset + i] =
+          state.interleavedBuffer[i * state.channels + srcCh];
+    }
+  }
+
+  if (framesRead < nonSilentFrames) {
+    processingBuffer->zero(startOffset + framesRead, nonSilentFrames - framesRead);
+    playbackState_ = PlaybackState::STOP_SCHEDULED;
+  }
+
+  handleStopScheduled();
+  return processingBuffer;
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
new file mode 100644
index 000000000..ea718e391
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <audioapi/libs/miniaudio/miniaudio.h>
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+struct AudioFileSourceOptions;
+
+struct AudioFileDecoderState {
+  ma_decoder decoder;
+  std::vector<uint8_t> memoryData;      // keeps memory alive for memory-based decoder
+  std::vector<float> interleavedBuffer; // pre-allocated read buffer
+  int channels = 0;
+  float sampleRate = 0;
+
+  ~AudioFileDecoderState() {
+    ma_decoder_uninit(&decoder);
+  }
+};
+
+class AudioFileSourceNode : public AudioScheduledSourceNode {
+ public:
+  explicit AudioFileSourceNode(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const AudioFileSourceOptions &options);
+  ~AudioFileSourceNode() override = default;
+
+  /// @note Audio Thread only
+  void setDecoderState(const std::shared_ptr<AudioFileDecoderState> &state);
+
+  void disable() override;
+
+ protected:
+  std::shared_ptr<DSPAudioBuffer> processNode(
+      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
+      int framesToProcess) override;
+
+ private:
+  std::shared_ptr<AudioFileDecoderState> decoderState_;
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/types/NodeOptions.h b/packages/react-native-audio-api/common/cpp/audioapi/types/NodeOptions.h
index b2df4a479..ed44abaea 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/types/NodeOptions.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/types/NodeOptions.h
@@ -111,6 +111,10 @@ struct AudioBufferSourceOptions : BaseAudioBufferSourceOptions {
   }
 };
 
+struct AudioFileSourceOptions : AudioScheduledSourceNodeOptions {
+  std::vector<uint8_t> data;
+};
+
 struct StreamerOptions : AudioScheduledSourceNodeOptions {
   std::string streamPath;
 };
diff --git a/packages/react-native-audio-api/src/api.ts b/packages/react-native-audio-api/src/api.ts
index 2cd0f3728..b2e369df7 100644
--- a/packages/react-native-audio-api/src/api.ts
+++ b/packages/react-native-audio-api/src/api.ts
@@ -4,6 +4,7 @@ export { default as AnalyserNode } from './core/AnalyserNode';
 export { default as AudioBuffer } from './core/AudioBuffer';
 export { default as AudioBufferQueueSourceNode } from './core/AudioBufferQueueSourceNode';
 export { default as AudioBufferSourceNode } from './core/AudioBufferSourceNode';
+export { default as AudioFileSourceNode } from './core/AudioFileSourceNode';
 export { default as AudioContext } from './core/AudioContext';
 export { decodeAudioData, decodePCMInBase64 } from './core/AudioDecoder';
 export { default as AudioDestinationNode } from './core/AudioDestinationNode';
diff --git a/packages/react-native-audio-api/src/core/AudioFileSourceNode.ts b/packages/react-native-audio-api/src/core/AudioFileSourceNode.ts
new file mode 100644
index 000000000..5f78ddb17
--- /dev/null
+++ b/packages/react-native-audio-api/src/core/AudioFileSourceNode.ts
@@ -0,0 +1,9 @@
+import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+import BaseAudioContext from './BaseAudioContext';
+
+export default class AudioFileSourceNode extends AudioScheduledSourceNode {
+  constructor(context: BaseAudioContext, arrayBuffer: ArrayBuffer) {
+    const node = context.context.createFileSource(arrayBuffer);
+    super(context, node);
+  }
+}
diff --git a/packages/react-native-audio-api/src/core/BaseAudioContext.ts b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
index 55d354e4e..67f108e77 100644
--- a/packages/react-native-audio-api/src/core/BaseAudioContext.ts
+++ b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
@@ -10,6 +10,7 @@ import AnalyserNode from './AnalyserNode';
 import AudioBuffer from './AudioBuffer';
 import AudioBufferQueueSourceNode from './AudioBufferQueueSourceNode';
 import AudioBufferSourceNode from './AudioBufferSourceNode';
+import AudioFileSourceNode from './AudioFileSourceNode';
 import { decodeAudioData, decodePCMInBase64 } from './AudioDecoder';
 import AudioDestinationNode from './AudioDestinationNode';
 import BiquadFilterNode from './BiquadFilterNode';
@@ -134,6 +135,10 @@ export default class BaseAudioContext {
     return new StreamerNode(this, { streamPath });
   }
 
+  createAudioFileSource(arrayBuffer: ArrayBuffer): AudioFileSourceNode {
+    return new AudioFileSourceNode(this, arrayBuffer);
+  }
+
   createConstantSource(): ConstantSourceNode {
     return new ConstantSourceNode(this);
   }
diff --git a/packages/react-native-audio-api/src/interfaces.ts b/packages/react-native-audio-api/src/interfaces.ts
index bc3ff0481..26a88735f 100644
--- a/packages/react-native-audio-api/src/interfaces.ts
+++ b/packages/react-native-audio-api/src/interfaces.ts
@@ -102,6 +102,7 @@ export interface IBaseAudioContext {
   createConvolver: (convolverOptions?: IConvolverOptions) => IConvolverNode;
   createStreamer: (streamerOptions: StreamerOptions) => IStreamerNode | null; // null when FFmpeg is not enabled
   createWaveShaper: (waveShaperOptions?: WaveShaperOptions) => IWaveShaperNode;
+  createFileSource: (arrayBuffer: ArrayBuffer) => IAudioFileSourceNode;
 }
 
 export interface IAudioContext extends IBaseAudioContext {
@@ -228,6 +229,8 @@ export interface IAudioBufferQueueSourceNode
   onBufferEnded: string;
 }
 
+export interface IAudioFileSourceNode extends IAudioScheduledSourceNode {}
+
 export interface IConvolverNode extends IAudioNode {
   readonly buffer: IAudioBuffer | null;
   normalize: boolean;

From 429310a695e64b54befe2cadcd6b1f96e2ebab47 Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Tue, 17 Mar 2026 17:19:18 +0100
Subject: [PATCH 2/8] feat: file playback

---
 .../BaseAudioContextHostObject.cpp            | 16 +++++++++------
 .../core/sources/AudioFileSourceNode.cpp      | 20 +++++++++++++++----
 .../common/cpp/audioapi/types/NodeOptions.h   |  1 +
 .../src/core/AudioFileSourceNode.ts           |  4 ++--
 .../src/core/BaseAudioContext.ts              |  4 ++--
 .../react-native-audio-api/src/interfaces.ts  |  2 +-
 6 files changed, 32 insertions(+), 15 deletions(-)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
index 7eae2ab14..4aec47875 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp
@@ -255,12 +255,16 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferSource) {
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createFileSource) {
   AudioFileSourceOptions options;
   if (count > 0 && !args[0].isUndefined() && !args[0].isNull()) {
-    auto obj = args[0].asObject(runtime);
-    if (obj.isArrayBuffer(runtime)) {
-      auto arrayBuffer = obj.getArrayBuffer(runtime);
-      auto *data = arrayBuffer.data(runtime);
-      auto size = arrayBuffer.size(runtime);
-      options.data = std::vector<uint8_t>(data, data + size);
+    if (args[0].isString()) {
+      options.filePath = args[0].getString(runtime).utf8(runtime);
+    } else {
+      auto obj = args[0].asObject(runtime);
+      if (obj.isArrayBuffer(runtime)) {
+        auto arrayBuffer = obj.getArrayBuffer(runtime);
+        auto *data = arrayBuffer.data(runtime);
+        auto size = arrayBuffer.size(runtime);
+        options.data = std::vector<uint8_t>(data, data + size);
+      }
     }
   }
   const auto fileSourceHostObject =
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
index a54a28dc9..4527b20e9 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
@@ -6,6 +6,7 @@
 #include <audioapi/libs/miniaudio/miniaudio.h>
 #include <audioapi/types/NodeOptions.h>
 
+#include <cstdio>
 #include <memory>
 #include <utility>
 
@@ -15,9 +16,14 @@ AudioFileSourceNode::AudioFileSourceNode(
     const std::shared_ptr<BaseAudioContext> &context,
     const AudioFileSourceOptions &options)
     : AudioScheduledSourceNode(context, options) {
-  if (!options.data.empty()) {
+  const bool useFilePath = !options.filePath.empty();
+  const bool useData = !options.data.empty();
+
+  if (useFilePath || useData) {
     auto state = std::make_shared<AudioFileDecoderState>();
-    state->memoryData = options.data;
+    if (useData) {
+      state->memoryData = options.data;
+    }
 
     ma_decoder_config config =
         ma_decoder_config_init(ma_format_f32, 0, static_cast<ma_uint32>(context->getSampleRate()));
@@ -26,8 +32,14 @@ AudioFileSourceNode::AudioFileSourceNode(
     config.ppCustomBackendVTables = customBackends;
     config.customBackendCount = sizeof(customBackends) / sizeof(customBackends[0]);
 
-    ma_result result = ma_decoder_init_memory(
-        state->memoryData.data(), state->memoryData.size(), &config, &state->decoder);
+    ma_result result;
+    if (useFilePath) {
+      result = ma_decoder_init_file(options.filePath.c_str(), &config, &state->decoder);
+    } else {
+      result = ma_decoder_init_memory(
+          state->memoryData.data(), state->memoryData.size(), &config, &state->decoder);
+    }
+
     if (result == MA_SUCCESS) {
       state->channels = static_cast<int>(state->decoder.outputChannels);
       state->sampleRate = static_cast<float>(state->decoder.outputSampleRate);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/types/NodeOptions.h b/packages/react-native-audio-api/common/cpp/audioapi/types/NodeOptions.h
index ed44abaea..0174c1434 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/types/NodeOptions.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/types/NodeOptions.h
@@ -113,6 +113,7 @@ struct AudioBufferSourceOptions : BaseAudioBufferSourceOptions {
 
 struct AudioFileSourceOptions : AudioScheduledSourceNodeOptions {
   std::vector<uint8_t> data;
+  std::string filePath;
 };
 
 struct StreamerOptions : AudioScheduledSourceNodeOptions {
diff --git a/packages/react-native-audio-api/src/core/AudioFileSourceNode.ts b/packages/react-native-audio-api/src/core/AudioFileSourceNode.ts
index 5f78ddb17..ef19e7c3a 100644
--- a/packages/react-native-audio-api/src/core/AudioFileSourceNode.ts
+++ b/packages/react-native-audio-api/src/core/AudioFileSourceNode.ts
@@ -2,8 +2,8 @@ import AudioScheduledSourceNode from './AudioScheduledSourceNode';
 import BaseAudioContext from './BaseAudioContext';
 
 export default class AudioFileSourceNode extends AudioScheduledSourceNode {
-  constructor(context: BaseAudioContext, arrayBuffer: ArrayBuffer) {
-    const node = context.context.createFileSource(arrayBuffer);
+  constructor(context: BaseAudioContext, source: ArrayBuffer | string) {
+    const node = context.context.createFileSource(source);
     super(context, node);
   }
 }
diff --git a/packages/react-native-audio-api/src/core/BaseAudioContext.ts b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
index 67f108e77..09bc19baa 100644
--- a/packages/react-native-audio-api/src/core/BaseAudioContext.ts
+++ b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
@@ -135,8 +135,8 @@ export default class BaseAudioContext {
     return new StreamerNode(this, { streamPath });
   }
 
-  createAudioFileSource(arrayBuffer: ArrayBuffer): AudioFileSourceNode {
-    return new AudioFileSourceNode(this, arrayBuffer);
+  createAudioFileSource(source: ArrayBuffer | string): AudioFileSourceNode {
+    return new AudioFileSourceNode(this, source);
   }
 
   createConstantSource(): ConstantSourceNode {
diff --git a/packages/react-native-audio-api/src/interfaces.ts b/packages/react-native-audio-api/src/interfaces.ts
index 26a88735f..fd5f92c8f 100644
--- a/packages/react-native-audio-api/src/interfaces.ts
+++ b/packages/react-native-audio-api/src/interfaces.ts
@@ -102,7 +102,7 @@ export interface IBaseAudioContext {
   createConvolver: (convolverOptions?: IConvolverOptions) => IConvolverNode;
   createStreamer: (streamerOptions: StreamerOptions) => IStreamerNode | null; // null when FFmpeg is not enabled
   createWaveShaper: (waveShaperOptions?: WaveShaperOptions) => IWaveShaperNode;
-  createFileSource: (arrayBuffer: ArrayBuffer) => IAudioFileSourceNode;
+  createFileSource: (source: ArrayBuffer | string) => IAudioFileSourceNode;
 }
 
 export interface IAudioContext extends IBaseAudioContext {

From feaecf6961fb040109e542b62a7e1196e248a00d Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Wed, 18 Mar 2026 14:46:08 +0100
Subject: [PATCH 3/8] feat: working ffmpeg files playback

---
 .../src/examples/AudioStream/AudioStream.tsx  |  77 +++
 .../src/examples/AudioStream/index.ts         |   0
 .../AudioVisualizer/AudioVisualizer.tsx       | 113 ++--
 apps/common-app/src/examples/index.ts         |   8 +
 .../ios/FabricExample/AppDelegate.swift       |   5 +
 apps/fabric-example/ios/Podfile.lock          |   6 +-
 .../core/sources/AudioFileSourceNode.cpp      |  89 ++-
 .../core/sources/AudioFileSourceNode.h        |   4 +
 .../cpp/audioapi/core/utils/AudioDecoder.h    |  24 +-
 .../audioapi/libs/ffmpeg/FFmpegDecoding.cpp   | 606 +++++++++++-------
 .../cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h | 129 ++--
 .../common/cpp/cursor/CMakeLists.txt          |   2 +-
 12 files changed, 706 insertions(+), 357 deletions(-)
 create mode 100644 apps/common-app/src/examples/AudioStream/AudioStream.tsx
 create mode 100644 apps/common-app/src/examples/AudioStream/index.ts

diff --git a/apps/common-app/src/examples/AudioStream/AudioStream.tsx b/apps/common-app/src/examples/AudioStream/AudioStream.tsx
new file mode 100644
index 000000000..b89a6c9e4
--- /dev/null
+++ b/apps/common-app/src/examples/AudioStream/AudioStream.tsx
@@ -0,0 +1,77 @@
+import React, { useEffect, useRef, useState } from 'react';
+import { ActivityIndicator, View } from 'react-native';
+import { AudioContext, AudioFileSourceNode } from 'react-native-audio-api';
+
+import { Button, Container } from '../../components';
+import { layout } from '../../styles';
+
+/** Small public WAV for demo (works with miniaudio file decoder). */
+const DEMO_AUDIO_URL =
+  'https://filesamples.com/samples/audio/aac/sample4.aac';
+  // '/Users/michal/Library/Developer/CoreSimulator/Devices/BD13B970-9C15-4FB4-91C8-38CBFFFDD3B8/data/Containers/Data/Application/40127BF3-30D7-44BD-9AFC-34DB21106188/Documents/audio.aac';
+
+const AudioStream: React.FC = () => {
+  const [playing, setPlaying] = useState(false);
+  const [loading, setLoading] = useState(false);
+  const [buffer, setBuffer] = useState<ArrayBuffer | string | null>(null);
+
+  const ctxRef = useRef<AudioContext | null>(null);
+  const sourceRef = useRef<AudioFileSourceNode | null>(null);
+
+  useEffect(() => {
+    ctxRef.current = new AudioContext();
+    setLoading(true);
+
+    if (DEMO_AUDIO_URL.startsWith('https')) {
+      fetch(DEMO_AUDIO_URL)
+          .then((r) => r.arrayBuffer())
+          .then(setBuffer)
+          .finally(() => setLoading(false));
+    } else {
+      setBuffer(DEMO_AUDIO_URL);
+      setLoading(false);
+    }
+    return () => {
+      sourceRef.current?.stop(0);
+      ctxRef.current?.close();
+    };
+  }, []);
+
+  const toggle = async () => {
+    const ctx = ctxRef.current;
+    if (!ctx || !buffer) return;
+
+    if (playing) {
+      sourceRef.current?.stop(ctx.currentTime);
+      sourceRef.current = null;
+      setPlaying(false);
+      return;
+    }
+
+    await ctx.resume();
+
+    const source = ctx.createAudioFileSource(buffer);
+    source.connect(ctx.destination);
+    source.start(ctx.currentTime);
+
+    sourceRef.current = source;
+    setPlaying(true);
+  };
+
+  return (
+    <Container disablePadding>
+      <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
+        {loading && <ActivityIndicator color="#fff" />}
+        <View style={{ marginTop: layout.spacing * 2 }}>
+          <Button
+            onPress={toggle}
+            title={playing ? 'Stop' : 'Play'}
+            disabled={!buffer || loading}
+          />
+        </View>
+      </View>
+    </Container>
+  );
+};
+
+export default AudioStream;
diff --git a/apps/common-app/src/examples/AudioStream/index.ts b/apps/common-app/src/examples/AudioStream/index.ts
new file mode 100644
index 000000000..e69de29bb
diff --git a/apps/common-app/src/examples/AudioVisualizer/AudioVisualizer.tsx b/apps/common-app/src/examples/AudioVisualizer/AudioVisualizer.tsx
index 8e6960e88..731aba9c9 100644
--- a/apps/common-app/src/examples/AudioVisualizer/AudioVisualizer.tsx
+++ b/apps/common-app/src/examples/AudioVisualizer/AudioVisualizer.tsx
@@ -2,8 +2,9 @@ import React, { useEffect, useRef, useState } from 'react';
 import { ActivityIndicator, View } from 'react-native';
 import {
   AnalyserNode,
+  AudioBuffer,
+  AudioBufferSourceNode,
   AudioContext,
-  AudioFileSourceNode,
 } from 'react-native-audio-api';
 
 import { Button, Container } from '../../components';
@@ -12,13 +13,13 @@ import FreqTimeChart from './FreqTimeChart';
 
 const FFT_SIZE = 512;
 
-const AUDIO_URL =
-  'https://upload.wikimedia.org/wikipedia/commons/9/91/Dl1bajkiwisdr.ddns.net_2026-02-02T18_39_07Z_4625.00_usb.wav';
+const URL =
+  'https://software-mansion.github.io/react-native-audio-api/audio/music/example-music-02.mp3';
 
 const AudioVisualizer: React.FC = () => {
   const [isPlaying, setIsPlaying] = useState(false);
   const [isLoading, setIsLoading] = useState(false);
-  const [arrayBuffer, setArrayBuffer] = useState<ArrayBuffer | null>(null);
+  const [audioBuffer, setAudioBuffer] = useState<AudioBuffer | null>(null);
 
   const [times, setTimes] = useState<Uint8Array>(
     new Uint8Array(FFT_SIZE).fill(127)
@@ -27,70 +28,90 @@ const AudioVisualizer: React.FC = () => {
     new Uint8Array(FFT_SIZE / 2).fill(0)
   );
 
+  const [startTime, setStartTime] = useState(0);
+  const [offset, setOffset] = useState(0);
+
   const audioContextRef = useRef<AudioContext | null>(null);
   const analyserRef = useRef<AnalyserNode | null>(null);
-  const fileSourceRef = useRef<AudioFileSourceNode | null>(null);
-  const animFrameRef = useRef<number>(0);
+  const bufferSourceRef = useRef<AudioBufferSourceNode | null>(null);
+
+  const handlePlayPause = () => {
+    if (isPlaying) {
+      const stopTime = audioContextRef.current!.currentTime;
+      bufferSourceRef.current?.stop(stopTime);
+      setOffset((prev) => prev + stopTime - startTime);
+    } else {
+      if (!audioContextRef.current || !analyserRef.current) {
+        return;
+      }
+
+      if (!audioBuffer) {
+        fetchAudioBuffer();
+      }
+
+      bufferSourceRef.current = audioContextRef.current.createBufferSource();
+      bufferSourceRef.current.buffer = audioBuffer;
+      bufferSourceRef.current.connect(analyserRef.current);
+
+      setStartTime(audioContextRef.current.currentTime);
+      bufferSourceRef.current.start(startTime, offset);
+
+      requestAnimationFrame(draw);
+    }
+
+    setIsPlaying((prev) => !prev);
+  };
 
   const draw = () => {
     if (!analyserRef.current) {
       return;
     }
 
-    const timesArray = new Uint8Array(analyserRef.current.fftSize);
+    const timesArrayLength = analyserRef.current.fftSize;
+    const frequencyArrayLength = analyserRef.current.frequencyBinCount;
+
+    const timesArray = new Uint8Array(timesArrayLength);
     analyserRef.current.getByteTimeDomainData(timesArray);
     setTimes(timesArray);
 
-    const freqsArray = new Uint8Array(analyserRef.current.frequencyBinCount);
+    const freqsArray = new Uint8Array(frequencyArrayLength);
     analyserRef.current.getByteFrequencyData(freqsArray);
     setFreqs(freqsArray);
 
-    // animFrameRef.current = requestAnimationFrame(draw);
+    requestAnimationFrame(draw);
   };
 
-  const handlePlayPause = () => {
-    if (!audioContextRef.current || !analyserRef.current || !arrayBuffer) {
-      return;
-    }
+  const fetchAudioBuffer = async () => {
+    setIsLoading(true);
 
-    if (isPlaying) {
-      fileSourceRef.current?.stop(audioContextRef.current.currentTime);
-      fileSourceRef.current = null;
-      cancelAnimationFrame(animFrameRef.current);
-    } else {
-      fileSourceRef.current = audioContextRef.current.createAudioFileSource(
-        arrayBuffer
-      );
-      fileSourceRef.current.connect(audioContextRef.current.destination);
-      fileSourceRef.current.start(audioContextRef.current.currentTime);
-      // animFrameRef.current = requestAnimationFrame(draw);
-    }
+    const buffer = await fetch(URL)
+      .then((response) => response.arrayBuffer())
+      .then((arrayBuffer) =>
+        audioContextRef.current!.decodeAudioData(arrayBuffer)
+      )
+      .catch((error) => {
+        console.error('Error decoding audio data source:', error);
+        return null;
+      });
 
-    setIsPlaying((prev) => !prev);
+    setAudioBuffer(buffer);
+
+    setIsLoading(false);
   };
 
   useEffect(() => {
-    audioContextRef.current = new AudioContext();
-    analyserRef.current = new AnalyserNode(audioContextRef.current, {
-      fftSize: FFT_SIZE,
-      smoothingTimeConstant: 0.2,
-    });
-    // analyserRef.current.connect(audioContextRef.current.destination);
+    if (!audioContextRef.current) {
+      audioContextRef.current = new AudioContext();
+    }
 
-    setIsLoading(true);
-    fetch(AUDIO_URL)
-      .then((response) => response.arrayBuffer())
-      .then((buffer) => {
-        setArrayBuffer(buffer);
-        setIsLoading(false);
-      })
-      .catch((error) => {
-        console.error('Error fetching audio:', error);
-        setIsLoading(false);
-      });
+    if (!analyserRef.current) {
+      analyserRef.current = new AnalyserNode(audioContextRef.current, { fftSize: FFT_SIZE, smoothingTimeConstant: 0.2 });
+      analyserRef.current.connect(audioContextRef.current.destination);
+    }
+
+    fetchAudioBuffer();
 
     return () => {
-      cancelAnimationFrame(animFrameRef.current);
       audioContextRef.current?.close();
     };
   }, []);
@@ -117,8 +138,8 @@ const AudioVisualizer: React.FC = () => {
           }}>
           <Button
             onPress={handlePlayPause}
-            title={isPlaying ? 'Stop' : 'Play'}
-            disabled={!arrayBuffer}
+            title={isPlaying ? 'Pause' : 'Play'}
+            disabled={!audioBuffer}
           />
         </View>
       </View>
diff --git a/apps/common-app/src/examples/index.ts b/apps/common-app/src/examples/index.ts
index 554dcaf49..112443157 100644
--- a/apps/common-app/src/examples/index.ts
+++ b/apps/common-app/src/examples/index.ts
@@ -12,6 +12,7 @@ import PlaybackSpeed from './PlaybackSpeed/PlaybackSpeed';
 import Record from './Record/Record';
 import Streaming from './Streaming/Streaming';
 import Worklets from './Worklets/Worklets';
+import AudioStream from './AudioStream/AudioStream';
 
 type NavigationParamList = {
   Oscillator: undefined;
@@ -26,6 +27,7 @@ type NavigationParamList = {
   Record: undefined;
   Worklets: undefined;
   Streamer: undefined;
+  AudioStream: undefined;
 };
 
 export type ExampleKey = keyof NavigationParamList;
@@ -110,4 +112,10 @@ export const Examples: Example[] = [
     Icon: icons.Radio,
     screen: Streaming,
   },
+  {
+    key: 'AudioStream',
+    title: 'Audio Stream',
+    Icon: icons.Music,
+    screen: AudioStream,
+  }
 ] as const;
diff --git a/apps/fabric-example/ios/FabricExample/AppDelegate.swift b/apps/fabric-example/ios/FabricExample/AppDelegate.swift
index 3e7e49895..58a3fcf48 100644
--- a/apps/fabric-example/ios/FabricExample/AppDelegate.swift
+++ b/apps/fabric-example/ios/FabricExample/AppDelegate.swift
@@ -28,6 +28,11 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
       in: window,
       launchOptions: launchOptions
     )
+    let fileManager = FileManager.default
+    let docsURL = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first!
+    let filePath = docsURL.appendingPathComponent("audio.wav").path
+    
+    print(filePath);
 
     return true
   }
diff --git a/apps/fabric-example/ios/Podfile.lock b/apps/fabric-example/ios/Podfile.lock
index a344b24dc..0ff51c1dc 100644
--- a/apps/fabric-example/ios/Podfile.lock
+++ b/apps/fabric-example/ios/Podfile.lock
@@ -2514,7 +2514,7 @@ EXTERNAL SOURCES:
 
 SPEC CHECKSUMS:
   FBLazyVector: e97c19a5a442429d1988f182a1940fb08df514da
-  hermes-engine: ca0c1d4fe0200e05fedd8d7c0c283b54cd461436
+  hermes-engine: 471e81260adadffc041e40c5eea01333addabb53
   RCTDeprecation: af44b104091a34482596cd9bd7e8d90c4e9b4bd7
   RCTRequired: bb77b070f75f53398ce43c0aaaa58337cebe2bf6
   RCTSwiftUI: afc0a0a635860da1040a0b894bfd529da06d7810
@@ -2523,7 +2523,7 @@ SPEC CHECKSUMS:
   React: 1ba7d364ade7d883a1ec055bfc3606f35fdee17b
   React-callinvoker: bc2a26f8d84fb01f003fc6de6c9337b64715f95b
   React-Core: 7840d3a80b43a95c5e80ef75146bd70925ebab0f
-  React-Core-prebuilt: e44365cf4785c3aa56ababc9ab204fe8bc6b17d0
+  React-Core-prebuilt: 6586031f606ff8ab466cac9e8284053a91342881
   React-CoreModules: 2eb010400b63b89e53a324ffb3c112e4c7c3ce42
   React-cxxreact: a558e92199d26f145afa9e62c4233cf8e7950efe
   React-debug: 755200a6e7f5e6e0a40ff8d215493d43cce285fc
@@ -2587,7 +2587,7 @@ SPEC CHECKSUMS:
   ReactAppDependencyProvider: e96e93b493d8d86eeaee3e590ba0be53f6abe46f
   ReactCodegen: f66521b131699d6af0790f10653933b3f1f79a6f
   ReactCommon: 07572bf9e687c8a52fbe4a3641e9e3a1a477c78e
-  ReactNativeDependencies: 3467a1fea6f7a524df13b30430bebcc254d9aee2
+  ReactNativeDependencies: a5d71d95f2654107eb45e6ece04caba36beac2bd
   RNAudioAPI: fa5c075d2fcdb1ad9a695754b38f07c8c3074396
   RNGestureHandler: 07de6f059e0ee5744ae9a56feb07ee345338cc31
   RNReanimated: d75c81956bf7531fe08ba4390149002ab8bdd127
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
index 4527b20e9..0e0da8234 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
@@ -1,6 +1,8 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/AudioFileSourceNode.h>
+#include <audioapi/core/utils/AudioDecoder.h>
 #include <audioapi/core/utils/Constants.h>
+#include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
 #include <audioapi/libs/miniaudio/decoders/libopus/miniaudio_libopus.h>
 #include <audioapi/libs/miniaudio/decoders/libvorbis/miniaudio_libvorbis.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>
@@ -24,28 +26,56 @@ AudioFileSourceNode::AudioFileSourceNode(
     if (useData) {
       state->memoryData = options.data;
     }
-
-    ma_decoder_config config =
-        ma_decoder_config_init(ma_format_f32, 0, static_cast<ma_uint32>(context->getSampleRate()));
-    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 result;
     if (useFilePath) {
-      result = ma_decoder_init_file(options.filePath.c_str(), &config, &state->decoder);
+      FFmpegNeeded_ = AudioDecoder::pathHasExtension(options.filePath, {".mp4", ".m4a", ".aac"});
     } else {
-      result = ma_decoder_init_memory(
-          state->memoryData.data(), state->memoryData.size(), &config, &state->decoder);
+      auto format = AudioDecoder::detectAudioFormat(options.data.data(), options.data.size());
+      FFmpegNeeded_ =
+          format == AudioFormat::MP4 || format == AudioFormat::M4A || format == AudioFormat::AAC;
     }
 
-    if (result == MA_SUCCESS) {
-      state->channels = static_cast<int>(state->decoder.outputChannels);
-      state->sampleRate = static_cast<float>(state->decoder.outputSampleRate);
-      state->interleavedBuffer.resize(RENDER_QUANTUM_SIZE * state->channels);
-      decoderState_ = std::move(state);
-      channelCount_ = decoderState_->channels;
+    if (FFmpegNeeded_) {
+#if RN_AUDIO_API_FFMPEG_DISABLED
+      assert(false && "File codec is not supported when FFmpeg is disabled");
+#else
+      ffmpegdecoder::ffmpegDecoderConfigInit(&cfg, static_cast<int>(context->getSampleRate()));
+      bool result;
+      if (useFilePath) {
+        result = decoder.openFile(cfg, options.filePath);
+      } else {
+        result = decoder.openMemory(cfg, state->memoryData.data(), state->memoryData.size());
+      }
+      if (result) {
+        state->channels = decoder.outputChannels();
+        state->sampleRate = static_cast<float>(decoder.outputSampleRate());
+        state->interleavedBuffer.resize(RENDER_QUANTUM_SIZE * state->channels);
+        decoderState_ = std::move(state);
+        channelCount_ = decoderState_->channels;
+      }
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
+    } else {
+      ma_decoder_config config = ma_decoder_config_init(
+          ma_format_f32, 0, static_cast<ma_uint32>(context->getSampleRate()));
+      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 result;
+      if (useFilePath) {
+        result = ma_decoder_init_file(options.filePath.c_str(), &config, &state->decoder);
+      } else {
+        result = ma_decoder_init_memory(
+            state->memoryData.data(), state->memoryData.size(), &config, &state->decoder);
+      }
+
+      if (result == MA_SUCCESS) {
+        state->channels = static_cast<int>(state->decoder.outputChannels);
+        state->sampleRate = static_cast<float>(state->decoder.outputSampleRate);
+        state->interleavedBuffer.resize(RENDER_QUANTUM_SIZE * state->channels);
+        decoderState_ = std::move(state);
+        channelCount_ = decoderState_->channels;
+      }
     }
   }
 
@@ -58,6 +88,11 @@ void AudioFileSourceNode::setDecoderState(const std::shared_ptr<AudioFileDecoder
 }
 
 void AudioFileSourceNode::disable() {
+  if (FFmpegNeeded_) {
+    decoder.close();
+  } else {
+    ma_decoder_uninit(&decoderState_->decoder);
+  }
   AudioScheduledSourceNode::disable();
 }
 
@@ -95,12 +130,18 @@ std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processNode(
   }
 
   auto &state = *decoderState_;
-  ma_uint64 framesRead = 0;
-  ma_decoder_read_pcm_frames(
-      &state.decoder, state.interleavedBuffer.data(), nonSilentFrames, &framesRead);
+  size_t framesReadCount = 0;
+  if (FFmpegNeeded_) {
+    framesReadCount = decoder.readPcmFrames(state.interleavedBuffer.data(), nonSilentFrames);
+  } else {
+    ma_uint64 framesRead = 0;
+    ma_decoder_read_pcm_frames(
+        &state.decoder, state.interleavedBuffer.data(), nonSilentFrames, &framesRead);
+    framesReadCount = static_cast<size_t>(framesRead);
+  }
 
   int numOutputChannels = processingBuffer->getNumberOfChannels();
-  for (size_t i = 0; i < framesRead; i++) {
+  for (size_t i = 0; i < framesReadCount; i++) {
     for (int ch = 0; ch < numOutputChannels; ch++) {
       int srcCh = ch < state.channels ? ch : state.channels - 1;
       processingBuffer->getChannel(ch)->span()[startOffset + i] =
@@ -108,8 +149,8 @@ std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processNode(
     }
   }
 
-  if (framesRead < nonSilentFrames) {
-    processingBuffer->zero(startOffset + framesRead, nonSilentFrames - framesRead);
+  if (framesReadCount < nonSilentFrames) {
+    processingBuffer->zero(startOffset + framesReadCount, nonSilentFrames - framesReadCount);
     playbackState_ = PlaybackState::STOP_SCHEDULED;
   }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
index ea718e391..86c0f8f16 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>
 
 #include <memory>
@@ -41,6 +42,9 @@ class AudioFileSourceNode : public AudioScheduledSourceNode {
 
  private:
   std::shared_ptr<AudioFileDecoderState> decoderState_;
+  bool FFmpegNeeded_;
+  ffmpegdecoder::FFmpegDecoder decoder;
+  ffmpegdecoder::FFmpegDecoderConfig cfg;
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioDecoder.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioDecoder.h
index 0c44d7419..1e5451996 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioDecoder.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioDecoder.h
@@ -39,16 +39,7 @@ class AudioDecoder {
       int inputChannelCount,
       bool interleaved);
 
- 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);
-  static AudioFormat detectAudioFormat(const void *data, size_t size) {
+  [[nodiscard]] static AudioFormat detectAudioFormat(const void *data, size_t size) {
     if (size < 12)
       return AudioFormat::UNKNOWN;
     const auto *bytes = static_cast<const unsigned char *>(data);
@@ -84,7 +75,8 @@ class AudioDecoder {
     }
     return AudioFormat::UNKNOWN;
   }
-  static inline bool pathHasExtension(
+
+  [[nodiscard]] static inline bool pathHasExtension(
       const std::string &path,
       const std::vector<std::string> &extensions) {
     std::string pathLower = path;
@@ -95,6 +87,16 @@ class AudioDecoder {
     }
     return false;
   }
+
+ 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 inline int16_t floatToInt16(float sample) {
     return static_cast<int16_t>(sample * INT16_MAX);
   }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp b/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp
index 041992795..360d66762 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp
@@ -10,323 +10,459 @@
 
 #if !RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
-#include <audioapi/utils/AudioArray.hpp>
+
+#include <algorithm>
+#include <cstring>
+#include <utility>
+
+extern "C" {
+#include <libavutil/channel_layout.h>
+}
 
 namespace audioapi::ffmpegdecoder {
 
 int read_packet(void *opaque, uint8_t *buf, int buf_size) {
-  MemoryIOContext *ctx = static_cast<MemoryIOContext *>(opaque);
-
+  auto *ctx = static_cast<MemoryIOContext *>(opaque);
   if (ctx->pos >= ctx->size) {
     return AVERROR_EOF;
   }
-
-  int bytes_to_read = std::min(buf_size, static_cast<int>(ctx->size - ctx->pos));
-  memcpy(buf, ctx->data + ctx->pos, bytes_to_read);
-  ctx->pos += bytes_to_read;
-
-  return bytes_to_read;
+  int n = std::min(buf_size, static_cast<int>(ctx->size - ctx->pos));
+  memcpy(buf, ctx->data + ctx->pos, n);
+  ctx->pos += static_cast<size_t>(n);
+  return n;
 }
 
 int64_t seek_packet(void *opaque, int64_t offset, int whence) {
-  MemoryIOContext *ctx = static_cast<MemoryIOContext *>(opaque);
-
+  auto *ctx = static_cast<MemoryIOContext *>(opaque);
   switch (whence) {
     case SEEK_SET:
-      ctx->pos = offset;
+      ctx->pos = static_cast<size_t>(offset);
       break;
     case SEEK_CUR:
-      ctx->pos += offset;
+      ctx->pos += static_cast<size_t>(offset);
       break;
     case SEEK_END:
-      ctx->pos = ctx->size + offset;
+      ctx->pos = ctx->size + static_cast<size_t>(offset);
       break;
     case AVSEEK_SIZE:
-      return ctx->size;
+      return static_cast<int64_t>(ctx->size);
+    default:
+      return AVERROR(EINVAL);
   }
+  ctx->pos = std::min(ctx->pos, ctx->size);
+  return static_cast<int64_t>(ctx->pos);
+}
 
-  if (ctx->pos > ctx->size) {
-    ctx->pos = ctx->size;
+int findAudioStreamIndex(AVFormatContext *fmt_ctx) {
+  for (unsigned i = 0; i < fmt_ctx->nb_streams; i++) {
+    if (fmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
+      return static_cast<int>(i);
+    }
   }
+  return -1;
+}
 
-  return ctx->pos;
+bool openCodec(AVFormatContext *fmt_ctx, int &audio_stream_index, AVCodecContext **out_codec) {
+  audio_stream_index = findAudioStreamIndex(fmt_ctx);
+  if (audio_stream_index < 0) {
+    return false;
+  }
+  AVCodecParameters *codecpar = fmt_ctx->streams[audio_stream_index]->codecpar;
+  const AVCodec *codec = avcodec_find_decoder(codecpar->codec_id);
+  if (codec == nullptr) {
+    return false;
+  }
+  AVCodecContext *ctx = avcodec_alloc_context3(codec);
+  if (ctx == nullptr) {
+    return false;
+  }
+  if (avcodec_parameters_to_context(ctx, codecpar) < 0) {
+    avcodec_free_context(&ctx);
+    return false;
+  }
+  if (avcodec_open2(ctx, codec, nullptr) < 0) {
+    avcodec_free_context(&ctx);
+    return false;
+  }
+  *out_codec = ctx;
+  return true;
 }
 
-void convertFrameToBuffer(
-    SwrContext *swr,
-    AVFrame *frame,
-    int output_channel_count,
-    std::vector<float> &buffer,
-    size_t &framesRead,
-    uint8_t **&resampled_data,
-    int &max_resampled_samples) {
-  const int out_samples = swr_get_out_samples(swr, frame->nb_samples);
-  if (out_samples > max_resampled_samples) {
-    av_freep(&resampled_data[0]);
-    av_freep(&resampled_data);
-    max_resampled_samples = out_samples;
+FFmpegDecoder::FFmpegDecoder(FFmpegDecoder &&other) noexcept {
+  *this = std::move(other);
+}
 
-    if (av_samples_alloc_array_and_samples(
-            &resampled_data,
-            nullptr,
-            output_channel_count,
-            max_resampled_samples,
-            AV_SAMPLE_FMT_FLT,
-            0) < 0) {
-      return;
-    }
+FFmpegDecoder &FFmpegDecoder::operator=(FFmpegDecoder &&other) noexcept {
+  if (this != &other) {
+    close();
+    fmt_ctx_ = other.fmt_ctx_;
+    codec_ctx_ = other.codec_ctx_;
+    swr_ = other.swr_;
+    packet_ = other.packet_;
+    frame_ = other.frame_;
+    resampled_data_ = other.resampled_data_;
+    max_resampled_samples_ = other.max_resampled_samples_;
+    mem_io_ = std::move(other.mem_io_);
+    avio_ctx_ = other.avio_ctx_;
+    leftover_ = std::move(other.leftover_);
+    audio_stream_index_ = other.audio_stream_index_;
+    output_channels_ = other.output_channels_;
+    output_sample_rate_ = other.output_sample_rate_;
+
+    other.fmt_ctx_ = nullptr;
+    other.codec_ctx_ = nullptr;
+    other.swr_ = nullptr;
+    other.packet_ = nullptr;
+    other.frame_ = nullptr;
+    other.resampled_data_ = nullptr;
+    other.max_resampled_samples_ = 0;
+    other.avio_ctx_ = nullptr;
   }
+  return *this;
+}
 
-  int converted_samples = swr_convert(
-      swr,
-      resampled_data,
-      max_resampled_samples,
-      const_cast<const uint8_t **>(frame->data),
-      frame->nb_samples);
+FFmpegDecoder::~FFmpegDecoder() {
+  close();
+}
 
-  if (converted_samples > 0) {
-    const size_t current_size = buffer.size();
-    const size_t new_samples = static_cast<size_t>(converted_samples) * output_channel_count;
-    buffer.resize(current_size + new_samples);
-    memcpy(buffer.data() + current_size, resampled_data[0], new_samples * sizeof(float));
-    framesRead += converted_samples;
+void FFmpegDecoder::close() {
+  if (resampled_data_ != nullptr) {
+    av_freep(&resampled_data_[0]);
+    av_freep(&resampled_data_);
   }
+  max_resampled_samples_ = 0;
+  if (swr_ != nullptr) {
+    swr_free(&swr_);
+  }
+  if (packet_ != nullptr) {
+    av_packet_free(&packet_);
+  }
+  if (frame_ != nullptr) {
+    av_frame_free(&frame_);
+  }
+  if (codec_ctx_ != nullptr) {
+    avcodec_free_context(&codec_ctx_);
+  }
+  if (fmt_ctx_ != nullptr) {
+    avformat_close_input(&fmt_ctx_);
+  }
+  if (avio_ctx_ != nullptr) {
+    avio_context_free(&avio_ctx_);
+  }
+  mem_io_.reset();
+  leftover_.clear();
+  audio_stream_index_ = -1;
+  output_channels_ = 0;
+  output_sample_rate_ = 0;
 }
 
-std::vector<float> readAllPcmFrames(
-    AVFormatContext *fmt_ctx,
-    AVCodecContext *codec_ctx,
-    int out_sample_rate,
-    int output_channel_count,
-    int audio_stream_index,
-    size_t &framesRead) {
-  framesRead = 0;
-  std::vector<float> buffer;
-  auto swr = std::unique_ptr<SwrContext, std::function<void(SwrContext *)>>(
-      swr_alloc(), [](SwrContext *ctx) { swr_free(&ctx); });
-
-  if (swr == nullptr)
-    return buffer;
-
-  av_opt_set_chlayout(swr.get(), "in_chlayout", &codec_ctx->ch_layout, 0);
-  av_opt_set_int(swr.get(), "in_sample_rate", codec_ctx->sample_rate, 0);
-  av_opt_set_sample_fmt(swr.get(), "in_sample_fmt", codec_ctx->sample_fmt, 0);
-
-  AVChannelLayout out_ch_layout;
-  av_channel_layout_default(&out_ch_layout, output_channel_count);
-  av_opt_set_chlayout(swr.get(), "out_chlayout", &out_ch_layout, 0);
-  av_opt_set_int(swr.get(), "out_sample_rate", out_sample_rate, 0);
-  av_opt_set_sample_fmt(swr.get(), "out_sample_fmt", AV_SAMPLE_FMT_FLT, 0);
-
-  if (swr_init(swr.get()) < 0) {
-    av_channel_layout_uninit(&out_ch_layout);
-    return buffer;
-  }
-
-  auto packet = std::unique_ptr<AVPacket, std::function<void(AVPacket *)>>(
-      av_packet_alloc(), [](AVPacket *p) { av_packet_free(&p); });
-  auto frame = std::unique_ptr<AVFrame, std::function<void(AVFrame *)>>(
-      av_frame_alloc(), [](AVFrame *p) { av_frame_free(&p); });
-
-  if (packet == nullptr || frame == nullptr) {
-    av_channel_layout_uninit(&out_ch_layout);
-    return buffer;
-  }
-
-  // Allocate buffer for resampled data
-  uint8_t **resampled_data = nullptr;
-  int max_resampled_samples = 4096; // Initial size
+bool FFmpegDecoder::setupSwr() {
+  swr_ = swr_alloc();
+  if (swr_ == nullptr) {
+    return false;
+  }
+  av_opt_set_chlayout(swr_, "in_chlayout", &codec_ctx_->ch_layout, 0);
+  av_opt_set_int(swr_, "in_sample_rate", codec_ctx_->sample_rate, 0);
+  av_opt_set_sample_fmt(swr_, "in_sample_fmt", codec_ctx_->sample_fmt, 0);
+
+  AVChannelLayout out_layout;
+  av_channel_layout_default(&out_layout, output_channels_);
+  av_opt_set_chlayout(swr_, "out_chlayout", &out_layout, 0);
+  av_opt_set_int(swr_, "out_sample_rate", output_sample_rate_, 0);
+  av_opt_set_sample_fmt(swr_, "out_sample_fmt", AV_SAMPLE_FMT_FLT, 0);
+  if (swr_init(swr_) < 0) {
+    av_channel_layout_uninit(&out_layout);
+    return false;
+  }
+  av_channel_layout_uninit(&out_layout);
+
   if (av_samples_alloc_array_and_samples(
-          &resampled_data,
+          &resampled_data_,
           nullptr,
-          output_channel_count,
-          max_resampled_samples,
+          output_channels_,
+          FFmpegDecoder::CHUNK_SIZE,
           AV_SAMPLE_FMT_FLT,
           0) < 0) {
-    av_channel_layout_uninit(&out_ch_layout);
-    return buffer;
-  }
-
-  while (av_read_frame(fmt_ctx, packet.get()) >= 0) {
-    if (packet->stream_index == audio_stream_index) {
-      if (avcodec_send_packet(codec_ctx, packet.get()) == 0) {
-        while (avcodec_receive_frame(codec_ctx, frame.get()) == 0) {
-          convertFrameToBuffer(
-              swr.get(),
-              frame.get(),
-              output_channel_count,
-              buffer,
-              framesRead,
-              resampled_data,
-              max_resampled_samples);
-        }
-      }
-    }
-    av_packet_unref(packet.get());
-  }
-
-  // Flush decoder
-  avcodec_send_packet(codec_ctx, nullptr);
-  while (avcodec_receive_frame(codec_ctx, frame.get()) == 0) {
-    convertFrameToBuffer(
-        swr.get(),
-        frame.get(),
-        output_channel_count,
-        buffer,
-        framesRead,
-        resampled_data,
-        max_resampled_samples);
+    return false;
   }
-
-  av_freep(&resampled_data[0]);
-  av_freep(&resampled_data);
-  av_channel_layout_uninit(&out_ch_layout);
-
-  return buffer;
+  max_resampled_samples_ = FFmpegDecoder::CHUNK_SIZE;
+  return true;
 }
 
-inline int findAudioStreamIndex(AVFormatContext *fmt_ctx) {
-  for (int i = 0; i < fmt_ctx->nb_streams; i++) {
-    if (fmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
-      return i;
-    }
+bool FFmpegDecoder::openFile(const FFmpegDecoderConfig &cfg, const std::string &path) {
+  close();
+  if (path.empty()) {
+    return false;
   }
-  return -1;
+  if (avformat_open_input(&fmt_ctx_, path.c_str(), nullptr, nullptr) < 0) {
+    fmt_ctx_ = nullptr;
+    return false;
+  }
+  if (avformat_find_stream_info(fmt_ctx_, nullptr) < 0) {
+    avformat_close_input(&fmt_ctx_);
+    fmt_ctx_ = nullptr;
+    return false;
+  }
+  if (!openCodec(fmt_ctx_, audio_stream_index_, &codec_ctx_)) {
+    avformat_close_input(&fmt_ctx_);
+    fmt_ctx_ = nullptr;
+    return false;
+  }
+  output_channels_ = codec_ctx_->ch_layout.nb_channels;
+  output_sample_rate_ =
+      (cfg.outputSampleRate > 0) ? cfg.outputSampleRate : codec_ctx_->sample_rate;
+
+  packet_ = av_packet_alloc();
+  frame_ = av_frame_alloc();
+  if (packet_ == nullptr || frame_ == nullptr || !setupSwr()) {
+    close();
+    return false;
+  }
+  return true;
 }
 
-bool setupDecoderContext(
-    AVFormatContext *fmt_ctx,
-    int &audio_stream_index,
-    std::unique_ptr<AVCodecContext, std::function<void(AVCodecContext *)>> &codec_ctx) {
-  audio_stream_index = findAudioStreamIndex(fmt_ctx);
-  if (audio_stream_index == -1) {
+bool FFmpegDecoder::openMemory(const FFmpegDecoderConfig &cfg, const void *data, size_t size) {
+  close();
+  if (data == nullptr || size == 0) {
     return false;
   }
-
-  AVCodecParameters *codecpar = fmt_ctx->streams[audio_stream_index]->codecpar;
-  const AVCodec *codec = avcodec_find_decoder(codecpar->codec_id);
-  if (codec == nullptr) {
+  mem_io_ = std::make_unique<MemoryIOContext>();
+  mem_io_->data = static_cast<const uint8_t *>(data);
+  mem_io_->size = size;
+  mem_io_->pos = 0;
+
+  auto* io_buf = static_cast<uint8_t *>(av_malloc(FFmpegDecoder::CHUNK_SIZE));
+  if (io_buf == nullptr) {
+    close();
+    return false;
+  }
+  avio_ctx_ = avio_alloc_context(
+    io_buf,
+    static_cast<int>(FFmpegDecoder::CHUNK_SIZE),
+    0,
+    mem_io_.get(),
+    read_packet,
+    nullptr,
+    seek_packet);
+  if (avio_ctx_ == nullptr) {
+    av_free(io_buf);
+    mem_io_.reset();
     return false;
   }
 
-  AVCodecContext *raw_codec_ctx = avcodec_alloc_context3(codec);
-  if (raw_codec_ctx == nullptr) {
+  fmt_ctx_ = avformat_alloc_context();
+  if (fmt_ctx_ == nullptr) {
+    close();
     return false;
   }
+  fmt_ctx_->pb = avio_ctx_;
 
-  codec_ctx.reset(raw_codec_ctx);
-  if (avcodec_parameters_to_context(codec_ctx.get(), codecpar) < 0) {
+  if (avformat_open_input(&fmt_ctx_, nullptr, nullptr, nullptr) < 0) {
+    close();
     return false;
   }
-  if (avcodec_open2(codec_ctx.get(), codec, nullptr) < 0) {
+  if (avformat_find_stream_info(fmt_ctx_, nullptr) < 0) {
+    close();
+    return false;
+  }
+  if (!openCodec(fmt_ctx_, audio_stream_index_, &codec_ctx_)) {
+    close();
+    return false;
+  }
+  output_channels_ = codec_ctx_->ch_layout.nb_channels;
+  output_sample_rate_ =
+      (cfg.outputSampleRate > 0) ? cfg.outputSampleRate : codec_ctx_->sample_rate;
+
+  packet_ = av_packet_alloc();
+  frame_ = av_frame_alloc();
+  if (packet_ == nullptr || frame_ == nullptr || !setupSwr()) {
+    close();
     return false;
   }
-
   return true;
 }
 
-std::shared_ptr<AudioBuffer> decodeAudioFrames(
-    AVFormatContext *fmt_ctx,
-    AVCodecContext *codec_ctx,
-    int audio_stream_index,
-    int sample_rate) {
-  size_t framesRead = 0;
-  int output_sample_rate = (sample_rate > 0) ? sample_rate : codec_ctx->sample_rate;
-  int output_channel_count = codec_ctx->ch_layout.nb_channels;
-
-  std::vector<float> decoded_buffer = readAllPcmFrames(
-      fmt_ctx, codec_ctx, output_sample_rate, output_channel_count, audio_stream_index, framesRead);
-
-  if (framesRead == 0 || decoded_buffer.empty()) {
-    return nullptr;
+void FFmpegDecoder::appendFrameResampled(AVFrame *frame) {
+  int out_samples = swr_get_out_samples(swr_, frame->nb_samples);
+  if (out_samples > max_resampled_samples_) {
+    av_freep(&resampled_data_[0]);
+    av_freep(&resampled_data_);
+    max_resampled_samples_ = out_samples;
+    if (av_samples_alloc_array_and_samples(
+            &resampled_data_,
+            nullptr,
+            output_channels_,
+            max_resampled_samples_,
+            AV_SAMPLE_FMT_FLT,
+            0) < 0) {
+      return;
+    }
   }
+  int converted = swr_convert(
+      swr_,
+      resampled_data_,
+      max_resampled_samples_,
+      const_cast<const uint8_t **>(frame->data),
+      frame->nb_samples);
+  if (converted > 0) {
+    size_t n = static_cast<size_t>(converted) * static_cast<size_t>(output_channels_);
+    const float *src = reinterpret_cast<float *>(resampled_data_[0]);
+    leftover_.insert(leftover_.end(), src, src + n);
+  }
+}
 
-  auto outputFrames = decoded_buffer.size() / output_channel_count;
-  auto audioBuffer =
-      std::make_shared<AudioBuffer>(outputFrames, output_channel_count, output_sample_rate);
+bool FFmpegDecoder::feedPipeline() {
+  for (;;) {
+    int r = avcodec_receive_frame(codec_ctx_, frame_);
+    if (r == 0) {
+      appendFrameResampled(frame_);
+      return true;
+    }
+    if (r == AVERROR_EOF) {
+      return !leftover_.empty();
+    }
+    if (r != AVERROR(EAGAIN)) {
+      return false;
+    }
 
-  for (size_t ch = 0; ch < output_channel_count; ++ch) {
-    auto channelData = audioBuffer->getChannel(ch)->span();
-    for (int i = 0; i < outputFrames; ++i) {
-      channelData[i] = decoded_buffer[i * output_channel_count + ch];
+    r = av_read_frame(fmt_ctx_, packet_);
+    if (r == AVERROR_EOF) {
+      if (avcodec_send_packet(codec_ctx_, nullptr) < 0) {
+        return false;
+      }
+      continue;
+    }
+    if (r < 0) {
+      return false;
+    }
+    if (packet_->stream_index != audio_stream_index_) {
+      av_packet_unref(packet_);
+      continue;
+    }
+    r = avcodec_send_packet(codec_ctx_, packet_);
+    av_packet_unref(packet_);
+    if (r < 0) {
+      return false;
     }
   }
-  return audioBuffer;
 }
 
-std::shared_ptr<AudioBuffer> decodeWithMemoryBlock(const void *data, size_t size, int sample_rate) {
-  if (data == nullptr || size == 0) {
-    return nullptr;
-  }
-
-  MemoryIOContext io_ctx{static_cast<const uint8_t *>(data), size, 0};
-
-  constexpr size_t buffer_size = 4096;
-  uint8_t *io_buffer = static_cast<uint8_t *>(av_malloc(buffer_size));
-  if (io_buffer == nullptr) {
-    return nullptr;
+size_t FFmpegDecoder::readPcmFrames(float *outInterleaved, size_t frameCount) {
+  if (!isOpen() || outInterleaved == nullptr || frameCount == 0 || output_channels_ <= 0) {
+    return 0;
   }
-
-  auto avio_ctx = std::unique_ptr<AVIOContext, std::function<void(AVIOContext *)>>(
-      avio_alloc_context(io_buffer, buffer_size, 0, &io_ctx, read_packet, nullptr, seek_packet),
-      [](AVIOContext *ctx) { avio_context_free(&ctx); });
-  if (avio_ctx == nullptr) {
-    return nullptr;
+  size_t delivered = 0;
+  const auto ch = static_cast<size_t>(output_channels_);
+
+  while (delivered < frameCount) {
+    size_t need = frameCount - delivered;
+    size_t leftover_frames = leftover_.size() / ch;
+    if (leftover_frames > 0) {
+      size_t take = std::min(need, leftover_frames);
+      size_t samples = take * ch;
+      memcpy(
+          outInterleaved + delivered * ch,
+          leftover_.data(),
+          samples * sizeof(float));
+      leftover_.erase(leftover_.begin(), leftover_.begin() + static_cast<ptrdiff_t>(samples));
+      delivered += take;
+    } else if (!feedPipeline()) {
+      break;
+    }
   }
+  return delivered;
+}
 
-  AVFormatContext *raw_fmt_ctx = avformat_alloc_context();
-  if (raw_fmt_ctx == nullptr) {
+static std::shared_ptr<AudioBuffer> buildAudioBufferFromInterleaved(
+    std::vector<float> &interleaved,
+    int channels,
+    int sample_rate) {
+  if (interleaved.empty() || channels <= 0) {
     return nullptr;
   }
-  raw_fmt_ctx->pb = avio_ctx.get();
-
-  if (avformat_open_input(&raw_fmt_ctx, nullptr, nullptr, nullptr) < 0) {
-    avformat_free_context(raw_fmt_ctx);
-    return nullptr;
+  size_t frames = interleaved.size() / static_cast<size_t>(channels);
+  auto buf = std::make_shared<AudioBuffer>(frames, channels, static_cast<float>(sample_rate));
+  for (int c = 0; c < channels; ++c) {
+    auto span = buf->getChannel(c)->span();
+    for (size_t i = 0; i < frames; ++i) {
+      span[i] = interleaved[i * static_cast<size_t>(channels) + static_cast<size_t>(c)];
+    }
   }
+  return buf;
+}
 
-  auto fmt_ctx = std::unique_ptr<AVFormatContext, decltype(&avformat_free_context)>(
-      raw_fmt_ctx, &avformat_free_context);
-
-  if (avformat_find_stream_info(fmt_ctx.get(), nullptr) < 0) {
+std::shared_ptr<AudioBuffer> decodeWithFilePath(const std::string &path, int sample_rate) {
+  FFmpegDecoderConfig cfg;
+  ffmpegDecoderConfigInit(&cfg, sample_rate);
+  FFmpegDecoder dec;
+  if (!dec.openFile(cfg, path)) {
     return nullptr;
   }
-
-  auto codec_ctx = std::unique_ptr<AVCodecContext, std::function<void(AVCodecContext *)>>(
-      nullptr, [](AVCodecContext *ctx) { avcodec_free_context(&ctx); });
-  int audio_stream_index = -1;
-  if (!setupDecoderContext(fmt_ctx.get(), audio_stream_index, codec_ctx)) {
-    return nullptr;
+  std::vector<float> acc;
+  std::vector<float> tmp(FFmpegDecoder::CHUNK_SIZE * static_cast<size_t>(std::max(1, dec.outputChannels())));
+  while (true) {
+    size_t n = dec.readPcmFrames(tmp.data(), FFmpegDecoder::CHUNK_SIZE);
+    if (n == 0) {
+      break;
+    }
+    acc.insert(
+        acc.end(),
+        tmp.begin(),
+        tmp.begin() + static_cast<ptrdiff_t>(n * static_cast<size_t>(dec.outputChannels())));
   }
-
-  return decodeAudioFrames(fmt_ctx.get(), codec_ctx.get(), audio_stream_index, sample_rate);
+  return buildAudioBufferFromInterleaved(acc, dec.outputChannels(), dec.outputSampleRate());
 }
 
-std::shared_ptr<AudioBuffer> decodeWithFilePath(const std::string &path, int sample_rate) {
-  if (path.empty()) {
+std::shared_ptr<AudioBuffer> decodeWithMemoryBlock(const void *data, size_t size, int sample_rate) {
+  FFmpegDecoderConfig cfg;
+  ffmpegDecoderConfigInit(&cfg, sample_rate);
+  FFmpegDecoder dec;
+  if (!dec.openMemory(cfg, data, size)) {
     return nullptr;
   }
+  std::vector<float> acc;
+  std::vector<float> tmp(FFmpegDecoder::CHUNK_SIZE * static_cast<size_t>(std::max(1, dec.outputChannels())));
+  while (true) {
+    size_t n = dec.readPcmFrames(tmp.data(), FFmpegDecoder::CHUNK_SIZE);
+    if (n == 0) {
+      break;
+    }
+    acc.insert(
+        acc.end(),
+        tmp.begin(),
+        tmp.begin() + static_cast<ptrdiff_t>(n * static_cast<size_t>(dec.outputChannels())));
+  }
+  return buildAudioBufferFromInterleaved(acc, dec.outputChannels(), dec.outputSampleRate());
+}
 
-  AVFormatContext *raw_fmt_ctx = nullptr;
-  if (avformat_open_input(&raw_fmt_ctx, path.c_str(), nullptr, nullptr) < 0)
-    return nullptr;
+} // namespace audioapi::ffmpegdecoder
 
-  auto fmt_ctx = std::unique_ptr<AVFormatContext, std::function<void(AVFormatContext *)>>(
-      raw_fmt_ctx, [](AVFormatContext *ctx) { avformat_close_input(&ctx); });
+#else
 
-  if (avformat_find_stream_info(fmt_ctx.get(), nullptr) < 0) {
-    return nullptr;
-  }
+#include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
 
-  auto codec_ctx = std::unique_ptr<AVCodecContext, std::function<void(AVCodecContext *)>>(
-      nullptr, [](AVCodecContext *ctx) { avcodec_free_context(&ctx); });
-  int audio_stream_index = -1;
-  if (!setupDecoderContext(fmt_ctx.get(), audio_stream_index, codec_ctx)) {
-    return nullptr;
-  }
+namespace audioapi::ffmpegdecoder {
 
-  return decodeAudioFrames(fmt_ctx.get(), codec_ctx.get(), audio_stream_index, sample_rate);
+FFmpegDecoder::FFmpegDecoder(FFmpegDecoder &&) noexcept = default;
+FFmpegDecoder &FFmpegDecoder::operator=(FFmpegDecoder &&) noexcept = default;
+FFmpegDecoder::~FFmpegDecoder() = default;
+void FFmpegDecoder::close() {}
+bool FFmpegDecoder::openFile(const FFmpegDecoderConfig &, const std::string &) {
+  return false;
+}
+bool FFmpegDecoder::openMemory(const FFmpegDecoderConfig &, const void *, size_t) {
+  return false;
+}
+size_t FFmpegDecoder::readPcmFrames(float *, size_t) {
+  return 0;
+}
+std::shared_ptr<AudioBuffer> decodeWithFilePath(const std::string &, int) {
+  return nullptr;
+}
+std::shared_ptr<AudioBuffer> decodeWithMemoryBlock(const void *, size_t, int) {
+  return nullptr;
 }
 
 } // namespace audioapi::ffmpegdecoder
+
+#endif // !RN_AUDIO_API_FFMPEG_DISABLED
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h b/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h
index 46eea8f1d..5914f7d04 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h
@@ -8,8 +8,12 @@
  * FFmpeg, you must comply with the terms of the LGPL for FFmpeg itself.
  */
 
+#pragma once
+
 #include <audioapi/utils/AudioBuffer.hpp>
+#include <cstddef>
 #include <memory>
+#include <string>
 #include <vector>
 
 extern "C" {
@@ -18,53 +22,104 @@ extern "C" {
 #include <libavutil/opt.h>
 #include <libswresample/swresample.h>
 }
+
 class AudioBuffer;
 
 namespace audioapi::ffmpegdecoder {
-// Custom IO context for reading from memory
+
+/// Opaque IO state for openMemory (must outlive decode until close).
 struct MemoryIOContext {
-  const uint8_t *data;
-  size_t size;
-  size_t pos;
+  const uint8_t *data = nullptr;
+  size_t size = 0;
+  size_t pos = 0;
 };
 
-struct AudioStreamContext {
-  AVFormatContext *fmt_ctx = nullptr;
-  AVCodecContext *codec_ctx = nullptr;
-  int audio_stream_index = -1;
+/// Step 1 — like ma_decoder_config_init: desired output sample rate (0 = use stream rate).
+struct FFmpegDecoderConfig {
+  int outputSampleRate = 0;
 };
 
-int read_packet(void *opaque, uint8_t *buf, int buf_size);
-int64_t seek_packet(void *opaque, int64_t offset, int whence);
-inline int findAudioStreamIndex(AVFormatContext *fmt_ctx);
-std::vector<float> readAllPcmFrames(
-    AVFormatContext *fmt_ctx,
-    AVCodecContext *codec_ctx,
-    int out_sample_rate,
-    int output_channel_count,
-    int audio_stream_index,
-    size_t &framesRead);
-
-void convertFrameToBuffer(
-    SwrContext *swr,
-    AVFrame *frame,
-    int output_channel_count,
-    std::vector<float> &buffer,
-    size_t &framesRead,
-    uint8_t **&resampled_data,
-    int &max_resampled_samples);
-bool setupDecoderContext(
-    AVFormatContext *fmt_ctx,
-    int &audio_stream_index,
-    std::unique_ptr<AVCodecContext, decltype(&avcodec_free_context)> &codec_ctx);
-std::shared_ptr<AudioBuffer> decodeAudioFrames(
-    AVFormatContext *fmt_ctx,
-    AVCodecContext *codec_ctx,
-    int audio_stream_index,
-    int sample_rate);
+/// Initialize decoder config (mirrors miniaudio-style config step).
+void ffmpegDecoderConfigInit(FFmpegDecoderConfig *cfg, int outputSampleRate) {
+  if (cfg != nullptr) {
+    cfg->outputSampleRate = outputSampleRate;
+  }
+}
 
-std::shared_ptr<AudioBuffer> decodeWithMemoryBlock(const void *data, size_t size, int sample_rate);
+/**
+ * FFmpeg decoder with incremental read, analogous to ma_decoder:
+ *   1) ffmpegDecoderConfigInit
+ *   2) openFile or openMemory
+ *   3) readPcmFrames repeatedly; 0 returned = end of stream
+ *   4) close when done
+ *
+ * For openMemory, \p data must remain valid until close().
+ */
+class FFmpegDecoder {
+ public:
+  FFmpegDecoder() = default;
+  FFmpegDecoder(const FFmpegDecoder &) = delete;
+  FFmpegDecoder &operator=(const FFmpegDecoder &) = delete;
+  FFmpegDecoder(FFmpegDecoder &&other) noexcept;
+  FFmpegDecoder &operator=(FFmpegDecoder &&other) noexcept;
+  ~FFmpegDecoder();
+
+  /// @brief Opens a file for decoding.
+  /// @param cfg The configuration for the decoder.
+  /// @param path The path to the file.
+  /// @return True if the file was opened successfully, false otherwise.
+  [[nodiscard]] bool openFile(const FFmpegDecoderConfig &cfg, const std::string &path);
+
+  /// @brief Opens a memory block for decoding.
+  /// @param cfg The configuration for the decoder.
+  /// @param data The data to decode.
+  /// @param size The size of the data.
+  /// @return True if the memory block was opened successfully, false otherwise.
+  [[nodiscard]] bool openMemory(const FFmpegDecoderConfig &cfg, const void *data, size_t size);
+
+  /// @brief Reads frames from the decoder.
+  /// @param outInterleaved The output buffer for the frames.
+  /// @param frameCount The maximum number of frames to read.
+  /// @return The number of frames actually read (0 = EOF).
+  [[nodiscard]] size_t readPcmFrames(float *outInterleaved, size_t frameCount);
+
+  /// @brief Closes the decoder.
+  void close();
 
+  /// @brief Checks if the decoder is open.
+  /// @return True if the decoder is open, false otherwise.
+  [[nodiscard]] bool isOpen() const { return fmt_ctx_ != nullptr && codec_ctx_ != nullptr; }
+  [[nodiscard]] int outputChannels() const { return output_channels_; }
+  [[nodiscard]] int outputSampleRate() const { return output_sample_rate_; }
+
+  static constexpr size_t CHUNK_SIZE = 4096;
+
+ private:
+  bool setupSwr();
+  bool feedPipeline();
+  void appendFrameResampled(AVFrame *frame);
+
+  AVFormatContext *fmt_ctx_ = nullptr;
+  AVCodecContext *codec_ctx_ = nullptr;
+  SwrContext *swr_ = nullptr;
+  AVPacket *packet_ = nullptr;
+  AVFrame *frame_ = nullptr;
+
+  uint8_t **resampled_data_ = nullptr;
+  int max_resampled_samples_ = 0;
+
+  std::unique_ptr<MemoryIOContext> mem_io_;
+  AVIOContext *avio_ctx_ = nullptr;
+
+  std::vector<float> leftover_;
+  int audio_stream_index_ = -1;
+  int output_channels_ = 0;
+  int output_sample_rate_ = 0;
+};
+
+// --- One-shot decode (existing API) ----------------------------------------
+
+std::shared_ptr<AudioBuffer> decodeWithMemoryBlock(const void *data, size_t size, int sample_rate);
 std::shared_ptr<AudioBuffer> decodeWithFilePath(const std::string &path, int sample_rate);
 
 } // namespace audioapi::ffmpegdecoder
diff --git a/packages/react-native-audio-api/common/cpp/cursor/CMakeLists.txt b/packages/react-native-audio-api/common/cpp/cursor/CMakeLists.txt
index bd9378edc..f8a3da551 100644
--- a/packages/react-native-audio-api/common/cpp/cursor/CMakeLists.txt
+++ b/packages/react-native-audio-api/common/cpp/cursor/CMakeLists.txt
@@ -16,7 +16,7 @@ list(REMOVE_ITEM COMMON_CPP_SOURCES
 )
 
 set(INCLUDE_DIR ${COMMON_CPP_DIR}/audioapi/external/include)
-set(FFMPEG_INCLUDE_DIR ${COMMON_CPP_DIR}/audioapi/external/ffmpeg_include)
+set(FFMPEG_INCLUDE_DIR ${COMMON_CPP_DIR}/audioapi/external/include_ffmpeg)
 set(EXTERNAL_DIR ${COMMON_CPP_DIR}/audioapi/external)
 set(JNI_LIBS_DIR ${COMMON_CPP_DIR}/../../android/src/main/jniLibs)
 

From a54bbe3ef0a0b7faef755239e6e3278c4f04e649 Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Fri, 20 Mar 2026 10:28:53 +0100
Subject: [PATCH 4/8] feat: alpha integration with audio tag

---
 .../src/examples/AudioStream/AudioContent.tsx |  54 ++++++
 .../src/examples/AudioStream/AudioStream.tsx  |  77 ---------
 .../src/examples/AudioStream/AudioTag.tsx     |  27 +++
 .../src/examples/AudioStream/PlayButton.tsx   |  13 ++
 .../src/examples/AudioStream/VolumeSlider.tsx |  22 +++
 apps/common-app/src/examples/index.ts         |  10 +-
 .../sources/AudioFileSourceNodeHostObject.cpp |  15 +-
 .../sources/AudioFileSourceNodeHostObject.h   |   3 +
 .../core/sources/AudioFileSourceNode.cpp      |  25 +--
 .../core/sources/AudioFileSourceNode.h        |  10 ++
 .../cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h |   2 +-
 .../src/core/AudioFileSourceNode.ts           |   9 +
 .../src/development/react/Audio/Audio.tsx     | 156 +++++++++++++++++-
 .../src/development/react/Audio/Audio.web.tsx |  96 ++++++++++-
 .../src/development/react/Audio/index.ts      |   1 +
 .../src/development/react/Audio/types.ts      |   8 +-
 .../src/development/react/Audio/utils.ts      |  32 +++-
 .../react-native-audio-api/src/interfaces.ts  |   4 +-
 18 files changed, 459 insertions(+), 105 deletions(-)
 create mode 100644 apps/common-app/src/examples/AudioStream/AudioContent.tsx
 delete mode 100644 apps/common-app/src/examples/AudioStream/AudioStream.tsx
 create mode 100644 apps/common-app/src/examples/AudioStream/AudioTag.tsx
 create mode 100644 apps/common-app/src/examples/AudioStream/PlayButton.tsx
 create mode 100644 apps/common-app/src/examples/AudioStream/VolumeSlider.tsx

diff --git a/apps/common-app/src/examples/AudioStream/AudioContent.tsx b/apps/common-app/src/examples/AudioStream/AudioContent.tsx
new file mode 100644
index 000000000..a894c4519
--- /dev/null
+++ b/apps/common-app/src/examples/AudioStream/AudioContent.tsx
@@ -0,0 +1,54 @@
+import { useContext } from 'react';
+import { AudioComponentContext } from 'react-native-audio-api/development/react';
+import { ActivityIndicator, Button, View } from 'react-native';
+import VolumeSlider from './VolumeSlider';
+import { Spacer } from '../../components';
+
+type Status = 'idle' | 'playing' | 'paused';
+
+type IdleState = {
+  status: 'idle';
+}
+
+type PlayingState = {
+  status: 'playing';
+  time: number;
+}
+
+type PausedState = {
+  status: 'paused';
+  time: number;
+  pausedAt: number;
+}
+
+type State = IdleState | PlayingState | PausedState;
+
+const AudioContent: React.FC = () => {
+  const { isReady, play, setMuted, muted } = useContext(AudioComponentContext);
+
+  // switch (state.status) {
+  //   case 'idle':
+  //     return <IdleState />;
+  //   case 'playing':
+  //     state.time;
+  //   case 'paused':
+  //     return <PausedState />;
+  // }
+
+  return (
+    <View>
+      {!isReady ?
+        <ActivityIndicator color="#fff" /> :
+        <>
+        <Button onPress={() => setMuted(!muted)} title={muted ? 'Unmute' : 'Mute'}/>
+        <Spacer.Vertical size={20} />
+        <Button onPress={play} title="Play"/>
+        <Spacer.Vertical size={50} />
+        <VolumeSlider />
+      </>
+    }
+    </View>
+  );
+};
+
+export default AudioContent;
diff --git a/apps/common-app/src/examples/AudioStream/AudioStream.tsx b/apps/common-app/src/examples/AudioStream/AudioStream.tsx
deleted file mode 100644
index b89a6c9e4..000000000
--- a/apps/common-app/src/examples/AudioStream/AudioStream.tsx
+++ /dev/null
@@ -1,77 +0,0 @@
-import React, { useEffect, useRef, useState } from 'react';
-import { ActivityIndicator, View } from 'react-native';
-import { AudioContext, AudioFileSourceNode } from 'react-native-audio-api';
-
-import { Button, Container } from '../../components';
-import { layout } from '../../styles';
-
-/** Small public WAV for demo (works with miniaudio file decoder). */
-const DEMO_AUDIO_URL =
-  'https://filesamples.com/samples/audio/aac/sample4.aac';
-  // '/Users/michal/Library/Developer/CoreSimulator/Devices/BD13B970-9C15-4FB4-91C8-38CBFFFDD3B8/data/Containers/Data/Application/40127BF3-30D7-44BD-9AFC-34DB21106188/Documents/audio.aac';
-
-const AudioStream: React.FC = () => {
-  const [playing, setPlaying] = useState(false);
-  const [loading, setLoading] = useState(false);
-  const [buffer, setBuffer] = useState<ArrayBuffer | string | null>(null);
-
-  const ctxRef = useRef<AudioContext | null>(null);
-  const sourceRef = useRef<AudioFileSourceNode | null>(null);
-
-  useEffect(() => {
-    ctxRef.current = new AudioContext();
-    setLoading(true);
-
-    if (DEMO_AUDIO_URL.startsWith('https')) {
-      fetch(DEMO_AUDIO_URL)
-          .then((r) => r.arrayBuffer())
-          .then(setBuffer)
-          .finally(() => setLoading(false));
-    } else {
-      setBuffer(DEMO_AUDIO_URL);
-      setLoading(false);
-    }
-    return () => {
-      sourceRef.current?.stop(0);
-      ctxRef.current?.close();
-    };
-  }, []);
-
-  const toggle = async () => {
-    const ctx = ctxRef.current;
-    if (!ctx || !buffer) return;
-
-    if (playing) {
-      sourceRef.current?.stop(ctx.currentTime);
-      sourceRef.current = null;
-      setPlaying(false);
-      return;
-    }
-
-    await ctx.resume();
-
-    const source = ctx.createAudioFileSource(buffer);
-    source.connect(ctx.destination);
-    source.start(ctx.currentTime);
-
-    sourceRef.current = source;
-    setPlaying(true);
-  };
-
-  return (
-    <Container disablePadding>
-      <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
-        {loading && <ActivityIndicator color="#fff" />}
-        <View style={{ marginTop: layout.spacing * 2 }}>
-          <Button
-            onPress={toggle}
-            title={playing ? 'Stop' : 'Play'}
-            disabled={!buffer || loading}
-          />
-        </View>
-      </View>
-    </Container>
-  );
-};
-
-export default AudioStream;
diff --git a/apps/common-app/src/examples/AudioStream/AudioTag.tsx b/apps/common-app/src/examples/AudioStream/AudioTag.tsx
new file mode 100644
index 000000000..e0f805d5e
--- /dev/null
+++ b/apps/common-app/src/examples/AudioStream/AudioTag.tsx
@@ -0,0 +1,27 @@
+import React from 'react';
+import { ActivityIndicator, View } from 'react-native';
+import { Audio } from 'react-native-audio-api/development/react';
+
+import { Button, Container } from '../../components';
+import { layout } from '../../styles';
+import AudioContent from './AudioContent';
+
+const DEMO_AUDIO_URL =
+  // 'https://filesamples.com/samples/audio/aac/sample4.aac';
+  '/data/data/com.fabricexample/cache/audio.wav';
+
+const AudioTag: React.FC = () => {
+  return (
+    <Container disablePadding>
+      <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
+        <View style={{ marginTop: layout.spacing * 2 }}>
+          <Audio source={DEMO_AUDIO_URL} volume={0.3} autoPlay>
+            <AudioContent />
+          </Audio>
+        </View>
+      </View>
+    </Container>
+  );
+};
+
+export default AudioTag;
diff --git a/apps/common-app/src/examples/AudioStream/PlayButton.tsx b/apps/common-app/src/examples/AudioStream/PlayButton.tsx
new file mode 100644
index 000000000..2ee696d74
--- /dev/null
+++ b/apps/common-app/src/examples/AudioStream/PlayButton.tsx
@@ -0,0 +1,13 @@
+import { useContext } from 'react';
+import { AudioComponentContext } from 'react-native-audio-api/development/react';
+import { Button } from 'react-native';
+
+const AudioPlayerButton: React.FC = () => {
+  const { play } = useContext(AudioComponentContext);
+
+  return (
+    <Button onPress={play} title="Play" />
+  );
+};
+
+export default AudioPlayerButton;
diff --git a/apps/common-app/src/examples/AudioStream/VolumeSlider.tsx b/apps/common-app/src/examples/AudioStream/VolumeSlider.tsx
new file mode 100644
index 000000000..da49ade3a
--- /dev/null
+++ b/apps/common-app/src/examples/AudioStream/VolumeSlider.tsx
@@ -0,0 +1,22 @@
+import { useContext } from 'react';
+import { AudioComponentContext } from 'react-native-audio-api/development/react';
+import { Slider } from '../../components';
+import { View } from 'react-native';
+
+const VolumeSlider: React.FC = () => {
+  const { volume, setVolume } = useContext(AudioComponentContext);
+
+  return (
+    <View style={{ width: 200 }}>
+    <Slider
+      value={volume}
+      onValueChange={setVolume}
+      min={0}
+      max={1}
+      step={0.01}
+    />
+    </View>
+  );
+};
+
+export default VolumeSlider;
diff --git a/apps/common-app/src/examples/index.ts b/apps/common-app/src/examples/index.ts
index 112443157..e30db29d6 100644
--- a/apps/common-app/src/examples/index.ts
+++ b/apps/common-app/src/examples/index.ts
@@ -12,7 +12,7 @@ import PlaybackSpeed from './PlaybackSpeed/PlaybackSpeed';
 import Record from './Record/Record';
 import Streaming from './Streaming/Streaming';
 import Worklets from './Worklets/Worklets';
-import AudioStream from './AudioStream/AudioStream';
+import AudioStream from './AudioStream/AudioTag';
 
 type NavigationParamList = {
   Oscillator: undefined;
@@ -27,7 +27,7 @@ type NavigationParamList = {
   Record: undefined;
   Worklets: undefined;
   Streamer: undefined;
-  AudioStream: undefined;
+  AudioTag: undefined;
 };
 
 export type ExampleKey = keyof NavigationParamList;
@@ -113,9 +113,9 @@ export const Examples: Example[] = [
     screen: Streaming,
   },
   {
-    key: 'AudioStream',
-    title: 'Audio Stream',
-    Icon: icons.Music,
+    key: 'AudioTag',
+    title: 'Audio Tag',
+    Icon: icons.Tag,
     screen: AudioStream,
   }
 ] as const;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
index 374f6e5ea..ca68d3a83 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
@@ -10,6 +10,19 @@ namespace audioapi {
 AudioFileSourceNodeHostObject::AudioFileSourceNodeHostObject(
     const std::shared_ptr<BaseAudioContext> &context,
     const AudioFileSourceOptions &options)
-    : AudioScheduledSourceNodeHostObject(context->createFileSource(options), options) {}
+    : AudioScheduledSourceNodeHostObject(context->createFileSource(options), options) {
+  addGetters(JSI_EXPORT_PROPERTY_GETTER(AudioFileSourceNodeHostObject, volume));
+  addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioFileSourceNodeHostObject, volume));
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioFileSourceNodeHostObject, volume) {
+  auto node = std::static_pointer_cast<AudioFileSourceNode>(node_);
+  return jsi::Value(node->getVolume());
+}
+
+JSI_PROPERTY_SETTER_IMPL(AudioFileSourceNodeHostObject, volume) {
+  auto node = std::static_pointer_cast<AudioFileSourceNode>(node_);
+  node->setVolume(static_cast<float>(value.getNumber()));
+}
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h
index 28c8b8771..221dc955c 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h
@@ -17,6 +17,9 @@ class AudioFileSourceNodeHostObject : public AudioScheduledSourceNodeHostObject
       const AudioFileSourceOptions &options);
 
   ~AudioFileSourceNodeHostObject() override = default;
+
+  JSI_PROPERTY_GETTER_DECL(volume);
+  JSI_PROPERTY_SETTER_DECL(volume);
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
index 0e0da8234..906bca437 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
@@ -140,18 +140,23 @@ std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processNode(
     framesReadCount = static_cast<size_t>(framesRead);
   }
 
-  int numOutputChannels = processingBuffer->getNumberOfChannels();
-  for (size_t i = 0; i < framesReadCount; i++) {
-    for (int ch = 0; ch < numOutputChannels; ch++) {
-      int srcCh = ch < state.channels ? ch : state.channels - 1;
-      processingBuffer->getChannel(ch)->span()[startOffset + i] =
-          state.interleavedBuffer[i * state.channels + srcCh];
+  const float vol = volume_.load(std::memory_order_acquire);
+  if (vol == 0) {
+    processingBuffer->zero();
+  } else {
+    int numOutputChannels = processingBuffer->getNumberOfChannels();
+    for (size_t i = 0; i < framesReadCount; i++) {
+      for (int ch = 0; ch < numOutputChannels; ch++) {
+        int srcCh = ch < state.channels ? ch : state.channels - 1;
+        processingBuffer->getChannel(ch)->span()[startOffset + i] =
+            vol * state.interleavedBuffer[i * state.channels + srcCh];
+      }
     }
-  }
 
-  if (framesReadCount < nonSilentFrames) {
-    processingBuffer->zero(startOffset + framesReadCount, nonSilentFrames - framesReadCount);
-    playbackState_ = PlaybackState::STOP_SCHEDULED;
+    if (framesReadCount < nonSilentFrames) {
+      processingBuffer->zero(startOffset + framesReadCount, nonSilentFrames - framesReadCount);
+      playbackState_ = PlaybackState::STOP_SCHEDULED;
+    }
   }
 
   handleStopScheduled();
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
index 86c0f8f16..cbe61e694 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
@@ -4,6 +4,7 @@
 #include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>
 
+#include <atomic>
 #include <memory>
 #include <vector>
 
@@ -35,6 +36,14 @@ class AudioFileSourceNode : public AudioScheduledSourceNode {
 
   void disable() override;
 
+  float getVolume() const {
+    return volume_.load(std::memory_order_acquire);
+  }
+
+  void setVolume(float v) {
+    volume_.store(v, std::memory_order_release);
+  }
+
  protected:
   std::shared_ptr<DSPAudioBuffer> processNode(
       const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
@@ -42,6 +51,7 @@ class AudioFileSourceNode : public AudioScheduledSourceNode {
 
  private:
   std::shared_ptr<AudioFileDecoderState> decoderState_;
+  std::atomic<float> volume_;
   bool FFmpegNeeded_;
   ffmpegdecoder::FFmpegDecoder decoder;
   ffmpegdecoder::FFmpegDecoderConfig cfg;
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h b/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h
index 5914f7d04..7766967c6 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h
@@ -40,7 +40,7 @@ struct FFmpegDecoderConfig {
 };
 
 /// Initialize decoder config (mirrors miniaudio-style config step).
-void ffmpegDecoderConfigInit(FFmpegDecoderConfig *cfg, int outputSampleRate) {
+inline void ffmpegDecoderConfigInit(FFmpegDecoderConfig *cfg, int outputSampleRate) {
   if (cfg != nullptr) {
     cfg->outputSampleRate = outputSampleRate;
   }
diff --git a/packages/react-native-audio-api/src/core/AudioFileSourceNode.ts b/packages/react-native-audio-api/src/core/AudioFileSourceNode.ts
index ef19e7c3a..9fd253c30 100644
--- a/packages/react-native-audio-api/src/core/AudioFileSourceNode.ts
+++ b/packages/react-native-audio-api/src/core/AudioFileSourceNode.ts
@@ -1,3 +1,4 @@
+import { IAudioFileSourceNode } from '../interfaces';
 import AudioScheduledSourceNode from './AudioScheduledSourceNode';
 import BaseAudioContext from './BaseAudioContext';
 
@@ -6,4 +7,12 @@ export default class AudioFileSourceNode extends AudioScheduledSourceNode {
     const node = context.context.createFileSource(source);
     super(context, node);
   }
+
+  get volume(): number {
+    return (this.node as IAudioFileSourceNode).volume ?? 1;
+  }
+
+  set volume(value: number) {
+    (this.node as IAudioFileSourceNode).volume = value;
+  }
 }
diff --git a/packages/react-native-audio-api/src/development/react/Audio/Audio.tsx b/packages/react-native-audio-api/src/development/react/Audio/Audio.tsx
index 0a95bf409..687ae3d3b 100644
--- a/packages/react-native-audio-api/src/development/react/Audio/Audio.tsx
+++ b/packages/react-native-audio-api/src/development/react/Audio/Audio.tsx
@@ -1,9 +1,37 @@
-import React from 'react';
+import React, {
+  createContext,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
 
-import type { AudioProps } from './types';
+import AudioFileSourceNode from '../../../core/AudioFileSourceNode';
+import type { AudioProps, AudioURISource } from './types';
 import { useStableAudioProps } from './utils';
 
+export type AudioComponentContextType = {
+  play: () => void;
+  volume: number;
+  setVolume: (volume: number) => void;
+  muted: boolean;
+  setMuted: (muted: boolean) => void;
+  isReady: boolean;
+};
+
+export const AudioComponentContext = createContext<AudioComponentContextType>({
+  play: () => {},
+  volume: 1,
+  setVolume: () => {},
+  muted: false,
+  setMuted: () => {},
+  isReady: false,
+});
+
 const Audio: React.FC<AudioProps> = (inProps) => {
+  const { children } = inProps;
+
   /* eslint-disable @typescript-eslint/no-unused-vars */
   const {
     autoPlay,
@@ -15,10 +43,130 @@ const Audio: React.FC<AudioProps> = (inProps) => {
     playbackRate,
     preservesPitch,
     volume,
+    context,
   } = useStableAudioProps(inProps);
-  /* eslint-enable @typescript-eslint/no-unused-vars */
 
-  return null;
+  const path = useMemo(() => {
+    if (typeof source === 'string') {
+      return source;
+    }
+    return (source as AudioURISource).uri ?? '';
+  }, [source]);
+
+  const nodeRef = useRef<AudioFileSourceNode | null>(null);
+  const [volumeState, setVolumeState] = useState(volume);
+  const [mutedState, setMutedState] = useState(muted);
+  const [isReady, setIsReady] = useState(false);
+
+  const contextRef = useRef(context);
+  contextRef.current = context;
+
+  useEffect(() => {
+    setVolumeState(volume);
+  }, [volume]);
+
+  useEffect(() => {
+    setMutedState(muted);
+  }, [muted]);
+
+  const play = useCallback(() => {
+    const n = nodeRef.current;
+    const ctx = contextRef.current;
+    if (!n || !ctx) {
+      return;
+    }
+    n.connect(ctx.destination);
+    n.start(0);
+  }, []);
+
+  const attachNode = useCallback(
+    (n: AudioFileSourceNode) => {
+      n.volume = volumeState;
+      nodeRef.current = n;
+      setIsReady(true);
+      if (autoPlay) {
+        play();
+      }
+    },
+    [autoPlay, play, volumeState]
+  );
+
+  useEffect(() => {
+    if (!context || !path) {
+      return;
+    }
+
+    const run = async () => {
+      if (path.startsWith('http')) {
+        const response = await fetch(path);
+        const arrayBuffer = await response.arrayBuffer();
+        attachNode(new AudioFileSourceNode(context, arrayBuffer));
+      } else {
+        attachNode(new AudioFileSourceNode(context, path));
+      }
+    };
+
+    setIsReady(false);
+    run();
+
+    return () => {
+      nodeRef.current?.disconnect();
+      nodeRef.current = null;
+      setIsReady(false);
+    };
+  }, [path, context, attachNode]);
+
+  useEffect(() => {
+    const n = nodeRef.current;
+    if (n) {
+      n.volume = volumeState;
+    }
+  }, [volumeState]);
+
+  const setVolume = useCallback((next: number) => {
+    setVolumeState(next);
+    const n = nodeRef.current;
+    if (n) {
+      n.volume = next;
+    }
+  }, []);
+
+  const setMuted = useCallback(
+    (next: boolean) => {
+      setMutedState(next);
+      const n = nodeRef.current;
+      if (n) {
+        if (next) {
+          n.volume = 0;
+        } else {
+          n.volume = volumeState;
+        }
+      }
+    },
+    [volumeState]
+  );
+
+  const ctxValue = useMemo(
+    () => ({
+      play,
+      volume: volumeState,
+      setVolume,
+      muted: mutedState,
+      setMuted,
+      isReady,
+    }),
+    [play, setVolume, volumeState, mutedState, setMuted, isReady]
+  );
+
+  if (context === null) {
+    return null;
+  }
+
+  return (
+    <AudioComponentContext.Provider value={ctxValue}>
+      {children}
+    </AudioComponentContext.Provider>
+  );
 };
 
 export default Audio;
diff --git a/packages/react-native-audio-api/src/development/react/Audio/Audio.web.tsx b/packages/react-native-audio-api/src/development/react/Audio/Audio.web.tsx
index be6453af0..ee08e257e 100644
--- a/packages/react-native-audio-api/src/development/react/Audio/Audio.web.tsx
+++ b/packages/react-native-audio-api/src/development/react/Audio/Audio.web.tsx
@@ -1,9 +1,101 @@
-import React from 'react';
+import React, {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
 import type { AudioProps } from './types';
+import { AudioComponentContext } from './Audio';
+import { useStableAudioProps } from './utils';
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const Audio: React.FC<AudioProps> = (props) => {
-  return null;
+  const { children } = props;
+  /* eslint-disable @typescript-eslint/no-unused-vars */
+  const {
+    autoPlay,
+    controls,
+    loop,
+    muted,
+    preload,
+    source,
+    playbackRate,
+    preservesPitch,
+    volume,
+    context, // null on web, since web do not use AudioContext for audio tag, left for mobile compatibility
+  } = useStableAudioProps(props);
+
+  const audioRef = useRef<HTMLAudioElement>(null);
+  const [volumeState, setVolumeState] = useState(volume);
+  const [mutedState, setMutedState] = useState(muted);
+  const [isReady, setIsReady] = useState(false);
+
+  useEffect(() => {
+    setVolumeState(volume);
+  }, [volume]);
+
+  useEffect(() => {
+    setMutedState(muted);
+  }, [muted]);
+
+  useEffect(() => {
+    const el = audioRef.current;
+    if (el) {
+      el.volume = volumeState;
+    }
+  }, [volumeState]);
+
+  useEffect(() => {
+    const el = audioRef.current;
+    if (el) {
+      el.muted = mutedState;
+    }
+  }, [mutedState]);
+
+  const play = useCallback(() => {
+    audioRef.current?.play()?.catch(() => {});
+  }, []);
+
+  const setVolume = useCallback((next: number) => {
+    setVolumeState(next);
+    const el = audioRef.current;
+    if (el) {
+      el.volume = next;
+    }
+  }, []);
+
+  const setMuted = useCallback((next: boolean) => {
+    setMutedState(next);
+    const el = audioRef.current;
+    if (el) {
+      el.muted = next;
+    }
+  }, []);
+
+  const ctxValue = useMemo(
+    () => ({
+      play,
+      volume: volumeState,
+      setVolume,
+      muted: mutedState,
+      setMuted,
+      isReady,
+    }),
+    [play, setVolume, volumeState, mutedState, setMuted, isReady]
+  );
+
+  return (
+    <AudioComponentContext.Provider value={ctxValue}>
+      <audio
+        autoPlay={autoPlay}
+        muted={mutedState}
+        ref={audioRef}
+        onLoadedData={() => setIsReady(true)}
+      />
+      {children}
+    </AudioComponentContext.Provider>
+  );
 };
 
 export default Audio;
diff --git a/packages/react-native-audio-api/src/development/react/Audio/index.ts b/packages/react-native-audio-api/src/development/react/Audio/index.ts
index 7789950e7..eeafee03a 100644
--- a/packages/react-native-audio-api/src/development/react/Audio/index.ts
+++ b/packages/react-native-audio-api/src/development/react/Audio/index.ts
@@ -1,3 +1,4 @@
 export { default } from './Audio';
+export { AudioComponentContext } from './Audio';
 
 export type { AudioProps, AudioSource, TimeRanges } from './types';
diff --git a/packages/react-native-audio-api/src/development/react/Audio/types.ts b/packages/react-native-audio-api/src/development/react/Audio/types.ts
index b7c6b1512..c74f6ae0c 100644
--- a/packages/react-native-audio-api/src/development/react/Audio/types.ts
+++ b/packages/react-native-audio-api/src/development/react/Audio/types.ts
@@ -1,3 +1,6 @@
+import { ReactNode } from 'react';
+import type BaseAudioContext from '../../../core/BaseAudioContext';
+
 export interface AudioURISource {
   uri?: string | undefined;
   // bundle?: string | undefined;
@@ -18,7 +21,8 @@ export interface TimeRanges {
 export type AudioSource =
   | AudioURISource
   | AudioRequireSource
-  | ReadonlyArray<AudioURISource>;
+  | ReadonlyArray<AudioURISource>
+  | string;
 
 export type PreloadType = 'auto' | 'metadata' | 'none';
 
@@ -32,6 +36,8 @@ interface AudioControlProps {
   playbackRate: number;
   preservesPitch: boolean;
   volume: number;
+  children?: ReactNode;
+  context: BaseAudioContext | null; // null on web, since web do not use AudioContext for audio tag
 }
 
 interface AudioReadonlyProps {
diff --git a/packages/react-native-audio-api/src/development/react/Audio/utils.ts b/packages/react-native-audio-api/src/development/react/Audio/utils.ts
index 28741d93d..4d55c0ddf 100644
--- a/packages/react-native-audio-api/src/development/react/Audio/utils.ts
+++ b/packages/react-native-audio-api/src/development/react/Audio/utils.ts
@@ -1,7 +1,18 @@
-import { useMemo } from 'react';
+import { useMemo, useRef } from 'react';
+import { Platform } from 'react-native';
+import AudioContext from '../../../core/AudioContext';
+import type BaseAudioContext from '../../../core/BaseAudioContext';
 import { AudioProps, AudioPropsBase } from './types';
 
-export function withPropsDefaults(props: AudioProps): AudioPropsBase {
+/**
+ * Merge props with defaults. `resolvedContext` must be stable when using the
+ * implicit default (see `useStableAudioProps` — one `AudioContext` per hook
+ * mount).
+ */
+export function withPropsDefaults(
+  props: AudioProps,
+  resolvedContext: BaseAudioContext | null
+): AudioPropsBase {
   return {
     ...props,
     autoPlay: props.autoPlay ?? false,
@@ -13,10 +24,22 @@ export function withPropsDefaults(props: AudioProps): AudioPropsBase {
     playbackRate: props.playbackRate ?? 1.0,
     preservesPitch: props.preservesPitch ?? true,
     volume: props.volume ?? 1.0,
+    context: resolvedContext,
   };
 }
 
 export function useStableAudioProps(props: AudioProps): AudioPropsBase {
+  const defaultContextRef = useRef<BaseAudioContext | null>(null);
+  const resolvedContext: BaseAudioContext | null =
+    Platform.OS === 'web'
+      ? null
+      : (() => {
+          if (defaultContextRef.current === null) {
+            defaultContextRef.current = new AudioContext();
+          }
+          return props.context ?? defaultContextRef.current;
+        })();
+
   const {
     // Control Props
     autoPlay,
@@ -28,6 +51,7 @@ export function useStableAudioProps(props: AudioProps): AudioPropsBase {
     playbackRate,
     preservesPitch,
     volume,
+    context,
 
     // Event Props
     onLoadStart,
@@ -38,7 +62,7 @@ export function useStableAudioProps(props: AudioProps): AudioPropsBase {
     onEnded,
     onPlay,
     onPause,
-  } = withPropsDefaults(props);
+  } = withPropsDefaults(props, resolvedContext);
 
   return useMemo(
     () => ({
@@ -52,6 +76,7 @@ export function useStableAudioProps(props: AudioProps): AudioPropsBase {
       playbackRate,
       preservesPitch,
       volume,
+      context,
 
       // Event Props
       onLoadStart,
@@ -73,6 +98,7 @@ export function useStableAudioProps(props: AudioProps): AudioPropsBase {
       playbackRate,
       preservesPitch,
       volume,
+      context,
       onLoadStart,
       onLoad,
       onError,
diff --git a/packages/react-native-audio-api/src/interfaces.ts b/packages/react-native-audio-api/src/interfaces.ts
index fd5f92c8f..f2cf8a609 100644
--- a/packages/react-native-audio-api/src/interfaces.ts
+++ b/packages/react-native-audio-api/src/interfaces.ts
@@ -229,7 +229,9 @@ export interface IAudioBufferQueueSourceNode
   onBufferEnded: string;
 }
 
-export interface IAudioFileSourceNode extends IAudioScheduledSourceNode {}
+export interface IAudioFileSourceNode extends IAudioScheduledSourceNode {
+  volume?: number;
+}
 
 export interface IConvolverNode extends IAudioNode {
   readonly buffer: IAudioBuffer | null;

From 0e1c08a7758e677e2adaea1970379b94ba81d84a Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Fri, 20 Mar 2026 11:21:36 +0100
Subject: [PATCH 5/8] feat: basic integration with audio tag

---
 .../src/examples/AudioStream/AudioContent.tsx | 65 +++++++----------
 .../src/examples/AudioStream/AudioTag.tsx     |  8 +--
 apps/fabric-example/ios/Podfile.lock          |  2 +-
 .../sources/AudioFileSourceNodeHostObject.cpp | 14 ++++
 .../sources/AudioFileSourceNodeHostObject.h   |  2 +
 .../core/sources/AudioFileSourceNode.cpp      | 22 ++++++
 .../core/sources/AudioFileSourceNode.h        |  6 ++
 packages/react-native-audio-api/src/api.ts    |  1 -
 .../src/core/AudioFileSourceNode.ts           | 18 -----
 .../src/core/BaseAudioContext.ts              |  5 --
 .../src/development/react/Audio/Audio.tsx     | 71 +++++++++++++++----
 .../src/development/react/Audio/Audio.web.tsx | 26 ++++++-
 .../src/development/react/Audio/index.ts      |  7 +-
 .../src/development/react/Audio/types.ts      |  6 ++
 .../react-native-audio-api/src/interfaces.ts  |  1 +
 15 files changed, 169 insertions(+), 85 deletions(-)
 delete mode 100644 packages/react-native-audio-api/src/core/AudioFileSourceNode.ts

diff --git a/apps/common-app/src/examples/AudioStream/AudioContent.tsx b/apps/common-app/src/examples/AudioStream/AudioContent.tsx
index a894c4519..ca59889b1 100644
--- a/apps/common-app/src/examples/AudioStream/AudioContent.tsx
+++ b/apps/common-app/src/examples/AudioStream/AudioContent.tsx
@@ -1,52 +1,39 @@
 import { useContext } from 'react';
 import { AudioComponentContext } from 'react-native-audio-api/development/react';
-import { ActivityIndicator, Button, View } from 'react-native';
+import { ActivityIndicator, Button, Text, View } from 'react-native';
 import VolumeSlider from './VolumeSlider';
 import { Spacer } from '../../components';
 
-type Status = 'idle' | 'playing' | 'paused';
-
-type IdleState = {
-  status: 'idle';
-}
-
-type PlayingState = {
-  status: 'playing';
-  time: number;
-}
-
-type PausedState = {
-  status: 'paused';
-  time: number;
-  pausedAt: number;
-}
-
-type State = IdleState | PlayingState | PausedState;
-
 const AudioContent: React.FC = () => {
-  const { isReady, play, setMuted, muted } = useContext(AudioComponentContext);
-
-  // switch (state.status) {
-  //   case 'idle':
-  //     return <IdleState />;
-  //   case 'playing':
-  //     state.time;
-  //   case 'paused':
-  //     return <PausedState />;
-  // }
+  const { isReady, play, pause, playbackState, setMuted, muted } = useContext(
+    AudioComponentContext
+  );
 
   return (
     <View>
-      {!isReady ?
-        <ActivityIndicator color="#fff" /> :
+      {!isReady ? (
+        <ActivityIndicator color="#fff" />
+      ) : (
         <>
-        <Button onPress={() => setMuted(!muted)} title={muted ? 'Unmute' : 'Mute'}/>
-        <Spacer.Vertical size={20} />
-        <Button onPress={play} title="Play"/>
-        <Spacer.Vertical size={50} />
-        <VolumeSlider />
-      </>
-    }
+          <Text style={{ color: '#fff' }}>{playbackState}</Text>
+          <Spacer.Vertical size={12} />
+          <Button
+            onPress={() => setMuted(!muted)}
+            title={muted ? 'Unmute' : 'Mute'}
+          />
+          <Spacer.Vertical size={20} />
+          <Button onPress={() => {
+            if (playbackState === 'playing') {
+              pause();
+            } else {
+              play();
+            }
+          }} title={playbackState === 'playing' ? 'Pause' : 'Play'} />
+          <Spacer.Vertical size={12} />
+          <Spacer.Vertical size={50} />
+          <VolumeSlider />
+        </>
+      )}
     </View>
   );
 };
diff --git a/apps/common-app/src/examples/AudioStream/AudioTag.tsx b/apps/common-app/src/examples/AudioStream/AudioTag.tsx
index e0f805d5e..da3cd6407 100644
--- a/apps/common-app/src/examples/AudioStream/AudioTag.tsx
+++ b/apps/common-app/src/examples/AudioStream/AudioTag.tsx
@@ -1,14 +1,14 @@
 import React from 'react';
-import { ActivityIndicator, View } from 'react-native';
+import { View } from 'react-native';
 import { Audio } from 'react-native-audio-api/development/react';
 
-import { Button, Container } from '../../components';
+import { Container } from '../../components';
 import { layout } from '../../styles';
 import AudioContent from './AudioContent';
 
 const DEMO_AUDIO_URL =
-  // 'https://filesamples.com/samples/audio/aac/sample4.aac';
-  '/data/data/com.fabricexample/cache/audio.wav';
+  'https://filesamples.com/samples/audio/aac/sample4.aac';
+  // '/data/data/com.fabricexample/cache/audio.wav';
 
 const AudioTag: React.FC = () => {
   return (
diff --git a/apps/fabric-example/ios/Podfile.lock b/apps/fabric-example/ios/Podfile.lock
index 0ff51c1dc..cdd4bf9ed 100644
--- a/apps/fabric-example/ios/Podfile.lock
+++ b/apps/fabric-example/ios/Podfile.lock
@@ -2553,7 +2553,7 @@ SPEC CHECKSUMS:
   React-microtasksnativemodule: d1956f0eec54c619b63a379520fb4c618a55ccb9
   react-native-background-timer: 4638ae3bee00320753647900b21260b10587b6f7
   react-native-safe-area-context: ae7587b95fb580d1800c5b0b2a7bd48c2868e67a
-  react-native-skia: 5f68d3c3749bfb4f726e408410b8be5999392cd9
+  react-native-skia: 9e5b3a8a4ced921df89cb625dd9eb4fb10be1acf
   React-NativeModulesApple: 5ba0903927f6b8d335a091700e9fda143980f819
   React-networking: 3a4b7f9ed2b2d1c0441beacb79674323a24bcca6
   React-oscompat: ff26abf0ae3e3fdbe47b44224571e3fc7226a573
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
index ca68d3a83..4ccfd97e8 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
@@ -4,6 +4,7 @@
 #include <audioapi/core/sources/AudioFileSourceNode.h>
 #include <audioapi/types/NodeOptions.h>
 #include <memory>
+#include <utility>
 
 namespace audioapi {
 
@@ -13,6 +14,8 @@ AudioFileSourceNodeHostObject::AudioFileSourceNodeHostObject(
     : AudioScheduledSourceNodeHostObject(context->createFileSource(options), options) {
   addGetters(JSI_EXPORT_PROPERTY_GETTER(AudioFileSourceNodeHostObject, volume));
   addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioFileSourceNodeHostObject, volume));
+
+  addFunctions(JSI_EXPORT_FUNCTION(AudioFileSourceNodeHostObject, pause));
 }
 
 JSI_PROPERTY_GETTER_IMPL(AudioFileSourceNodeHostObject, volume) {
@@ -25,4 +28,15 @@ JSI_PROPERTY_SETTER_IMPL(AudioFileSourceNodeHostObject, volume) {
   node->setVolume(static_cast<float>(value.getNumber()));
 }
 
+JSI_HOST_FUNCTION_IMPL(AudioFileSourceNodeHostObject, pause) {
+  auto audioFileSourceNode = std::static_pointer_cast<AudioFileSourceNode>(node_);
+
+  auto event = [audioFileSourceNode](BaseAudioContext &) {
+    audioFileSourceNode->pause();
+  };
+  audioFileSourceNode->scheduleAudioEvent(std::move(event));
+
+  return jsi::Value::undefined();
+}
+
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h
index 221dc955c..cf7a5497e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h
@@ -20,6 +20,8 @@ class AudioFileSourceNodeHostObject : public AudioScheduledSourceNodeHostObject
 
   JSI_PROPERTY_GETTER_DECL(volume);
   JSI_PROPERTY_SETTER_DECL(volume);
+
+  JSI_HOST_FUNCTION_DECL(pause);
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
index 906bca437..c4f56b14a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
@@ -87,7 +87,24 @@ void AudioFileSourceNode::setDecoderState(const std::shared_ptr<AudioFileDecoder
   channelCount_ = state != nullptr ? state->channels : 1;
 }
 
+void AudioFileSourceNode::start(double when) {
+  if (filePaused_.load(std::memory_order_acquire)) {
+    filePaused_.store(false, std::memory_order_release);
+    if (fileStarted_) {
+      return;
+    }
+  }
+
+  AudioScheduledSourceNode::start(when);
+}
+
+void AudioFileSourceNode::pause() {
+  filePaused_.store(true, std::memory_order_release);
+}
+
 void AudioFileSourceNode::disable() {
+  filePaused_.store(false, std::memory_order_release);
+  fileStarted_ = false;
   if (FFmpegNeeded_) {
     decoder.close();
   } else {
@@ -129,6 +146,11 @@ std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processNode(
     processingBuffer->zero(0, startOffset);
   }
 
+  if (filePaused_.load(std::memory_order_acquire)) {
+    processingBuffer->zero(startOffset, nonSilentFrames);
+    return processingBuffer;
+  }
+
   auto &state = *decoderState_;
   size_t framesReadCount = 0;
   if (FFmpegNeeded_) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
index cbe61e694..525a3cfcf 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
@@ -36,6 +36,8 @@ class AudioFileSourceNode : public AudioScheduledSourceNode {
 
   void disable() override;
 
+  void start(double when) override;
+
   float getVolume() const {
     return volume_.load(std::memory_order_acquire);
   }
@@ -44,6 +46,8 @@ class AudioFileSourceNode : public AudioScheduledSourceNode {
     volume_.store(v, std::memory_order_release);
   }
 
+  void pause();
+
  protected:
   std::shared_ptr<DSPAudioBuffer> processNode(
       const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
@@ -55,6 +59,8 @@ class AudioFileSourceNode : public AudioScheduledSourceNode {
   bool FFmpegNeeded_;
   ffmpegdecoder::FFmpegDecoder decoder;
   ffmpegdecoder::FFmpegDecoderConfig cfg;
+  std::atomic<bool> filePaused_{false};
+  bool fileStarted_{false};
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/src/api.ts b/packages/react-native-audio-api/src/api.ts
index b2e369df7..2cd0f3728 100644
--- a/packages/react-native-audio-api/src/api.ts
+++ b/packages/react-native-audio-api/src/api.ts
@@ -4,7 +4,6 @@ export { default as AnalyserNode } from './core/AnalyserNode';
 export { default as AudioBuffer } from './core/AudioBuffer';
 export { default as AudioBufferQueueSourceNode } from './core/AudioBufferQueueSourceNode';
 export { default as AudioBufferSourceNode } from './core/AudioBufferSourceNode';
-export { default as AudioFileSourceNode } from './core/AudioFileSourceNode';
 export { default as AudioContext } from './core/AudioContext';
 export { decodeAudioData, decodePCMInBase64 } from './core/AudioDecoder';
 export { default as AudioDestinationNode } from './core/AudioDestinationNode';
diff --git a/packages/react-native-audio-api/src/core/AudioFileSourceNode.ts b/packages/react-native-audio-api/src/core/AudioFileSourceNode.ts
deleted file mode 100644
index 9fd253c30..000000000
--- a/packages/react-native-audio-api/src/core/AudioFileSourceNode.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import { IAudioFileSourceNode } from '../interfaces';
-import AudioScheduledSourceNode from './AudioScheduledSourceNode';
-import BaseAudioContext from './BaseAudioContext';
-
-export default class AudioFileSourceNode extends AudioScheduledSourceNode {
-  constructor(context: BaseAudioContext, source: ArrayBuffer | string) {
-    const node = context.context.createFileSource(source);
-    super(context, node);
-  }
-
-  get volume(): number {
-    return (this.node as IAudioFileSourceNode).volume ?? 1;
-  }
-
-  set volume(value: number) {
-    (this.node as IAudioFileSourceNode).volume = value;
-  }
-}
diff --git a/packages/react-native-audio-api/src/core/BaseAudioContext.ts b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
index 09bc19baa..55d354e4e 100644
--- a/packages/react-native-audio-api/src/core/BaseAudioContext.ts
+++ b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
@@ -10,7 +10,6 @@ import AnalyserNode from './AnalyserNode';
 import AudioBuffer from './AudioBuffer';
 import AudioBufferQueueSourceNode from './AudioBufferQueueSourceNode';
 import AudioBufferSourceNode from './AudioBufferSourceNode';
-import AudioFileSourceNode from './AudioFileSourceNode';
 import { decodeAudioData, decodePCMInBase64 } from './AudioDecoder';
 import AudioDestinationNode from './AudioDestinationNode';
 import BiquadFilterNode from './BiquadFilterNode';
@@ -135,10 +134,6 @@ export default class BaseAudioContext {
     return new StreamerNode(this, { streamPath });
   }
 
-  createAudioFileSource(source: ArrayBuffer | string): AudioFileSourceNode {
-    return new AudioFileSourceNode(this, source);
-  }
-
   createConstantSource(): ConstantSourceNode {
     return new ConstantSourceNode(this);
   }
diff --git a/packages/react-native-audio-api/src/development/react/Audio/Audio.tsx b/packages/react-native-audio-api/src/development/react/Audio/Audio.tsx
index 687ae3d3b..469eecaf1 100644
--- a/packages/react-native-audio-api/src/development/react/Audio/Audio.tsx
+++ b/packages/react-native-audio-api/src/development/react/Audio/Audio.tsx
@@ -7,26 +7,34 @@ import React, {
   useState,
 } from 'react';
 
-import AudioFileSourceNode from '../../../core/AudioFileSourceNode';
-import type { AudioProps, AudioURISource } from './types';
+import { IAudioFileSourceNode } from '../../../interfaces';
+import type {
+  AudioProps,
+  AudioTagPlaybackState,
+  AudioURISource,
+} from './types';
 import { useStableAudioProps } from './utils';
 
 export type AudioComponentContextType = {
   play: () => void;
+  pause: () => void;
   volume: number;
   setVolume: (volume: number) => void;
   muted: boolean;
   setMuted: (muted: boolean) => void;
   isReady: boolean;
+  playbackState: AudioTagPlaybackState;
 };
 
 export const AudioComponentContext = createContext<AudioComponentContextType>({
   play: () => {},
+  pause: () => {},
   volume: 1,
   setVolume: () => {},
   muted: false,
   setMuted: () => {},
   isReady: false,
+  playbackState: 'idle',
 });
 
 const Audio: React.FC<AudioProps> = (inProps) => {
@@ -53,10 +61,18 @@ const Audio: React.FC<AudioProps> = (inProps) => {
     return (source as AudioURISource).uri ?? '';
   }, [source]);
 
-  const nodeRef = useRef<AudioFileSourceNode | null>(null);
+  const nodeRef = useRef<IAudioFileSourceNode | null>(null);
   const [volumeState, setVolumeState] = useState(volume);
   const [mutedState, setMutedState] = useState(muted);
   const [isReady, setIsReady] = useState(false);
+  const [playbackState, setPlaybackState] =
+    useState<AudioTagPlaybackState>('idle');
+
+  const volumeStateRef = useRef(volumeState);
+  volumeStateRef.current = volumeState;
+
+  const mutedStateRef = useRef(mutedState);
+  mutedStateRef.current = mutedState;
 
   const contextRef = useRef(context);
   contextRef.current = context;
@@ -75,20 +91,30 @@ const Audio: React.FC<AudioProps> = (inProps) => {
     if (!n || !ctx) {
       return;
     }
-    n.connect(ctx.destination);
+    // @ts-ignore - internal
+    n.connect(ctx.destination.node);
     n.start(0);
+    setPlaybackState('playing');
+  }, []);
+
+  const pause = useCallback(() => {
+    if (!nodeRef.current) {
+      return;
+    }
+    nodeRef.current.pause();
+    setPlaybackState((s) => (s === 'idle' ? 'idle' : 'paused'));
   }, []);
 
   const attachNode = useCallback(
-    (n: AudioFileSourceNode) => {
-      n.volume = volumeState;
+    (n: IAudioFileSourceNode) => {
+      n.volume = mutedStateRef.current ? 0 : volumeStateRef.current;
       nodeRef.current = n;
       setIsReady(true);
       if (autoPlay) {
         play();
       }
     },
-    [autoPlay, play, volumeState]
+    [autoPlay, play]
   );
 
   useEffect(() => {
@@ -100,34 +126,40 @@ const Audio: React.FC<AudioProps> = (inProps) => {
       if (path.startsWith('http')) {
         const response = await fetch(path);
         const arrayBuffer = await response.arrayBuffer();
-        attachNode(new AudioFileSourceNode(context, arrayBuffer));
+        attachNode(context.context.createFileSource(arrayBuffer));
       } else {
-        attachNode(new AudioFileSourceNode(context, path));
+        attachNode(context.context.createFileSource(path));
       }
     };
 
     setIsReady(false);
+    setPlaybackState('idle');
     run();
 
     return () => {
-      nodeRef.current?.disconnect();
+      const prev = nodeRef.current;
+      if (prev) {
+        prev.onEnded = '0';
+      }
+      prev?.disconnect(undefined);
       nodeRef.current = null;
       setIsReady(false);
+      setPlaybackState('idle');
     };
   }, [path, context, attachNode]);
 
   useEffect(() => {
     const n = nodeRef.current;
     if (n) {
-      n.volume = volumeState;
+      n.volume = mutedState ? 0 : volumeState;
     }
-  }, [volumeState]);
+  }, [volumeState, mutedState]);
 
   const setVolume = useCallback((next: number) => {
     setVolumeState(next);
     const n = nodeRef.current;
     if (n) {
-      n.volume = next;
+      n.volume = mutedStateRef.current ? 0 : next;
     }
   }, []);
 
@@ -149,13 +181,24 @@ const Audio: React.FC<AudioProps> = (inProps) => {
   const ctxValue = useMemo(
     () => ({
       play,
+      pause,
       volume: volumeState,
       setVolume,
       muted: mutedState,
       setMuted,
       isReady,
+      playbackState,
     }),
-    [play, setVolume, volumeState, mutedState, setMuted, isReady]
+    [
+      play,
+      pause,
+      setVolume,
+      volumeState,
+      mutedState,
+      setMuted,
+      isReady,
+      playbackState,
+    ]
   );
 
   if (context === null) {
diff --git a/packages/react-native-audio-api/src/development/react/Audio/Audio.web.tsx b/packages/react-native-audio-api/src/development/react/Audio/Audio.web.tsx
index ee08e257e..5ffb79ca3 100644
--- a/packages/react-native-audio-api/src/development/react/Audio/Audio.web.tsx
+++ b/packages/react-native-audio-api/src/development/react/Audio/Audio.web.tsx
@@ -5,7 +5,7 @@ import React, {
   useRef,
   useState,
 } from 'react';
-import type { AudioProps } from './types';
+import type { AudioProps, AudioTagPlaybackState } from './types';
 import { AudioComponentContext } from './Audio';
 import { useStableAudioProps } from './utils';
 
@@ -30,6 +30,8 @@ const Audio: React.FC<AudioProps> = (props) => {
   const [volumeState, setVolumeState] = useState(volume);
   const [mutedState, setMutedState] = useState(muted);
   const [isReady, setIsReady] = useState(false);
+  const [playbackState, setPlaybackState] =
+    useState<AudioTagPlaybackState>('idle');
 
   useEffect(() => {
     setVolumeState(volume);
@@ -57,6 +59,10 @@ const Audio: React.FC<AudioProps> = (props) => {
     audioRef.current?.play()?.catch(() => {});
   }, []);
 
+  const pause = useCallback(() => {
+    audioRef.current?.pause();
+  }, []);
+
   const setVolume = useCallback((next: number) => {
     setVolumeState(next);
     const el = audioRef.current;
@@ -76,13 +82,24 @@ const Audio: React.FC<AudioProps> = (props) => {
   const ctxValue = useMemo(
     () => ({
       play,
+      pause,
       volume: volumeState,
       setVolume,
       muted: mutedState,
       setMuted,
       isReady,
+      playbackState,
     }),
-    [play, setVolume, volumeState, mutedState, setMuted, isReady]
+    [
+      play,
+      pause,
+      setVolume,
+      volumeState,
+      mutedState,
+      setMuted,
+      isReady,
+      playbackState,
+    ]
   );
 
   return (
@@ -92,6 +109,11 @@ const Audio: React.FC<AudioProps> = (props) => {
         muted={mutedState}
         ref={audioRef}
         onLoadedData={() => setIsReady(true)}
+        onPlay={() => setPlaybackState('playing')}
+        onPause={() =>
+          setPlaybackState((s) => (s === 'playing' ? 'paused' : s))
+        }
+        onEnded={() => setPlaybackState('idle')}
       />
       {children}
     </AudioComponentContext.Provider>
diff --git a/packages/react-native-audio-api/src/development/react/Audio/index.ts b/packages/react-native-audio-api/src/development/react/Audio/index.ts
index eeafee03a..086043633 100644
--- a/packages/react-native-audio-api/src/development/react/Audio/index.ts
+++ b/packages/react-native-audio-api/src/development/react/Audio/index.ts
@@ -1,4 +1,9 @@
 export { default } from './Audio';
 export { AudioComponentContext } from './Audio';
 
-export type { AudioProps, AudioSource, TimeRanges } from './types';
+export type {
+  AudioProps,
+  AudioSource,
+  AudioTagPlaybackState,
+  TimeRanges,
+} from './types';
diff --git a/packages/react-native-audio-api/src/development/react/Audio/types.ts b/packages/react-native-audio-api/src/development/react/Audio/types.ts
index c74f6ae0c..36f109fbf 100644
--- a/packages/react-native-audio-api/src/development/react/Audio/types.ts
+++ b/packages/react-native-audio-api/src/development/react/Audio/types.ts
@@ -26,6 +26,12 @@ export type AudioSource =
 
 export type PreloadType = 'auto' | 'metadata' | 'none';
 
+/**
+ * Playback phase exposed on `<Audio />` context (native file source or
+ * `<audio>` element).
+ */
+export type AudioTagPlaybackState = 'idle' | 'playing' | 'paused';
+
 interface AudioControlProps {
   autoPlay: boolean;
   controls: boolean; // TBD: should we support control display at all?
diff --git a/packages/react-native-audio-api/src/interfaces.ts b/packages/react-native-audio-api/src/interfaces.ts
index f2cf8a609..aeea1a8b3 100644
--- a/packages/react-native-audio-api/src/interfaces.ts
+++ b/packages/react-native-audio-api/src/interfaces.ts
@@ -231,6 +231,7 @@ export interface IAudioBufferQueueSourceNode
 
 export interface IAudioFileSourceNode extends IAudioScheduledSourceNode {
   volume?: number;
+  pause: () => void;
 }
 
 export interface IConvolverNode extends IAudioNode {

From 1935fba2f2a2c5388d87a0b4a046828ee94dce6c Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Fri, 20 Mar 2026 11:35:49 +0100
Subject: [PATCH 6/8] fix: tests

---
 .../common/cpp/audioapi/core/BaseAudioContext.cpp               | 2 ++
 .../common/cpp/audioapi/core/BaseAudioContext.h                 | 2 ++
 packages/react-native-audio-api/common/cpp/test/CMakeLists.txt  | 1 +
 3 files changed, 5 insertions(+)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
index 98ea980d4..41e95a136 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.cpp
@@ -178,12 +178,14 @@ std::shared_ptr<AudioBufferSourceNode> BaseAudioContext::createBufferSource(
   return bufferSource;
 }
 
+#if !RN_AUDIO_API_TEST
 std::shared_ptr<AudioFileSourceNode> BaseAudioContext::createFileSource(
     const AudioFileSourceOptions &options) {
   auto fileSource = std::make_shared<AudioFileSourceNode>(shared_from_this(), options);
   graphManager_->addSourceNode(fileSource);
   return fileSource;
 }
+#endif // RN_AUDIO_API_TEST
 
 std::shared_ptr<IIRFilterNode> BaseAudioContext::createIIRFilter(const IIRFilterOptions &options) {
   auto iirFilter = std::make_shared<IIRFilterNode>(shared_from_this(), options);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
index dd2c9c74e..4e2d97e05 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/BaseAudioContext.h
@@ -95,7 +95,9 @@ class BaseAudioContext : public std::enable_shared_from_this<BaseAudioContext> {
   std::shared_ptr<BiquadFilterNode> createBiquadFilter(const BiquadFilterOptions &options);
   std::shared_ptr<AudioBufferSourceNode> createBufferSource(
       const AudioBufferSourceOptions &options);
+#if !RN_AUDIO_API_TEST
   std::shared_ptr<AudioFileSourceNode> createFileSource(const AudioFileSourceOptions &options);
+#endif // RN_AUDIO_API_TEST
   std::shared_ptr<AudioBufferQueueSourceNode> createBufferQueueSource(
       const BaseAudioBufferSourceOptions &options);
   std::shared_ptr<PeriodicWave> createPeriodicWave(
diff --git a/packages/react-native-audio-api/common/cpp/test/CMakeLists.txt b/packages/react-native-audio-api/common/cpp/test/CMakeLists.txt
index b363b9631..a010be6a5 100644
--- a/packages/react-native-audio-api/common/cpp/test/CMakeLists.txt
+++ b/packages/react-native-audio-api/common/cpp/test/CMakeLists.txt
@@ -38,6 +38,7 @@ list(FILTER RNAUDIOAPI_SRC EXCLUDE REGEX ".*/Worklet.*Node\\.cpp$")
 list(REMOVE_ITEM RNAUDIOAPI_SRC
   "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/core/AudioContext.cpp"
   "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp"
+  "${REACT_NATIVE_AUDIO_API_DIR}/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp"
 )
 
 file(GLOB_RECURSE RNAUDIOAPI_LIBS

From 9b0e748e8bd76a0c5089927d7c0c22fb3ff4a0c9 Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Fri, 20 Mar 2026 11:41:06 +0100
Subject: [PATCH 7/8] fix: testsV2

---
 .../common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp  | 2 ++
 .../common/cpp/audioapi/core/sources/AudioFileSourceNode.h    | 4 ++++
 2 files changed, 6 insertions(+)

diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
index c4f56b14a..eae025cf1 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
@@ -154,7 +154,9 @@ std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processNode(
   auto &state = *decoderState_;
   size_t framesReadCount = 0;
   if (FFmpegNeeded_) {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
     framesReadCount = decoder.readPcmFrames(state.interleavedBuffer.data(), nonSilentFrames);
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
   } else {
     ma_uint64 framesRead = 0;
     ma_decoder_read_pcm_frames(
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
index 525a3cfcf..ae5c57615 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
@@ -1,7 +1,9 @@
 #pragma once
 
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#if !RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/libs/miniaudio/miniaudio.h>
 
 #include <atomic>
@@ -57,8 +59,10 @@ class AudioFileSourceNode : public AudioScheduledSourceNode {
   std::shared_ptr<AudioFileDecoderState> decoderState_;
   std::atomic<float> volume_;
   bool FFmpegNeeded_;
+#if !RN_AUDIO_API_FFMPEG_DISABLED
   ffmpegdecoder::FFmpegDecoder decoder;
   ffmpegdecoder::FFmpegDecoderConfig cfg;
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
   std::atomic<bool> filePaused_{false};
   bool fileStarted_{false};
 };

From df70d91d457a33e663de7620678a7ab3e4f2c08e Mon Sep 17 00:00:00 2001
From: michal <dydmichal@gmail.com>
Date: Fri, 20 Mar 2026 16:22:41 +0100
Subject: [PATCH 8/8] feat: loop controls state

---
 .../src/examples/AudioStream/AudioContent.tsx |  11 +-
 .../src/examples/AudioStream/AudioTag.tsx     |  11 +-
 .../src/examples/AudioStream/PlayButton.tsx   |   5 +-
 .../src/examples/AudioStream/VolumeSlider.tsx |   5 +-
 .../src/examples/AudioStream/index.ts         |   1 +
 .../sources/AudioFileSourceNodeHostObject.cpp |  24 ++
 .../sources/AudioFileSourceNodeHostObject.h   |   4 +
 .../core/sources/AudioFileSourceNode.cpp      | 228 +++++++++++-----
 .../core/sources/AudioFileSourceNode.h        |  53 +++-
 .../audioapi/libs/ffmpeg/FFmpegDecoding.cpp   | 100 ++++---
 .../cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h |  16 +-
 .../src/development/react/Audio/Audio.tsx     | 102 ++++----
 .../src/development/react/Audio/Audio.web.tsx |  30 ++-
 .../development/react/Audio/AudioControls.tsx | 247 ++++++++++++++++++
 .../react/Audio/AudioTagContext.ts            |  29 ++
 .../src/development/react/Audio/index.ts      |   2 +-
 .../src/development/react/Audio/types.ts      |   2 +-
 .../src/development/react/Audio/utils.ts      |   8 +-
 .../src/development/react/index.ts            |   1 +
 .../react-native-audio-api/src/interfaces.ts  |   3 +
 20 files changed, 692 insertions(+), 190 deletions(-)
 create mode 100644 packages/react-native-audio-api/src/development/react/Audio/AudioControls.tsx
 create mode 100644 packages/react-native-audio-api/src/development/react/Audio/AudioTagContext.ts

diff --git a/apps/common-app/src/examples/AudioStream/AudioContent.tsx b/apps/common-app/src/examples/AudioStream/AudioContent.tsx
index ca59889b1..3c136ab7e 100644
--- a/apps/common-app/src/examples/AudioStream/AudioContent.tsx
+++ b/apps/common-app/src/examples/AudioStream/AudioContent.tsx
@@ -1,20 +1,17 @@
-import { useContext } from 'react';
-import { AudioComponentContext } from 'react-native-audio-api/development/react';
+import { useAudioTagContext } from 'react-native-audio-api/development/react';
 import { ActivityIndicator, Button, Text, View } from 'react-native';
 import VolumeSlider from './VolumeSlider';
 import { Spacer } from '../../components';
 
 const AudioContent: React.FC = () => {
-  const { isReady, play, pause, playbackState, setMuted, muted } = useContext(
-    AudioComponentContext
-  );
+  const { isReady, play, pause, playbackState, setMuted, muted } = useAudioTagContext();
 
   return (
     <View>
       {!isReady ? (
         <ActivityIndicator color="#fff" />
       ) : (
-        <>
+        <View style={{ justifyContent: 'center', alignItems: 'center' }}>
           <Text style={{ color: '#fff' }}>{playbackState}</Text>
           <Spacer.Vertical size={12} />
           <Button
@@ -32,7 +29,7 @@ const AudioContent: React.FC = () => {
           <Spacer.Vertical size={12} />
           <Spacer.Vertical size={50} />
           <VolumeSlider />
-        </>
+        </View>
       )}
     </View>
   );
diff --git a/apps/common-app/src/examples/AudioStream/AudioTag.tsx b/apps/common-app/src/examples/AudioStream/AudioTag.tsx
index da3cd6407..fbac30a43 100644
--- a/apps/common-app/src/examples/AudioStream/AudioTag.tsx
+++ b/apps/common-app/src/examples/AudioStream/AudioTag.tsx
@@ -3,21 +3,20 @@ import { View } from 'react-native';
 import { Audio } from 'react-native-audio-api/development/react';
 
 import { Container } from '../../components';
-import { layout } from '../../styles';
 import AudioContent from './AudioContent';
 
 const DEMO_AUDIO_URL =
-  'https://filesamples.com/samples/audio/aac/sample4.aac';
+  'https://filesampleshub.com/download/audio/aac/sample1.AAC';
   // '/data/data/com.fabricexample/cache/audio.wav';
 
 const AudioTag: React.FC = () => {
   return (
     <Container disablePadding>
       <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
-        <View style={{ marginTop: layout.spacing * 2 }}>
-          <Audio source={DEMO_AUDIO_URL} volume={0.3} autoPlay>
-            <AudioContent />
-          </Audio>
+        <View style={{ width: '90%' }}>
+          <Audio source={DEMO_AUDIO_URL} volume={0.7} controls/>
+            {/* <AudioContent /> */}
+          {/* </Audio> */}
         </View>
       </View>
     </Container>
diff --git a/apps/common-app/src/examples/AudioStream/PlayButton.tsx b/apps/common-app/src/examples/AudioStream/PlayButton.tsx
index 2ee696d74..a2d96bde3 100644
--- a/apps/common-app/src/examples/AudioStream/PlayButton.tsx
+++ b/apps/common-app/src/examples/AudioStream/PlayButton.tsx
@@ -1,9 +1,8 @@
-import { useContext } from 'react';
-import { AudioComponentContext } from 'react-native-audio-api/development/react';
+import { useAudioTagContext } from 'react-native-audio-api/development/react';
 import { Button } from 'react-native';
 
 const AudioPlayerButton: React.FC = () => {
-  const { play } = useContext(AudioComponentContext);
+  const { play } = useAudioTagContext();
 
   return (
     <Button onPress={play} title="Play" />
diff --git a/apps/common-app/src/examples/AudioStream/VolumeSlider.tsx b/apps/common-app/src/examples/AudioStream/VolumeSlider.tsx
index da49ade3a..fa20eae75 100644
--- a/apps/common-app/src/examples/AudioStream/VolumeSlider.tsx
+++ b/apps/common-app/src/examples/AudioStream/VolumeSlider.tsx
@@ -1,10 +1,9 @@
-import { useContext } from 'react';
-import { AudioComponentContext } from 'react-native-audio-api/development/react';
+import { useAudioTagContext } from 'react-native-audio-api/development/react';
 import { Slider } from '../../components';
 import { View } from 'react-native';
 
 const VolumeSlider: React.FC = () => {
-  const { volume, setVolume } = useContext(AudioComponentContext);
+  const { volume, setVolume } = useAudioTagContext();
 
   return (
     <View style={{ width: 200 }}>
diff --git a/apps/common-app/src/examples/AudioStream/index.ts b/apps/common-app/src/examples/AudioStream/index.ts
index e69de29bb..ad47e827f 100644
--- a/apps/common-app/src/examples/AudioStream/index.ts
+++ b/apps/common-app/src/examples/AudioStream/index.ts
@@ -0,0 +1 @@
+export { default } from './AudioTag';
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
index 4ccfd97e8..20b5c591e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
@@ -14,6 +14,10 @@ AudioFileSourceNodeHostObject::AudioFileSourceNodeHostObject(
     : AudioScheduledSourceNodeHostObject(context->createFileSource(options), options) {
   addGetters(JSI_EXPORT_PROPERTY_GETTER(AudioFileSourceNodeHostObject, volume));
   addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioFileSourceNodeHostObject, volume));
+  addGetters(JSI_EXPORT_PROPERTY_GETTER(AudioFileSourceNodeHostObject, loop));
+  addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioFileSourceNodeHostObject, loop));
+  addGetters(JSI_EXPORT_PROPERTY_GETTER(AudioFileSourceNodeHostObject, currentTime));
+  addGetters(JSI_EXPORT_PROPERTY_GETTER(AudioFileSourceNodeHostObject, duration));
 
   addFunctions(JSI_EXPORT_FUNCTION(AudioFileSourceNodeHostObject, pause));
 }
@@ -28,6 +32,26 @@ JSI_PROPERTY_SETTER_IMPL(AudioFileSourceNodeHostObject, volume) {
   node->setVolume(static_cast<float>(value.getNumber()));
 }
 
+JSI_PROPERTY_GETTER_IMPL(AudioFileSourceNodeHostObject, loop) {
+  auto node = std::static_pointer_cast<AudioFileSourceNode>(node_);
+  return jsi::Value(node->getLoop());
+}
+
+JSI_PROPERTY_SETTER_IMPL(AudioFileSourceNodeHostObject, loop) {
+  auto node = std::static_pointer_cast<AudioFileSourceNode>(node_);
+  node->setLoop(value.getBool());
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioFileSourceNodeHostObject, currentTime) {
+  auto node = std::static_pointer_cast<AudioFileSourceNode>(node_);
+  return jsi::Value(node->getCurrentTime());
+}
+
+JSI_PROPERTY_GETTER_IMPL(AudioFileSourceNodeHostObject, duration) {
+  auto node = std::static_pointer_cast<AudioFileSourceNode>(node_);
+  return jsi::Value(node->getDuration());
+}
+
 JSI_HOST_FUNCTION_IMPL(AudioFileSourceNodeHostObject, pause) {
   auto audioFileSourceNode = std::static_pointer_cast<AudioFileSourceNode>(node_);
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h
index cf7a5497e..222978337 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h
@@ -20,6 +20,10 @@ class AudioFileSourceNodeHostObject : public AudioScheduledSourceNodeHostObject
 
   JSI_PROPERTY_GETTER_DECL(volume);
   JSI_PROPERTY_SETTER_DECL(volume);
+  JSI_PROPERTY_GETTER_DECL(loop);
+  JSI_PROPERTY_SETTER_DECL(loop);
+  JSI_PROPERTY_GETTER_DECL(currentTime);
+  JSI_PROPERTY_GETTER_DECL(duration);
 
   JSI_HOST_FUNCTION_DECL(pause);
 };
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
index eae025cf1..d37ae7488 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
@@ -10,7 +10,6 @@
 
 #include <cstdio>
 #include <memory>
-#include <utility>
 
 namespace audioapi {
 
@@ -27,59 +26,75 @@ AudioFileSourceNode::AudioFileSourceNode(
       state->memoryData = options.data;
     }
     if (useFilePath) {
+      state->filePath = options.filePath;
       FFmpegNeeded_ = AudioDecoder::pathHasExtension(options.filePath, {".mp4", ".m4a", ".aac"});
     } else {
       auto format = AudioDecoder::detectAudioFormat(options.data.data(), options.data.size());
       FFmpegNeeded_ =
           format == AudioFormat::MP4 || format == AudioFormat::M4A || format == AudioFormat::AAC;
     }
+    initDecoders(useFilePath, context, state);
+  }
 
-    if (FFmpegNeeded_) {
+  isInitialized_.store(true, std::memory_order_release);
+}
+
+void AudioFileSourceNode::initDecoders(
+    bool useFilePath,
+    const std::shared_ptr<BaseAudioContext> &context,
+    const std::shared_ptr<AudioFileDecoderState> &state) {
+  if (FFmpegNeeded_) {
 #if RN_AUDIO_API_FFMPEG_DISABLED
-      assert(false && "File codec is not supported when FFmpeg is disabled");
+    assert(false && "File codec is not supported when FFmpeg is disabled");
 #else
-      ffmpegdecoder::ffmpegDecoderConfigInit(&cfg, static_cast<int>(context->getSampleRate()));
-      bool result;
-      if (useFilePath) {
-        result = decoder.openFile(cfg, options.filePath);
-      } else {
-        result = decoder.openMemory(cfg, state->memoryData.data(), state->memoryData.size());
-      }
-      if (result) {
-        state->channels = decoder.outputChannels();
-        state->sampleRate = static_cast<float>(decoder.outputSampleRate());
-        state->interleavedBuffer.resize(RENDER_QUANTUM_SIZE * state->channels);
-        decoderState_ = std::move(state);
-        channelCount_ = decoderState_->channels;
-      }
+    ffmpegdecoder::ffmpegDecoderConfigInit(&cfg, static_cast<int>(context->getSampleRate()));
+    bool result;
+    if (useFilePath) {
+      result = decoder.openFile(cfg, state->filePath);
+    } else {
+      result = decoder.openMemory(cfg, state->memoryData.data(), state->memoryData.size());
+    }
+    if (result) {
+      state->channels = decoder.outputChannels();
+      state->sampleRate = static_cast<float>(decoder.outputSampleRate());
+      duration_.store(decoder.getDurationInSeconds(), std::memory_order_release);
+    } else {
+      decoder.close();
+    }
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
+  } else {
+    ma_decoder_config config =
+        ma_decoder_config_init(ma_format_f32, 0, static_cast<ma_uint32>(context->getSampleRate()));
+    ma_decoding_backend_vtable *customBackends[] = {
+        ma_decoding_backend_libvorbis, ma_decoding_backend_libopus};
+    config.ppCustomBackendVTables = customBackends;
+    config.customBackendCount = sizeof(customBackends) / sizeof(customBackends[0]);
+
+    maDecoder_ = std::make_unique<ma_decoder>();
+    ma_result result;
+    if (useFilePath) {
+      result = ma_decoder_init_file(state->filePath.c_str(), &config, maDecoder_.get());
     } else {
-      ma_decoder_config config = ma_decoder_config_init(
-          ma_format_f32, 0, static_cast<ma_uint32>(context->getSampleRate()));
-      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 result;
-      if (useFilePath) {
-        result = ma_decoder_init_file(options.filePath.c_str(), &config, &state->decoder);
-      } else {
-        result = ma_decoder_init_memory(
-            state->memoryData.data(), state->memoryData.size(), &config, &state->decoder);
-      }
+      result = ma_decoder_init_memory(
+          state->memoryData.data(), state->memoryData.size(), &config, maDecoder_.get());
+    }
 
-      if (result == MA_SUCCESS) {
-        state->channels = static_cast<int>(state->decoder.outputChannels);
-        state->sampleRate = static_cast<float>(state->decoder.outputSampleRate);
-        state->interleavedBuffer.resize(RENDER_QUANTUM_SIZE * state->channels);
-        decoderState_ = std::move(state);
-        channelCount_ = decoderState_->channels;
+    if (result == MA_SUCCESS) {
+      state->channels = static_cast<int>(maDecoder_->outputChannels);
+      state->sampleRate = static_cast<float>(maDecoder_->outputSampleRate);
+      ma_uint64 length = 0;
+      if (ma_decoder_get_length_in_pcm_frames(maDecoder_.get(), &length) == MA_SUCCESS) {
+        duration_.store(static_cast<double>(length) / state->sampleRate, std::memory_order_release);
       }
+    } else {
+      ma_decoder_uninit(maDecoder_.get());
+      maDecoder_.reset();
     }
   }
-
-  isInitialized_.store(true, std::memory_order_release);
+  state->interleavedBuffer.resize(RENDER_QUANTUM_SIZE * state->channels);
+  decoderState_ = state;
+  channelCount_ = decoderState_->channels;
+  sampleRate_ = decoderState_->sampleRate;
 }
 
 void AudioFileSourceNode::setDecoderState(const std::shared_ptr<AudioFileDecoderState> &state) {
@@ -105,14 +120,108 @@ void AudioFileSourceNode::pause() {
 void AudioFileSourceNode::disable() {
   filePaused_.store(false, std::memory_order_release);
   fileStarted_ = false;
+  totalFramesRead_ = 0;
   if (FFmpegNeeded_) {
     decoder.close();
-  } else {
-    ma_decoder_uninit(&decoderState_->decoder);
+  } else if (maDecoder_ != nullptr) {
+    ma_decoder_uninit(maDecoder_.get());
+    maDecoder_.reset();
   }
   AudioScheduledSourceNode::disable();
 }
 
+size_t AudioFileSourceNode::readFrames(float *buf, size_t frameCount) {
+  if (FFmpegNeeded_) {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+    return decoder.readPcmFrames(buf, frameCount);
+#else
+    return 0;
+#endif
+  }
+  if (maDecoder_ == nullptr) {
+    return 0;
+  }
+  ma_uint64 framesRead = 0;
+  ma_decoder_read_pcm_frames(maDecoder_.get(), buf, frameCount, &framesRead);
+  return static_cast<size_t>(framesRead);
+}
+
+bool AudioFileSourceNode::seekToStart() {
+  bool seeked = false;
+  if (FFmpegNeeded_) {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+    seeked = decoder.seekToStart();
+#endif
+  } else if (maDecoder_ != nullptr) {
+    seeked = ma_decoder_seek_to_pcm_frame(maDecoder_.get(), 0) == MA_SUCCESS;
+  }
+  if (seeked) {
+    totalFramesRead_ = 0;
+    currentTime_.store(0.0, std::memory_order_release);
+  }
+  return seeked;
+}
+
+void AudioFileSourceNode::writeInterleavedToBuffer(
+    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
+    const AudioFileDecoderState &state,
+    size_t destSampleOffset,
+    size_t frameCount,
+    float vol) {
+  if (vol == 0) {
+    processingBuffer->zero();
+    return;
+  }
+  auto numOutputChannels = static_cast<int>(processingBuffer->getNumberOfChannels());
+  for (size_t i = 0; i < frameCount; i++) {
+    for (int ch = 0; ch < numOutputChannels; ch++) {
+      int srcCh = ch < state.channels ? ch : state.channels - 1;
+      processingBuffer->getChannel(ch)->span()[destSampleOffset + i] =
+          vol * state.interleavedBuffer[i * state.channels + srcCh];
+    }
+  }
+}
+
+size_t AudioFileSourceNode::handleEof(
+    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
+    size_t nonSilentFrames,
+    size_t framesRead,
+    float vol,
+    size_t startOffset) {
+  if (!loop_.load(std::memory_order_acquire)) {
+    currentTime_.store(decoder.getDurationInSeconds(), std::memory_order_release);
+    playbackState_ = PlaybackState::STOP_SCHEDULED;
+    return framesRead;
+  }
+
+  if (!seekToStart()) {
+    currentTime_.store(decoder.getDurationInSeconds(), std::memory_order_release);
+    playbackState_ = PlaybackState::STOP_SCHEDULED;
+    return framesRead;
+  }
+
+  playbackState_ = PlaybackState::PLAYING;
+
+  size_t toFill = nonSilentFrames - framesRead;
+  if (toFill == 0) {
+    return framesRead;
+  }
+
+  auto &state = *decoderState_;
+  size_t extra = readFrames(state.interleavedBuffer.data(), toFill);
+  totalFramesRead_ += extra;
+  if (sampleRate_ > 0) {
+    currentTime_.store(
+        static_cast<double>(totalFramesRead_) / sampleRate_, std::memory_order_release);
+  }
+
+  if (vol != 0) {
+    writeInterleavedToBuffer(processingBuffer, state, startOffset + framesRead, extra, vol);
+  }
+
+  return framesRead + extra;
+}
+
 std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processNode(
     const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
     int framesToProcess) {
@@ -146,41 +255,26 @@ std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processNode(
     processingBuffer->zero(0, startOffset);
   }
 
+  auto &state = *decoderState_;
+
   if (filePaused_.load(std::memory_order_acquire)) {
     processingBuffer->zero(startOffset, nonSilentFrames);
     return processingBuffer;
   }
 
-  auto &state = *decoderState_;
-  size_t framesReadCount = 0;
-  if (FFmpegNeeded_) {
-#if !RN_AUDIO_API_FFMPEG_DISABLED
-    framesReadCount = decoder.readPcmFrames(state.interleavedBuffer.data(), nonSilentFrames);
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
-  } else {
-    ma_uint64 framesRead = 0;
-    ma_decoder_read_pcm_frames(
-        &state.decoder, state.interleavedBuffer.data(), nonSilentFrames, &framesRead);
-    framesReadCount = static_cast<size_t>(framesRead);
+  size_t framesRead = readFrames(state.interleavedBuffer.data(), nonSilentFrames);
+  totalFramesRead_ += framesRead;
+  if (sampleRate_ > 0) {
+    currentTime_.store(
+        static_cast<double>(totalFramesRead_) / sampleRate_, std::memory_order_release);
   }
 
   const float vol = volume_.load(std::memory_order_acquire);
-  if (vol == 0) {
-    processingBuffer->zero();
-  } else {
-    int numOutputChannels = processingBuffer->getNumberOfChannels();
-    for (size_t i = 0; i < framesReadCount; i++) {
-      for (int ch = 0; ch < numOutputChannels; ch++) {
-        int srcCh = ch < state.channels ? ch : state.channels - 1;
-        processingBuffer->getChannel(ch)->span()[startOffset + i] =
-            vol * state.interleavedBuffer[i * state.channels + srcCh];
-      }
-    }
+  writeInterleavedToBuffer(processingBuffer, state, startOffset, framesRead, vol);
 
-    if (framesReadCount < nonSilentFrames) {
-      processingBuffer->zero(startOffset + framesReadCount, nonSilentFrames - framesReadCount);
-      playbackState_ = PlaybackState::STOP_SCHEDULED;
-    }
+  if (framesRead < nonSilentFrames) {
+    size_t totalFilled = handleEof(processingBuffer, nonSilentFrames, framesRead, vol, startOffset);
+    processingBuffer->zero(startOffset + totalFilled, nonSilentFrames - totalFilled);
   }
 
   handleStopScheduled();
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
index ae5c57615..ed1c35e2a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
@@ -8,6 +8,7 @@
 
 #include <atomic>
 #include <memory>
+#include <string>
 #include <vector>
 
 namespace audioapi {
@@ -15,15 +16,11 @@ namespace audioapi {
 struct AudioFileSourceOptions;
 
 struct AudioFileDecoderState {
-  ma_decoder decoder;
-  std::vector<uint8_t> memoryData;      // keeps memory alive for memory-based decoder
-  std::vector<float> interleavedBuffer; // pre-allocated read buffer
+  std::vector<uint8_t> memoryData;
+  std::vector<float> interleavedBuffer;
   int channels = 0;
   float sampleRate = 0;
-
-  ~AudioFileDecoderState() {
-    ma_decoder_uninit(&decoder);
-  }
+  std::string filePath;
 };
 
 class AudioFileSourceNode : public AudioScheduledSourceNode {
@@ -50,13 +47,35 @@ class AudioFileSourceNode : public AudioScheduledSourceNode {
 
   void pause();
 
+  bool getLoop() const {
+    return loop_.load(std::memory_order_acquire);
+  }
+
+  void setLoop(bool v) {
+    loop_.store(v, std::memory_order_release);
+  }
+
+  double getDuration() const {
+    return duration_.load(std::memory_order_acquire);
+  }
+
+  double getCurrentTime() const {
+    return currentTime_.load(std::memory_order_acquire);
+  }
+
  protected:
   std::shared_ptr<DSPAudioBuffer> processNode(
       const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
       int framesToProcess) override;
 
  private:
+  void initDecoders(
+      bool useFilePath,
+      const std::shared_ptr<BaseAudioContext> &context,
+      const std::shared_ptr<AudioFileDecoderState> &state);
+
   std::shared_ptr<AudioFileDecoderState> decoderState_;
+  std::unique_ptr<ma_decoder> maDecoder_;
   std::atomic<float> volume_;
   bool FFmpegNeeded_;
 #if !RN_AUDIO_API_FFMPEG_DISABLED
@@ -65,6 +84,26 @@ class AudioFileSourceNode : public AudioScheduledSourceNode {
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
   std::atomic<bool> filePaused_{false};
   bool fileStarted_{false};
+  std::atomic<bool> loop_{false};
+  std::atomic<double> duration_{0};
+  std::atomic<double> currentTime_{0};
+  size_t totalFramesRead_{0};
+  double sampleRate_{0};
+
+  size_t readFrames(float *buf, size_t frameCount);
+  bool seekToStart();
+  static void writeInterleavedToBuffer(
+      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
+      const AudioFileDecoderState &state,
+      size_t destSampleOffset,
+      size_t frameCount,
+      float vol);
+  size_t handleEof(
+      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
+      size_t nonSilentFrames,
+      size_t framesRead,
+      float vol,
+      size_t startOffset);
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp b/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp
index 360d66762..a379eee17 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp
@@ -12,11 +12,13 @@
 #include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
 
 #include <algorithm>
+#include <cmath>
 #include <cstring>
-#include <utility>
 
 extern "C" {
+#include <libavutil/avutil.h>
 #include <libavutil/channel_layout.h>
+#include <libavutil/mathematics.h>
 }
 
 namespace audioapi::ffmpegdecoder {
@@ -88,39 +90,6 @@ bool openCodec(AVFormatContext *fmt_ctx, int &audio_stream_index, AVCodecContext
   return true;
 }
 
-FFmpegDecoder::FFmpegDecoder(FFmpegDecoder &&other) noexcept {
-  *this = std::move(other);
-}
-
-FFmpegDecoder &FFmpegDecoder::operator=(FFmpegDecoder &&other) noexcept {
-  if (this != &other) {
-    close();
-    fmt_ctx_ = other.fmt_ctx_;
-    codec_ctx_ = other.codec_ctx_;
-    swr_ = other.swr_;
-    packet_ = other.packet_;
-    frame_ = other.frame_;
-    resampled_data_ = other.resampled_data_;
-    max_resampled_samples_ = other.max_resampled_samples_;
-    mem_io_ = std::move(other.mem_io_);
-    avio_ctx_ = other.avio_ctx_;
-    leftover_ = std::move(other.leftover_);
-    audio_stream_index_ = other.audio_stream_index_;
-    output_channels_ = other.output_channels_;
-    output_sample_rate_ = other.output_sample_rate_;
-
-    other.fmt_ctx_ = nullptr;
-    other.codec_ctx_ = nullptr;
-    other.swr_ = nullptr;
-    other.packet_ = nullptr;
-    other.frame_ = nullptr;
-    other.resampled_data_ = nullptr;
-    other.max_resampled_samples_ = 0;
-    other.avio_ctx_ = nullptr;
-  }
-  return *this;
-}
-
 FFmpegDecoder::~FFmpegDecoder() {
   close();
 }
@@ -151,9 +120,11 @@ void FFmpegDecoder::close() {
   }
   mem_io_.reset();
   leftover_.clear();
+  leftover_offset_ = 0;
   audio_stream_index_ = -1;
   output_channels_ = 0;
   output_sample_rate_ = 0;
+  total_output_frames_ = 0;
 }
 
 bool FFmpegDecoder::setupSwr() {
@@ -218,6 +189,7 @@ bool FFmpegDecoder::openFile(const FFmpegDecoderConfig &cfg, const std::string &
     close();
     return false;
   }
+  total_output_frames_ = 0;
   return true;
 }
 
@@ -279,6 +251,7 @@ bool FFmpegDecoder::openMemory(const FFmpegDecoderConfig &cfg, const void *data,
     close();
     return false;
   }
+  total_output_frames_ = 0;
   return true;
 }
 
@@ -347,6 +320,42 @@ bool FFmpegDecoder::feedPipeline() {
   }
 }
 
+float FFmpegDecoder::getDurationInSeconds() const {
+  if (!isOpen() || fmt_ctx_ == nullptr || audio_stream_index_ < 0) {
+    return 0;
+  }
+  if (fmt_ctx_->duration != AV_NOPTS_VALUE && fmt_ctx_->duration >= 0) {
+    double t =
+        static_cast<double>(fmt_ctx_->duration) / static_cast<double>(AV_TIME_BASE);
+    if (t > 0 && std::isfinite(t)) {
+      return static_cast<float>(t);
+    }
+  }
+  return 0;
+}
+
+float FFmpegDecoder::getCurrentPositionInSeconds() const {
+  if (!isOpen() || output_sample_rate_ <= 0) {
+    return 0;
+  }
+  return static_cast<float>(total_output_frames_) / static_cast<float>(output_sample_rate_);
+}
+
+bool FFmpegDecoder::seekToStart() {
+  if (!isOpen() || audio_stream_index_ < 0) {
+    return false;
+  }
+  if (avformat_seek_file(
+          fmt_ctx_, -1, INT64_MIN, 0, INT64_MAX, 0) < 0) {
+    return false;
+  }
+  avcodec_flush_buffers(codec_ctx_);
+  leftover_.clear();
+  leftover_offset_ = 0;
+  total_output_frames_ = 0;
+  return true;
+}
+
 size_t FFmpegDecoder::readPcmFrames(float *outInterleaved, size_t frameCount) {
   if (!isOpen() || outInterleaved == nullptr || frameCount == 0 || output_channels_ <= 0) {
     return 0;
@@ -356,20 +365,28 @@ size_t FFmpegDecoder::readPcmFrames(float *outInterleaved, size_t frameCount) {
 
   while (delivered < frameCount) {
     size_t need = frameCount - delivered;
-    size_t leftover_frames = leftover_.size() / ch;
+    size_t available_samples = leftover_.size() > leftover_offset_
+        ? leftover_.size() - leftover_offset_
+        : 0;
+    size_t leftover_frames = available_samples / ch;
     if (leftover_frames > 0) {
       size_t take = std::min(need, leftover_frames);
       size_t samples = take * ch;
       memcpy(
           outInterleaved + delivered * ch,
-          leftover_.data(),
+          leftover_.data() + leftover_offset_,
           samples * sizeof(float));
-      leftover_.erase(leftover_.begin(), leftover_.begin() + static_cast<ptrdiff_t>(samples));
+      leftover_offset_ += samples;
+      if (leftover_offset_ >= leftover_.size()) {
+        leftover_.clear();
+        leftover_offset_ = 0;
+      }
       delivered += take;
     } else if (!feedPipeline()) {
       break;
     }
   }
+  total_output_frames_ += delivered;
   return delivered;
 }
 
@@ -453,6 +470,15 @@ bool FFmpegDecoder::openFile(const FFmpegDecoderConfig &, const std::string &) {
 bool FFmpegDecoder::openMemory(const FFmpegDecoderConfig &, const void *, size_t) {
   return false;
 }
+float FFmpegDecoder::getDurationInSeconds() const {
+  return 0;
+}
+float FFmpegDecoder::getCurrentPositionInSeconds() const {
+  return 0;
+}
+bool FFmpegDecoder::seekToStart() {
+  return false;
+}
 size_t FFmpegDecoder::readPcmFrames(float *, size_t) {
   return 0;
 }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h b/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h
index 7766967c6..35e366455 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h
@@ -60,8 +60,8 @@ class FFmpegDecoder {
   FFmpegDecoder() = default;
   FFmpegDecoder(const FFmpegDecoder &) = delete;
   FFmpegDecoder &operator=(const FFmpegDecoder &) = delete;
-  FFmpegDecoder(FFmpegDecoder &&other) noexcept;
-  FFmpegDecoder &operator=(FFmpegDecoder &&other) noexcept;
+  FFmpegDecoder(FFmpegDecoder &&other) = delete;
+  FFmpegDecoder &operator=(FFmpegDecoder &&other) = delete;
   ~FFmpegDecoder();
 
   /// @brief Opens a file for decoding.
@@ -92,6 +92,16 @@ class FFmpegDecoder {
   [[nodiscard]] int outputChannels() const { return output_channels_; }
   [[nodiscard]] int outputSampleRate() const { return output_sample_rate_; }
 
+  /// @brief Duration in seconds. Returns 0 if unknown.
+  [[nodiscard]] float getDurationInSeconds() const;
+
+  /// @brief Current playback position in seconds (frames read / sample rate).
+  [[nodiscard]] float getCurrentPositionInSeconds() const;
+
+  /// @brief Seeks to the start of the stream. Call after EOF to loop.
+  /// @return True if seek succeeded.
+  [[nodiscard]] bool seekToStart();
+
   static constexpr size_t CHUNK_SIZE = 4096;
 
  private:
@@ -112,9 +122,11 @@ class FFmpegDecoder {
   AVIOContext *avio_ctx_ = nullptr;
 
   std::vector<float> leftover_;
+  size_t leftover_offset_ = 0;
   int audio_stream_index_ = -1;
   int output_channels_ = 0;
   int output_sample_rate_ = 0;
+  size_t total_output_frames_ = 0;
 };
 
 // --- One-shot decode (existing API) ----------------------------------------
diff --git a/packages/react-native-audio-api/src/development/react/Audio/Audio.tsx b/packages/react-native-audio-api/src/development/react/Audio/Audio.tsx
index 469eecaf1..f2e7ed06f 100644
--- a/packages/react-native-audio-api/src/development/react/Audio/Audio.tsx
+++ b/packages/react-native-audio-api/src/development/react/Audio/Audio.tsx
@@ -1,11 +1,11 @@
 import React, {
-  createContext,
   useCallback,
   useEffect,
   useMemo,
   useRef,
   useState,
 } from 'react';
+import { View } from 'react-native';
 
 import { IAudioFileSourceNode } from '../../../interfaces';
 import type {
@@ -14,28 +14,8 @@ import type {
   AudioURISource,
 } from './types';
 import { useStableAudioProps } from './utils';
-
-export type AudioComponentContextType = {
-  play: () => void;
-  pause: () => void;
-  volume: number;
-  setVolume: (volume: number) => void;
-  muted: boolean;
-  setMuted: (muted: boolean) => void;
-  isReady: boolean;
-  playbackState: AudioTagPlaybackState;
-};
-
-export const AudioComponentContext = createContext<AudioComponentContextType>({
-  play: () => {},
-  pause: () => {},
-  volume: 1,
-  setVolume: () => {},
-  muted: false,
-  setMuted: () => {},
-  isReady: false,
-  playbackState: 'idle',
-});
+import { AudioComponentContext } from './AudioTagContext';
+import AudioControls from './AudioControls';
 
 const Audio: React.FC<AudioProps> = (inProps) => {
   const { children } = inProps;
@@ -67,15 +47,8 @@ const Audio: React.FC<AudioProps> = (inProps) => {
   const [isReady, setIsReady] = useState(false);
   const [playbackState, setPlaybackState] =
     useState<AudioTagPlaybackState>('idle');
-
-  const volumeStateRef = useRef(volumeState);
-  volumeStateRef.current = volumeState;
-
-  const mutedStateRef = useRef(mutedState);
-  mutedStateRef.current = mutedState;
-
-  const contextRef = useRef(context);
-  contextRef.current = context;
+  const [currentTime, setCurrentTime] = useState(0);
+  const [duration, setDuration] = useState(0);
 
   useEffect(() => {
     setVolumeState(volume);
@@ -87,15 +60,14 @@ const Audio: React.FC<AudioProps> = (inProps) => {
 
   const play = useCallback(() => {
     const n = nodeRef.current;
-    const ctx = contextRef.current;
-    if (!n || !ctx) {
+    if (!n || !context) {
       return;
     }
     // @ts-ignore - internal
-    n.connect(ctx.destination.node);
+    n.connect(context.destination.node);
     n.start(0);
     setPlaybackState('playing');
-  }, []);
+  }, [context]);
 
   const pause = useCallback(() => {
     if (!nodeRef.current) {
@@ -107,14 +79,16 @@ const Audio: React.FC<AudioProps> = (inProps) => {
 
   const attachNode = useCallback(
     (n: IAudioFileSourceNode) => {
-      n.volume = mutedStateRef.current ? 0 : volumeStateRef.current;
       nodeRef.current = n;
+      n.loop = loop;
+      setCurrentTime(n.currentTime);
+      setDuration(n.duration);
       setIsReady(true);
       if (autoPlay) {
         play();
       }
     },
-    [autoPlay, play]
+    [autoPlay, play, loop]
   );
 
   useEffect(() => {
@@ -137,11 +111,7 @@ const Audio: React.FC<AudioProps> = (inProps) => {
     run();
 
     return () => {
-      const prev = nodeRef.current;
-      if (prev) {
-        prev.onEnded = '0';
-      }
-      prev?.disconnect(undefined);
+      nodeRef.current?.disconnect(undefined);
       nodeRef.current = null;
       setIsReady(false);
       setPlaybackState('idle');
@@ -153,15 +123,40 @@ const Audio: React.FC<AudioProps> = (inProps) => {
     if (n) {
       n.volume = mutedState ? 0 : volumeState;
     }
-  }, [volumeState, mutedState]);
+  }, [volumeState, mutedState, isReady]);
 
-  const setVolume = useCallback((next: number) => {
-    setVolumeState(next);
+  useEffect(() => {
     const n = nodeRef.current;
     if (n) {
-      n.volume = mutedStateRef.current ? 0 : next;
+      n.loop = loop;
     }
-  }, []);
+  }, [loop, isReady]);
+
+  useEffect(() => {
+    const n = nodeRef.current;
+    if (!n || playbackState !== 'playing') return;
+    const id = setInterval(() => {
+      const node = nodeRef.current;
+      if (node) {
+        setCurrentTime(node.currentTime);
+      }
+      console.log('currentTime', node?.currentTime);
+    }, 250);
+    return () => {
+      clearInterval(id);
+    };
+  }, [playbackState]);
+
+  const setVolume = useCallback(
+    (next: number) => {
+      setVolumeState(next);
+      const n = nodeRef.current;
+      if (n) {
+        n.volume = mutedState ? 0 : next;
+      }
+    },
+    [mutedState]
+  );
 
   const setMuted = useCallback(
     (next: boolean) => {
@@ -188,6 +183,8 @@ const Audio: React.FC<AudioProps> = (inProps) => {
       setMuted,
       isReady,
       playbackState,
+      currentTime,
+      duration,
     }),
     [
       play,
@@ -198,16 +195,21 @@ const Audio: React.FC<AudioProps> = (inProps) => {
       setMuted,
       isReady,
       playbackState,
+      currentTime,
+      duration,
     ]
   );
 
-  if (context === null) {
+  if (context == null) {
     return null;
   }
 
   return (
     <AudioComponentContext.Provider value={ctxValue}>
-      {children}
+      <View style={{ alignSelf: 'stretch', width: '100%' }}>
+        {controls && <AudioControls />}
+        {children}
+      </View>
     </AudioComponentContext.Provider>
   );
 };
diff --git a/packages/react-native-audio-api/src/development/react/Audio/Audio.web.tsx b/packages/react-native-audio-api/src/development/react/Audio/Audio.web.tsx
index 5ffb79ca3..cec85f69c 100644
--- a/packages/react-native-audio-api/src/development/react/Audio/Audio.web.tsx
+++ b/packages/react-native-audio-api/src/development/react/Audio/Audio.web.tsx
@@ -6,7 +6,7 @@ import React, {
   useState,
 } from 'react';
 import type { AudioProps, AudioTagPlaybackState } from './types';
-import { AudioComponentContext } from './Audio';
+import { AudioComponentContext } from './AudioTagContext';
 import { useStableAudioProps } from './utils';
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -23,7 +23,6 @@ const Audio: React.FC<AudioProps> = (props) => {
     playbackRate,
     preservesPitch,
     volume,
-    context, // null on web, since web do not use AudioContext for audio tag, left for mobile compatibility
   } = useStableAudioProps(props);
 
   const audioRef = useRef<HTMLAudioElement>(null);
@@ -32,6 +31,8 @@ const Audio: React.FC<AudioProps> = (props) => {
   const [isReady, setIsReady] = useState(false);
   const [playbackState, setPlaybackState] =
     useState<AudioTagPlaybackState>('idle');
+  const [currentTime, setCurrentTime] = useState(0);
+  const [duration, setDuration] = useState(0);
 
   useEffect(() => {
     setVolumeState(volume);
@@ -48,6 +49,24 @@ const Audio: React.FC<AudioProps> = (props) => {
     }
   }, [volumeState]);
 
+  useEffect(() => {
+    const el = audioRef.current;
+    if (!el) return;
+    const onLoadedMetadata = () => {
+      setDuration(el.duration);
+      setCurrentTime(el.currentTime);
+    };
+    const onTimeUpdate = () => setCurrentTime(el.currentTime);
+    el.addEventListener('loadedmetadata', onLoadedMetadata);
+    el.addEventListener('timeupdate', onTimeUpdate);
+    if (!isNaN(el.duration)) setDuration(el.duration);
+    setCurrentTime(el.currentTime);
+    return () => {
+      el.removeEventListener('loadedmetadata', onLoadedMetadata);
+      el.removeEventListener('timeupdate', onTimeUpdate);
+    };
+  }, [isReady]);
+
   useEffect(() => {
     const el = audioRef.current;
     if (el) {
@@ -89,6 +108,8 @@ const Audio: React.FC<AudioProps> = (props) => {
       setMuted,
       isReady,
       playbackState,
+      currentTime,
+      duration,
     }),
     [
       play,
@@ -99,6 +120,8 @@ const Audio: React.FC<AudioProps> = (props) => {
       setMuted,
       isReady,
       playbackState,
+      currentTime,
+      duration,
     ]
   );
 
@@ -106,6 +129,9 @@ const Audio: React.FC<AudioProps> = (props) => {
     <AudioComponentContext.Provider value={ctxValue}>
       <audio
         autoPlay={autoPlay}
+        controls={controls}
+        loop={loop}
+        preload={preload}
         muted={mutedState}
         ref={audioRef}
         onLoadedData={() => setIsReady(true)}
diff --git a/packages/react-native-audio-api/src/development/react/Audio/AudioControls.tsx b/packages/react-native-audio-api/src/development/react/Audio/AudioControls.tsx
new file mode 100644
index 000000000..2be6d9973
--- /dev/null
+++ b/packages/react-native-audio-api/src/development/react/Audio/AudioControls.tsx
@@ -0,0 +1,247 @@
+import { Pause, Play, Volume, VolumeX } from 'lucide-react-native';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import {
+  ActivityIndicator,
+  LayoutChangeEvent,
+  PanResponder,
+  Platform,
+  Pressable,
+  StyleSheet,
+  Text,
+  View,
+} from 'react-native';
+import { useAudioTagContext } from './AudioTagContext';
+
+function formatTime(seconds: number): string {
+  if (!Number.isFinite(seconds) || seconds < 0) return '0:00';
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = Math.floor(seconds % 60);
+  if (h > 0) {
+    return `${h}:${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')}`;
+  } else {
+    return `${m}:${s.toString().padStart(2, '0')}`;
+  }
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flexDirection: 'column',
+    alignSelf: 'stretch',
+    minWidth: 200,
+    paddingVertical: 10,
+    paddingHorizontal: 12,
+    backgroundColor: '#f5f5f5',
+    borderRadius: 8,
+    borderWidth: 1,
+    borderColor: '#333',
+    ...Platform.select({
+      ios: {
+        shadowColor: '#000',
+        shadowOffset: { width: 0, height: 2 },
+        shadowOpacity: 0.15,
+        shadowRadius: 4,
+      },
+      android: {
+        elevation: 4,
+      },
+    }),
+  },
+  topRow: {
+    flexDirection: 'row',
+    alignItems: 'center',
+  },
+  playPause: {
+    padding: 4,
+    marginRight: 12,
+    flexShrink: 0,
+  },
+  timeText: {
+    color: '#000',
+    fontSize: 12,
+    marginRight: 10,
+    minWidth: 48,
+  },
+  progressTrack: {
+    flex: 1,
+    minWidth: 40,
+    height: 6,
+    justifyContent: 'center',
+    marginRight: 10,
+  },
+  progressTrackInner: {
+    flex: 1,
+    height: 6,
+    backgroundColor: '#ccc',
+    borderRadius: 3,
+    overflow: 'hidden',
+  },
+  progressFill: {
+    height: '100%',
+    backgroundColor: '#000',
+    borderRadius: 3,
+  },
+  volumeIcon: {
+    padding: 4,
+    flexShrink: 0,
+  },
+  bottomRow: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'center',
+    marginTop: 8,
+  },
+  volumeTrack: {
+    width: '50%',
+    height: 10,
+    flexDirection: 'column',
+    justifyContent: 'center',
+  },
+  volumeTrackPan: {
+    flex: 1,
+    width: '100%',
+    justifyContent: 'center',
+  },
+  volumeTrackInner: {
+    flex: 1,
+    height: 6,
+    backgroundColor: '#ccc',
+    borderRadius: 3,
+    overflow: 'hidden',
+  },
+  volumeFill: {
+    height: '100%',
+    backgroundColor: '#000',
+    borderRadius: 3,
+  },
+  loadingRow: {
+    flexDirection: 'row',
+    alignItems: 'center',
+  },
+  loadingText: {
+    color: '#333',
+    fontSize: 14,
+  },
+});
+
+const AudioControls: React.FC = () => {
+  const {
+    isReady,
+    play,
+    pause,
+    playbackState,
+    volume,
+    setVolume,
+    muted,
+    setMuted,
+    currentTime,
+    duration,
+  } = useAudioTagContext();
+
+  const [trackWidth, setTrackWidth] = useState(0);
+
+  const updateVolumeFromPosition = useCallback(
+    (locationX: number) => {
+      if (trackWidth <= 0) return;
+      const pct = Math.max(0, Math.min(1, locationX / trackWidth));
+      setVolume(pct);
+    },
+    [trackWidth, setVolume]
+  );
+
+  const panResponder = useMemo(
+    () =>
+      PanResponder.create({
+        onStartShouldSetPanResponder: () => true,
+        onMoveShouldSetPanResponder: () => true,
+        onPanResponderGrant: (e) =>
+          updateVolumeFromPosition(e.nativeEvent.locationX),
+        onPanResponderMove: (e) =>
+          updateVolumeFromPosition(e.nativeEvent.locationX),
+      }),
+    [updateVolumeFromPosition]
+  );
+
+  const onPlayPausePress = useCallback(() => {
+    if (playbackState === 'playing') {
+      pause();
+    } else {
+      play();
+    }
+  }, [playbackState, pause, play]);
+
+  const onVolumeTrackLayout = useCallback((e: LayoutChangeEvent) => {
+    setTrackWidth(e.nativeEvent.layout.width);
+  }, []);
+
+  useEffect(() => {
+    console.log('playbackState', playbackState);
+  }, [playbackState]);
+
+  if (!isReady) {
+    return (
+      <View style={styles.container}>
+        <View style={styles.loadingRow}>
+          <ActivityIndicator color="#333" size="small" />
+          <Text style={[styles.loadingText, { marginLeft: 8 }]}>Loading…</Text>
+        </View>
+      </View>
+    );
+  }
+
+  const progress = duration > 0 ? currentTime / duration : 0;
+
+  return (
+    <View style={styles.container}>
+      <View style={styles.topRow}>
+        <Pressable style={styles.playPause} onPress={onPlayPausePress}>
+          {playbackState === 'playing' ? (
+            <Pause color="#000" size={20} strokeWidth={2.5} />
+          ) : (
+            <Play color="#000" size={20} strokeWidth={2.5} />
+          )}
+        </Pressable>
+
+        <Text style={styles.timeText}>
+          {formatTime(currentTime)} / {formatTime(duration)}
+        </Text>
+
+        <View style={styles.progressTrack}>
+          <View style={styles.progressTrackInner}>
+            <View
+              style={[
+                styles.progressFill,
+                { width: `${Math.min(1, progress) * 100}%` },
+              ]}
+            />
+          </View>
+        </View>
+
+        <Pressable style={styles.volumeIcon} onPress={() => setMuted(!muted)}>
+          {muted ? (
+            <VolumeX color="#000" size={20} strokeWidth={2.5} />
+          ) : (
+            <Volume color="#000" size={20} strokeWidth={2.5} />
+          )}
+        </Pressable>
+      </View>
+
+      <View style={styles.bottomRow}>
+        <View style={styles.volumeTrack} onLayout={onVolumeTrackLayout}>
+          <View {...panResponder.panHandlers} style={styles.volumeTrackPan}>
+            <View style={styles.volumeTrackInner}>
+              <View
+                style={[
+                  styles.volumeFill,
+                  { width: `${(muted ? 0 : volume) * 100}%` },
+                ]}
+              />
+            </View>
+          </View>
+        </View>
+      </View>
+    </View>
+  );
+};
+
+export default AudioControls;
diff --git a/packages/react-native-audio-api/src/development/react/Audio/AudioTagContext.ts b/packages/react-native-audio-api/src/development/react/Audio/AudioTagContext.ts
new file mode 100644
index 000000000..9d8699fe3
--- /dev/null
+++ b/packages/react-native-audio-api/src/development/react/Audio/AudioTagContext.ts
@@ -0,0 +1,29 @@
+import { createContext, useContext } from 'react';
+import type { AudioTagPlaybackState } from './types';
+
+export type AudioComponentContextType = {
+  play: () => void;
+  pause: () => void;
+  volume: number;
+  setVolume: (volume: number) => void;
+  muted: boolean;
+  setMuted: (muted: boolean) => void;
+  isReady: boolean;
+  playbackState: AudioTagPlaybackState;
+  currentTime: number;
+  duration: number;
+};
+
+export const AudioComponentContext = createContext<
+  AudioComponentContextType | undefined
+>(undefined);
+
+export function useAudioTagContext(): AudioComponentContextType {
+  const context = useContext(AudioComponentContext);
+
+  if (context === undefined) {
+    throw new Error('useAudioTagContext must be used within an <Audio> tag.');
+  }
+
+  return context;
+}
diff --git a/packages/react-native-audio-api/src/development/react/Audio/index.ts b/packages/react-native-audio-api/src/development/react/Audio/index.ts
index 086043633..989faa08d 100644
--- a/packages/react-native-audio-api/src/development/react/Audio/index.ts
+++ b/packages/react-native-audio-api/src/development/react/Audio/index.ts
@@ -1,5 +1,5 @@
 export { default } from './Audio';
-export { AudioComponentContext } from './Audio';
+export { useAudioTagContext } from './AudioTagContext';
 
 export type {
   AudioProps,
diff --git a/packages/react-native-audio-api/src/development/react/Audio/types.ts b/packages/react-native-audio-api/src/development/react/Audio/types.ts
index 36f109fbf..b3e480fbc 100644
--- a/packages/react-native-audio-api/src/development/react/Audio/types.ts
+++ b/packages/react-native-audio-api/src/development/react/Audio/types.ts
@@ -43,7 +43,7 @@ interface AudioControlProps {
   preservesPitch: boolean;
   volume: number;
   children?: ReactNode;
-  context: BaseAudioContext | null; // null on web, since web do not use AudioContext for audio tag
+  context?: BaseAudioContext; // optional on web, since web do not use AudioContext for audio tag
 }
 
 interface AudioReadonlyProps {
diff --git a/packages/react-native-audio-api/src/development/react/Audio/utils.ts b/packages/react-native-audio-api/src/development/react/Audio/utils.ts
index 4d55c0ddf..77f4fc545 100644
--- a/packages/react-native-audio-api/src/development/react/Audio/utils.ts
+++ b/packages/react-native-audio-api/src/development/react/Audio/utils.ts
@@ -11,7 +11,7 @@ import { AudioProps, AudioPropsBase } from './types';
  */
 export function withPropsDefaults(
   props: AudioProps,
-  resolvedContext: BaseAudioContext | null
+  resolvedContext: BaseAudioContext | undefined
 ): AudioPropsBase {
   return {
     ...props,
@@ -30,14 +30,14 @@ export function withPropsDefaults(
 
 export function useStableAudioProps(props: AudioProps): AudioPropsBase {
   const defaultContextRef = useRef<BaseAudioContext | null>(null);
-  const resolvedContext: BaseAudioContext | null =
+  const resolvedContext: BaseAudioContext | undefined =
     Platform.OS === 'web'
-      ? null
+      ? undefined
       : (() => {
           if (defaultContextRef.current === null) {
             defaultContextRef.current = new AudioContext();
           }
-          return props.context ?? defaultContextRef.current;
+          return props.context ?? defaultContextRef.current ?? undefined;
         })();
 
   const {
diff --git a/packages/react-native-audio-api/src/development/react/index.ts b/packages/react-native-audio-api/src/development/react/index.ts
index f36f82cb4..050e12c15 100644
--- a/packages/react-native-audio-api/src/development/react/index.ts
+++ b/packages/react-native-audio-api/src/development/react/index.ts
@@ -1,2 +1,3 @@
 export * from './Audio';
 export { default as Audio } from './Audio';
+export { default as AudioControls } from './Audio/AudioControls';
diff --git a/packages/react-native-audio-api/src/interfaces.ts b/packages/react-native-audio-api/src/interfaces.ts
index aeea1a8b3..1b275546e 100644
--- a/packages/react-native-audio-api/src/interfaces.ts
+++ b/packages/react-native-audio-api/src/interfaces.ts
@@ -231,6 +231,9 @@ export interface IAudioBufferQueueSourceNode
 
 export interface IAudioFileSourceNode extends IAudioScheduledSourceNode {
   volume?: number;
+  loop: boolean;
+  readonly currentTime: number;
+  readonly duration: number;
   pause: () => void;
 }