react-native-audio-api 1.0.0-nightly-6fd4c68-20261102 → 1.0.0

package/android/src/main/cpp/audioapi/CMakeLists.txt

@@ -30,6 +30,19 @@ set_source_files_properties(
   COMPILE_FLAGS "-O3"
 )
 
+set_source_files_properties(
+  "${ANDROID_CPP_DIR}/audioapi/android/AndroidDecoding.cpp"
+  PROPERTIES
+  COMPILE_FLAGS "-O3 -D__ANDROID_UNAVAILABLE_SYMBOLS_ARE_WEAK__ -Werror=unguarded-availability"
+)
+
+# APerformanceHint (API 33) is weak-linked and guarded the same way.
+set_source_files_properties(
+  "${ANDROID_CPP_DIR}/audioapi/android/ThroughputHintSession.cpp"
+  PROPERTIES
+  COMPILE_FLAGS "-D__ANDROID_UNAVAILABLE_SYMBOLS_ARE_WEAK__ -Werror=unguarded-availability"
+)
+
 if(CMAKE_C_COMPILER_ID MATCHES "Clang")
   set_source_files_properties(
     "${COMMON_CPP_DIR}/audioapi/dsp/r8brain/fft/pffft_double.c"

package/android/src/main/cpp/audioapi/android/AndroidDecoding.cpp

@@ -1,5 +1,6 @@
 #include <audioapi/android/AndroidDecoding.h>
 #include <audioapi/android/AndroidDecodingDataSource.h>
+#include <audioapi/android/ThroughputHintSession.h>
 #include <audioapi/android/core/utils/AndroidMediaFormat.h>
 
 #include <audioapi/dsp/r8brain/Resampler.hpp>
@@ -10,18 +11,24 @@
 #include <media/NdkMediaCodec.h>
 #include <media/NdkMediaExtractor.h>
 #include <media/NdkMediaFormat.h>
+#include <chrono>
 
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #include <algorithm>
+#include <atomic>
 #include <cerrno>
 #include <cmath>
+#include <condition_variable>
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
+#include <deque>
 #include <memory>
+#include <mutex>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -35,6 +42,11 @@ constexpr int ENCODING_PCM_8 = 3;
 constexpr int ENCODING_PCM_FLOAT = 4;
 constexpr int RESAMPLE_MAX_IN_FRAMES = 4096;
 constexpr int64_t CODEC_TIMEOUT_US = 5000;
+constexpr auto CODEC_TIMEOUT = std::chrono::microseconds(CODEC_TIMEOUT_US);
+// Track mime the extractor uses for already-decoded PCM (e.g. WAV).
+constexpr const char *MIME_AUDIO_RAW = "audio/raw";
+constexpr size_t RAW_PACKET_INITIAL_BYTES = size_t{64} * 1024;
+constexpr size_t RAW_PACKET_MAX_BYTES = size_t{16} * 1024 * 1024;
 // Bail out of the drain loop if MediaCodec keeps saying "try again" after EOS
 // input without ever flagging EOS output (defensive against a stuck codec).
 constexpr int MAX_TRY_AGAIN_AFTER_EOS = 200;
@@ -61,6 +73,104 @@ using MediaExtractorPtr = std::unique_ptr<AMediaExtractor, FnDeleter<AMediaExtra
 using MediaCodecPtr = std::unique_ptr<AMediaCodec, MediaCodecDeleter>;
 using FilePtr = std::unique_ptr<FILE, FnDeleter<fclose>>;
 
+// Fields of a codec output format; 0 marks a key the format did not carry.
+struct CodecOutputFormat {
+  int sampleRate = 0;
+  int channels = 0;
+  int pcmEncoding = ENCODING_PCM_16;
+};
+
+CodecOutputFormat readCodecOutputFormat(AMediaFormat *format) {
+  CodecOutputFormat fields;
+  AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_SAMPLE_RATE, &fields.sampleRate);
+  AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_CHANNEL_COUNT, &fields.channels);
+  if (!AMediaFormat_getInt32(format, "pcm-encoding", &fields.pcmEncoding)) {
+    fields.pcmEncoding = ENCODING_PCM_16;
+  }
+  return fields;
+}
+
+// A filled output buffer, or (when outputFormat is set) a format change that
+// must apply before the buffers queued after it.
+struct AsyncOutputEvent {
+  int32_t index = -1;
+  AMediaCodecBufferInfo info{};
+  std::optional<CodecOutputFormat> outputFormat;
+};
+
+// Buffer indices handed over by the codec's callback thread in async mode.
+// After a flush, callbacks already in flight may still deliver indices from
+// before it; those buffers are no longer owned by the client, so their
+// getInputBuffer / getOutputBuffer lookup fails and the event is dropped.
+struct AsyncCodecEvents {
+  std::mutex mutex;
+  std::condition_variable ready;
+  std::deque<int32_t> inputs;
+  std::deque<AsyncOutputEvent> outputs;
+  bool failed = false;
+  // The NDK delivers every callback on one thread of its own.
+  std::atomic<pid_t> callbackThreadId{0};
+
+  void clear() {
+    std::scoped_lock lock(mutex);
+    inputs.clear();
+    outputs.clear();
+    failed = false;
+  }
+};
+
+void onAsyncInputAvailable(AMediaCodec * /*codec*/, void *userdata, int32_t index) {
+  auto &events = *static_cast<AsyncCodecEvents *>(userdata);
+  events.callbackThreadId.store(gettid(), std::memory_order_relaxed);
+  {
+    std::scoped_lock lock(events.mutex);
+    // A stale pre-flush callback and a fresh one can name the same buffer.
+    if (std::find(events.inputs.begin(), events.inputs.end(), index) == events.inputs.end()) {
+      events.inputs.push_back(index);
+    }
+  }
+  events.ready.notify_one();
+}
+
+void onAsyncOutputAvailable(
+    AMediaCodec * /*codec*/,
+    void *userdata,
+    int32_t index,
+    AMediaCodecBufferInfo *info) {
+  auto &events = *static_cast<AsyncCodecEvents *>(userdata);
+  {
+    std::scoped_lock lock(events.mutex);
+    events.outputs.push_back(AsyncOutputEvent{.index = index, .info = *info});
+  }
+  events.ready.notify_one();
+}
+
+void onAsyncFormatChanged(AMediaCodec * /*codec*/, void *userdata, AMediaFormat *format) {
+  auto &events = *static_cast<AsyncCodecEvents *>(userdata);
+  const CodecOutputFormat fields = readCodecOutputFormat(format);
+  // The NDK hands the callback a copy it never frees.
+  AMediaFormat_delete(format);
+  {
+    std::scoped_lock lock(events.mutex);
+    events.outputs.push_back(AsyncOutputEvent{.outputFormat = fields});
+  }
+  events.ready.notify_one();
+}
+
+void onAsyncError(
+    AMediaCodec * /*codec*/,
+    void *userdata,
+    media_status_t /*error*/,
+    int32_t /*actionCode*/,
+    const char * /*detail*/) {
+  auto &events = *static_cast<AsyncCodecEvents *>(userdata);
+  {
+    std::scoped_lock lock(events.mutex);
+    events.failed = true;
+  }
+  events.ready.notify_one();
+}
+
 decoding::DecoderResult attachMemoryExtractorViaTempFile(
     AMediaExtractor *extractor,
     FilePtr &tempFile,
@@ -94,7 +204,12 @@ struct AndroidDecoderState {
   FilePtr tempFile;
   AndroidMemoryDataSource dataSource;
   MediaExtractorPtr extractor;
+  // Outlives the codec, whose callbacks write into it until AMediaCodec_delete.
+  std::unique_ptr<AsyncCodecEvents> asyncEvents;
   MediaCodecPtr codec;
+  // The track is already PCM: packets are converted directly and no codec runs.
+  bool rawPcmTrack = false;
+  std::vector<uint8_t> rawPacket;
 
   int audioTrackIndex = -1;
   std::string codecMime;
@@ -122,6 +237,13 @@ struct AndroidDecoderState {
   std::unique_ptr<r8b::MultiChannelResampler> resampler;
   std::unique_ptr<AudioBuffer> resampleIn;
   std::unique_ptr<AudioBuffer> resampleOut;
+
+  // Decoding is a chain of short bursts on threads in two processes; none of
+  // them stays busy long enough for the CPU governor to raise clocks, which
+  // roughly halves decoding speed. The session asks for those clocks on our
+  // side of the chain: the decoding thread and the codec callback thread.
+  std::unique_ptr<ThroughputHintSession> throughputHint;
+  bool throughputHintRequested = false;
 };
 
 namespace {
@@ -141,22 +263,29 @@ void compactConsumed(std::vector<float> &buffer, size_t &cursor) {
 void appendNativePcm(AndroidDecoderState &state, const uint8_t *bytes, size_t byteCount) {
   compactConsumed(state.nativeLeftover, state.nativeCursor);
   auto &pcm = state.nativeLeftover;
+  const size_t base = pcm.size();
   if (state.pcmEncoding == ENCODING_PCM_FLOAT) {
     const size_t sampleCount = byteCount / sizeof(float);
-    const auto *samples = reinterpret_cast<const float *>(bytes);
-    pcm.insert(pcm.end(), samples, samples + sampleCount);
+    pcm.resize(base + sampleCount);
+    std::memcpy(pcm.data() + base, bytes, sampleCount * sizeof(float));
     return;
   }
   if (state.pcmEncoding == ENCODING_PCM_8) {
+    pcm.resize(base + byteCount);
+    float *out = pcm.data() + base;
     for (size_t i = 0; i < byteCount; ++i) {
-      pcm.push_back((static_cast<float>(bytes[i]) - 128.0f) / 128.0f);
+      out[i] = (static_cast<float>(bytes[i]) - 128.0f) / 128.0f;
     }
     return;
   }
   const size_t sampleCount = byteCount / sizeof(int16_t);
-  const auto *pcm16 = reinterpret_cast<const int16_t *>(bytes);
+  pcm.resize(base + sampleCount);
+  float *out = pcm.data() + base;
+  // memcpy per sample: codec output buffers carry no int16 alignment guarantee.
   for (size_t i = 0; i < sampleCount; ++i) {
-    pcm.push_back(static_cast<float>(pcm16[i]) / 32768.0f);
+    int16_t sample = 0;
+    std::memcpy(&sample, bytes + i * sizeof(int16_t), sizeof(sample));
+    out[i] = static_cast<float>(sample) / 32768.0f;
   }
 }
 
@@ -193,20 +322,20 @@ void setupResamplerIfNeeded(AndroidDecoderState &state) {
 // Applies MediaCodec output format. When rate/channels change vs track metadata
 // (common with AAC), rebuilds the resampler and drops PCM produced under the
 // previous layout so leftover samples are not misinterpreted.
-void applyCodecOutputFormat(AndroidDecoderState &state, AMediaFormat *outFormat) {
+void applyCodecOutputFormat(AndroidDecoderState &state, const CodecOutputFormat &format) {
   const int previousChannels = state.channels;
   const int previousNativeRate = state.nativeSampleRate;
 
-  AMediaFormat_getInt32(outFormat, AMEDIAFORMAT_KEY_SAMPLE_RATE, &state.nativeSampleRate);
-  AMediaFormat_getInt32(outFormat, AMEDIAFORMAT_KEY_CHANNEL_COUNT, &state.channels);
-  if (!AMediaFormat_getInt32(outFormat, "pcm-encoding", &state.pcmEncoding)) {
-    state.pcmEncoding = ENCODING_PCM_16;
-  }
-  if (state.channels <= 0) {
-    state.channels = previousChannels > 0 ? previousChannels : 1;
+  state.pcmEncoding = format.pcmEncoding;
+  if (format.channels > 0) {
+    state.channels = format.channels;
+  } else if (state.channels <= 0) {
+    state.channels = 1;
   }
-  if (state.nativeSampleRate <= 0) {
-    state.nativeSampleRate = previousNativeRate > 0 ? previousNativeRate : 44100;
+  if (format.sampleRate > 0) {
+    state.nativeSampleRate = format.sampleRate;
+  } else if (state.nativeSampleRate <= 0) {
+    state.nativeSampleRate = 44100;
   }
 
   if (state.channels == previousChannels && state.nativeSampleRate == previousNativeRate) {
@@ -220,62 +349,173 @@ void applyCodecOutputFormat(AndroidDecoderState &state, AMediaFormat *outFormat)
   setupResamplerIfNeeded(state);
 }
 
-// Advances the codec one step: feeds at most one input packet and drains at
-// most one output buffer into nativeLeftover. Sets outputEnded at EOS.
-void pumpCodec(AndroidDecoderState &state) {
-  if (state.outputEnded) {
+// Fills the codec input buffer at `index` with the next extractor packet, or
+// with end-of-stream once the extractor runs dry. Returns false when the
+// buffer is not ours (a stale async index) and nothing was queued.
+bool queueNextPacket(AndroidDecoderState &state, size_t index) {
+  auto *codec = state.codec.get();
+  auto *extractor = state.extractor.get();
+
+  size_t bufSize = 0;
+  uint8_t *buf = AMediaCodec_getInputBuffer(codec, index, &bufSize);
+  if (buf == nullptr) {
+    return false;
+  }
+
+  const ssize_t sampleSize = AMediaExtractor_readSampleData(extractor, buf, bufSize);
+  if (sampleSize < 0) {
+    AMediaCodec_queueInputBuffer(codec, index, 0, 0, 0, AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM);
+    state.inputEnded = true;
+  } else {
+    const int64_t pts = AMediaExtractor_getSampleTime(extractor);
+    AMediaCodec_queueInputBuffer(codec, index, 0, static_cast<size_t>(sampleSize), pts, 0);
+    AMediaExtractor_advance(extractor);
+  }
+  return true;
+}
+
+// Appends the PCM of the codec output buffer at `index` to nativeLeftover and
+// hands the buffer back. Sets outputEnded at EOS. A buffer that is not ours
+// (a stale async index) is ignored, EOS flag included.
+void drainOutputBuffer(
+    AndroidDecoderState &state,
+    size_t index,
+    const AMediaCodecBufferInfo &info) {
+  auto *codec = state.codec.get();
+
+  size_t outBufSize = 0;
+  uint8_t *outBuf = AMediaCodec_getOutputBuffer(codec, index, &outBufSize);
+  if (outBuf == nullptr) {
     return;
   }
 
+  state.tryAgainAfterEos = 0;
+  const auto offset = std::min(static_cast<size_t>(std::max(info.offset, 0)), outBufSize);
+  const auto size = std::min(static_cast<size_t>(std::max(info.size, 0)), outBufSize - offset);
+  if (size > 0) {
+    appendNativePcm(state, outBuf + offset, size);
+  }
+  AMediaCodec_releaseOutputBuffer(codec, index, false);
+  if ((info.flags & AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM) != 0) {
+    state.outputEnded = true;
+  }
+}
+
+void countTryAgainAfterEos(AndroidDecoderState &state) {
+  if (state.inputEnded && ++state.tryAgainAfterEos > MAX_TRY_AGAIN_AFTER_EOS) {
+    state.outputEnded = true;
+  }
+}
+
+// Sync mode: feeds at most one input packet and drains at most one output
+// buffer, each behind a blocking dequeue call.
+void pumpCodecSync(AndroidDecoderState &state) {
   auto *codec = state.codec.get();
-  auto *extractor = state.extractor.get();
 
   if (!state.inputEnded) {
     const ssize_t inIndex = AMediaCodec_dequeueInputBuffer(codec, CODEC_TIMEOUT_US);
-    if (inIndex >= 0) {
-      size_t bufSize = 0;
-      uint8_t *buf = AMediaCodec_getInputBuffer(codec, static_cast<size_t>(inIndex), &bufSize);
-      const ssize_t sampleSize =
-          buf != nullptr ? AMediaExtractor_readSampleData(extractor, buf, bufSize) : -1;
-      if (sampleSize < 0) {
-        AMediaCodec_queueInputBuffer(
-            codec, static_cast<size_t>(inIndex), 0, 0, 0, AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM);
-        state.inputEnded = true;
-      } else {
-        const int64_t pts = AMediaExtractor_getSampleTime(extractor);
-        AMediaCodec_queueInputBuffer(
-            codec, static_cast<size_t>(inIndex), 0, static_cast<size_t>(sampleSize), pts, 0);
-        AMediaExtractor_advance(extractor);
-      }
+    if (inIndex >= 0 && !queueNextPacket(state, static_cast<size_t>(inIndex))) {
+      state.inputEnded = true;
     }
   }
 
   AMediaCodecBufferInfo info{};
   const ssize_t outIndex = AMediaCodec_dequeueOutputBuffer(codec, &info, CODEC_TIMEOUT_US);
   if (outIndex >= 0) {
-    state.tryAgainAfterEos = 0;
-    if (info.size > 0) {
-      size_t outBufSize = 0;
-      uint8_t *outBuf =
-          AMediaCodec_getOutputBuffer(codec, static_cast<size_t>(outIndex), &outBufSize);
-      if (outBuf != nullptr) {
-        appendNativePcm(state, outBuf + info.offset, static_cast<size_t>(info.size));
-      }
-    }
-    AMediaCodec_releaseOutputBuffer(codec, static_cast<size_t>(outIndex), false);
-    if ((info.flags & AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM) != 0) {
-      state.outputEnded = true;
-    }
+    drainOutputBuffer(state, static_cast<size_t>(outIndex), info);
   } else if (outIndex == AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED) {
     AMediaFormat *outFormat = AMediaCodec_getOutputFormat(codec);
     if (outFormat != nullptr) {
-      applyCodecOutputFormat(state, outFormat);
+      applyCodecOutputFormat(state, readCodecOutputFormat(outFormat));
       AMediaFormat_delete(outFormat);
     }
   } else if (outIndex == AMEDIACODEC_INFO_TRY_AGAIN_LATER) {
-    if (state.inputEnded && ++state.tryAgainAfterEos > MAX_TRY_AGAIN_AFTER_EOS) {
-      state.outputEnded = true;
+    countTryAgainAfterEos(state);
+  }
+}
+
+// Async mode: waits for the codec callbacks, then feeds every input buffer and
+// drains every output buffer they announced. Skipping the dequeue calls saves
+// two of the six blocking codec round trips each packet costs in sync mode.
+void pumpCodecAsync(AndroidDecoderState &state) {
+  auto &events = *state.asyncEvents;
+  std::deque<int32_t> inputs;
+  std::deque<AsyncOutputEvent> outputs;
+  bool failed = false;
+  {
+    std::unique_lock lock(events.mutex);
+    events.ready.wait_for(lock, CODEC_TIMEOUT, [&] {
+      return events.failed || !events.outputs.empty() ||
+          (!state.inputEnded && !events.inputs.empty());
+    });
+    failed = events.failed;
+    if (!state.inputEnded) {
+      inputs.swap(events.inputs);
     }
+    outputs.swap(events.outputs);
+  }
+
+  if (failed) {
+    state.outputEnded = true;
+    return;
+  }
+  if (inputs.empty() && outputs.empty()) {
+    countTryAgainAfterEos(state);
+    return;
+  }
+
+  for (const int32_t index : inputs) {
+    if (state.inputEnded) {
+      break;
+    }
+    queueNextPacket(state, static_cast<size_t>(index));
+  }
+  for (const auto &event : outputs) {
+    if (state.outputEnded) {
+      break;
+    }
+    if (event.outputFormat.has_value()) {
+      applyCodecOutputFormat(state, *event.outputFormat);
+    } else {
+      drainOutputBuffer(state, static_cast<size_t>(event.index), event.info);
+    }
+  }
+}
+
+// Raw PCM track: converts the next extractor packet without a codec round trip.
+void pumpRawPcm(AndroidDecoderState &state) {
+  auto *extractor = state.extractor.get();
+  ssize_t packetBytes =
+      AMediaExtractor_readSampleData(extractor, state.rawPacket.data(), state.rawPacket.size());
+  // readSampleData also fails when the packet outgrows the buffer; a packet
+  // still has a timestamp then, while the end of the track has none.
+  while (packetBytes < 0 && AMediaExtractor_getSampleTime(extractor) >= 0 &&
+         state.rawPacket.size() < RAW_PACKET_MAX_BYTES) {
+    state.rawPacket.resize(state.rawPacket.size() * 2);
+    packetBytes =
+        AMediaExtractor_readSampleData(extractor, state.rawPacket.data(), state.rawPacket.size());
+  }
+  if (packetBytes < 0) {
+    state.inputEnded = true;
+    state.outputEnded = true;
+    return;
+  }
+  appendNativePcm(state, state.rawPacket.data(), static_cast<size_t>(packetBytes));
+  AMediaExtractor_advance(extractor);
+}
+
+// Advances the codec, appending whatever PCM it produced to nativeLeftover.
+// Sets outputEnded at EOS.
+void pumpCodec(AndroidDecoderState &state) {
+  if (state.outputEnded) {
+    return;
+  }
+  if (state.rawPcmTrack) {
+    pumpRawPcm(state);
+  } else if (state.asyncEvents != nullptr) {
+    pumpCodecAsync(state);
+  } else {
+    pumpCodecSync(state);
   }
 }
 
@@ -374,6 +614,14 @@ decoding::DecoderResult configureExtractorMetadata(
   state.codecMime = mime != nullptr ? mime : "audio/mp4a-latm";
   AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_SAMPLE_RATE, &state.nativeSampleRate);
   AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_CHANNEL_COUNT, &state.channels);
+  state.rawPcmTrack = state.codecMime == MIME_AUDIO_RAW;
+  if (state.rawPcmTrack) {
+    state.pcmEncoding = readCodecOutputFormat(format).pcmEncoding;
+    int32_t maxPacketBytes = 0;
+    AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_MAX_INPUT_SIZE, &maxPacketBytes);
+    state.rawPacket.resize(
+        std::max(RAW_PACKET_INITIAL_BYTES, static_cast<size_t>(std::max(maxPacketBytes, 0))));
+  }
   int64_t durationUs = 0;
   AMediaFormat_getInt64(format, AMEDIAFORMAT_KEY_DURATION, &durationUs);
   AMediaFormat_delete(format);
@@ -384,8 +632,43 @@ decoding::DecoderResult configureExtractorMetadata(
   return Ok(None);
 }
 
+// Routes codec buffer notifications into state.asyncEvents. Must run before
+// configure; returns false, leaving the codec in sync mode, below API 28.
+bool enableAsyncCallbacks(AndroidDecoderState &state, AMediaCodec *codec) {
+  if (__builtin_available(android 28, *)) {
+    auto events = std::make_unique<AsyncCodecEvents>();
+    const AMediaCodecOnAsyncNotifyCallback callbacks{
+        .onAsyncInputAvailable = onAsyncInputAvailable,
+        .onAsyncOutputAvailable = onAsyncOutputAvailable,
+        .onAsyncFormatChanged = onAsyncFormatChanged,
+        .onAsyncError = onAsyncError,
+    };
+    if (AMediaCodec_setAsyncNotifyCallback(codec, callbacks, events.get()) != AMEDIA_OK) {
+      return false;
+    }
+    state.asyncEvents = std::move(events);
+    return true;
+  }
+  return false;
+}
+
+// Joins the calling (decoding) thread and the codec callback thread into one
+// performance hint session. Tried once per decoder; without support it is a no-op.
+void startThroughputHint(AndroidDecoderState &state) {
+  state.throughputHintRequested = true;
+  std::vector<int32_t> threadIds{gettid()};
+  if (state.asyncEvents != nullptr) {
+    const pid_t callbackThreadId =
+        state.asyncEvents->callbackThreadId.load(std::memory_order_relaxed);
+    if (callbackThreadId != 0 && callbackThreadId != threadIds.front()) {
+      threadIds.push_back(callbackThreadId);
+    }
+  }
+  state.throughputHint = ThroughputHintSession::create(threadIds);
+}
+
 decoding::DecoderResult ensureCodecStarted(AndroidDecoderState &state) {
-  if (state.codec != nullptr) {
+  if (state.codec != nullptr || state.rawPcmTrack) {
     return Ok(None);
   }
   if (state.extractor == nullptr || state.audioTrackIndex < 0) {
@@ -403,8 +686,11 @@ decoding::DecoderResult ensureCodecStarted(AndroidDecoderState &state) {
     AMediaFormat_delete(format);
     return Err("AndroidDecoder: createDecoderByType failed");
   }
+  state.asyncEvents.reset();
+  enableAsyncCallbacks(state, codec);
   if (AMediaCodec_configure(codec, format, nullptr, nullptr, 0) != AMEDIA_OK) {
     AMediaCodec_delete(codec);
+    state.asyncEvents.reset();
     AMediaFormat_delete(format);
     return Err("AndroidDecoder: configure failed");
   }
@@ -412,6 +698,7 @@ decoding::DecoderResult ensureCodecStarted(AndroidDecoderState &state) {
 
   if (AMediaCodec_start(codec) != AMEDIA_OK) {
     AMediaCodec_delete(codec);
+    state.asyncEvents.reset();
     return Err("AndroidDecoder: start failed");
   }
 
@@ -555,6 +842,10 @@ size_t AndroidDecoder::readPcmFrames(float *outInterleaved, size_t frameCount) {
   if (ensureCodecStarted(state).is_err()) {
     return 0;
   }
+  if (preferThroughput_ && !state.throughputHintRequested) {
+    startThroughputHint(state);
+  }
+  const auto workStart = std::chrono::steady_clock::now();
 
   size_t filled = 0; // frames
   // The caller sized outInterleaved from outputChannels(), so this call must
@@ -598,6 +889,10 @@ size_t AndroidDecoder::readPcmFrames(float *outInterleaved, size_t frameCount) {
     }
   }
 
+  if (state.throughputHint != nullptr) {
+    state.throughputHint->reportWork(std::chrono::steady_clock::now() - workStart);
+  }
+
   framePosition_ += static_cast<int64_t>(filled);
   return filled;
 }
@@ -620,7 +915,16 @@ decoding::DecoderResult AndroidDecoder::seekToTime(double seconds) {
       AMEDIA_OK) {
     return Err("AndroidDecoder::seekToTime: AMediaExtractor_seekTo failed");
   }
-  AMediaCodec_flush(state.codec.get());
+  if (state.codec != nullptr) {
+    AMediaCodec_flush(state.codec.get());
+  }
+  if (state.asyncEvents != nullptr) {
+    // A flushed async codec stays silent until restarted.
+    state.asyncEvents->clear();
+    if (AMediaCodec_start(state.codec.get()) != AMEDIA_OK) {
+      return Err("AndroidDecoder::seekToTime: restarting the codec after flush failed");
+    }
+  }
 
   state.nativeLeftover.clear();
   state.nativeCursor = 0;
@@ -640,6 +944,15 @@ decoding::DecoderResult AndroidDecoder::seekToTime(double seconds) {
   return Ok(None);
 }
 
+void AndroidDecoder::setPreferThroughput(bool preferThroughput) {
+  preferThroughput_ = preferThroughput;
+  if (!preferThroughput && impl_ != nullptr) {
+    // Closing the session lets the clocks drop; re-enabling starts a new one.
+    impl_->throughputHint.reset();
+    impl_->throughputHintRequested = false;
+  }
+}
+
 void AndroidDecoder::releaseImpl() {
   impl_.reset();
 }

package/android/src/main/cpp/audioapi/android/AndroidDecoding.h

@@ -16,7 +16,8 @@ struct AndroidDecoderState;
  *
  * Opens local files or in-memory buffers and pulls interleaved float PCM on
  * demand. Container metadata (including duration) is read at open time; the
- * MediaCodec pipeline starts lazily on the first read or seek. In-memory
+ * MediaCodec pipeline starts lazily on the first read or seek, in async
+ * (callback) mode on API 28+ and sync mode below. In-memory
  * sources use AMediaDataSource on API 28+ (runtime check); API 21–27 falls
  * back to a temp file + fd. Remote URL / HLS decoding stays on FFmpeg.
  */
@@ -30,6 +31,9 @@ class AndroidDecoder : public decoding::OsDecoderBase {
   [[nodiscard]] decoding::DecoderResult open(const decoding::EncodedMemorySource &source);
   [[nodiscard]] size_t readPcmFrames(float *outInterleaved, size_t frameCount) override;
   [[nodiscard]] decoding::DecoderResult seekToTime(double seconds) override;
+  /// While on, boosts CPU clocks for the decoding threads through an ADPF
+  /// performance hint session on API 33+; does nothing below that.
+  void setPreferThroughput(bool preferThroughput) override;
 
  private:
   [[nodiscard]] decoding::DecoderResult finishOpeningDecoder(
@@ -40,6 +44,7 @@ class AndroidDecoder : public decoding::OsDecoderBase {
 
   // Opaque NDK state (defined in AndroidDecoding.cpp).
   std::unique_ptr<AndroidDecoderState> impl_;
+  bool preferThroughput_ = false;
 };
 
 } // namespace audioapi::android::decoder

package/android/src/main/cpp/audioapi/android/ThroughputHintSession.cpp

@@ -0,0 +1,51 @@
+#include <audioapi/android/ThroughputHintSession.h>
+
+#include <android/performance_hint.h>
+
+#include <algorithm>
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace audioapi::android {
+namespace {
+
+// Shorter than any burst on purpose: every report then asks for more CPU,
+// keeping the clocks raised for as long as the session lives.
+constexpr int64_t THROUGHPUT_HINT_TARGET_NS = 1'000'000;
+
+} // namespace
+
+std::unique_ptr<ThroughputHintSession> ThroughputHintSession::create(
+    const std::vector<int32_t> &threadIds) {
+  if (__builtin_available(android 33, *)) {
+    APerformanceHintManager *manager = APerformanceHint_getManager();
+    if (manager == nullptr) {
+      return nullptr;
+    }
+    SessionPtr session(APerformanceHint_createSession(
+        manager, threadIds.data(), threadIds.size(), THROUGHPUT_HINT_TARGET_NS));
+    if (session == nullptr) {
+      return nullptr;
+    }
+    return std::unique_ptr<ThroughputHintSession>(new ThroughputHintSession(std::move(session)));
+  }
+  return nullptr;
+}
+
+ThroughputHintSession::ThroughputHintSession(SessionPtr session) : session_(std::move(session)) {}
+
+void ThroughputHintSession::SessionCloser::operator()(APerformanceHintSession *session) const {
+  if (__builtin_available(android 33, *)) {
+    APerformanceHint_closeSession(session);
+  }
+}
+
+void ThroughputHintSession::reportWork(std::chrono::nanoseconds duration) {
+  if (__builtin_available(android 33, *)) {
+    APerformanceHint_reportActualWorkDuration(
+        session_.get(), std::max<int64_t>(duration.count(), 1));
+  }
+}
+
+} // namespace audioapi::android

package/android/src/main/cpp/audioapi/android/ThroughputHintSession.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <audioapi/utils/Macros.h>
+#include <chrono>
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+struct APerformanceHintSession;
+
+namespace audioapi::android {
+
+/// ADPF performance hint session that keeps CPU clocks raised for a group of
+/// threads doing bursty work which would otherwise never look busy enough to
+/// the governor. Requires API 33; ThroughputHintSession.cpp weak-links the NDK
+/// symbols and guards every call.
+class ThroughputHintSession {
+ public:
+  /// Returns null below API 33 or when the device offers no hint sessions.
+  [[nodiscard]] static std::unique_ptr<ThroughputHintSession> create(
+      const std::vector<int32_t> &threadIds);
+
+  ~ThroughputHintSession() = default;
+  DELETE_COPY_AND_MOVE(ThroughputHintSession);
+
+  /// Reports how long one burst of work took on the session's threads.
+  void reportWork(std::chrono::nanoseconds duration);
+
+ private:
+  struct SessionCloser {
+    void operator()(APerformanceHintSession *session) const;
+  };
+  using SessionPtr = std::unique_ptr<APerformanceHintSession, SessionCloser>;
+
+  explicit ThroughputHintSession(SessionPtr session);
+
+  SessionPtr session_;
+};
+
+} // namespace audioapi::android

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

@@ -17,6 +17,7 @@ import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
 import com.swmansion.audioapi.system.ForegroundServiceManager
 import com.swmansion.audioapi.system.MediaSessionManager
 import com.swmansion.audioapi.system.NativeFileInfo
+import com.swmansion.audioapi.system.NativeRecorderControl
 import com.swmansion.audioapi.system.PermissionRequestListener
 import java.lang.ref.WeakReference
 import kotlin.concurrent.thread
@@ -92,6 +93,8 @@ class AudioAPIModule(
   }
 
   override fun invalidate() {
+    // Before the cleanups below pull the foreground service and input routing from under it.
+    NativeRecorderControl.stop()
     reactContext.get()?.removeLifecycleEventListener(this)
     ForegroundServiceManager.cleanup()
     MediaSessionManager.cleanup()

package/common/cpp/audioapi/decoding/AudioDecoding.cpp

@@ -48,33 +48,67 @@ makeEncodedMemorySource(const void *data, size_t size, int sampleRate) {
       .sampleRate = sampleRate};
 }
 
+// Container durations are estimates, trusted only up to this length so a
+// corrupt header cannot force a huge allocation. Longer files grow past it.
+constexpr float MAX_TRUSTED_ESTIMATE_SECONDS = 30.0F * 60.0F;
+// Headroom over the estimate (1/64 ≈ 1.6%) for encoder padding and priming.
+constexpr size_t ESTIMATE_HEADROOM_DIVISOR = 64;
+// Capacity growth once the estimate is exceeded: x1.5.
+constexpr size_t GROWTH_NUMERATOR = 3;
+constexpr size_t GROWTH_DENOMINATOR = 2;
+// Unused capacity up to 1/8 of the decoded length is trimmed in place (the
+// allocation stays); more than that is worth an exact-size copy.
+constexpr size_t IN_PLACE_TRIM_SLACK_DIVISOR = 8;
+
+size_t initialDecodeCapacity(size_t estimatedFrames, float sampleRate, size_t chunkFrames) {
+  const auto maxTrustedEstimate =
+      static_cast<size_t>(std::max(1.0F, sampleRate) * MAX_TRUSTED_ESTIMATE_SECONDS);
+  const size_t trustedEstimate = std::min(estimatedFrames, maxTrustedEstimate);
+  return trustedEstimate + trustedEstimate / ESTIMATE_HEADROOM_DIVISOR + chunkFrames;
+}
+
+size_t grownDecodeCapacity(size_t currentCapacity, size_t requiredFrames) {
+  return std::max(requiredFrames, currentCapacity * GROWTH_NUMERATOR / GROWTH_DENOMINATOR);
+}
+
+// Decodes straight into the returned planar buffer, sized up front from the
+// decoder's frame estimate, so peak memory stays near one copy of the PCM.
 AudioBufferResult decodeAll(decoding::AudioDecoderBackend &decoder) {
+  constexpr size_t chunkFrames = decoding::AudioDecoderBackend::CHUNK_SIZE;
+  decoder.setPreferThroughput(true);
   const int channels = std::max(1, decoder.outputChannels());
   const auto outputSampleRate = static_cast<float>(decoder.outputSampleRate());
 
-  std::vector<float> interleaved;
-  std::vector<float> chunk(
-      decoding::AudioDecoderBackend::CHUNK_SIZE * static_cast<size_t>(channels));
+  const size_t initialCapacity =
+      initialDecodeCapacity(decoder.getTotalPcmFrameCount(), outputSampleRate, chunkFrames);
+  auto audioBuffer = std::make_shared<AudioBuffer>(initialCapacity, channels, outputSampleRate);
 
+  std::vector<float> chunk(chunkFrames * static_cast<size_t>(channels));
+  size_t framesDecoded = 0;
   while (true) {
-    const size_t framesRead =
-        decoder.readPcmFrames(chunk.data(), decoding::AudioDecoderBackend::CHUNK_SIZE);
+    const size_t framesRead = decoder.readPcmFrames(chunk.data(), chunkFrames);
     if (framesRead == 0) {
       break;
     }
-    interleaved.insert(
-        interleaved.end(),
-        chunk.begin(),
-        chunk.begin() + static_cast<std::ptrdiff_t>(framesRead * static_cast<size_t>(channels)));
+    if (framesDecoded + framesRead > audioBuffer->getSize()) {
+      audioBuffer->resize(grownDecodeCapacity(audioBuffer->getSize(), framesDecoded + framesRead));
+    }
+    audioBuffer->deinterleaveFrom(chunk.data(), framesDecoded, framesRead);
+    framesDecoded += framesRead;
   }
 
-  if (interleaved.empty()) {
+  if (framesDecoded == 0) {
     return Err("Failed to decode any frames");
   }
 
-  const size_t outputFrames = interleaved.size() / static_cast<size_t>(channels);
-  auto audioBuffer = std::make_shared<AudioBuffer>(outputFrames, channels, outputSampleRate);
-  audioBuffer->deinterleaveFrom(interleaved.data(), outputFrames);
+  const size_t capacity = audioBuffer->getSize();
+  if (capacity - framesDecoded <= framesDecoded / IN_PLACE_TRIM_SLACK_DIVISOR) {
+    audioBuffer->resize(framesDecoded);
+  } else {
+    auto exact = std::make_shared<AudioBuffer>(framesDecoded, channels, outputSampleRate);
+    exact->copy(*audioBuffer, 0, 0, framesDecoded);
+    audioBuffer = std::move(exact);
+  }
   return Ok(std::move(audioBuffer));
 }
 

package/common/cpp/audioapi/decoding/backends/AudioDecoderBackend.h

@@ -19,6 +19,10 @@ class AudioDecoderBackend {
 
   [[nodiscard]] virtual size_t readPcmFrames(float *outInterleaved, size_t frameCount) = 0;
   [[nodiscard]] virtual DecoderResult seekToTime(double seconds) = 0;
+  /// Whether the platform should favour decoding speed over power: on when
+  /// decoding a whole file at once rather than streaming it in real time.
+  /// Off initially; a no-op by default.
+  virtual void setPreferThroughput(bool /*preferThroughput*/) {}
   virtual void close() = 0;
   [[nodiscard]] virtual bool isOpen() const = 0;
 

package/common/cpp/audioapi/jsi/RuntimeInstanceCache.hpp

@@ -3,6 +3,7 @@
 #include <audioapi/jsi/RuntimeObserver.h>
 
 #include <jsi/jsi.h>
+#include <mutex>
 #include <unordered_map>
 #include <utility>
 
@@ -24,31 +25,36 @@ template <typename T>
 class RuntimeInstanceCache : public RuntimeObserverListener {
  public:
   void onRuntimeDestroyed(jsi::Runtime *rt) override {
-    // A runtime has been destroyed, so destroy the related cache.
+    std::scoped_lock lock(runtimeCachesMutex_);
     runtimeCaches_.erase(rt);
   }
 
   ~RuntimeInstanceCache() override {
-    for (auto &cache : runtimeCaches_) {
-      // remove all `onRuntimeDestroyed` listeners.
-      RuntimeObserver::removeListener(*cache.first, this);
-    }
+    // Unregister under the observer's lock rather than walking `runtimeCaches_`, which a runtime
+    // being torn down on another thread may be erasing from at the same time.
+    RuntimeObserver::removeListener(this);
   }
 
   T &get(jsi::Runtime &rt) {
-    if (runtimeCaches_.count(&rt) == 0) {
-      // This is the first time this Runtime has been accessed.
-      // We set up a `onRuntimeDestroyed` listener for it and
-      // initialize the cache map.
-      RuntimeObserver::addListener(rt, this);
-
-      T cache;
-      runtimeCaches_.emplace(&rt, std::move(cache));
+    {
+      std::scoped_lock lock(runtimeCachesMutex_);
+      if (auto cache = runtimeCaches_.find(&rt); cache != runtimeCaches_.end()) {
+        return cache->second;
+      }
     }
-    return runtimeCaches_.at(&rt);
+    // Registered without holding `runtimeCachesMutex_`: teardown takes the observer's lock and
+    // then this one, so taking them in the opposite order here could deadlock.
+    RuntimeObserver::addListener(rt, this);
+
+    std::scoped_lock lock(runtimeCachesMutex_);
+    // first time this runtime has seen this cache, create it and return it.
+    return runtimeCaches_.emplace(&rt, T{}).first->second;
   }
 
  private:
+  // Guards the map structure: `get` runs on each runtime's JS thread while `onRuntimeDestroyed`
+  // runs on whichever thread tears another runtime down.
+  std::mutex runtimeCachesMutex_;
   std::unordered_map<jsi::Runtime *, T> runtimeCaches_;
 };
 

package/common/cpp/audioapi/jsi/RuntimeObserver.cpp

@@ -8,25 +8,30 @@
 namespace audioapi {
 
 static std::unordered_map<jsi::Runtime *, std::unordered_set<RuntimeObserverListener *>> listeners;
-static std::mutex listenersMutex;
+// Host objects are destroyed on whichever thread drops their last reference, and runtimes can be
+// torn down off the JS thread. Recursive because notifying a listener can destroy other host
+// objects, which remove themselves on the same thread.
+static std::recursive_mutex listenersMutex;
 
 struct RuntimeObserverObject : public jsi::HostObject {
   jsi::Runtime *rt_;
   explicit RuntimeObserverObject(jsi::Runtime *rt) : rt_(rt) {}
   ~RuntimeObserverObject() override {
-    std::unordered_set<RuntimeObserverListener *> toNotify;
-    {
-      std::scoped_lock lock(listenersMutex);
-      auto listenersSet = listeners.find(rt_);
-      if (listenersSet != listeners.end()) {
-        toNotify = std::move(listenersSet->second);
-        listeners.erase(listenersSet);
-      }
+    // Notify while holding the lock, so a listener being destroyed on another thread cannot be
+    // freed between leaving the set and being notified. Take one listener at a time: a notified
+    // listener can remove others from this set.
+    std::scoped_lock lock(listenersMutex);
+    auto listenersSet = listeners.find(rt_);
+    if (listenersSet == listeners.end()) {
+      return;
     }
-    // Notify outside the lock — listener callbacks may re-enter add/remove.
-    for (auto *listener : toNotify) {
+    auto &runtimeListeners = listenersSet->second;
+    while (!runtimeListeners.empty()) {
+      auto *listener = *runtimeListeners.begin();
+      runtimeListeners.erase(runtimeListeners.begin());
       listener->onRuntimeDestroyed(rt_);
     }
+    listeners.erase(rt_);
   }
 };
 
@@ -60,4 +65,11 @@ void RuntimeObserver::removeListener(jsi::Runtime &rt, RuntimeObserverListener *
   }
 }
 
+void RuntimeObserver::removeListener(RuntimeObserverListener *listener) {
+  std::scoped_lock lock(listenersMutex);
+  for (auto &[rt, runtimeListeners] : listeners) {
+    runtimeListeners.erase(listener);
+  }
+}
+
 } // namespace audioapi

package/common/cpp/audioapi/jsi/RuntimeObserver.h

@@ -24,6 +24,8 @@ struct RuntimeObserverListener {
 struct RuntimeObserver {
   static void addListener(jsi::Runtime &rt, RuntimeObserverListener *listener);
   static void removeListener(jsi::Runtime &rt, RuntimeObserverListener *listener);
+  /** Removes the listener from every runtime it is registered with. */
+  static void removeListener(RuntimeObserverListener *listener);
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/libs/miniaudio/decoders/libvorbis/miniaudio_libvorbis.c

@@ -482,8 +482,11 @@ MA_API ma_result ma_libvorbis_get_length_in_pcm_frames(ma_libvorbis* pVorbis, ma
 
     #if !defined(MA_NO_LIBVORBIS)
     {
-        /* I don't know how to reliably retrieve the length in frames using libvorbis, so returning 0 for now. */
-        *pLength = 0;
+        /* ov_pcm_total() needs a seekable stream; an unseekable one keeps the length unknown (0). */
+        ogg_int64_t length = ov_pcm_total((OggVorbis_File*)pVorbis->vf, -1);
+        if (length > 0) {
+            *pLength = (ma_uint64)length;
+        }
 
         return MA_SUCCESS;
     }

package/common/cpp/audioapi/utils/AudioArray.hpp

@@ -67,6 +67,17 @@ class AlignedAudioArray {
     return size_;
   }
 
+  /// @brief Changes the length in place, keeping existing samples and zero-filling growth.
+  /// @note Shrinking keeps the allocation; growing reallocates to exactly `size`,
+  /// so the caller owns the growth policy.
+  void resize(size_t size) {
+    if (size > data_.capacity()) {
+      data_.reserve(size);
+    }
+    data_.resize(size, 0.0f);
+    size_ = size;
+  }
+
   float &operator[](size_t index) noexcept {
     return data_[index];
   }

package/common/cpp/audioapi/utils/AudioBuffer.hpp

@@ -109,6 +109,17 @@ class AlignedAudioBuffer {
   [[nodiscard]] size_t getSize() const noexcept {
     return size_;
   }
+
+  /// @brief Changes the frame count of every channel in place (see AlignedAudioArray::resize).
+  /// @note Only for a buffer nothing else references yet: channels shared through
+  /// shareChannels() or exposed to JS would change length under their holders.
+  void resize(size_t size) {
+    for (const auto &channel : channels_) {
+      channel->resize(size);
+    }
+    size_ = size;
+  }
+
   [[nodiscard]] double getDuration() const noexcept {
     return static_cast<double>(size_) / static_cast<double>(getSampleRate());
   }

package/ios/audioapi/ios/core/utils/IOSDecoding.mm

@@ -10,6 +10,8 @@
 #include <cstdint>
 #include <cstring>
 #include <memory>
+#include <optional>
+#include <span>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -116,6 +118,159 @@ AudioFileTypeID guessFileTypeHint(const void *data, size_t size)
 }
 // NOLINTEND(readability-magic-numbers, cppcoreguidelines-avoid-magic-numbers)
 
+using ChannelLayoutStorage = std::vector<std::byte>;
+
+AudioChannelLayout *asChannelLayout(ChannelLayoutStorage &storage)
+{
+  return reinterpret_cast<AudioChannelLayout *>(storage.data());
+}
+
+// Reads a variable-size AudioChannelLayout property through a GetPropertyInfo / GetProperty pair.
+template <typename GetInfo, typename Get>
+std::optional<ChannelLayoutStorage> readChannelLayout(GetInfo &&getInfo, Get &&get)
+{
+  UInt32 size = 0;
+  if (getInfo(&size) != noErr || size < sizeof(AudioChannelLayout)) {
+    return std::nullopt;
+  }
+  ChannelLayoutStorage storage(size);
+  if (get(&size, storage.data()) != noErr) {
+    return std::nullopt;
+  }
+  return storage;
+}
+
+// The layout is not always published by ExtAudioFile itself: for MP4/AAC it lives on
+// the wrapped AudioFile or only on the codec converter ExtAudioFile builds internally.
+std::optional<ChannelLayoutStorage> readFileChannelLayout(ExtAudioFileRef extFile)
+{
+  if (auto layout = readChannelLayout(
+          [&](UInt32 *size) {
+            return ExtAudioFileGetPropertyInfo(
+                extFile, kExtAudioFileProperty_FileChannelLayout, size, nullptr);
+          },
+          [&](UInt32 *size, void *data) {
+            return ExtAudioFileGetProperty(
+                extFile, kExtAudioFileProperty_FileChannelLayout, size, data);
+          })) {
+    return layout;
+  }
+
+  AudioFileID audioFile = nullptr;
+  UInt32 audioFileSize = sizeof(audioFile);
+  if (ExtAudioFileGetProperty(
+          extFile, kExtAudioFileProperty_AudioFile, &audioFileSize, &audioFile) == noErr &&
+      audioFile != nullptr) {
+    if (auto layout = readChannelLayout(
+            [&](UInt32 *size) {
+              return AudioFileGetPropertyInfo(
+                  audioFile, kAudioFilePropertyChannelLayout, size, nullptr);
+            },
+            [&](UInt32 *size, void *data) {
+              return AudioFileGetProperty(audioFile, kAudioFilePropertyChannelLayout, size, data);
+            })) {
+      return layout;
+    }
+  }
+
+  AudioConverterRef converter = nullptr;
+  UInt32 converterSize = sizeof(converter);
+  if (ExtAudioFileGetProperty(
+          extFile, kExtAudioFileProperty_AudioConverter, &converterSize, &converter) == noErr &&
+      converter != nullptr) {
+    if (auto layout = readChannelLayout(
+            [&](UInt32 *size) {
+              return AudioConverterGetPropertyInfo(
+                  converter, kAudioConverterInputChannelLayout, size, nullptr);
+            },
+            [&](UInt32 *size, void *data) {
+              return AudioConverterGetProperty(
+                  converter, kAudioConverterInputChannelLayout, size, data);
+            })) {
+      return layout;
+    }
+  }
+  return std::nullopt;
+}
+
+// Expands a tag- or bitmap-described layout into explicit per-channel descriptions.
+std::optional<ChannelLayoutStorage> expandToChannelDescriptions(ChannelLayoutStorage layout)
+{
+  const AudioChannelLayout *source = asChannelLayout(layout);
+  if (source->mChannelLayoutTag == kAudioChannelLayoutTag_UseChannelDescriptions) {
+    return layout;
+  }
+
+  const bool usesBitmap = source->mChannelLayoutTag == kAudioChannelLayoutTag_UseChannelBitmap;
+  const AudioFormatPropertyID property = usesBitmap ? kAudioFormatProperty_ChannelLayoutForBitmap
+                                                    : kAudioFormatProperty_ChannelLayoutForTag;
+  const void *specifier = usesBitmap ? static_cast<const void *>(&source->mChannelBitmap)
+                                     : static_cast<const void *>(&source->mChannelLayoutTag);
+  const UInt32 specifierSize =
+      usesBitmap ? sizeof(source->mChannelBitmap) : sizeof(source->mChannelLayoutTag);
+
+  UInt32 size = 0;
+  if (AudioFormatGetPropertyInfo(property, specifierSize, specifier, &size) != noErr ||
+      size < sizeof(AudioChannelLayout)) {
+    return std::nullopt;
+  }
+  ChannelLayoutStorage expanded(size);
+  if (AudioFormatGetProperty(property, specifierSize, specifier, &size, expanded.data()) != noErr) {
+    return std::nullopt;
+  }
+  return expanded;
+}
+
+bool isSpeakerLabel(AudioChannelLabel label)
+{
+  return label != kAudioChannelLabel_Unknown && label != kAudioChannelLabel_Unused &&
+      label < kAudioChannelLabel_Discrete;
+}
+
+// Decoded channels must follow the WAVE / Web Audio speaker order
+// (L R C LFE Ls Rs …), but AudioToolbox emits them in the file's native order —
+// C L R Ls Rs LFE for 5.1 AAC. Core Audio numbers its speaker labels in WAVE
+// order, so sorting the file's channels by label yields the target layout, and
+// ExtAudioFile reorders to it. Layouts without speaker positions stay in file order.
+void requestWebAudioChannelOrder(ExtAudioFileRef extFile, int channels)
+{
+  if (channels <= 2) {
+    return;
+  }
+  auto fileLayout = readFileChannelLayout(extFile);
+  if (!fileLayout) {
+    return;
+  }
+  auto described = expandToChannelDescriptions(std::move(*fileLayout));
+  if (!described) {
+    return;
+  }
+
+  AudioChannelLayout *layout = asChannelLayout(*described);
+  if (layout->mNumberChannelDescriptions != static_cast<UInt32>(channels)) {
+    return;
+  }
+  // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+  std::span descriptions(layout->mChannelDescriptions, layout->mNumberChannelDescriptions);
+  const bool allSpeakers = std::ranges::all_of(descriptions, [](const auto &description) {
+    return isSpeakerLabel(description.mChannelLabel);
+  });
+  if (!allSpeakers ||
+      std::ranges::is_sorted(descriptions, {}, &AudioChannelDescription::mChannelLabel)) {
+    return;
+  }
+
+  std::ranges::sort(descriptions, {}, &AudioChannelDescription::mChannelLabel);
+  layout->mChannelLayoutTag = kAudioChannelLayoutTag_UseChannelDescriptions;
+  layout->mChannelBitmap = 0;
+  // Best effort: on failure the channels simply keep the file order.
+  ExtAudioFileSetProperty(
+      extFile,
+      kExtAudioFileProperty_ClientChannelLayout,
+      static_cast<UInt32>(described->size()),
+      described->data());
+}
+
 } // namespace
 
 IOSDecoder::IOSDecoder() = default;
@@ -165,6 +320,8 @@ decoding::DecoderResult IOSDecoder::finishOpeningDecoder(
     return Err(
         "IOSDecoder: ExtAudioFileSetProperty(ClientDataFormat) failed: " + std::to_string(status));
   }
+  // After ClientDataFormat: setting the client format resets the client channel layout.
+  requestWebAudioChannelOrder(extFile, channels);
 
   SInt64 fileLengthFrames = 0;
   propSize = sizeof(fileLengthFrames);

package/ios/audioapi/ios/system/AudioEngine.mm

@@ -1,6 +1,7 @@
 #import <audioapi/ios/system/AudioEngine.h>
 #import <audioapi/ios/system/AudioSessionManager.h>
 
+#include <audioapi/core/inputs/ActiveRecorderHandle.h>
 #include <mutex>
 
 @interface AudioEngineSourceRegistration : NSObject
@@ -149,6 +150,9 @@ static AudioEngine *_sharedInstance = nil;
 
 - (void)cleanup
 {
+  // outside of lock because it locks on its own
+  (void)audioapi::ActiveRecorderHandle::global().stopAndReturnInfo();
+
   std::scoped_lock lock(_engineLock);
   [self destroyAudioEngine];
   self.state = AudioEngineState::AudioEngineStateIdle;

package/ios/audioapi/ios/system/AudioSessionManager.mm

@@ -70,7 +70,7 @@ static AudioSessionManager *_sharedInstance = nil;
 
 - (void)setPreferredIOBufferFrames:(int)frames
 {
-  if (!self.shouldManageSession) {
+  if (!self.shouldManageSession || self.audioSession == nil) {
     return;
   }
 

package/lib/commonjs/hooks/useAudioInput.js

@@ -7,6 +7,8 @@ exports.default = useAudioInput;
 var _react = require("react");
 var _api = require("../api");
 const meaningfulReasons = ['NewDeviceAvailable', 'OldDeviceUnavailable',
+// iOS reports a disconnected Bluetooth headset that was the current input this way not old device unavailable
+'Override',
 // e.g. system picks a different device as current one is not suitable for the new configuration
 'CategoryChange', 'ConfigurationChange'];
 

package/lib/commonjs/hooks/useAudioInput.js.map

@@ -1 +1 @@
-{"version":3,"names":["_react","require","_api","meaningfulReasons","useAudioInput","availableInputs","setAvailableInputs","useState","currentInput","setCurrentInput","selectInput","useCallback","device","selection","id","AudioManager","setInputDevice","devicesInfo","getDevicesInfo","useEffect","fetchAvailableInputs","audioDevices","currentDeviceId","currentInputs","length","handleRouteChange","event","includes","reason","sub","addSystemEventListener","remove","useMemo","find","d"],"sourceRoot":"../../../src","sources":["hooks/useAudioInput.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,IAAA,GAAAD,OAAA;AAQA,MAAME,iBAAsC,GAAG,CAC7C,oBAAoB,EACpB,sBAAsB;AACtB;AACA,gBAAgB,EAChB,qBAAqB,CACtB;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,aAAaA,CAAA,EAAG;EACtC,MAAM,CAACC,eAAe,EAAEC,kBAAkB,CAAC,GAAG,IAAAC,eAAQ,EAAkB,EAAE,CAAC;EAC3E,MAAM,CAACC,YAAY,EAAEC,eAAe,CAAC,GAAG,IAAAF,eAAQ,EAAgB,IAAI,CAAC;EAErE,MAAMG,WAAW,GAAG,IAAAC,kBAAW,EAC7B,MAAOC,MAAmC,IAAK;IAC7C,MAAMC,SAAS,GAAGD,MAAM,KAAK,SAAS,GAAG,SAAS,GAAGA,MAAM,CAACE,EAAE;IAE9D,MAAMC,iBAAY,CAACC,cAAc,CAACH,SAAS,CAAC;IAC5CJ,eAAe,CAACI,SAAS,KAAK,SAAS,GAAG,IAAI,GAAGA,SAAS,CAAC;IAE3D,MAAMI,WAA6B,GAAG,MAAMF,iBAAY,CAACG,cAAc,CAAC,CAAC;IACzEZ,kBAAkB,CAACW,WAAW,CAACZ,eAAe,CAAC;EACjD,CAAC,EACD,EACF,CAAC;EAED,IAAAc,gBAAS,EAAC,MAAM;IACd,eAAeC,oBAAoBA,CAAA,EAAG;MACpC,MAAMC,YAAY,GAAG,MAAMN,iBAAY,CAACG,cAAc,CAAC,CAAC;MACxD,MAAMI,eAAe,GAAGD,YAAY,CAACE,aAAa,CAACC,MAAM,GACrDH,YAAY,CAACE,aAAa,CAAC,CAAC,CAAC,CAACT,EAAE,GAChC,IAAI;MAERR,kBAAkB,CAACe,YAAY,CAAChB,eAAe,CAAC;MAChDI,eAAe,CAACa,eAAe,CAAC;IAClC;IAEA,eAAeG,iBAAiBA,CAACC,KAA6B,EAAE;MAC9D,IAAI,CAACvB,iBAAiB,CAACwB,QAAQ,CAACD,KAAK,CAACE,MAAM,CAAC,EAAE;QAC7C;MACF;MAEA,MAAMR,oBAAoB,CAAC,CAAC;IAC9B;IAEA,MAAMS,GAAG,GAAGd,iBAAY,CAACe,sBAAsB,CAC7C,aAAa,EACbL,iBACF,CAAC;IAEDL,oBAAoB,CAAC,CAAC;IACtB,OAAO,MAAM;MACXS,GAAG,EAAEE,MAAM,CAAC,CAAC;IACf,CAAC;EACH,CAAC,EAAE,EAAE,CAAC;EAEN,OAAO,IAAAC,cAAO,EACZ,OAAO;IACL;AACN;AACA;AACA;IACM3B,eAAe;IACf;AACN;AACA;AACA;IACMG,YAAY,EAAEH,eAAe,CAAC4B,IAAI,CAAEC,CAAC,IAAKA,CAAC,CAACpB,EAAE,KAAKN,YAAY,CAAC,IAAI,IAAI;IACxE;AACN;AACA;AACA;AACA;IACME;EACF,CAAC,CAAC,EACF,CAACL,eAAe,EAAEG,YAAY,EAAEE,WAAW,CAC7C,CAAC;AACH","ignoreList":[]}
+{"version":3,"names":["_react","require","_api","meaningfulReasons","useAudioInput","availableInputs","setAvailableInputs","useState","currentInput","setCurrentInput","selectInput","useCallback","device","selection","id","AudioManager","setInputDevice","devicesInfo","getDevicesInfo","useEffect","fetchAvailableInputs","audioDevices","currentDeviceId","currentInputs","length","handleRouteChange","event","includes","reason","sub","addSystemEventListener","remove","useMemo","find","d"],"sourceRoot":"../../../src","sources":["hooks/useAudioInput.ts"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEA,IAAAC,IAAA,GAAAD,OAAA;AAQA,MAAME,iBAAsC,GAAG,CAC7C,oBAAoB,EACpB,sBAAsB;AACtB;AACA,UAAU;AACV;AACA,gBAAgB,EAChB,qBAAqB,CACtB;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,SAASC,aAAaA,CAAA,EAAG;EACtC,MAAM,CAACC,eAAe,EAAEC,kBAAkB,CAAC,GAAG,IAAAC,eAAQ,EAAkB,EAAE,CAAC;EAC3E,MAAM,CAACC,YAAY,EAAEC,eAAe,CAAC,GAAG,IAAAF,eAAQ,EAAgB,IAAI,CAAC;EAErE,MAAMG,WAAW,GAAG,IAAAC,kBAAW,EAC7B,MAAOC,MAAmC,IAAK;IAC7C,MAAMC,SAAS,GAAGD,MAAM,KAAK,SAAS,GAAG,SAAS,GAAGA,MAAM,CAACE,EAAE;IAE9D,MAAMC,iBAAY,CAACC,cAAc,CAACH,SAAS,CAAC;IAC5CJ,eAAe,CAACI,SAAS,KAAK,SAAS,GAAG,IAAI,GAAGA,SAAS,CAAC;IAE3D,MAAMI,WAA6B,GAAG,MAAMF,iBAAY,CAACG,cAAc,CAAC,CAAC;IACzEZ,kBAAkB,CAACW,WAAW,CAACZ,eAAe,CAAC;EACjD,CAAC,EACD,EACF,CAAC;EAED,IAAAc,gBAAS,EAAC,MAAM;IACd,eAAeC,oBAAoBA,CAAA,EAAG;MACpC,MAAMC,YAAY,GAAG,MAAMN,iBAAY,CAACG,cAAc,CAAC,CAAC;MACxD,MAAMI,eAAe,GAAGD,YAAY,CAACE,aAAa,CAACC,MAAM,GACrDH,YAAY,CAACE,aAAa,CAAC,CAAC,CAAC,CAACT,EAAE,GAChC,IAAI;MAERR,kBAAkB,CAACe,YAAY,CAAChB,eAAe,CAAC;MAChDI,eAAe,CAACa,eAAe,CAAC;IAClC;IAEA,eAAeG,iBAAiBA,CAACC,KAA6B,EAAE;MAC9D,IAAI,CAACvB,iBAAiB,CAACwB,QAAQ,CAACD,KAAK,CAACE,MAAM,CAAC,EAAE;QAC7C;MACF;MAEA,MAAMR,oBAAoB,CAAC,CAAC;IAC9B;IAEA,MAAMS,GAAG,GAAGd,iBAAY,CAACe,sBAAsB,CAC7C,aAAa,EACbL,iBACF,CAAC;IAEDL,oBAAoB,CAAC,CAAC;IACtB,OAAO,MAAM;MACXS,GAAG,EAAEE,MAAM,CAAC,CAAC;IACf,CAAC;EACH,CAAC,EAAE,EAAE,CAAC;EAEN,OAAO,IAAAC,cAAO,EACZ,OAAO;IACL;AACN;AACA;AACA;IACM3B,eAAe;IACf;AACN;AACA;AACA;IACMG,YAAY,EAAEH,eAAe,CAAC4B,IAAI,CAAEC,CAAC,IAAKA,CAAC,CAACpB,EAAE,KAAKN,YAAY,CAAC,IAAI,IAAI;IACxE;AACN;AACA;AACA;AACA;IACME;EACF,CAAC,CAAC,EACF,CAACL,eAAe,EAAEG,YAAY,EAAEE,WAAW,CAC7C,CAAC;AACH","ignoreList":[]}

package/lib/module/hooks/useAudioInput.js

@@ -3,6 +3,8 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { AudioManager } from '../api';
 const meaningfulReasons = ['NewDeviceAvailable', 'OldDeviceUnavailable',
+// iOS reports a disconnected Bluetooth headset that was the current input this way not old device unavailable
+'Override',
 // e.g. system picks a different device as current one is not suitable for the new configuration
 'CategoryChange', 'ConfigurationChange'];
 

package/lib/module/hooks/useAudioInput.js.map

@@ -1 +1 @@
-{"version":3,"names":["useCallback","useEffect","useMemo","useState","AudioManager","meaningfulReasons","useAudioInput","availableInputs","setAvailableInputs","currentInput","setCurrentInput","selectInput","device","selection","id","setInputDevice","devicesInfo","getDevicesInfo","fetchAvailableInputs","audioDevices","currentDeviceId","currentInputs","length","handleRouteChange","event","includes","reason","sub","addSystemEventListener","remove","find","d"],"sourceRoot":"../../../src","sources":["hooks/useAudioInput.ts"],"mappings":";;AAAA,SAASA,WAAW,EAAEC,SAAS,EAAEC,OAAO,EAAEC,QAAQ,QAAQ,OAAO;AAEjE,SAASC,YAAY,QAAQ,QAAQ;AAQrC,MAAMC,iBAAsC,GAAG,CAC7C,oBAAoB,EACpB,sBAAsB;AACtB;AACA,gBAAgB,EAChB,qBAAqB,CACtB;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,aAAaA,CAAA,EAAG;EACtC,MAAM,CAACC,eAAe,EAAEC,kBAAkB,CAAC,GAAGL,QAAQ,CAAkB,EAAE,CAAC;EAC3E,MAAM,CAACM,YAAY,EAAEC,eAAe,CAAC,GAAGP,QAAQ,CAAgB,IAAI,CAAC;EAErE,MAAMQ,WAAW,GAAGX,WAAW,CAC7B,MAAOY,MAAmC,IAAK;IAC7C,MAAMC,SAAS,GAAGD,MAAM,KAAK,SAAS,GAAG,SAAS,GAAGA,MAAM,CAACE,EAAE;IAE9D,MAAMV,YAAY,CAACW,cAAc,CAACF,SAAS,CAAC;IAC5CH,eAAe,CAACG,SAAS,KAAK,SAAS,GAAG,IAAI,GAAGA,SAAS,CAAC;IAE3D,MAAMG,WAA6B,GAAG,MAAMZ,YAAY,CAACa,cAAc,CAAC,CAAC;IACzET,kBAAkB,CAACQ,WAAW,CAACT,eAAe,CAAC;EACjD,CAAC,EACD,EACF,CAAC;EAEDN,SAAS,CAAC,MAAM;IACd,eAAeiB,oBAAoBA,CAAA,EAAG;MACpC,MAAMC,YAAY,GAAG,MAAMf,YAAY,CAACa,cAAc,CAAC,CAAC;MACxD,MAAMG,eAAe,GAAGD,YAAY,CAACE,aAAa,CAACC,MAAM,GACrDH,YAAY,CAACE,aAAa,CAAC,CAAC,CAAC,CAACP,EAAE,GAChC,IAAI;MAERN,kBAAkB,CAACW,YAAY,CAACZ,eAAe,CAAC;MAChDG,eAAe,CAACU,eAAe,CAAC;IAClC;IAEA,eAAeG,iBAAiBA,CAACC,KAA6B,EAAE;MAC9D,IAAI,CAACnB,iBAAiB,CAACoB,QAAQ,CAACD,KAAK,CAACE,MAAM,CAAC,EAAE;QAC7C;MACF;MAEA,MAAMR,oBAAoB,CAAC,CAAC;IAC9B;IAEA,MAAMS,GAAG,GAAGvB,YAAY,CAACwB,sBAAsB,CAC7C,aAAa,EACbL,iBACF,CAAC;IAEDL,oBAAoB,CAAC,CAAC;IACtB,OAAO,MAAM;MACXS,GAAG,EAAEE,MAAM,CAAC,CAAC;IACf,CAAC;EACH,CAAC,EAAE,EAAE,CAAC;EAEN,OAAO3B,OAAO,CACZ,OAAO;IACL;AACN;AACA;AACA;IACMK,eAAe;IACf;AACN;AACA;AACA;IACME,YAAY,EAAEF,eAAe,CAACuB,IAAI,CAAEC,CAAC,IAAKA,CAAC,CAACjB,EAAE,KAAKL,YAAY,CAAC,IAAI,IAAI;IACxE;AACN;AACA;AACA;AACA;IACME;EACF,CAAC,CAAC,EACF,CAACJ,eAAe,EAAEE,YAAY,EAAEE,WAAW,CAC7C,CAAC;AACH","ignoreList":[]}
+{"version":3,"names":["useCallback","useEffect","useMemo","useState","AudioManager","meaningfulReasons","useAudioInput","availableInputs","setAvailableInputs","currentInput","setCurrentInput","selectInput","device","selection","id","setInputDevice","devicesInfo","getDevicesInfo","fetchAvailableInputs","audioDevices","currentDeviceId","currentInputs","length","handleRouteChange","event","includes","reason","sub","addSystemEventListener","remove","find","d"],"sourceRoot":"../../../src","sources":["hooks/useAudioInput.ts"],"mappings":";;AAAA,SAASA,WAAW,EAAEC,SAAS,EAAEC,OAAO,EAAEC,QAAQ,QAAQ,OAAO;AAEjE,SAASC,YAAY,QAAQ,QAAQ;AAQrC,MAAMC,iBAAsC,GAAG,CAC7C,oBAAoB,EACpB,sBAAsB;AACtB;AACA,UAAU;AACV;AACA,gBAAgB,EAChB,qBAAqB,CACtB;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,aAAaA,CAAA,EAAG;EACtC,MAAM,CAACC,eAAe,EAAEC,kBAAkB,CAAC,GAAGL,QAAQ,CAAkB,EAAE,CAAC;EAC3E,MAAM,CAACM,YAAY,EAAEC,eAAe,CAAC,GAAGP,QAAQ,CAAgB,IAAI,CAAC;EAErE,MAAMQ,WAAW,GAAGX,WAAW,CAC7B,MAAOY,MAAmC,IAAK;IAC7C,MAAMC,SAAS,GAAGD,MAAM,KAAK,SAAS,GAAG,SAAS,GAAGA,MAAM,CAACE,EAAE;IAE9D,MAAMV,YAAY,CAACW,cAAc,CAACF,SAAS,CAAC;IAC5CH,eAAe,CAACG,SAAS,KAAK,SAAS,GAAG,IAAI,GAAGA,SAAS,CAAC;IAE3D,MAAMG,WAA6B,GAAG,MAAMZ,YAAY,CAACa,cAAc,CAAC,CAAC;IACzET,kBAAkB,CAACQ,WAAW,CAACT,eAAe,CAAC;EACjD,CAAC,EACD,EACF,CAAC;EAEDN,SAAS,CAAC,MAAM;IACd,eAAeiB,oBAAoBA,CAAA,EAAG;MACpC,MAAMC,YAAY,GAAG,MAAMf,YAAY,CAACa,cAAc,CAAC,CAAC;MACxD,MAAMG,eAAe,GAAGD,YAAY,CAACE,aAAa,CAACC,MAAM,GACrDH,YAAY,CAACE,aAAa,CAAC,CAAC,CAAC,CAACP,EAAE,GAChC,IAAI;MAERN,kBAAkB,CAACW,YAAY,CAACZ,eAAe,CAAC;MAChDG,eAAe,CAACU,eAAe,CAAC;IAClC;IAEA,eAAeG,iBAAiBA,CAACC,KAA6B,EAAE;MAC9D,IAAI,CAACnB,iBAAiB,CAACoB,QAAQ,CAACD,KAAK,CAACE,MAAM,CAAC,EAAE;QAC7C;MACF;MAEA,MAAMR,oBAAoB,CAAC,CAAC;IAC9B;IAEA,MAAMS,GAAG,GAAGvB,YAAY,CAACwB,sBAAsB,CAC7C,aAAa,EACbL,iBACF,CAAC;IAEDL,oBAAoB,CAAC,CAAC;IACtB,OAAO,MAAM;MACXS,GAAG,EAAEE,MAAM,CAAC,CAAC;IACf,CAAC;EACH,CAAC,EAAE,EAAE,CAAC;EAEN,OAAO3B,OAAO,CACZ,OAAO;IACL;AACN;AACA;AACA;IACMK,eAAe;IACf;AACN;AACA;AACA;IACME,YAAY,EAAEF,eAAe,CAACuB,IAAI,CAAEC,CAAC,IAAKA,CAAC,CAACjB,EAAE,KAAKL,YAAY,CAAC,IAAI,IAAI;IACxE;AACN;AACA;AACA;AACA;IACME;EACF,CAAC,CAAC,EACF,CAACJ,eAAe,EAAEE,YAAY,EAAEE,WAAW,CAC7C,CAAC;AACH","ignoreList":[]}

package/lib/typescript/commonjs/hooks/useAudioInput.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAudioInput.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useAudioInput.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,eAAe,EACf,eAAe,EAEhB,MAAM,iBAAiB,CAAC;AAUzB;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa;IAiD/B;;;OAGG;;IAEH;;;OAGG;;IAEH;;;;OAIG;0BA1DU,eAAe,GAAG,SAAS;EA+D7C"}
+{"version":3,"file":"useAudioInput.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useAudioInput.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,eAAe,EACf,eAAe,EAEhB,MAAM,iBAAiB,CAAC;AAYzB;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa;IAiD/B;;;OAGG;;IAEH;;;OAGG;;IAEH;;;;OAIG;0BA1DU,eAAe,GAAG,SAAS;EA+D7C"}

package/lib/typescript/module/hooks/useAudioInput.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAudioInput.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useAudioInput.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,eAAe,EACf,eAAe,EAEhB,MAAM,iBAAiB,CAAC;AAUzB;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa;IAiD/B;;;OAGG;;IAEH;;;OAGG;;IAEH;;;;OAIG;0BA1DU,eAAe,GAAG,SAAS;EA+D7C"}
+{"version":3,"file":"useAudioInput.d.ts","sourceRoot":"","sources":["../../../../src/hooks/useAudioInput.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,eAAe,EACf,eAAe,EAEhB,MAAM,iBAAiB,CAAC;AAYzB;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa;IAiD/B;;;OAGG;;IAEH;;;OAGG;;IAEH;;;;OAIG;0BA1DU,eAAe,GAAG,SAAS;EA+D7C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-api",
-  "version": "1.0.0-nightly-6fd4c68-20261102",
+  "version": "1.0.0",
   "description": "react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification",
   "bin": {
     "setup-rn-audio-api-web": "./scripts/setup-rn-audio-api-web.js"

package/src/hooks/useAudioInput.ts

@@ -11,6 +11,8 @@ import {
 const meaningfulReasons: RouteChangeReason[] = [
   'NewDeviceAvailable',
   'OldDeviceUnavailable',
+  // iOS reports a disconnected Bluetooth headset that was the current input this way not old device unavailable
+  'Override',
   // e.g. system picks a different device as current one is not suitable for the new configuration
   'CategoryChange',
   'ConfigurationChange',