diff --git a/.claude/skills/post-work-checks/SKILL.md b/.claude/skills/post-work-checks/SKILL.md
index 951f994fc..40cc02bec 100644
--- a/.claude/skills/post-work-checks/SKILL.md
+++ b/.claude/skills/post-work-checks/SKILL.md
@@ -119,13 +119,13 @@ yarn test   # from monorepo root — runs test:js + test:cpp
 
 **When**: after any change to C++ files or TypeScript files in `src/`. Prefer this for a quick local test loop covering both TS and C++ logic; run `yarn validate:fast` before opening a PR.
 
-### AudioEvent enum sync check
+### Enum sync check
 
 ```bash
 yarn check-audio-enum-sync
 ```
 
-**When**: only when you modify the `AudioEvent` enum or any file that maps event names across C++/Kotlin/TypeScript. Skip this step if you already ran `validate:fast` (it includes enum sync).
+**When**: when you modify `AudioEvent`, `FileFormat` / `AudioFileProperties::Format`, or other JSI-crossing recorder enums (`FileDirectory`, `BitDepth`, `IOSAudioQuality`). Skip if you already ran `validate:fast` (it includes enum sync).
 
 ---
 
diff --git a/.claude/skills/post-work-checks/maintenance.md b/.claude/skills/post-work-checks/maintenance.md
index 1073cb524..3a866f18a 100644
--- a/.claude/skills/post-work-checks/maintenance.md
+++ b/.claude/skills/post-work-checks/maintenance.md
@@ -10,5 +10,5 @@ Review this skill when `pre-push-update` reports changes in:
 | `packages/react-native-audio-api/package.json` scripts | Package-level command changes (including per-language lint/format) |
 | `lefthook.yml` | Pre-commit / commit-msg hook changes |
 | `scripts/validate.sh` | Tier behavior (`--fast` / `--graph` / `--android` / `--ios` / `--full`), skip rules |
-| `scripts/check-audio-enum-sync*` or `packages/react-native-audio-api/scripts/check-audio-events-sync.sh` | Enum sync check details |
+| `scripts/check-audio-enum-sync*` or `packages/react-native-audio-api/scripts/check-*-enum-sync.sh` / `check-enum-sync.sh` | Enum sync check details (AudioEvent + AudioFileProperties) |
 | `.github/workflows/ci.yml`, `tests.yml`, `graph-tests.yml` | What CI covers vs local validation tiers |
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 3051bc4ff..bb45c5ad8 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -34,7 +34,7 @@ jobs:
   check-audio-enum-sync:
     uses: ./.github/workflows/ci-check.yml
     with:
-      name: Check AudioEvent enum sync
+      name: Check enum sync
       run: yarn check-audio-enum-sync
 
   build-audio-api:
diff --git a/apps/common-app/src/demos/Record/Record.tsx b/apps/common-app/src/demos/Record/Record.tsx
index 6bcb7df73..ac7695b5f 100644
--- a/apps/common-app/src/demos/Record/Record.tsx
+++ b/apps/common-app/src/demos/Record/Record.tsx
@@ -20,6 +20,12 @@ import RecordingVisualization from './RecordingVisualization';
 import Status from './Status';
 import { RecordingState } from './types';
 
+const RECORDING_EXTENSION = FileFormat.Wav;
+
+const RECORDING_EXTENSION_NAME_MAP = {
+  [FileFormat.Wav]: 'wav',
+  [FileFormat.M4A]: 'm4a',
+}
 const Record: FC = () => {
   const [state, setState] = useState<RecordingState>(RecordingState.Idle);
   const [hasPermissions, setHasPermissions] = useState<boolean>(false);
@@ -130,8 +136,13 @@ const Record: FC = () => {
       return;
     }
 
-    const outputPath = info.paths[0].replace(/[^/]+$/, 'recording.m4a');
+    const extension = RECORDING_EXTENSION_NAME_MAP[RECORDING_EXTENSION];
+    const outputPath = info.paths[0].replace(
+      /[^/]+$/,
+      `recording.${extension}`
+    );
 
+    console.log(info.paths.length);
     const finalPath = await concatAudioFiles(info.paths, outputPath);
     const audioBuffer = await audioContext.decodeAudioData(finalPath);
     setRecordedBuffer(audioBuffer);
@@ -262,7 +273,7 @@ const Record: FC = () => {
   }, [onPauseRecording, onResumeRecording]);
 
   useEffect(() => {
-    Recorder.enableFileOutput({ rotateIntervalBytes: 1_000_000, format: FileFormat.M4A });
+    Recorder.enableFileOutput({ rotateIntervalBytes: 1_000_000, format: RECORDING_EXTENSION });
 
     return () => {
       stopPlayback();
diff --git a/package.json b/package.json
index 7c4aff502..c81888eb2 100644
--- a/package.json
+++ b/package.json
@@ -19,7 +19,7 @@
     "clean": "del-cli packages/**/android/build apps/**/android/build apps/**/android/app/build apps/**/ios/build packages/**/lib node_modules apps/**/node_modules packages/**/node_modules",
     "typecheck": "yarn workspaces foreach -A -p run typecheck",
     "test": "yarn workspace react-native-audio-api run test",
-    "check-audio-enum-sync": "bash packages/react-native-audio-api/scripts/check-audio-events-sync.sh",
+    "check-audio-enum-sync": "bash packages/react-native-audio-api/scripts/check-enum-sync.sh",
     "validate:fast": "bash scripts/validate.sh --fast",
     "validate:graph": "bash scripts/validate.sh --graph",
     "validate:android": "bash scripts/validate.sh --android",
diff --git a/packages/audiodocs/docs/inputs/audio-recorder.mdx b/packages/audiodocs/docs/inputs/audio-recorder.mdx
index ac5574851..ab3b96ea5 100644
--- a/packages/audiodocs/docs/inputs/audio-recorder.mdx
+++ b/packages/audiodocs/docs/inputs/audio-recorder.mdx
@@ -654,17 +654,54 @@ interface AudioRecorderFileOptions {
 
 Describes desired file extension as well as codecs, containers (and muxers!) used to encode the file.
 
+All encoding is done with platform system APIs — iOS AVFoundation and Android MediaCodec/MediaMuxer. FFmpeg is never used for encoding. Because each platform exposes a different set of system encoders, format support is platform-specific.
+
 ```tsx
 enum FileFormat {
   Wav,
   Caf,
   M4A,
   Flac,
+  Aiff,
+  Alac,
+  OpusOgg,
+  OpusWebm,
+  VorbisWebm,
+  AmrNb,
+  AmrWb,
+  AacHe,
+  AacEld,
+  Ima4,
+  Ulaw,
+  Alaw,
+  Ilbc,
 }
 ```
 
-:::caution Android + FFmpeg
-On Android, encoded file output for `M4A`, `FLAC`, and `CAF` uses FFmpeg. When FFmpeg is disabled in the build, only **WAV** recording to file is supported. iOS uses system AVFoundation for all listed formats. See [Runtime flags](/docs/other/runtime-flags#where-ffmpeg-is-used).
+The table below lists which formats each platform can encode with its system APIs:
+
+| `FileFormat` | Container / codec | iOS | Android |
+| :--- | :--- | :---: | :---: |
+| `Wav` | WAV / PCM | ✅ | ✅ |
+| `M4A` | M4A / AAC-LC | ✅ | ✅ |
+| `Flac` | FLAC / FLAC | ✅ | ✅ |
+| `Caf` | CAF / PCM | ✅ | ❌ |
+| `Aiff` | AIFF / PCM | ✅ | ❌ |
+| `Alac` | M4A / Apple Lossless | ✅ | ❌ |
+| `AacHe` | M4A / AAC-HE | ✅ | ❌ |
+| `AacEld` | M4A / AAC-ELD | ✅ | ❌ |
+| `Ima4` | CAF / IMA4 (ADPCM) | ✅ | ❌ |
+| `Ulaw` | WAV / µ-law | ✅ | ❌ |
+| `Alaw` | WAV / a-law | ✅ | ❌ |
+| `Ilbc` | CAF / iLBC | ✅ | ❌ |
+| `OpusOgg` | OGG / Opus | ❌ | ✅ |
+| `OpusWebm` | WebM / Opus | ❌ | ✅ |
+| `VorbisWebm` | WebM / Vorbis | ❌ | ✅ |
+| `AmrNb` | 3GP / AMR-NB | ❌ | ✅ |
+| `AmrWb` | 3GP / AMR-WB | ❌ | ✅ |
+
+:::caution Platform support
+Selecting a format the current platform cannot encode (for example `Caf` on Android or `OpusOgg` on iOS) fails when file output is enabled, with a descriptive error. Some Android formats also depend on the device OS version (Opus/OGG muxing requires newer releases); if a device lacks a system encoder for the requested format, recording start returns an error. Use `Wav`, `M4A`, or `Flac` for the widest cross-platform support.
 :::
 
 #### FileInfo
diff --git a/packages/audiodocs/docs/other/disabling-prebuilt-libraries.mdx b/packages/audiodocs/docs/other/disabling-prebuilt-libraries.mdx
index a3a87ed39..3e0a042fb 100644
--- a/packages/audiodocs/docs/other/disabling-prebuilt-libraries.mdx
+++ b/packages/audiodocs/docs/other/disabling-prebuilt-libraries.mdx
@@ -17,7 +17,7 @@ The available flags are independent and can be combined:
 
 | Flag | What it removes | What stops working |
 | :---: | :---- | :---- |
-| `disableFFmpeg` | FFmpeg shared libraries (`libavcodec`, `libavformat`, `libavutil`, `libswresample`) | Streaming, remote playback/metadata, `.aac` / `.mp4` / `.m4a` decode, M4A concat, **Android** non-WAV recording — see [Runtime flags](/docs/other/runtime-flags#where-ffmpeg-is-used) |
+| `disableFFmpeg` | FFmpeg shared libraries (`libavcodec`, `libavformat`, `libavutil`, `libswresample`) | Streaming, remote playback/metadata, `.aac` / `.mp4` / `.m4a` decode — see [Runtime flags](/docs/other/runtime-flags#where-ffmpeg-is-used). Recording and `concatAudioFiles` are unaffected. |
 | `disableStaticExternalLibs` | Static libs: `libopus`, `libopusfile`, `libogg`, `libvorbis`, `libvorbisenc`, `libvorbisfile` | Decoding `ogg`, `opus`, `oga` files |
 
 :::info
diff --git a/packages/audiodocs/docs/other/runtime-flags.mdx b/packages/audiodocs/docs/other/runtime-flags.mdx
index 7cbe0364b..4b147d2a2 100644
--- a/packages/audiodocs/docs/other/runtime-flags.mdx
+++ b/packages/audiodocs/docs/other/runtime-flags.mdx
@@ -2,7 +2,7 @@
 
 These helpers let you check at runtime which optional native features are compiled into your app. They are synchronous and safe to call from JavaScript after the library has been installed.
 
-Use them to branch UI or loading logic — for example, skip remote metadata preload when FFmpeg is disabled, disable hls streaming, or offer only WAV recording on Android.
+Use them to branch UI or loading logic — for example, skip remote metadata preload when FFmpeg is disabled or disable hls streaming.
 
 :::info Build-time vs runtime
 To **disable** optional libraries at build time (and reduce app size), see [Disabling prebuilt libraries](/docs/other/disabling-prebuilt-libraries). Runtime flags only tell you what ended up in the binary you are running.
@@ -20,7 +20,7 @@ Returns whether the native build includes [`FFmpeg`](https://github.com/FFmpeg/F
 import { isFfmpegEnabled } from 'react-native-audio-api';
 
 if (!isFfmpegEnabled()) {
-  console.warn('Remote URL metadata, streaming, and Android M4A recording require an FFmpeg build.');
+  console.warn('Remote URL metadata and streaming require an FFmpeg build.');
 }
 ```
 </details>
@@ -33,12 +33,19 @@ if (!isFfmpegEnabled()) {
 | Playback | `createFileSource`, [`<Audio>`](/docs/sources/audio-tag) | Remote URL streaming, HLS (`.m3u8`), local `.mp4` / `.m4a` / `.aac`. Without FFmpeg, remote sources are downloaded and decoded with miniaudio where supported. |
 | Decoding | [`decodeAudioData`](/docs/utils/decoding#decodeaudiodata) | `.aac`, `.mp4`, `.m4a` (and remote URLs for any format) |
 | Metadata | [`getAudioDuration`](/docs/utils/decoding#getaudioduration), [`<Audio>`](/docs/sources/audio-tag) `preload="metadata"` | Remote `http(s):` URL duration probing |
-| Recording | [`AudioRecorder`](/docs/inputs/audio-recorder) file output | **Android only:** `M4A`, `FLAC`, and `CAF` (WAV uses miniaudio). iOS uses system AVFoundation instead. |
-| File utils | [`concatAudioFiles`](/docs/utils/file-concatenation#concataudiofiles) | M4A concatenation (WAV uses miniaudio) |
 
 Formats such as `.mp3`, `.wav`, and `.flac` are often handled by miniaudio for **local** decode paths and for **downloaded** remote sources when FFmpeg is disabled.
 
-When `isFfmpegEnabled()` returns `false`, the features in the table above are unavailable or fall back to errors. On **Android**, [`AudioRecorder`](/docs/inputs/audio-recorder) file output is limited to **WAV**.
+:::note Recording and file concatenation are FFmpeg-free
+[`AudioRecorder`](/docs/inputs/audio-recorder) file output and
+[`concatAudioFiles`](/docs/utils/file-concatenation#concataudiofiles) do **not**
+use FFmpeg on any platform. Recording encodes with system APIs (iOS AVFoundation,
+Android MediaCodec/MediaMuxer). `concatAudioFiles` supports **WAV** (miniaudio) and
+**M4A/MP4 AAC** (system remux). Neither is affected by `isFfmpegEnabled()`.
+See the [per-platform format matrix](/docs/inputs/audio-recorder#fileformat).
+:::
+
+When `isFfmpegEnabled()` returns `false`, the features in the table above are unavailable or fall back to errors.
 
 ### Disabling FFmpeg
 
diff --git a/packages/audiodocs/docs/utils/file-concatenation.mdx b/packages/audiodocs/docs/utils/file-concatenation.mdx
index 7fdffdbab..ee41bff8d 100644
--- a/packages/audiodocs/docs/utils/file-concatenation.mdx
+++ b/packages/audiodocs/docs/utils/file-concatenation.mdx
@@ -21,14 +21,20 @@ recording is finished.
 :::
 
 :::caution
-**M4A and WAV concatenation is only supported.**
+**WAV and M4A concatenation is only supported.**
 
-M4A format requires FFmpeg to be available in the native build. WAV
-concatenation uses miniaudio and does not require FFmpeg. See [Runtime flags](/docs/other/runtime-flags#where-ffmpeg-is-used) for details.
+WAV uses miniaudio (PCM remux). M4A/MP4 remuxes AAC packets with system APIs —
+iOS AVFoundation and Android MediaExtractor/MediaMuxer — and does **not**
+require FFmpeg.
 :::
 
 :::tip Segment size and quality
-`concatAudioFiles` joins segments losslessly for **WAV** (PCM re-mux). For **M4A**, it remuxes encoded AAC packets from separately encoded segments. Each rotated chunk starts a fresh AAC encoder, so very small [`rotateIntervalBytes`](/docs/inputs/audio-recorder#audiorecorderfileoptions) values can produce clicks, muffled joins, or timing gaps after concatenation.
+`concatAudioFiles` joins segments losslessly for **WAV** (PCM remux). For **M4A**,
+Android remuxes the encoded AAC packets losslessly, while iOS re-encodes the
+joined audio once through AVFoundation. Each rotated chunk is
+a separate AAC encode, so very small
+[`rotateIntervalBytes`](/docs/inputs/audio-recorder#audiorecorderfileoptions)
+values can still produce clicks, muffled joins, or timing gaps after concatenation.
 
 If playback quality is poor after joining rotated M4A files, increase `rotateIntervalBytes` (for example **≥ 200 KB**) or record without rotation. WAV segments are less sensitive, but the same guidance applies below roughly **512 KB–1 MB** per segment.
 :::
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/AndroidEncoding.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/AndroidEncoding.cpp
new file mode 100644
index 000000000..6a12a0c84
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/AndroidEncoding.cpp
@@ -0,0 +1,869 @@
+#include <audioapi/AndroidEncoding.h>
+
+#include <audioapi/dsp/r8brain/Resampler.hpp>
+#include <audioapi/utils/AudioBuffer.hpp>
+#include <audioapi/utils/AudioFileProperties.h>
+
+#include <media/NdkMediaCodec.h>
+#include <media/NdkMediaFormat.h>
+#include <media/NdkMediaMuxer.h>
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <memory>
+#include <string>
+#include <vector>
+
+// AMEDIAMUXER_OUTPUT_FORMAT_OGG was added to the NDK at API level 34; fall back
+// to a numeric value so builds against older NDK headers still compile. Runtime
+// availability is still gated by the device OS version.
+#ifndef AMEDIAMUXER_OUTPUT_FORMAT_OGG
+#define AMEDIAMUXER_OUTPUT_FORMAT_OGG 4
+#endif
+
+namespace audioapi::android_encoder {
+namespace {
+
+constexpr int64_t kStreamTimeoutUs = 0;
+constexpr int64_t kDrainTimeoutUs = 10000;
+constexpr int kMaxTryAgainAtEos = 200;
+constexpr int kAacProfileLc = 2;     // MediaCodecInfo.CodecProfileLevel.AACObjectLC
+constexpr int kPcmEncoding16Bit = 2; // AudioFormat.ENCODING_PCM_16BIT
+constexpr int kResampleMaxInFrames = 4096;
+
+int16_t floatToS16(float sample) {
+  float clamped = std::max(-1.0f, std::min(1.0f, sample));
+  return static_cast<int16_t>(clamped * 32767.0f);
+}
+
+struct MediaCodecDeleter {
+  void operator()(AMediaCodec *codec) const {
+    if (codec != nullptr) {
+      AMediaCodec_stop(codec);
+      AMediaCodec_delete(codec);
+    }
+  }
+};
+using MediaCodecPtr = std::unique_ptr<AMediaCodec, MediaCodecDeleter>;
+
+} // namespace
+
+// ---------------------------------------------------------------------------
+// Backend interface
+// ---------------------------------------------------------------------------
+
+class IEncoderBackend {
+ public:
+  virtual ~IEncoderBackend() = default;
+
+  // Opens the backend. `desiredSampleRate`/`desiredChannelCount` come from the
+  // file properties; the backend may override them (e.g. AMR/Opus) via the out
+  // parameters, which the caller then resamples/channel-maps to.
+  virtual std::string open(
+      int desiredSampleRate,
+      int desiredChannelCount,
+      const std::string &filePath,
+      const std::shared_ptr<AudioFileProperties> &properties,
+      const EncoderOutputSpec &outputSpec,
+      int &effectiveSampleRate,
+      int &effectiveChannelCount) = 0;
+
+  // Encodes interleaved float32 frames already in the backend's effective format.
+  virtual std::string encodeFloat(const float *interleaved, int numFrames) = 0;
+
+  virtual std::string close() = 0;
+
+  [[nodiscard]] virtual size_t getFileSizeBytes() const = 0;
+};
+
+// ---------------------------------------------------------------------------
+// WAV (RIFF) backend — pure container writing, no third-party codec.
+// ---------------------------------------------------------------------------
+
+class WavBackend : public IEncoderBackend {
+ public:
+  std::string open(
+      int desiredSampleRate,
+      int desiredChannelCount,
+      const std::string &filePath,
+      const std::shared_ptr<AudioFileProperties> &properties,
+      const EncoderOutputSpec &outputSpec,
+      int &effectiveSampleRate,
+      int &effectiveChannelCount) override {
+    (void)outputSpec;
+    sampleRate_ = desiredSampleRate;
+    channelCount_ = desiredChannelCount;
+    effectiveSampleRate = sampleRate_;
+    effectiveChannelCount = channelCount_;
+
+    switch (properties->bitDepth) {
+      case AudioFileProperties::BitDepth::Bit16:
+        bytesPerSample_ = 2;
+        isFloat_ = false;
+        break;
+      case AudioFileProperties::BitDepth::Bit24:
+        bytesPerSample_ = 3;
+        isFloat_ = false;
+        break;
+      case AudioFileProperties::BitDepth::Bit32:
+      default:
+        bytesPerSample_ = 4;
+        isFloat_ = true;
+        break;
+    }
+
+    file_ = std::fopen(filePath.c_str(), "wb");
+    if (file_ == nullptr) {
+      return "WavBackend: failed to open file for writing";
+    }
+    // Reserve the 44-byte canonical WAV header; patched on close.
+    std::vector<uint8_t> placeholder(44, 0);
+    std::fwrite(placeholder.data(), 1, placeholder.size(), file_);
+    dataBytes_ = 0;
+    return "";
+  }
+
+  std::string encodeFloat(const float *interleaved, int numFrames) override {
+    if (file_ == nullptr) {
+      return "WavBackend: file not open";
+    }
+    const size_t sampleCount = static_cast<size_t>(numFrames) * channelCount_;
+    scratch_.resize(sampleCount * bytesPerSample_);
+    uint8_t *out = scratch_.data();
+
+    for (size_t i = 0; i < sampleCount; ++i) {
+      if (isFloat_) {
+        float v = interleaved[i];
+        std::memcpy(out, &v, sizeof(float));
+        out += 4;
+      } else if (bytesPerSample_ == 2) {
+        int16_t v = floatToS16(interleaved[i]);
+        std::memcpy(out, &v, sizeof(int16_t));
+        out += 2;
+      } else { // 24-bit
+        float clamped = std::max(-1.0f, std::min(1.0f, interleaved[i]));
+        int32_t v = static_cast<int32_t>(clamped * 8388607.0f);
+        out[0] = static_cast<uint8_t>(v & 0xFF);
+        out[1] = static_cast<uint8_t>((v >> 8) & 0xFF);
+        out[2] = static_cast<uint8_t>((v >> 16) & 0xFF);
+        out += 3;
+      }
+    }
+
+    size_t written = std::fwrite(scratch_.data(), 1, scratch_.size(), file_);
+    if (written != scratch_.size()) {
+      return "WavBackend: short write";
+    }
+    dataBytes_ += scratch_.size();
+    return "";
+  }
+
+  std::string close() override {
+    if (file_ == nullptr) {
+      return "WavBackend: file not open";
+    }
+    writeHeader();
+    std::fclose(file_);
+    file_ = nullptr;
+    return "";
+  }
+
+  [[nodiscard]] size_t getFileSizeBytes() const override {
+    return 44 + dataBytes_;
+  }
+
+ private:
+  void writeHeader() {
+    const uint16_t audioFormatTag = isFloat_ ? 3 : 1; // 3 = IEEE float, 1 = PCM
+    const uint16_t bitsPerSample = static_cast<uint16_t>(bytesPerSample_ * 8);
+    const uint32_t byteRate = static_cast<uint32_t>(sampleRate_) * channelCount_ * bytesPerSample_;
+    const uint16_t blockAlign = static_cast<uint16_t>(channelCount_ * bytesPerSample_);
+    const uint32_t dataChunkSize = static_cast<uint32_t>(dataBytes_);
+    const uint32_t riffChunkSize = 36 + dataChunkSize;
+
+    uint8_t header[44];
+    std::memcpy(header, "RIFF", 4);
+    writeU32(header + 4, riffChunkSize);
+    std::memcpy(header + 8, "WAVE", 4);
+    std::memcpy(header + 12, "fmt ", 4);
+    writeU32(header + 16, 16); // PCM fmt chunk size
+    writeU16(header + 20, audioFormatTag);
+    writeU16(header + 22, static_cast<uint16_t>(channelCount_));
+    writeU32(header + 24, static_cast<uint32_t>(sampleRate_));
+    writeU32(header + 28, byteRate);
+    writeU16(header + 32, blockAlign);
+    writeU16(header + 34, bitsPerSample);
+    std::memcpy(header + 36, "data", 4);
+    writeU32(header + 40, dataChunkSize);
+
+    std::fseek(file_, 0, SEEK_SET);
+    std::fwrite(header, 1, sizeof(header), file_);
+  }
+
+  static void writeU32(uint8_t *p, uint32_t v) {
+    p[0] = static_cast<uint8_t>(v & 0xFF);
+    p[1] = static_cast<uint8_t>((v >> 8) & 0xFF);
+    p[2] = static_cast<uint8_t>((v >> 16) & 0xFF);
+    p[3] = static_cast<uint8_t>((v >> 24) & 0xFF);
+  }
+  static void writeU16(uint8_t *p, uint16_t v) {
+    p[0] = static_cast<uint8_t>(v & 0xFF);
+    p[1] = static_cast<uint8_t>((v >> 8) & 0xFF);
+  }
+
+  std::FILE *file_{nullptr};
+  int sampleRate_{0};
+  int channelCount_{0};
+  int bytesPerSample_{2};
+  bool isFloat_{false};
+  size_t dataBytes_{0};
+  std::vector<uint8_t> scratch_;
+};
+
+// ---------------------------------------------------------------------------
+// MediaCodec base — shared PCM → codec pumping.
+// ---------------------------------------------------------------------------
+
+class MediaCodecBackend : public IEncoderBackend {
+ public:
+  std::string encodeFloat(const float *interleaved, int numFrames) override {
+    if (codec_ == nullptr) {
+      return "MediaCodecBackend: codec not started";
+    }
+    const size_t sampleCount = static_cast<size_t>(numFrames) * channelCount_;
+    const size_t byteOffset = pcmLeftover_.size();
+    pcmLeftover_.resize(byteOffset + sampleCount * sizeof(int16_t));
+    auto *dst = reinterpret_cast<int16_t *>(pcmLeftover_.data() + byteOffset);
+    for (size_t i = 0; i < sampleCount; ++i) {
+      dst[i] = floatToS16(interleaved[i]);
+    }
+
+    std::string err = feedInput(false);
+    if (!err.empty()) {
+      return err;
+    }
+    return drainOutput(false);
+  }
+
+  std::string close() override {
+    if (codec_ == nullptr) {
+      return "";
+    }
+
+    // Keep feeding (to queue any remaining PCM and the end-of-stream marker) and
+    // draining until the codec reports EOS on the output, or we make no progress
+    // for too long (defensive against a stuck codec).
+    int stagnation = 0;
+    while (!outputDone_ && stagnation < kMaxTryAgainAtEos) {
+      const size_t drainedBefore = drainCount_;
+      const bool inputWasEnded = inputEnded_;
+
+      std::string err = feedInput(true);
+      if (!err.empty()) {
+        return err;
+      }
+      err = drainOutput(true);
+      if (!err.empty()) {
+        return err;
+      }
+
+      const bool madeProgress = drainCount_ != drainedBefore || (inputEnded_ && !inputWasEnded);
+      stagnation = madeProgress ? 0 : stagnation + 1;
+    }
+    return finalize();
+  }
+
+ protected:
+  // Subclass hooks.
+  virtual std::string onFormatChanged(AMediaFormat *outputFormat) = 0;
+  virtual std::string onEncodedSample(const uint8_t *data, const AMediaCodecBufferInfo &info) = 0;
+  virtual std::string finalize() = 0;
+
+  // Creates + starts the encoder for `mime` at the given format.
+  std::string
+  startCodec(const char *mime, int sampleRate, int channelCount, int bitRate, bool isAac) {
+    sampleRate_ = sampleRate;
+    channelCount_ = channelCount;
+
+    AMediaFormat *format = AMediaFormat_new();
+    AMediaFormat_setString(format, AMEDIAFORMAT_KEY_MIME, mime);
+    AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_SAMPLE_RATE, sampleRate);
+    AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_CHANNEL_COUNT, channelCount);
+    if (bitRate > 0) {
+      AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_BIT_RATE, bitRate);
+    }
+    AMediaFormat_setInt32(format, "pcm-encoding", kPcmEncoding16Bit);
+    if (isAac) {
+      AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_AAC_PROFILE, kAacProfileLc);
+    }
+
+    AMediaCodec *codec = AMediaCodec_createEncoderByType(mime);
+    if (codec == nullptr) {
+      AMediaFormat_delete(format);
+      return std::string("No system encoder available for ") + mime;
+    }
+    media_status_t status =
+        AMediaCodec_configure(codec, format, nullptr, nullptr, AMEDIACODEC_CONFIGURE_FLAG_ENCODE);
+    AMediaFormat_delete(format);
+    if (status != AMEDIA_OK) {
+      AMediaCodec_delete(codec);
+      return std::string("Failed to configure encoder for ") + mime;
+    }
+    if (AMediaCodec_start(codec) != AMEDIA_OK) {
+      AMediaCodec_delete(codec);
+      return std::string("Failed to start encoder for ") + mime;
+    }
+    codec_.reset(codec);
+    return "";
+  }
+
+  AMediaCodec *codec() {
+    return codec_.get();
+  }
+
+ private:
+  std::string feedInput(bool endOfStream) {
+    auto *codec = codec_.get();
+    size_t cursor = 0;
+    while (cursor < pcmLeftover_.size() || (endOfStream && !inputEnded_)) {
+      const ssize_t inIndex = AMediaCodec_dequeueInputBuffer(codec, kStreamTimeoutUs);
+      if (inIndex < 0) {
+        break; // no input buffer free right now
+      }
+      size_t bufSize = 0;
+      uint8_t *buf = AMediaCodec_getInputBuffer(codec, static_cast<size_t>(inIndex), &bufSize);
+      if (buf == nullptr) {
+        return "MediaCodecBackend: null input buffer";
+      }
+
+      const size_t remaining = pcmLeftover_.size() - cursor;
+      const size_t toCopy = std::min(remaining, bufSize);
+      if (toCopy > 0) {
+        std::memcpy(buf, pcmLeftover_.data() + cursor, toCopy);
+      }
+
+      const int64_t ptsUs = static_cast<int64_t>(
+          static_cast<double>(framesFed_) * 1e6 / static_cast<double>(sampleRate_));
+
+      uint32_t flags = 0;
+      const bool lastChunk = endOfStream && (cursor + toCopy >= pcmLeftover_.size());
+      if (lastChunk) {
+        flags = AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM;
+        inputEnded_ = true;
+      }
+
+      AMediaCodec_queueInputBuffer(codec, static_cast<size_t>(inIndex), 0, toCopy, ptsUs, flags);
+
+      if (channelCount_ > 0) {
+        framesFed_ += toCopy / (sizeof(int16_t) * static_cast<size_t>(channelCount_));
+      }
+      cursor += toCopy;
+
+      if (lastChunk) {
+        break;
+      }
+    }
+
+    if (cursor >= pcmLeftover_.size()) {
+      pcmLeftover_.clear();
+    } else if (cursor > 0) {
+      pcmLeftover_.erase(
+          pcmLeftover_.begin(), pcmLeftover_.begin() + static_cast<std::ptrdiff_t>(cursor));
+    }
+    return "";
+  }
+
+  std::string drainOutput(bool endOfStream) {
+    auto *codec = codec_.get();
+    const int64_t timeout = endOfStream ? kDrainTimeoutUs : kStreamTimeoutUs;
+
+    while (true) {
+      AMediaCodecBufferInfo info{};
+      const ssize_t outIndex = AMediaCodec_dequeueOutputBuffer(codec, &info, timeout);
+      if (outIndex >= 0) {
+        ++drainCount_;
+        size_t outSize = 0;
+        uint8_t *outBuf =
+            AMediaCodec_getOutputBuffer(codec, static_cast<size_t>(outIndex), &outSize);
+        if (outBuf != nullptr && info.size > 0) {
+          std::string err = onEncodedSample(outBuf, info);
+          if (!err.empty()) {
+            AMediaCodec_releaseOutputBuffer(codec, static_cast<size_t>(outIndex), false);
+            return err;
+          }
+        }
+        AMediaCodec_releaseOutputBuffer(codec, static_cast<size_t>(outIndex), false);
+        if ((info.flags & AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM) != 0) {
+          outputDone_ = true;
+          break;
+        }
+      } else if (outIndex == AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED) {
+        AMediaFormat *outFormat = AMediaCodec_getOutputFormat(codec);
+        std::string err = onFormatChanged(outFormat);
+        AMediaFormat_delete(outFormat);
+        if (!err.empty()) {
+          return err;
+        }
+      } else {
+        // AMEDIACODEC_INFO_TRY_AGAIN_LATER / OUTPUT_BUFFERS_CHANGED
+        break;
+      }
+    }
+    return "";
+  }
+
+ protected:
+  MediaCodecPtr codec_;
+  int sampleRate_{0};
+  int channelCount_{0};
+
+ private:
+  std::vector<uint8_t> pcmLeftover_;
+  uint64_t framesFed_{0};
+  bool inputEnded_{false};
+  bool outputDone_{false};
+  size_t drainCount_{0};
+};
+
+// ---------------------------------------------------------------------------
+// Muxed backend — AAC / AMR / Opus / Vorbis via AMediaMuxer.
+// ---------------------------------------------------------------------------
+
+class MuxedBackend : public MediaCodecBackend {
+ public:
+  std::string open(
+      int desiredSampleRate,
+      int desiredChannelCount,
+      const std::string &filePath,
+      const std::shared_ptr<AudioFileProperties> &properties,
+      const EncoderOutputSpec &outputSpec,
+      int &effectiveSampleRate,
+      int &effectiveChannelCount) override {
+    int sampleRate = desiredSampleRate;
+    int channels = desiredChannelCount;
+    const char *mime = "audio/mp4a-latm";
+    bool isAac = false;
+    int bitRate = static_cast<int>(properties->bitRate);
+
+    switch (outputSpec.codec) {
+      case AudioCodec::AAC:
+        mime = "audio/mp4a-latm";
+        isAac = true;
+        muxerFormat_ = AMEDIAMUXER_OUTPUT_FORMAT_MPEG_4;
+        break;
+      case AudioCodec::AMR_NB:
+        mime = "audio/3gpp";
+        sampleRate = 8000;
+        channels = 1;
+        if (bitRate <= 0) {
+          bitRate = 12200;
+        }
+        muxerFormat_ = AMEDIAMUXER_OUTPUT_FORMAT_THREE_GPP;
+        break;
+      case AudioCodec::AMR_WB:
+        mime = "audio/amr-wb";
+        sampleRate = 16000;
+        channels = 1;
+        if (bitRate <= 0) {
+          bitRate = 23850;
+        }
+        muxerFormat_ = AMEDIAMUXER_OUTPUT_FORMAT_THREE_GPP;
+        break;
+      case AudioCodec::OPUS:
+        mime = "audio/opus";
+        sampleRate = 48000;
+        if (bitRate <= 0) {
+          bitRate = 96000;
+        }
+        muxerFormat_ = outputSpec.container == AudioContainer::OGG ? AMEDIAMUXER_OUTPUT_FORMAT_OGG
+                                                                   : AMEDIAMUXER_OUTPUT_FORMAT_WEBM;
+        break;
+      case AudioCodec::VORBIS:
+        mime = "audio/vorbis";
+        if (bitRate <= 0) {
+          bitRate = 128000;
+        }
+        muxerFormat_ = AMEDIAMUXER_OUTPUT_FORMAT_WEBM;
+        break;
+      default:
+        return "MuxedBackend: unsupported codec";
+    }
+
+    effectiveSampleRate = sampleRate;
+    effectiveChannelCount = channels;
+
+    fd_ = ::open(filePath.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+    if (fd_ < 0) {
+      return "MuxedBackend: failed to open file descriptor";
+    }
+    muxer_ = AMediaMuxer_new(fd_, static_cast<OutputFormat>(muxerFormat_));
+    if (muxer_ == nullptr) {
+      ::close(fd_);
+      fd_ = -1;
+      return "MuxedBackend: failed to create muxer";
+    }
+
+    std::string err = startCodec(mime, sampleRate, channels, bitRate, isAac);
+    if (!err.empty()) {
+      AMediaMuxer_delete(muxer_);
+      muxer_ = nullptr;
+      ::close(fd_);
+      fd_ = -1;
+      return err;
+    }
+    filePath_ = filePath;
+    return "";
+  }
+
+  [[nodiscard]] size_t getFileSizeBytes() const override {
+    struct stat st{};
+    if (!filePath_.empty() && ::stat(filePath_.c_str(), &st) == 0) {
+      return static_cast<size_t>(st.st_size);
+    }
+    return 0;
+  }
+
+ protected:
+  std::string onFormatChanged(AMediaFormat *outputFormat) override {
+    if (muxerStarted_) {
+      return "";
+    }
+    trackIndex_ = AMediaMuxer_addTrack(muxer_, outputFormat);
+    if (trackIndex_ < 0) {
+      return "MuxedBackend: addTrack failed";
+    }
+    if (AMediaMuxer_start(muxer_) != AMEDIA_OK) {
+      return "MuxedBackend: muxer start failed";
+    }
+    muxerStarted_ = true;
+    return "";
+  }
+
+  std::string onEncodedSample(const uint8_t *data, const AMediaCodecBufferInfo &info) override {
+    // Codec-specific data is carried in the output format for the muxer; skip it.
+    if ((info.flags & AMEDIACODEC_BUFFER_FLAG_CODEC_CONFIG) != 0) {
+      return "";
+    }
+    if (!muxerStarted_) {
+      // Some encoders emit the first frame before a format-changed event; the
+      // muxer must be started first.
+      AMediaFormat *outFormat = AMediaCodec_getOutputFormat(codec());
+      std::string err = onFormatChanged(outFormat);
+      AMediaFormat_delete(outFormat);
+      if (!err.empty()) {
+        return err;
+      }
+    }
+    AMediaCodecBufferInfo writeInfo = info;
+    if (AMediaMuxer_writeSampleData(muxer_, static_cast<size_t>(trackIndex_), data, &writeInfo) !=
+        AMEDIA_OK) {
+      return "MuxedBackend: writeSampleData failed";
+    }
+    return "";
+  }
+
+  std::string finalize() override {
+    codec_.reset();
+    if (muxer_ != nullptr) {
+      if (muxerStarted_) {
+        AMediaMuxer_stop(muxer_);
+      }
+      AMediaMuxer_delete(muxer_);
+      muxer_ = nullptr;
+    }
+    if (fd_ >= 0) {
+      ::close(fd_);
+      fd_ = -1;
+    }
+    return "";
+  }
+
+ private:
+  AMediaMuxer *muxer_{nullptr};
+  int fd_{-1};
+  int muxerFormat_{AMEDIAMUXER_OUTPUT_FORMAT_MPEG_4};
+  ssize_t trackIndex_{-1};
+  bool muxerStarted_{false};
+  std::string filePath_;
+};
+
+// ---------------------------------------------------------------------------
+// FLAC backend — MediaCodec FLAC encoder, raw stream written to file.
+// ---------------------------------------------------------------------------
+
+class FlacBackend : public MediaCodecBackend {
+ public:
+  std::string open(
+      int desiredSampleRate,
+      int desiredChannelCount,
+      const std::string &filePath,
+      const std::shared_ptr<AudioFileProperties> &properties,
+      const EncoderOutputSpec &outputSpec,
+      int &effectiveSampleRate,
+      int &effectiveChannelCount) override {
+    (void)outputSpec;
+    effectiveSampleRate = desiredSampleRate;
+    effectiveChannelCount = desiredChannelCount;
+
+    file_ = std::fopen(filePath.c_str(), "wb");
+    if (file_ == nullptr) {
+      return "FlacBackend: failed to open file for writing";
+    }
+    filePath_ = filePath;
+
+    // FLAC has no MediaMuxer container; the codec emits "fLaC" + STREAMINFO as
+    // codec-config, followed by raw FLAC frames — concatenating yields a valid
+    // .flac file. compression-level is advisory.
+    int bitRate = 0; // lossless; ignored
+    std::string err =
+        startCodec("audio/flac", desiredSampleRate, desiredChannelCount, bitRate, false);
+    if (!err.empty()) {
+      std::fclose(file_);
+      file_ = nullptr;
+      return err;
+    }
+    return "";
+  }
+
+  [[nodiscard]] size_t getFileSizeBytes() const override {
+    return bytesWritten_;
+  }
+
+ protected:
+  std::string onFormatChanged(AMediaFormat *outputFormat) override {
+    (void)outputFormat;
+    return "";
+  }
+
+  std::string onEncodedSample(const uint8_t *data, const AMediaCodecBufferInfo &info) override {
+    if (file_ == nullptr) {
+      return "FlacBackend: file not open";
+    }
+    size_t written = std::fwrite(data + info.offset, 1, static_cast<size_t>(info.size), file_);
+    if (written != static_cast<size_t>(info.size)) {
+      return "FlacBackend: short write";
+    }
+    bytesWritten_ += written;
+    return "";
+  }
+
+  std::string finalize() override {
+    codec_.reset();
+    if (file_ != nullptr) {
+      std::fclose(file_);
+      file_ = nullptr;
+    }
+    return "";
+  }
+
+ private:
+  std::FILE *file_{nullptr};
+  std::string filePath_;
+  size_t bytesWritten_{0};
+};
+
+// ---------------------------------------------------------------------------
+// Resampler state (rate conversion only; channel mapping done separately).
+// ---------------------------------------------------------------------------
+
+struct AndroidEncoder::ResamplerState {
+  ResamplerState(int srcRate, int dstRate, int channels)
+      : resampler(srcRate, dstRate, channels, kResampleMaxInFrames),
+        inBuffer(static_cast<size_t>(kResampleMaxInFrames), channels, static_cast<float>(srcRate)),
+        outBuffer(
+            static_cast<size_t>(std::max(1, resamplerMaxOut(srcRate, dstRate))),
+            channels,
+            static_cast<float>(dstRate)) {}
+
+  static int resamplerMaxOut(int srcRate, int dstRate) {
+    r8b::MultiChannelResampler probe(srcRate, dstRate, 1, kResampleMaxInFrames);
+    return probe.getMaxOutLen();
+  }
+
+  r8b::MultiChannelResampler resampler;
+  AudioBuffer inBuffer;
+  AudioBuffer outBuffer;
+};
+
+// ---------------------------------------------------------------------------
+// AndroidEncoder
+// ---------------------------------------------------------------------------
+
+AndroidEncoder::AndroidEncoder(const std::shared_ptr<AudioFileProperties> &fileProperties)
+    : AudioEncoder(fileProperties) {}
+
+AndroidEncoder::~AndroidEncoder() {
+  if (isOpen()) {
+    close();
+  }
+}
+
+OpenEncoderResult AndroidEncoder::open(
+    const StreamFormat &inputFormat,
+    const EncoderOutputSpec &outputSpec,
+    size_t maxBufferSizeInFrames,
+    const std::string &filePath) {
+  if (isOpen()) {
+    return OpenEncoderResult::Err("Encoder already open");
+  }
+  if (inputFormat.sampleRate <= 0 || inputFormat.channelCount <= 0) {
+    return OpenEncoderResult::Err("Invalid input format");
+  }
+
+  inputFormat_ = inputFormat;
+  outputSpec_ = outputSpec;
+  maxBufferSizeInFrames_ = maxBufferSizeInFrames;
+  filePath_ = filePath;
+  inputSampleRate_ = inputFormat.sampleRate;
+  inputChannelCount_ = inputFormat.channelCount;
+  resetFramesEncoded();
+
+  switch (outputSpec.codec) {
+    case AudioCodec::PCM:
+      backend_ = std::make_unique<WavBackend>();
+      break;
+    case AudioCodec::FLAC:
+      backend_ = std::make_unique<FlacBackend>();
+      break;
+    case AudioCodec::AAC:
+    case AudioCodec::AMR_NB:
+    case AudioCodec::AMR_WB:
+    case AudioCodec::OPUS:
+    case AudioCodec::VORBIS:
+      backend_ = std::make_unique<MuxedBackend>();
+      break;
+    default:
+      return OpenEncoderResult::Err(
+          std::string(toString(outputSpec.codec)) + " is not encodable on Android");
+  }
+
+  int effectiveSampleRate = static_cast<int>(fileProperties_->sampleRate);
+  int effectiveChannelCount = fileProperties_->channelCount;
+  std::string err = backend_->open(
+      static_cast<int>(fileProperties_->sampleRate),
+      fileProperties_->channelCount,
+      filePath,
+      fileProperties_,
+      outputSpec,
+      effectiveSampleRate,
+      effectiveChannelCount);
+  if (!err.empty()) {
+    backend_.reset();
+    return OpenEncoderResult::Err(err);
+  }
+
+  outputSampleRate_ = effectiveSampleRate;
+  outputChannelCount_ = effectiveChannelCount;
+
+  if (static_cast<int>(inputSampleRate_) != effectiveSampleRate) {
+    resampler_ = std::make_unique<ResamplerState>(
+        static_cast<int>(inputSampleRate_), effectiveSampleRate, outputChannelCount_);
+  }
+
+  markOpen();
+  return OpenEncoderResult::Ok(filePath_);
+}
+
+int AndroidEncoder::convertToOutput(const float *input, int numFrames) {
+  // Step 1: channel conversion (input layout → output layout).
+  const float *channelMapped = input;
+  if (inputChannelCount_ != outputChannelCount_) {
+    AudioBuffer inBuf(
+        static_cast<size_t>(numFrames), inputChannelCount_, static_cast<float>(inputSampleRate_));
+    inBuf.deinterleaveFrom(input, static_cast<size_t>(numFrames));
+    AudioBuffer outBuf(
+        static_cast<size_t>(numFrames), outputChannelCount_, static_cast<float>(inputSampleRate_));
+    outBuf.copy(inBuf);
+    channelBuffer_.resize(static_cast<size_t>(numFrames) * outputChannelCount_);
+    outBuf.interleaveTo(channelBuffer_.data(), static_cast<size_t>(numFrames));
+    channelMapped = channelBuffer_.data();
+  }
+
+  // Step 2: sample-rate conversion.
+  if (resampler_ == nullptr) {
+    convertedBuffer_.assign(
+        channelMapped, channelMapped + static_cast<size_t>(numFrames) * outputChannelCount_);
+    return numFrames;
+  }
+
+  convertedBuffer_.clear();
+  int totalOut = 0;
+  int consumed = 0;
+  while (consumed < numFrames) {
+    const int chunk = std::min(numFrames - consumed, kResampleMaxInFrames);
+    resampler_->inBuffer.deinterleaveFrom(
+        channelMapped + static_cast<size_t>(consumed) * outputChannelCount_,
+        static_cast<size_t>(chunk));
+    const int produced =
+        resampler_->resampler.process(resampler_->inBuffer, chunk, resampler_->outBuffer);
+    consumed += chunk;
+    if (produced <= 0) {
+      continue;
+    }
+    const size_t base = convertedBuffer_.size();
+    convertedBuffer_.resize(base + static_cast<size_t>(produced) * outputChannelCount_);
+    resampler_->outBuffer.interleaveTo(
+        convertedBuffer_.data() + base, static_cast<size_t>(produced));
+    totalOut += produced;
+  }
+  return totalOut;
+}
+
+EncodeResult AndroidEncoder::encode(const void *data, int numFrames) {
+  if (!isOpen() || backend_ == nullptr) {
+    return EncodeResult::Err("Encoder is not open");
+  }
+  if (data == nullptr || numFrames <= 0) {
+    return EncodeResult::Err("Invalid encode input");
+  }
+
+  const auto *input = static_cast<const float *>(data);
+  const int outFrames = convertToOutput(input, numFrames);
+  if (outFrames > 0) {
+    std::string err = backend_->encodeFloat(convertedBuffer_.data(), outFrames);
+    if (!err.empty()) {
+      return EncodeResult::Err(err);
+    }
+  }
+
+  addEncodedFrames(static_cast<size_t>(numFrames));
+  return EncodeResult::Ok(static_cast<size_t>(numFrames));
+}
+
+CloseEncoderResult AndroidEncoder::close() {
+  if (!isOpen() || backend_ == nullptr) {
+    return CloseEncoderResult::Err("Encoder is not open");
+  }
+  markClosed();
+
+  std::string err = backend_->close();
+  const size_t sizeBytes = backend_->getFileSizeBytes();
+  const double durationSeconds = inputSampleRate_ > 0
+      ? static_cast<double>(framesEncoded_.load(std::memory_order_acquire)) / inputSampleRate_
+      : 0.0;
+  backend_.reset();
+  resampler_.reset();
+  resetFramesEncoded();
+
+  if (!err.empty()) {
+    return CloseEncoderResult::Err(err);
+  }
+
+  const double sizeMB = static_cast<double>(sizeBytes) / (1024.0 * 1024.0);
+  return CloseEncoderResult::Ok(std::make_tuple(sizeMB, durationSeconds));
+}
+
+size_t AndroidEncoder::getFileSizeBytes() const {
+  if (backend_ == nullptr) {
+    return 0;
+  }
+  return backend_->getFileSizeBytes();
+}
+
+} // namespace audioapi::android_encoder
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/AndroidEncoding.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/AndroidEncoding.h
new file mode 100644
index 000000000..005e5ea8c
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/AndroidEncoding.h
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <audioapi/encoding/AudioEncoder.h>
+#include <audioapi/utils/Result.hpp>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace audioapi::android_encoder {
+
+class IEncoderBackend;
+
+/// Android system-API encoder (RIFF / MediaCodec + MediaMuxer).
+class AndroidEncoder : public AudioEncoder {
+ public:
+  explicit AndroidEncoder(const std::shared_ptr<AudioFileProperties> &fileProperties);
+  ~AndroidEncoder() override;
+
+  OpenEncoderResult open(
+      const StreamFormat &inputFormat,
+      const EncoderOutputSpec &outputSpec,
+      size_t maxBufferSizeInFrames,
+      const std::string &filePath) override;
+
+  EncodeResult encode(const void *data, int numFrames) override;
+
+  CloseEncoderResult close() override;
+
+  [[nodiscard]] size_t getFileSizeBytes() const override;
+
+ private:
+  int convertToOutput(const float *input, int numFrames);
+
+  std::unique_ptr<IEncoderBackend> backend_;
+  std::vector<float> channelBuffer_;
+  std::vector<float> convertedBuffer_;
+
+  double inputSampleRate_{0.0};
+  double outputSampleRate_{0.0};
+  int inputChannelCount_{0};
+  int outputChannelCount_{0};
+
+  struct ResamplerState;
+  std::unique_ptr<ResamplerState> resampler_;
+};
+
+} // namespace audioapi::android_encoder
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/AndroidRemux.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/AndroidRemux.cpp
new file mode 100644
index 000000000..2f71f1ebf
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/AndroidRemux.cpp
@@ -0,0 +1,392 @@
+#include <audioapi/AndroidRemux.h>
+
+#include <media/NdkMediaCodec.h>
+#include <media/NdkMediaExtractor.h>
+#include <media/NdkMediaFormat.h>
+#include <media/NdkMediaMuxer.h>
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <cerrno>
+#include <cstring>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace audioapi::android_remux {
+namespace {
+
+constexpr size_t kSampleBufferBytes = 256 * 1024;
+
+struct TrackInfo {
+  std::string mime;
+  int32_t sampleRate{0};
+  int32_t channelCount{0};
+  std::vector<uint8_t> csd0;
+};
+
+class ExtractorGuard {
+ public:
+  ExtractorGuard() = default;
+  ExtractorGuard(const ExtractorGuard &) = delete;
+  ExtractorGuard &operator=(const ExtractorGuard &) = delete;
+
+  ~ExtractorGuard() {
+    reset();
+  }
+
+  void reset() {
+    if (extractor_ != nullptr) {
+      AMediaExtractor_delete(extractor_);
+      extractor_ = nullptr;
+    }
+    if (fd_ >= 0) {
+      ::close(fd_);
+      fd_ = -1;
+    }
+  }
+
+  [[nodiscard]] AMediaExtractor *get() const {
+    return extractor_;
+  }
+
+  [[nodiscard]] AndroidRemuxResult open(const std::string &path) {
+    reset();
+
+    fd_ = ::open(path.c_str(), O_RDONLY);
+    if (fd_ < 0) {
+      return Err("Failed to open input file '" + path + "': " + std::strerror(errno));
+    }
+
+    struct stat st{};
+    if (::fstat(fd_, &st) != 0) {
+      reset();
+      return Err("Failed to stat input file '" + path + "': " + std::strerror(errno));
+    }
+
+    extractor_ = AMediaExtractor_new();
+    if (extractor_ == nullptr) {
+      reset();
+      return Err("Failed to create MediaExtractor for '" + path + "'.");
+    }
+
+    const media_status_t status =
+        AMediaExtractor_setDataSourceFd(extractor_, fd_, 0, static_cast<off64_t>(st.st_size));
+    if (status != AMEDIA_OK) {
+      reset();
+      return Err("Failed to set MediaExtractor data source for '" + path + "'.");
+    }
+
+    return Ok(path);
+  }
+
+ private:
+  AMediaExtractor *extractor_{nullptr};
+  int fd_{-1};
+};
+
+class MuxerGuard {
+ public:
+  MuxerGuard() = default;
+  MuxerGuard(const MuxerGuard &) = delete;
+  MuxerGuard &operator=(const MuxerGuard &) = delete;
+
+  ~MuxerGuard() {
+    reset();
+  }
+
+  void reset() {
+    if (muxer_ != nullptr) {
+      if (started_) {
+        AMediaMuxer_stop(muxer_);
+        started_ = false;
+      }
+      AMediaMuxer_delete(muxer_);
+      muxer_ = nullptr;
+    }
+    if (fd_ >= 0) {
+      ::close(fd_);
+      fd_ = -1;
+    }
+  }
+
+  [[nodiscard]] AMediaMuxer *get() const {
+    return muxer_;
+  }
+
+  [[nodiscard]] ssize_t trackIndex() const {
+    return trackIndex_;
+  }
+
+  [[nodiscard]] AndroidRemuxResult open(const std::string &path) {
+    reset();
+
+    fd_ = ::open(path.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0644);
+    if (fd_ < 0) {
+      return Err("Failed to open output file '" + path + "': " + std::strerror(errno));
+    }
+
+    muxer_ = AMediaMuxer_new(fd_, AMEDIAMUXER_OUTPUT_FORMAT_MPEG_4);
+    if (muxer_ == nullptr) {
+      reset();
+      return Err("Failed to create MediaMuxer for '" + path + "'.");
+    }
+
+    return Ok(path);
+  }
+
+  [[nodiscard]] AndroidRemuxResult addTrackAndStart(AMediaFormat *format) {
+    trackIndex_ = AMediaMuxer_addTrack(muxer_, format);
+    if (trackIndex_ < 0) {
+      return Err("Failed to add audio track to MediaMuxer.");
+    }
+    if (AMediaMuxer_start(muxer_) != AMEDIA_OK) {
+      return Err("Failed to start MediaMuxer.");
+    }
+    started_ = true;
+    return Ok(std::string());
+  }
+
+ private:
+  AMediaMuxer *muxer_{nullptr};
+  int fd_{-1};
+  ssize_t trackIndex_{-1};
+  bool started_{false};
+};
+
+[[nodiscard]] AndroidRemuxResult
+findAudioTrack(AMediaExtractor *extractor, size_t &trackIndex, TrackInfo &info) {
+  const size_t trackCount = AMediaExtractor_getTrackCount(extractor);
+  for (size_t i = 0; i < trackCount; ++i) {
+    AMediaFormat *format = AMediaExtractor_getTrackFormat(extractor, i);
+    if (format == nullptr) {
+      continue;
+    }
+
+    const char *mime = nullptr;
+    if (!AMediaFormat_getString(format, AMEDIAFORMAT_KEY_MIME, &mime) || mime == nullptr) {
+      AMediaFormat_delete(format);
+      continue;
+    }
+
+    if (std::strncmp(mime, "audio/", 6) != 0) {
+      AMediaFormat_delete(format);
+      continue;
+    }
+
+    TrackInfo candidate;
+    candidate.mime = mime;
+    if (!AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_SAMPLE_RATE, &candidate.sampleRate) ||
+        candidate.sampleRate <= 0) {
+      AMediaFormat_delete(format);
+      return Err("Input audio track is missing a valid sample rate.");
+    }
+    if (!AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_CHANNEL_COUNT, &candidate.channelCount) ||
+        candidate.channelCount <= 0) {
+      AMediaFormat_delete(format);
+      return Err("Input audio track is missing a valid channel count.");
+    }
+
+    void *csd = nullptr;
+    size_t csdSize = 0;
+    if (AMediaFormat_getBuffer(format, "csd-0", &csd, &csdSize) && csd != nullptr && csdSize > 0) {
+      const auto *bytes = static_cast<const uint8_t *>(csd);
+      candidate.csd0.assign(bytes, bytes + csdSize);
+    }
+
+    AMediaFormat_delete(format);
+    trackIndex = i;
+    info = std::move(candidate);
+    return Ok(std::string());
+  }
+
+  return Err("Input file does not contain an audio stream.");
+}
+
+// Opens an extractor for `path` and locates its audio track, prefixing any
+// track error with the file path for consistent messages.
+[[nodiscard]] AndroidRemuxResult openAndFindAudioTrack(
+    const std::string &path,
+    ExtractorGuard &extractor,
+    size_t &trackIndex,
+    TrackInfo &info) {
+  auto openResult = extractor.open(path);
+  if (openResult.is_err()) {
+    return openResult;
+  }
+
+  auto found = findAudioTrack(extractor.get(), trackIndex, info);
+  if (found.is_err()) {
+    return Err("Input file '" + path + "': " + found.unwrap_err());
+  }
+
+  return Ok(path);
+}
+
+[[nodiscard]] AndroidRemuxResult validateCompatible(
+    const TrackInfo &candidate,
+    const TrackInfo &reference,
+    const std::string &filePath) {
+  if (candidate.mime != reference.mime) {
+    return Err("Input file '" + filePath + "' uses a different audio codec.");
+  }
+  if (candidate.sampleRate != reference.sampleRate) {
+    return Err("Input file '" + filePath + "' uses a different sample rate.");
+  }
+  if (candidate.channelCount != reference.channelCount) {
+    return Err("Input file '" + filePath + "' uses a different channel layout.");
+  }
+  return Ok(filePath);
+}
+
+[[nodiscard]] AMediaFormat *buildOutputFormat(const TrackInfo &info) {
+  AMediaFormat *format = AMediaFormat_new();
+  AMediaFormat_setString(format, AMEDIAFORMAT_KEY_MIME, info.mime.c_str());
+  AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_SAMPLE_RATE, info.sampleRate);
+  AMediaFormat_setInt32(format, AMEDIAFORMAT_KEY_CHANNEL_COUNT, info.channelCount);
+  if (!info.csd0.empty()) {
+    AMediaFormat_setBuffer(format, "csd-0", info.csd0.data(), info.csd0.size());
+  }
+  return format;
+}
+
+[[nodiscard]] AndroidRemuxResult appendSamples(
+    AMediaExtractor *extractor,
+    size_t extractorTrackIndex,
+    AMediaMuxer *muxer,
+    size_t muxerTrackIndex,
+    int64_t &timeOffsetUs) {
+  if (AMediaExtractor_selectTrack(extractor, extractorTrackIndex) != AMEDIA_OK) {
+    return Err("Failed to select audio track.");
+  }
+
+  std::vector<uint8_t> buffer(kSampleBufferBytes);
+  int64_t baseTimeUs = -1;
+  int64_t segmentEndUs = timeOffsetUs;
+
+  while (true) {
+    const ssize_t sampleSize =
+        AMediaExtractor_readSampleData(extractor, buffer.data(), buffer.size());
+    if (sampleSize < 0) {
+      break;
+    }
+
+    const int64_t sampleTimeUs = AMediaExtractor_getSampleTime(extractor);
+    const uint32_t flags = AMediaExtractor_getSampleFlags(extractor);
+
+    if ((flags & AMEDIACODEC_BUFFER_FLAG_CODEC_CONFIG) != 0) {
+      if (!AMediaExtractor_advance(extractor)) {
+        break;
+      }
+      continue;
+    }
+
+    if (baseTimeUs < 0) {
+      baseTimeUs = sampleTimeUs >= 0 ? sampleTimeUs : 0;
+    }
+
+    const int64_t presentationTimeUs =
+        (sampleTimeUs >= 0 ? sampleTimeUs - baseTimeUs : 0) + timeOffsetUs;
+
+    AMediaCodecBufferInfo writeInfo{};
+    writeInfo.offset = 0;
+    writeInfo.size = static_cast<int32_t>(sampleSize);
+    writeInfo.presentationTimeUs = presentationTimeUs;
+    writeInfo.flags = static_cast<uint32_t>(flags);
+
+    if (AMediaMuxer_writeSampleData(muxer, muxerTrackIndex, buffer.data(), &writeInfo) !=
+        AMEDIA_OK) {
+      return Err("Failed to write sample data to MediaMuxer.");
+    }
+
+    if (presentationTimeUs >= segmentEndUs) {
+      segmentEndUs = presentationTimeUs + 1;
+    }
+
+    if (!AMediaExtractor_advance(extractor)) {
+      break;
+    }
+  }
+
+  timeOffsetUs = segmentEndUs;
+  return Ok(std::string());
+}
+
+} // namespace
+
+AndroidRemuxResult concatAudioFiles(
+    const std::vector<std::string> &inputPaths,
+    const std::string &outputPath) {
+  if (inputPaths.empty()) {
+    return Err("concatAudioFiles requires at least one input path.");
+  }
+
+  ExtractorGuard firstExtractor;
+  size_t firstTrackIndex = 0;
+  TrackInfo referenceInfo;
+  auto refResult =
+      openAndFindAudioTrack(inputPaths.front(), firstExtractor, firstTrackIndex, referenceInfo);
+  if (refResult.is_err()) {
+    return refResult;
+  }
+
+  if (referenceInfo.mime != "audio/mp4a-latm") {
+    return Err(
+        "Input file '" + inputPaths.front() +
+        "' is not AAC-in-M4A/MP4; only AAC remux is supported.");
+  }
+
+  for (size_t i = 1; i < inputPaths.size(); ++i) {
+    ExtractorGuard extractor;
+    size_t trackIndex = 0;
+    TrackInfo info;
+    auto result = openAndFindAudioTrack(inputPaths[i], extractor, trackIndex, info);
+    if (result.is_err()) {
+      return result;
+    }
+
+    auto validation = validateCompatible(info, referenceInfo, inputPaths[i]);
+    if (validation.is_err()) {
+      return validation;
+    }
+  }
+
+  MuxerGuard muxer;
+  auto muxerOpen = muxer.open(outputPath);
+  if (muxerOpen.is_err()) {
+    return muxerOpen;
+  }
+
+  AMediaFormat *outputFormat = buildOutputFormat(referenceInfo);
+  auto startResult = muxer.addTrackAndStart(outputFormat);
+  AMediaFormat_delete(outputFormat);
+  if (startResult.is_err()) {
+    return startResult;
+  }
+
+  int64_t timeOffsetUs = 0;
+  const size_t muxerTrackIndex = static_cast<size_t>(muxer.trackIndex());
+
+  firstExtractor.reset();
+  for (const auto &inputPath : inputPaths) {
+    ExtractorGuard extractor;
+    size_t extractorTrackIndex = 0;
+    TrackInfo info;
+    auto result = openAndFindAudioTrack(inputPath, extractor, extractorTrackIndex, info);
+    if (result.is_err()) {
+      return result;
+    }
+
+    auto appendResult = appendSamples(
+        extractor.get(), extractorTrackIndex, muxer.get(), muxerTrackIndex, timeOffsetUs);
+    if (appendResult.is_err()) {
+      return Err("Failed while remuxing '" + inputPath + "': " + appendResult.unwrap_err());
+    }
+  }
+
+  muxer.reset();
+  return Ok(outputPath);
+}
+
+} // namespace audioapi::android_remux
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/AndroidRemux.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/AndroidRemux.h
new file mode 100644
index 000000000..1d64e2105
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/AndroidRemux.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <audioapi/utils/Result.hpp>
+
+#include <string>
+#include <vector>
+
+namespace audioapi::android_remux {
+
+using AndroidRemuxResult = Result<std::string, std::string>;
+
+/// Packet-copy remux of compatible AAC-in-M4A/MP4 via AMediaExtractor + AMediaMuxer.
+[[nodiscard]] AndroidRemuxResult concatAudioFiles(
+    const std::vector<std::string> &inputPaths,
+    const std::string &outputPath);
+
+} // namespace audioapi::android_remux
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/CMakeLists.txt b/packages/react-native-audio-api/android/src/main/cpp/audioapi/CMakeLists.txt
index 04d808875..7be6ed2d9 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/CMakeLists.txt
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/CMakeLists.txt
@@ -102,6 +102,7 @@ set(LINK_LIBRARIES
   fbjni::fbjni
   android
   log
+  mediandk
   oboe::oboe
 )
 
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp
index eaa32085d..abc0e799d 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp
@@ -3,12 +3,8 @@
 #include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
 #include <audioapi/android/core/utils/AndroidRecorderCallback.h>
 
-#if !RN_AUDIO_API_FFMPEG_DISABLED
-#include <audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h>
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
-
 #include <audioapi/android/core/utils/AndroidRotatingFileWriter.h>
-#include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h>
+#include <audioapi/android/core/utils/OsAudioFileWriter.h>
 #include <audioapi/core/sources/RecorderAdapterNode.h>
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/Locker.h>
@@ -272,36 +268,17 @@ Result<NoneType, std::string> AndroidAudioRecorder::enableFileOutput(
 
 std::shared_ptr<AudioFileWriter> AndroidAudioRecorder::createFileWriter(
     const std::shared_ptr<AudioFileProperties> &props) {
-  if (props->format == AudioFileProperties::Format::WAV) {
-    return std::make_shared<MiniAudioFileWriter>(
-        audioEventHandlerRegistry_,
-        props,
-        streamSampleRate_,
-        streamChannelCount_,
-        streamMaxBufferSizeInFrames_);
-  }
-#if !RN_AUDIO_API_FFMPEG_DISABLED
-  return std::make_shared<android::ffmpeg::FFmpegAudioFileWriter>(
+  return std::make_shared<OsAudioFileWriter>(
       audioEventHandlerRegistry_,
       props,
       streamSampleRate_,
       streamChannelCount_,
       streamMaxBufferSizeInFrames_);
-#else
-  return nullptr;
-#endif
 }
 
 Result<NoneType, std::string> AndroidAudioRecorder::setupFileWriter(
     const std::shared_ptr<AudioFileProperties> &properties,
     const std::string &fileNameOverride) {
-#if RN_AUDIO_API_FFMPEG_DISABLED
-  if (properties->format != AudioFileProperties::Format::WAV) {
-    return Result<NoneType, std::string>::Err(
-        "FFmpeg backend is disabled. Cannot create file writer for the requested format. Use WAV format instead.");
-  }
-#endif
-
   if (properties->rotateIntervalBytes > 0) {
     fileWriter_ = std::make_shared<AndroidRotatingFileWriter>(
         audioEventHandlerRegistry_,
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/FileOptions.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/FileOptions.cpp
index 2bb2ece5d..3f6de7f64 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/FileOptions.cpp
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/FileOptions.cpp
@@ -1,6 +1,7 @@
 #include <android/log.h>
 #include <audioapi/android/core/utils/FileOptions.h>
 #include <audioapi/android/system/NativeFileInfo.hpp>
+#include <audioapi/encoding/EncoderCapabilities.h>
 #include <audioapi/utils/AudioFileProperties.h>
 #include <chrono>
 #include <filesystem>
@@ -48,18 +49,7 @@ std::string getDirectory(const std::shared_ptr<AudioFileProperties> &properties)
 }
 
 std::string getFileExtension(const std::shared_ptr<AudioFileProperties> &properties) {
-  switch (properties->format) {
-    case AudioFileProperties::Format::WAV:
-      return "wav";
-    case AudioFileProperties::Format::CAF:
-      return "caf";
-    case AudioFileProperties::Format::M4A:
-      return "m4a";
-    case AudioFileProperties::Format::FLAC:
-      return "flac";
-    default:
-      return "m4a";
-  }
+  return EncoderCapabilities::specForFormat(properties->format).extension;
 }
 
 Result<std::string, std::string> getFilePath(
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/OsAudioFileWriter.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/OsAudioFileWriter.cpp
new file mode 100644
index 000000000..82372eaa4
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/OsAudioFileWriter.cpp
@@ -0,0 +1,141 @@
+#include <audioapi/AndroidEncoding.h>
+#include <audioapi/android/core/utils/FileOptions.h>
+#include <audioapi/android/core/utils/OsAudioFileWriter.h>
+#include <audioapi/encoding/EncoderCapabilities.h>
+#include <audioapi/encoding/StreamFormat.h>
+#include <audioapi/utils/AudioFileProperties.h>
+
+#include <sys/stat.h>
+#include <cstdio>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace audioapi {
+
+OsAudioFileWriter::OsAudioFileWriter(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    const std::shared_ptr<AudioFileProperties> &fileProperties,
+    float streamSampleRate,
+    int32_t streamChannelCount,
+    int32_t streamMaxBufferSize)
+    : AndroidFileWriterBackend(audioEventHandlerRegistry, fileProperties) {}
+
+OsAudioFileWriter::~OsAudioFileWriter() {
+  isFileOpen_.store(false, std::memory_order_release);
+  cleanupPreallocatedInputPool();
+  encoder_.reset();
+}
+
+OpenFileResult OsAudioFileWriter::openFile(
+    float streamSampleRate,
+    int32_t streamChannelCount,
+    int32_t streamMaxBufferSize,
+    const std::string &fileNameOverride) {
+  streamSampleRate_ = streamSampleRate;
+  streamChannelCount_ = streamChannelCount;
+  streamMaxBufferSize_ = streamMaxBufferSize;
+  framesWritten_.store(0, std::memory_order_release);
+
+  if (fileProperties_->sampleRate <= 0 || fileProperties_->channelCount <= 0) {
+    return OpenFileResult::Err(
+        "Invalid file properties: sampleRate and channelCount must be greater than 0");
+  }
+
+  auto specResult = EncoderCapabilities::resolveOutputSpec(fileProperties_->format);
+  if (specResult.is_err()) {
+    return OpenFileResult::Err(specResult.unwrap_err());
+  }
+  EncoderOutputSpec outputSpec = specResult.unwrap();
+
+  auto filePathResult = android::fileoptions::getFilePath(fileProperties_, fileNameOverride);
+  if (!filePathResult.is_ok()) {
+    return OpenFileResult::Err(filePathResult.unwrap_err());
+  }
+  filePath_ = filePathResult.unwrap();
+
+  StreamFormat inputFormat{
+      .sampleRate = streamSampleRate,
+      .channelCount = streamChannelCount,
+      .isInterleaved = true,
+  };
+
+  auto encoder = std::make_unique<android_encoder::AndroidEncoder>(fileProperties_);
+  auto openResult =
+      encoder->open(inputFormat, outputSpec, static_cast<size_t>(streamMaxBufferSize), filePath_);
+  if (openResult.is_err()) {
+    return OpenFileResult::Err(openResult.unwrap_err());
+  }
+  encoder_ = std::move(encoder);
+
+  if (!initializePreallocatedInputPool()) {
+    rollbackFailedOpen();
+    return OpenFileResult::Err("Failed to preallocate Android file writer buffers");
+  }
+
+  isFileOpen_.store(true, std::memory_order_release);
+  return OpenFileResult::Ok(filePath_);
+}
+
+void OsAudioFileWriter::rollbackFailedOpen() {
+  cleanupPreallocatedInputPool();
+  if (encoder_ != nullptr) {
+    encoder_->close();
+    encoder_.reset();
+  }
+  if (!filePath_.empty()) {
+    std::remove(filePath_.c_str());
+    filePath_ = "";
+  }
+  framesWritten_.store(0, std::memory_order_release);
+  isFileOpen_.store(false, std::memory_order_release);
+}
+
+CloseFileResult OsAudioFileWriter::closeFile() {
+  if (!isFileOpen() || encoder_ == nullptr) {
+    return CloseFileResult::Err("File is not open");
+  }
+
+  isFileOpen_.store(false, std::memory_order_release);
+
+  // Drains the worker queue before finalizing the encoder below.
+  cleanupPreallocatedInputPool();
+
+  auto closeResult = encoder_->close();
+  encoder_.reset();
+  framesWritten_.store(0, std::memory_order_release);
+  filePath_ = "";
+
+  if (closeResult.is_err()) {
+    return CloseFileResult::Err(closeResult.unwrap_err());
+  }
+  return CloseFileResult::Ok(closeResult.unwrap());
+}
+
+size_t OsAudioFileWriter::getFileSizeBytes() const {
+  if (encoder_ != nullptr) {
+    return encoder_->getFileSizeBytes();
+  }
+  struct stat st{};
+  if (!filePath_.empty() && stat(filePath_.c_str(), &st) == 0) {
+    return static_cast<size_t>(st.st_size);
+  }
+  return 0;
+}
+
+void OsAudioFileWriter::processWriterData(void *audioData, int numFrames) {
+  if (!isFileOpen() || encoder_ == nullptr) {
+    return;
+  }
+
+  auto result = encoder_->encode(audioData, numFrames);
+  if (result.is_err()) {
+    invokeOnErrorCallback(
+        "Failed to write audio data to file: " + filePath_ + " - " + result.unwrap_err());
+    return;
+  }
+
+  framesWritten_.fetch_add(numFrames, std::memory_order_acq_rel);
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/OsAudioFileWriter.h
similarity index 54%
rename from packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h
rename to packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/OsAudioFileWriter.h
index f29196201..3e9830007 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/OsAudioFileWriter.h
@@ -1,23 +1,24 @@
 #pragma once
 
 #include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
-#include <audioapi/libs/miniaudio/miniaudio.h>
+#include <audioapi/encoding/AudioEncoder.h>
 
-#include <atomic>
+#include <cstdint>
 #include <memory>
 #include <string>
 
 namespace audioapi {
 
-class MiniAudioFileWriter : public AndroidFileWriterBackend {
+/// Android recorder file writer backed by the system AudioEncoder.
+class OsAudioFileWriter : public AndroidFileWriterBackend {
  public:
-  explicit MiniAudioFileWriter(
+  OsAudioFileWriter(
       const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
       const std::shared_ptr<AudioFileProperties> &fileProperties,
       float streamSampleRate,
       int32_t streamChannelCount,
       int32_t streamMaxBufferSize);
-  ~MiniAudioFileWriter();
+  ~OsAudioFileWriter() override;
 
   size_t getFileSizeBytes() const override;
 
@@ -29,21 +30,10 @@ class MiniAudioFileWriter : public AndroidFileWriterBackend {
   CloseFileResult closeFile() override;
 
  private:
-  std::atomic<bool> isConverterRequired_{false};
-
-  std::unique_ptr<ma_encoder> encoder_{nullptr};
-  std::unique_ptr<ma_data_converter> converter_{nullptr};
-  void *processingBuffer_{nullptr};
-  ma_uint64 processingBufferLength_{0};
-
-  ma_result initializeConverterIfNeeded();
-  ma_result initializeEncoder(const std::string &fileNameOverride);
-  // TODO: rewrite to use r8brain resampler
-  ma_uint64 convertBuffer(void *data, int numFrames);
-
-  bool isConverterRequired();
   void processWriterData(void *data, int numFrames) override;
   void rollbackFailedOpen();
+
+  std::unique_ptr<AudioEncoder> encoder_;
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.cpp
deleted file mode 100644
index 06c31e69a..000000000
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.cpp
+++ /dev/null
@@ -1,509 +0,0 @@
-#if !RN_AUDIO_API_FFMPEG_DISABLED
-
-extern "C" {
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-#include <libavutil/audio_fifo.h>
-#include <libavutil/opt.h>
-#include <libswresample/swresample.h>
-}
-
-#include <android/log.h>
-#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
-#include <audioapi/android/core/utils/FileOptions.h>
-#include <audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h>
-#include <audioapi/android/core/utils/ffmpegBackend/ptrs.hpp>
-#include <audioapi/android/core/utils/ffmpegBackend/utils.h>
-#include <audioapi/core/utils/AudioFileWriter.h>
-#include <audioapi/utils/AudioFileProperties.h>
-#include <audioapi/utils/UnitConversion.h>
-
-#include <sys/stat.h>
-#include <algorithm>
-#include <cassert>
-#include <cstdio>
-#include <memory>
-#include <string>
-#include <utility>
-
-constexpr int fallbackFIFOSize = 8192;
-constexpr int fallbackFrameSize = 512;
-constexpr int defaultFlushInterval = 100;
-
-namespace audioapi::android::ffmpeg {
-
-FFmpegAudioFileWriter::FFmpegAudioFileWriter(
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
-    const std::shared_ptr<AudioFileProperties> &fileProperties,
-    float streamSampleRate,
-    int32_t streamChannelCount,
-    int32_t streamMaxBufferSize)
-    : AndroidFileWriterBackend(audioEventHandlerRegistry, fileProperties) {
-  // Set flush interval from properties, limit minimum to 100ms
-  // to avoid people hurting themselves too much
-  flushIntervalMs_ = std::max(fileProperties_->androidFlushIntervalMs, defaultFlushInterval);
-}
-
-FFmpegAudioFileWriter::~FFmpegAudioFileWriter() {
-  if (isFileOpen()) {
-    closeFile();
-  }
-}
-
-/// @brief Opens a specified audio file for writing and prepares any necessary resources.
-/// such as codecs, conversion buffers or circular AVIO FIFO.
-/// This method should be called from the JS thread only.
-/// @param streamSampleRate The sample rate of the incoming audio stream (aka microphone).
-/// @param streamChannelCount The number of channels in the incoming audio stream.
-/// @param streamMaxBufferSize The estimated maximum buffer size for the incoming audio stream.
-/// @returns Success status with file path or Error status with message.
-OpenFileResult FFmpegAudioFileWriter::openFile(
-    float streamSampleRate,
-    int32_t streamChannelCount,
-    int32_t streamMaxBufferSize,
-    const std::string &fileNameOverride) {
-  streamSampleRate_ = streamSampleRate;
-  streamChannelCount_ = streamChannelCount;
-  streamMaxBufferSize_ = streamMaxBufferSize;
-  framesWritten_.store(0, std::memory_order_release);
-  nextPts_ = 0;
-  auto filePathResult = fileoptions::getFilePath(fileProperties_, fileNameOverride);
-
-  if (!filePathResult.is_ok()) {
-    return OpenFileResult::Err(filePathResult.unwrap_err());
-  }
-
-  filePath_ = filePathResult.unwrap();
-
-  const AVCodec *codec = getCodec(fileProperties_);
-
-  if (!codec) {
-    return OpenFileResult::Err("Unsupported codec for the given file format");
-  }
-
-  return initializeFormatContext(codec)
-      .and_then([this, codec](auto) { return configureAndOpenCodec(codec); })
-      .and_then([this](auto) { return initializeStream(); })
-      .and_then([this](auto) { return openIOAndWriteHeader(); })
-      .and_then(
-          [this](auto) { return initializeResampler(streamSampleRate_, streamChannelCount_); })
-      .and_then([this](auto) {
-        initializeBuffers(streamMaxBufferSize_);
-        if (!initializePreallocatedInputPool()) {
-          rollbackFailedOpen();
-          return OpenFileResult::Err("Failed to preallocate Android file writer buffers");
-        }
-        isFileOpen_.store(true, std::memory_order_release);
-        return OpenFileResult::Ok(filePath_);
-      });
-}
-
-/// @brief Closes the currently opened audio file, flushing any remaining data and finalizing the file.
-/// This method should called from the JS thread only.
-/// @returns CloseFileStatus indicating success with file path, size and duration, or error with message.
-CloseFileResult FFmpegAudioFileWriter::closeFile() {
-  int result = 0;
-
-  if (!isFileOpen()) {
-    return CloseFileResult::Err("File is not open");
-  }
-
-  isFileOpen_.store(false, std::memory_order_release);
-
-  // Drains the worker queue before flushing/finalizing the encoder below.
-  cleanupPreallocatedInputPool();
-
-  result = processFifo(true);
-
-  if (result < 0) {
-    return finalizeOutput();
-  }
-
-  result = avcodec_send_frame(encoderCtx_.get(), nullptr);
-
-  if (result < 0) {
-    return CloseFileResult::Err("Failed to send EOF to encoder");
-  }
-
-  if (writeEncodedPackets() < 0) {
-    return CloseFileResult::Err("Failed to drain encoder packets");
-  }
-
-  return finalizeOutput();
-}
-
-/// @brief Writes audio data to the currently opened file.
-void FFmpegAudioFileWriter::processWriterData(void *audioData, int numFrames) {
-  if (!isFileOpen()) {
-    return;
-  }
-
-  if (!resampleAndPushToFifo(audioData, numFrames)) {
-    return;
-  }
-
-  framesWritten_.fetch_add(numFrames, std::memory_order_acq_rel);
-
-  if (processFifo(false) < 0) {
-    return;
-  }
-}
-
-/// @brief Initializes the FFmpeg format context for the output file.
-/// @param codec The codec to be used for encoding.
-/// @returns Success status or Error status with message.
-Result<NoneType, std::string> FFmpegAudioFileWriter::initializeFormatContext(const AVCodec *codec) {
-  AVFormatContext *rawFormatCtx = nullptr;
-
-  int result = avformat_alloc_output_context2(
-      &rawFormatCtx, nullptr, getMuxerName(fileProperties_).c_str(), filePath_.c_str());
-
-  if (result < 0 || !rawFormatCtx) {
-    return Result<NoneType, std::string>::Err(
-        "Failed to allocate FFmpeg format context with error: " + parseErrorCode(result));
-  }
-
-  formatCtx_ = av_unique_ptr<AVFormatContext>(rawFormatCtx);
-  return Result<NoneType, std::string>::Ok(None);
-}
-
-/// @brief Configures and opens the codec context for encoding.
-/// @param codec The codec to be used for encoding.
-/// @returns Success status or Error status with message.
-Result<NoneType, std::string> FFmpegAudioFileWriter::configureAndOpenCodec(const AVCodec *codec) {
-  encoderCtx_ = av_unique_ptr<AVCodecContext>(avcodec_alloc_context3(codec));
-
-  if (!encoderCtx_) {
-    return Result<NoneType, std::string>::Err("Failed to allocate FFmpeg codec context");
-  }
-
-  av_channel_layout_default(&encoderCtx_->ch_layout, fileProperties_->channelCount);
-  encoderCtx_->sample_rate = static_cast<int>(fileProperties_->sampleRate);
-  encoderCtx_->sample_fmt = getSampleFormat(fileProperties_);
-
-  if (fileProperties_->bitRate > 0) {
-    encoderCtx_->bit_rate = fileProperties_->bitRate;
-  }
-
-  AVDictionary *codecOptions = nullptr;
-
-  if (fileProperties_->flacCompressionLevel >= 0) {
-    av_dict_set_int(&codecOptions, "compression_level", fileProperties_->flacCompressionLevel, 0);
-  }
-
-  int result = avcodec_open2(encoderCtx_.get(), codec, &codecOptions);
-  av_dict_free(&codecOptions);
-
-  if (result < 0) {
-    return Result<NoneType, std::string>::Err(
-        "Failed to open FFmpeg codec with error: " + parseErrorCode(result));
-  }
-
-  return Result<NoneType, std::string>::Ok(None);
-}
-
-/// @brief Initializes a new stream in the format context.
-/// @returns Success status or Error status with message.
-Result<NoneType, std::string> FFmpegAudioFileWriter::initializeStream() {
-  stream_ = avformat_new_stream(formatCtx_.get(), nullptr);
-
-  if (!stream_) {
-    return Result<NoneType, std::string>::Err("Failed to create new stream in format context");
-  }
-
-  int result = avcodec_parameters_from_context(stream_->codecpar, encoderCtx_.get());
-
-  if (result < 0) {
-    return Result<NoneType, std::string>::Err(
-        "Failed to copy codec parameters to stream with error: " + parseErrorCode(result));
-  }
-
-  stream_->time_base = AVRational{1, static_cast<int>(encoderCtx_->sample_rate)};
-  return Result<NoneType, std::string>::Ok(None);
-}
-
-/// @brief Opens the file and writes the basic header (depends on the codec/format used).
-/// @returns Success status or Error status with message.
-Result<NoneType, std::string> FFmpegAudioFileWriter::openIOAndWriteHeader() {
-  int result = 0;
-
-  if (!(formatCtx_->oformat->flags & AVFMT_NOFILE)) {
-    result = avio_open(&formatCtx_->pb, filePath_.c_str(), AVIO_FLAG_WRITE);
-
-    if (result < 0) {
-      return Result<NoneType, std::string>::Err(
-          "Failed to open output file with error: " + parseErrorCode(result));
-    }
-  }
-
-  result = avformat_write_header(formatCtx_.get(), nullptr);
-
-  if (result < 0) {
-    return Result<NoneType, std::string>::Err("Failed to write header to file: " + filePath_);
-  }
-
-  return Result<NoneType, std::string>::Ok(None);
-}
-
-size_t FFmpegAudioFileWriter::getFileSizeBytes() const {
-  if (formatCtx_ == nullptr) {
-    return 0;
-  }
-
-  if (formatCtx_ != nullptr && formatCtx_->pb != nullptr) {
-    return static_cast<size_t>(avio_tell(formatCtx_->pb));
-  }
-
-  // Fallback
-  struct stat st;
-  if (stat(filePath_.c_str(), &st) == 0) {
-    return st.st_size;
-  }
-  return 0;
-}
-
-/// @brief Initializes the resampler context for audio conversion.
-/// @param inputRate The sample rate of the input audio.
-/// @param inputChannels The number of channels in the input audio.
-/// @returns Success status or Error status with message.
-Result<NoneType, std::string> FFmpegAudioFileWriter::initializeResampler(
-    float inputRate,
-    int inputChannels) {
-  resampleCtx_ = av_unique_ptr<SwrContext>(swr_alloc());
-
-  if (!resampleCtx_) {
-    return Result<NoneType, std::string>::Err("Failed to allocate resampler context");
-  }
-
-  AVChannelLayout inChannelLayout;
-  av_channel_layout_default(&inChannelLayout, inputChannels);
-
-  av_opt_set_chlayout(resampleCtx_.get(), "in_chlayout", &inChannelLayout, 0);
-  av_opt_set_chlayout(resampleCtx_.get(), "out_chlayout", &encoderCtx_->ch_layout, 0);
-
-  av_opt_set_int(resampleCtx_.get(), "in_sample_rate", static_cast<int64_t>(inputRate), 0);
-  av_opt_set_int(resampleCtx_.get(), "out_sample_rate", encoderCtx_->sample_rate, 0);
-
-  av_opt_set_sample_fmt(resampleCtx_.get(), "in_sample_fmt", AV_SAMPLE_FMT_FLT, 0);
-  av_opt_set_sample_fmt(resampleCtx_.get(), "out_sample_fmt", encoderCtx_->sample_fmt, 0);
-
-  int result = swr_init(resampleCtx_.get());
-
-  if (result < 0) {
-    return Result<NoneType, std::string>::Err(
-        "Failed to initialize resampler for file: " + parseErrorCode(result));
-  }
-
-  return Result<NoneType, std::string>::Ok(None);
-}
-
-/// @brief Initializes frame and packet buffers as well as the audio FIFO,
-/// that might be needed for storing intermediate audio data or buffering before encoding.
-/// @param maxBufferSize The maximum buffer size to allocate.
-void FFmpegAudioFileWriter::initializeBuffers(int32_t maxBufferSize) {
-  resamplerFrame_ = av_unique_ptr<AVFrame>(av_frame_alloc());
-  writingFrame_ = av_unique_ptr<AVFrame>(av_frame_alloc());
-  packet_ = av_unique_ptr<AVPacket>(av_packet_alloc());
-
-  // Calculate resampler size of output buffer from the resampler
-  int resamplerFrameSize = av_rescale_rnd(
-      maxBufferSize,
-      static_cast<int>(encoderCtx_->sample_rate),
-      static_cast<int>(streamSampleRate_),
-      AV_ROUND_UP);
-
-  // Configure frame parameters for desired file output
-  resamplerFrame_->nb_samples = resamplerFrameSize;
-  resamplerFrame_->format = encoderCtx_->sample_fmt;
-  av_channel_layout_copy(&resamplerFrame_->ch_layout, &encoderCtx_->ch_layout);
-  // Allocate buffer for the resampler frame
-  av_frame_get_buffer(resamplerFrame_.get(), 0);
-
-  // calculate FIFO size based on max buffer size and encoder frame size
-  // max(2 * resamplerFrameSize, 2 * encoderCtx_->frame_size, fallbackFIFOSize)
-  int writingFrameSize = 2 * std::max(encoderCtx_->frame_size, fallbackFrameSize);
-  int fifoSize = std::max(std::max(2 * resamplerFrameSize, writingFrameSize), fallbackFIFOSize);
-
-  audioFifo_ = av_unique_ptr<AVAudioFifo>(
-      av_audio_fifo_alloc(encoderCtx_->sample_fmt, encoderCtx_->ch_layout.nb_channels, fifoSize));
-
-  // Configure writing frame parameters
-  // size 2 x encoder frame size + same format as encoder
-  writingFrame_->nb_samples = writingFrameSize;
-  av_channel_layout_copy(&writingFrame_->ch_layout, &encoderCtx_->ch_layout);
-  writingFrame_->format = encoderCtx_->sample_fmt;
-  writingFrame_->sample_rate = encoderCtx_->sample_rate;
-  // Allocate buffer for the writing frame
-  av_frame_get_buffer(writingFrame_.get(), 0);
-}
-
-/// @brief Resamples input audio data and pushes it to the audio FIFO.
-/// @param inputData Pointer to the input audio data.
-/// @param inputFrameCount Number of input frames.
-/// @returns True if successful, false otherwise.
-bool FFmpegAudioFileWriter::resampleAndPushToFifo(void *inputData, int inputFrameCount) {
-  int64_t outputLength = av_rescale_rnd(
-      inputFrameCount, encoderCtx_->sample_rate, static_cast<int>(streamSampleRate_), AV_ROUND_UP);
-
-  const uint8_t *inputs[1] = {reinterpret_cast<const uint8_t *>(inputData)};
-
-  assert(outputLength <= resamplerFrame_->nb_samples);
-
-  int convertedSamples = swr_convert(
-      resampleCtx_.get(),
-      resamplerFrame_->data,
-      static_cast<int>(outputLength),
-      inputs,
-      inputFrameCount);
-
-  if (convertedSamples < 0) {
-    invokeOnErrorCallback("Failed to convert audio samples: " + parseErrorCode(convertedSamples));
-    return false;
-  }
-
-  int written = av_audio_fifo_write(
-      audioFifo_.get(), reinterpret_cast<void **>(resamplerFrame_->data), convertedSamples);
-
-  if (written < convertedSamples) {
-    invokeOnErrorCallback("Failed to write all samples to FIFO");
-    return false;
-  }
-
-  return true;
-}
-
-/// @brief pushes the audio data from FIFO to the encoder in chunks,
-/// defined by the encoder (512 samples by default) or flushes the FIFO if requested.
-/// Note: flush might be called only when writing the final data batch, otherwise
-/// the codec will crash (especially in case of defined size frames like AAC).
-/// @param flush Indicates whether to flush the FIFO.
-/// @returns 0 on success, -1 or AV_ERROR code on failure
-int FFmpegAudioFileWriter::processFifo(bool flush) {
-  int result = 0;
-  int frameSize = std::max(encoderCtx_->frame_size, fallbackFrameSize);
-
-  while (av_audio_fifo_size(audioFifo_.get()) >= (flush ? 1 : frameSize)) {
-    const int chunkSize = std::min(av_audio_fifo_size(audioFifo_.get()), frameSize);
-
-    if (av_audio_fifo_read(
-            audioFifo_.get(), reinterpret_cast<void **>(writingFrame_->data), chunkSize) !=
-        chunkSize) {
-      invokeOnErrorCallback("Failed to read data from FIFO");
-      return -1;
-    }
-
-    writingFrame_->nb_samples = chunkSize;
-    writingFrame_->pts = nextPts_;
-    nextPts_ += chunkSize;
-
-    result = avcodec_send_frame(encoderCtx_.get(), writingFrame_.get());
-
-    if (result < 0) {
-      invokeOnErrorCallback("Failed to send frame to encoder: " + parseErrorCode(result));
-      return result;
-    }
-
-    result = writeEncodedPackets();
-
-    if (result < 0) {
-      invokeOnErrorCallback("Failed to write encoded packets: " + parseErrorCode(result));
-      return result;
-    }
-  }
-
-  return 0;
-}
-
-/// @brief Takes ready encoded packets from the encoder and writes them to the output file.
-/// Also in order to optimize file writing vs file resilience from crashes, it periodically
-/// forces the AVIO buffer to flush data to disk, by default every 0,5 second.
-/// @returns 0 on success, AV_ERROR code on failure
-int FFmpegAudioFileWriter::writeEncodedPackets() {
-  int result = 0;
-
-  while (true) {
-    result = avcodec_receive_packet(encoderCtx_.get(), packet_.get());
-
-    if (result == AVERROR(EAGAIN) || result == AVERROR_EOF) {
-      return 0;
-    } else if (result < 0) {
-      invokeOnErrorCallback("Failed to receive packet from encoder: " + parseErrorCode(result));
-      return result;
-    }
-
-    av_packet_rescale_ts(packet_.get(), encoderCtx_->time_base, stream_->time_base);
-    packet_->stream_index = stream_->index;
-
-    result = av_interleaved_write_frame(formatCtx_.get(), packet_.get());
-
-    auto now = std::chrono::steady_clock::now();
-    auto elapsedMs =
-        std::chrono::duration_cast<std::chrono::milliseconds>(now - lastFlushTime_).count();
-
-    if (formatCtx_->pb && elapsedMs >= flushIntervalMs_) {
-      avio_flush(formatCtx_->pb);
-      lastFlushTime_ = now;
-    }
-
-    if (result < 0) {
-      return result;
-    }
-  }
-}
-
-/// @brief Closes the currently opened audio file, flushing any remaining data and finalizing the file.
-/// Method checks the file size and duration for convenience.
-/// @returns CloseFileResult indicating success or error details
-CloseFileResult FFmpegAudioFileWriter::finalizeOutput() {
-  int result = av_write_trailer(formatCtx_.get());
-
-  if (result < 0) {
-    return CloseFileResult::Err("Failed to write trailer: " + parseErrorCode(result));
-  }
-
-  double fileSizeInMB = 0;
-
-  if (formatCtx_->pb) {
-    fileSizeInMB = static_cast<double>(avio_size(formatCtx_->pb)) / MB_IN_BYTES;
-    avio_closep(&formatCtx_->pb);
-  }
-
-  double durationInSeconds = 0.0;
-  if (encoderCtx_ != nullptr && encoderCtx_->sample_rate > 0) {
-    durationInSeconds = static_cast<double>(nextPts_) / encoderCtx_->sample_rate;
-  }
-
-  filePath_ = "";
-
-  return CloseFileResult::Ok({fileSizeInMB, durationInSeconds});
-}
-
-void FFmpegAudioFileWriter::rollbackFailedOpen() {
-  cleanupPreallocatedInputPool();
-
-  if (formatCtx_ != nullptr && formatCtx_->pb != nullptr) {
-    avio_closep(&formatCtx_->pb);
-  }
-
-  encoderCtx_.reset();
-  formatCtx_.reset();
-  resampleCtx_.reset();
-  audioFifo_.reset();
-  packet_.reset();
-  resamplerFrame_.reset();
-  writingFrame_.reset();
-  stream_ = nullptr;
-  nextPts_ = 0;
-
-  if (!filePath_.empty()) {
-    std::remove(filePath_.c_str());
-    filePath_ = "";
-  }
-
-  framesWritten_.store(0, std::memory_order_release);
-  isFileOpen_.store(false, std::memory_order_release);
-}
-
-} // namespace audioapi::android::ffmpeg
-
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h
deleted file mode 100644
index fe7a03e2b..000000000
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h
+++ /dev/null
@@ -1,80 +0,0 @@
-#pragma once
-
-#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
-#include <audioapi/android/core/utils/ffmpegBackend/utils.h>
-#include <audioapi/utils/Result.hpp>
-#include <chrono>
-#include <memory>
-#include <string>
-
-struct AVCodecContext;
-struct AVFormatContext;
-struct AVFrame;
-struct AVPacket;
-struct AVAudioFifo;
-struct SwrContext;
-struct AVStream;
-
-namespace audioapi {
-
-class AudioFileProperties;
-
-namespace android::ffmpeg {
-
-class FFmpegAudioFileWriter : public AndroidFileWriterBackend {
- public:
-  explicit FFmpegAudioFileWriter(
-      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
-      const std::shared_ptr<AudioFileProperties> &fileProperties,
-      float streamSampleRate,
-      int32_t streamChannelCount,
-      int32_t streamMaxBufferSize);
-  ~FFmpegAudioFileWriter();
-
-  size_t getFileSizeBytes() const override;
-
-  OpenFileResult openFile(
-      float streamSampleRate,
-      int32_t streamChannelCount,
-      int32_t streamMaxBufferSize,
-      const std::string &fileNameOverride) override;
-  CloseFileResult closeFile() override;
-
- private:
-  av_unique_ptr<AVCodecContext> encoderCtx_{nullptr};
-  av_unique_ptr<AVFormatContext> formatCtx_{nullptr};
-  av_unique_ptr<SwrContext> resampleCtx_{nullptr};
-  av_unique_ptr<AVAudioFifo> audioFifo_{nullptr};
-  av_unique_ptr<AVPacket> packet_{nullptr};
-  av_unique_ptr<AVFrame> resamplerFrame_{nullptr};
-  av_unique_ptr<AVFrame> writingFrame_{nullptr};
-  AVStream *stream_{nullptr};
-
-  unsigned int nextPts_{0};
-
-  std::chrono::steady_clock::time_point lastFlushTime_ = std::chrono::steady_clock::now();
-  int flushIntervalMs_;
-
-  // Initialization helper methods
-  Result<NoneType, std::string> initializeFormatContext(const AVCodec *codec);
-  Result<NoneType, std::string> configureAndOpenCodec(const AVCodec *codec);
-  Result<NoneType, std::string> initializeStream();
-  Result<NoneType, std::string> openIOAndWriteHeader();
-  // TODO: rewrite to use r8brain resampler
-  Result<NoneType, std::string> initializeResampler(float inputRate, int inputChannels);
-  void initializeBuffers(int32_t maxBufferSize);
-
-  // Processing helper methods
-  bool resampleAndPushToFifo(void *data, int numFrames);
-  int processFifo(bool flush);
-  int writeEncodedPackets();
-
-  // Finalization helper methods
-  CloseFileResult finalizeOutput();
-  void rollbackFailedOpen();
-  void processWriterData(void *data, int numFrames) override;
-};
-
-} // namespace android::ffmpeg
-
-} // namespace audioapi
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/ptrs.hpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/ptrs.hpp
deleted file mode 100644
index b260fbd4b..000000000
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/ptrs.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#if !RN_AUDIO_API_FFMPEG_DISABLED
-
-#pragma once
-
-extern "C" {
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-#include <libavutil/audio_fifo.h>
-#include <libswresample/swresample.h>
-}
-
-#include <audioapi/android/core/utils/ffmpegBackend/utils.h>
-
-namespace audioapi::android::ffmpeg {
-
-template <>
-inline void AvDtor<AVCodecContext>::operator()(AVCodecContext *ctx) const {
-  if (ctx != nullptr) {
-    avcodec_free_context(&ctx);
-  }
-}
-
-template <>
-inline void AvDtor<AVFormatContext>::operator()(AVFormatContext *ctx) const {
-  if (ctx != nullptr) {
-    avformat_free_context(ctx);
-  }
-}
-
-template <>
-inline void AvDtor<AVFrame>::operator()(AVFrame *frame) const {
-  if (frame != nullptr) {
-    av_frame_free(&frame);
-  }
-}
-
-template <>
-inline void AvDtor<AVPacket>::operator()(AVPacket *packet) const {
-  if (packet != nullptr) {
-    av_packet_free(&packet);
-  }
-}
-
-template <>
-inline void AvDtor<SwrContext>::operator()(SwrContext *ctx) const {
-  if (ctx != nullptr) {
-    swr_free(&ctx);
-  }
-}
-
-template <>
-inline void AvDtor<AVAudioFifo>::operator()(AVAudioFifo *fifo) const {
-  if (fifo != nullptr) {
-    av_audio_fifo_free(fifo);
-  }
-}
-
-} // namespace audioapi::android::ffmpeg
-
-#else
-
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/utils.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/utils.cpp
deleted file mode 100644
index 0f780b2f0..000000000
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/utils.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-#if !RN_AUDIO_API_FFMPEG_DISABLED
-
-extern "C" {
-#include <libavcodec/avcodec.h>
-}
-
-#include <audioapi/android/core/utils/ffmpegBackend/utils.h>
-
-#include <audioapi/android/core/utils/FileOptions.h>
-#include <audioapi/utils/AudioFileProperties.h>
-
-#include <memory>
-#include <string>
-
-namespace audioapi::android::ffmpeg {
-
-/// @brief Get the PCM codec ID based on the bit depth.
-/// Note: This function returns only PCM codec IDs and its different from getSampleFormat. :)
-/// @param properties The audio file properties.
-/// @return The corresponding PCM AVCodecID.
-AVCodecID getPCMCodecID(const std::shared_ptr<AudioFileProperties> &properties) {
-  switch (properties->bitDepth) {
-    case AudioFileProperties::BitDepth::Bit16:
-      return AV_CODEC_ID_PCM_S16LE;
-    case AudioFileProperties::BitDepth::Bit24:
-      return AV_CODEC_ID_PCM_S24LE;
-    case AudioFileProperties::BitDepth::Bit32:
-      return AV_CODEC_ID_PCM_F32LE;
-    default:
-      return AV_CODEC_ID_PCM_F32LE;
-  }
-}
-
-/// @brief Get the codec ID based on the audio file properties.
-/// Note: PCM codec is used with wav and caf formats as both are uncompressed formats.
-/// @param properties The audio file properties.
-/// @return The corresponding AVCodecID.
-AVCodecID getCodecID(const std::shared_ptr<AudioFileProperties> &properties) {
-  switch (properties->format) {
-    case AudioFileProperties::Format::WAV:
-    case AudioFileProperties::Format::CAF:
-      return getPCMCodecID(properties);
-    case AudioFileProperties::Format::M4A:
-      return AV_CODEC_ID_AAC;
-    case AudioFileProperties::Format::FLAC:
-      return AV_CODEC_ID_FLAC;
-    default:
-      return AV_CODEC_ID_AAC;
-  }
-}
-
-/// @brief Returns the appropriate AVSampleFormat for codecs that require it. (non-PCM codecs)
-/// @param properties The audio file properties.
-/// @return The corresponding AVSampleFormat.
-AVSampleFormat getSampleFormat(const std::shared_ptr<AudioFileProperties> &properties) {
-  if (properties->format == AudioFileProperties::Format::M4A) {
-    return AV_SAMPLE_FMT_FLTP;
-  }
-
-  switch (properties->bitDepth) {
-    case AudioFileProperties::BitDepth::Bit16:
-      return AV_SAMPLE_FMT_S16;
-    case AudioFileProperties::BitDepth::Bit24:
-      return AV_SAMPLE_FMT_S32;
-    case AudioFileProperties::BitDepth::Bit32:
-      return AV_SAMPLE_FMT_FLT;
-    default:
-      return AV_SAMPLE_FMT_FLT;
-  }
-}
-
-/// @brief Finds the appropriate codec based on the audio file properties.
-/// @param properties The audio file properties.
-/// @return A pointer to the AVCodec.
-const AVCodec *getCodec(const std::shared_ptr<AudioFileProperties> &properties) {
-  return avcodec_find_encoder(getCodecID(properties));
-}
-
-/// @brief Returns the appropriate muxer name based on the audio file properties.
-/// Note: most of the time, the muxer name is same as the file extension, (M4A uses MP4 muxer :))
-/// thus this is kept separate from format -> extension mapping.
-/// @param properties The audio file properties.
-/// @return The corresponding muxer name.
-std::string getMuxerName(const std::shared_ptr<AudioFileProperties> &properties) {
-  switch (properties->format) {
-    case AudioFileProperties::Format::WAV:
-      return "wav";
-    case AudioFileProperties::Format::CAF:
-      return "caf";
-    case AudioFileProperties::Format::M4A:
-      return "mp4";
-    case AudioFileProperties::Format::FLAC:
-      return "flac";
-    default:
-      return "mp4";
-  }
-}
-
-/// @brief Parses the FFmpeg error int code into a human-readable string.
-/// @param errorCode The FFmpeg error code.
-/// @return A human-readable string describing the error.
-std::string parseErrorCode(int errorCode) {
-  char errorBuffer[AV_ERROR_MAX_STRING_SIZE];
-
-  if (av_strerror(errorCode, errorBuffer, sizeof(errorBuffer)) < 0) {
-    return "Unknown FFmpeg error: " + std::to_string(errorCode);
-  }
-
-  return std::string(errorBuffer);
-}
-
-} // namespace audioapi::android::ffmpeg
-
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/utils.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/utils.h
deleted file mode 100644
index b9cd92939..000000000
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/utils.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#pragma once
-
-extern "C" {
-#include <libavcodec/avcodec.h>
-}
-
-#include <memory>
-#include <string>
-
-namespace audioapi {
-
-class AudioFileProperties;
-
-namespace android::ffmpeg {
-
-template <typename AVT>
-struct AvDtor {
-  void operator()(AVT *ptr) const;
-};
-
-template <typename AVT>
-using av_unique_ptr = std::unique_ptr<AVT, AvDtor<AVT>>;
-
-AVCodecID getPCMCodecID(const std::shared_ptr<AudioFileProperties> &properties);
-AVCodecID getCodecID(const std::shared_ptr<AudioFileProperties> &properties);
-AVSampleFormat getSampleFormat(const std::shared_ptr<AudioFileProperties> &properties);
-const AVCodec *getCodec(const std::shared_ptr<AudioFileProperties> &properties);
-std::string getMuxerName(const std::shared_ptr<AudioFileProperties> &properties);
-
-std::string parseErrorCode(int errorCode);
-
-} // namespace android::ffmpeg
-
-} // namespace audioapi
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.cpp
deleted file mode 100644
index 293e1b007..000000000
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.cpp
+++ /dev/null
@@ -1,344 +0,0 @@
-#include <android/log.h>
-#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
-#include <audioapi/android/core/utils/FileOptions.h>
-#include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h>
-#include <audioapi/core/utils/AudioFileWriter.h>
-#include <audioapi/libs/miniaudio/miniaudio.h>
-#include <audioapi/utils/AudioFileProperties.h>
-#include <audioapi/utils/UnitConversion.h>
-
-#include <sys/stat.h>
-#include <cstdio>
-#include <memory>
-#include <string>
-
-namespace audioapi {
-
-/// @brief Get the encoding format based on the audio file properties (only WAV supported).
-// Currently, miniaudio supports only WAV encoding, but out of convenience
-// or potential future shenanigans, we keep this as a separate function.
-inline ma_encoding_format getFormat(const std::shared_ptr<AudioFileProperties> &properties) {
-  return ma_encoding_format_wav;
-}
-
-/// @brief Get the data format based on the bit depth.
-/// @param properties The audio file properties.
-/// @return The corresponding ma_format.
-inline ma_format getDataFormat(const std::shared_ptr<AudioFileProperties> &properties) {
-  switch (properties->bitDepth) {
-    case AudioFileProperties::BitDepth::Bit16:
-      return ma_format_s16;
-
-    case AudioFileProperties::BitDepth::Bit24:
-      return ma_format_s24;
-
-    case AudioFileProperties::BitDepth::Bit32:
-      return ma_format_f32;
-
-    default:
-      return ma_format_f32;
-  }
-}
-
-MiniAudioFileWriter::MiniAudioFileWriter(
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
-    const std::shared_ptr<AudioFileProperties> &fileProperties,
-    float streamSampleRate,
-    int32_t streamChannelCount,
-    int32_t streamMaxBufferSize)
-    : AndroidFileWriterBackend(audioEventHandlerRegistry, fileProperties) {}
-
-MiniAudioFileWriter::~MiniAudioFileWriter() {
-  isFileOpen_.store(false, std::memory_order_release);
-  cleanupPreallocatedInputPool();
-  fileProperties_.reset();
-
-  if (encoder_ != nullptr) {
-    ma_encoder_uninit(encoder_.get());
-    encoder_.reset();
-  }
-
-  if (converter_ != nullptr) {
-    ma_data_converter_uninit(converter_.get(), nullptr);
-    converter_.reset();
-  }
-
-  if (processingBuffer_ != nullptr) {
-    ma_free(processingBuffer_, nullptr);
-    processingBuffer_ = nullptr;
-    processingBufferLength_ = 0;
-  }
-}
-
-/// @brief Opens the audio file for writing.
-/// This method initializes the audio converter and encoder together with any
-/// necessary buffers required during the writing process.
-/// this method should be called only on the JS thread.
-/// @param streamSampleRate The sample rate of the incoming audio stream.
-/// @param streamChannelCount The channel count of the incoming audio stream.
-/// @param streamMaxBufferSize The maximum buffer size of the incoming audio stream.
-/// @return The status of the file opening operation.
-OpenFileResult MiniAudioFileWriter::openFile(
-    float streamSampleRate,
-    int32_t streamChannelCount,
-    int32_t streamMaxBufferSize,
-    const std::string &fileNameOverride) {
-  streamSampleRate_ = streamSampleRate;
-  streamChannelCount_ = streamChannelCount;
-  streamMaxBufferSize_ = streamMaxBufferSize;
-  ma_result result;
-  framesWritten_.store(0, std::memory_order_release);
-
-  isConverterRequired_.store(
-      (streamSampleRate_ != fileProperties_->sampleRate) ||
-          (streamChannelCount_ != fileProperties_->channelCount) ||
-          (getDataFormat(fileProperties_) != ma_format_f32),
-      std::memory_order_release);
-
-  result = initializeConverterIfNeeded();
-
-  if (result != MA_SUCCESS) {
-    return OpenFileResult ::Err(
-        "Failed to initialize converter" + std::string(ma_result_description(result)));
-  }
-
-  result = initializeEncoder(fileNameOverride);
-
-  if (result != MA_SUCCESS) {
-    return OpenFileResult ::Err(
-        "Failed to initialize encoder" + std::string(ma_result_description(result)));
-  }
-
-  if (!initializePreallocatedInputPool()) {
-    rollbackFailedOpen();
-    return OpenFileResult::Err("Failed to preallocate Android file writer buffers");
-  }
-
-  isFileOpen_.store(true, std::memory_order_release);
-  return OpenFileResult ::Ok(filePath_);
-}
-
-void MiniAudioFileWriter::rollbackFailedOpen() {
-  cleanupPreallocatedInputPool();
-
-  if (encoder_ != nullptr) {
-    ma_encoder_uninit(encoder_.get());
-    encoder_.reset();
-  }
-
-  if (converter_ != nullptr) {
-    ma_data_converter_uninit(converter_.get(), nullptr);
-    converter_.reset();
-  }
-
-  if (processingBuffer_ != nullptr) {
-    ma_free(processingBuffer_, nullptr);
-    processingBuffer_ = nullptr;
-    processingBufferLength_ = 0;
-  }
-
-  if (!filePath_.empty()) {
-    std::remove(filePath_.c_str());
-    filePath_ = "";
-  }
-
-  framesWritten_.store(0, std::memory_order_release);
-  isFileOpen_.store(false, std::memory_order_release);
-}
-
-/// @brief Closes the audio file.
-/// This method finalizes the writing process, releases resources,
-/// and retrieves the duration and size of the written audio file.
-/// It should be called only on the JS thread.
-/// @return The status of the file closing operation.
-CloseFileResult MiniAudioFileWriter::closeFile() {
-  if (!isFileOpen()) {
-    return CloseFileResult ::Err("File is not open");
-  }
-
-  isFileOpen_.store(false, std::memory_order_release);
-
-  // Drains the worker queue before the encoder teardown below.
-  cleanupPreallocatedInputPool();
-
-  if (encoder_ != nullptr) {
-    ma_encoder_uninit(encoder_.get());
-    encoder_.reset();
-  }
-
-  if (converter_ != nullptr) {
-    ma_data_converter_uninit(converter_.get(), nullptr);
-    converter_.reset();
-  }
-
-  if (processingBuffer_ != nullptr) {
-    ma_free(processingBuffer_, nullptr);
-    processingBuffer_ = nullptr;
-    processingBufferLength_ = 0;
-  }
-
-  // Retrieve duration and file size
-  double durationInSeconds = 0.0;
-  double fileSizeInMB = 0.0;
-
-  ma_decoder decoder;
-
-  if (ma_decoder_init_file(filePath_.c_str(), nullptr, &decoder) == MA_SUCCESS) {
-    ma_uint64 frameCount = 0;
-
-    if (ma_decoder_get_length_in_pcm_frames(&decoder, &frameCount) == MA_SUCCESS) {
-      durationInSeconds = static_cast<double>(frameCount) / decoder.outputSampleRate;
-    }
-
-    ma_decoder_uninit(&decoder);
-  }
-
-  FILE *file = fopen(filePath_.c_str(), "rb");
-
-  if (file != nullptr) {
-    fseek(file, 0, SEEK_END);
-    uint64_t fileSizeInBytes = ftell(file);
-    fclose(file);
-    fileSizeInMB = static_cast<double>(fileSizeInBytes) / MB_IN_BYTES;
-  }
-
-  filePath_ = "";
-  return CloseFileResult ::Ok({fileSizeInMB, durationInSeconds});
-}
-
-/// @brief Get the current file size in bytes.
-/// @return The size of the file in bytes.
-size_t MiniAudioFileWriter::getFileSizeBytes() const {
-  struct stat st;
-  if (stat(filePath_.c_str(), &st) == 0) {
-    return st.st_size;
-  }
-  return 0;
-}
-
-/// @brief Writes audio data to the file.
-/// If possible (sample format, channel count, and interleaving matches),
-/// the data is written directly, otherwise in-memory conversion is performed first
-void MiniAudioFileWriter::processWriterData(void *audioData, int numFrames) {
-  ma_uint64 framesWritten = 0;
-  ma_result result;
-
-  if (!isFileOpen()) {
-    return;
-  }
-
-  if (!isConverterRequired()) {
-    result = ma_encoder_write_pcm_frames(encoder_.get(), audioData, numFrames, &framesWritten);
-
-    if (result != MA_SUCCESS) {
-      invokeOnErrorCallback(
-          "Failed to write audio data to file: " + filePath_ +
-          std::string(ma_result_description(result)));
-      return;
-    }
-
-    framesWritten_.fetch_add(numFrames, std::memory_order_acq_rel);
-    return;
-  }
-
-  ma_uint64 convertedFrameCount = convertBuffer(audioData, numFrames);
-
-  result = ma_encoder_write_pcm_frames(
-      encoder_.get(), processingBuffer_, convertedFrameCount, &framesWritten);
-
-  if (result != MA_SUCCESS) {
-    invokeOnErrorCallback(
-        "Failed to write converted audio data to file: " + filePath_ +
-        std::string(ma_result_description(result)));
-    return;
-  }
-
-  framesWritten_.fetch_add(numFrames, std::memory_order_acq_rel);
-}
-
-/// @brief Converts the audio data buffer if necessary.
-/// @param data Pointer to the audio data buffer.
-/// @param numFrames Number of audio frames to convert.
-/// @return The number of frames after conversion.
-ma_uint64 MiniAudioFileWriter::convertBuffer(void *data, int numFrames) {
-  ma_uint64 inputFrameCount = numFrames;
-  ma_uint64 outputFrameCount = 0;
-
-  ma_data_converter_get_expected_output_frame_count(
-      converter_.get(), inputFrameCount, &outputFrameCount);
-
-  ma_data_converter_process_pcm_frames(
-      converter_.get(), data, &inputFrameCount, processingBuffer_, &outputFrameCount);
-
-  return outputFrameCount;
-}
-
-/// @brief Initializes the data converter if needed.
-/// This method sets up the data converter and allocates, so it should be called
-/// only on the JS thread. (during file opening)
-/// @return MA_SUCCESS if initialization was successful, otherwise an error code.
-ma_result MiniAudioFileWriter::initializeConverterIfNeeded() {
-  if (!isConverterRequired_) {
-    return MA_SUCCESS;
-  }
-
-  ma_result result;
-  ma_format dataFormat = getDataFormat(fileProperties_);
-
-  ma_data_converter_config converterConfig = ma_data_converter_config_init(
-      ma_format_f32,
-      dataFormat,
-      streamChannelCount_,
-      fileProperties_->channelCount,
-      static_cast<int32_t>(streamSampleRate_),
-      fileProperties_->sampleRate);
-
-  converter_ = std::make_unique<ma_data_converter>();
-  result = ma_data_converter_init(&converterConfig, nullptr, converter_.get());
-
-  if (result != MA_SUCCESS) {
-    return result;
-  }
-
-  ma_data_converter_get_expected_output_frame_count(
-      converter_.get(), streamMaxBufferSize_, &processingBufferLength_);
-
-  processingBuffer_ = ma_malloc(
-      processingBufferLength_ * fileProperties_->channelCount * ma_get_bytes_per_sample(dataFormat),
-      nullptr);
-
-  return MA_SUCCESS;
-}
-
-/// @brief Initializes the audio encoder.
-/// This method sets up the audio encoder for writing to the file,
-/// it should be called only on the JS thread. (during file opening)
-/// @return MA_SUCCESS if initialization was successful, otherwise an error code.
-ma_result MiniAudioFileWriter::initializeEncoder(const std::string &fileNameOverride) {
-  ma_result result;
-  Result<std::string, std::string> filePathResult =
-      android::fileoptions::getFilePath(fileProperties_, fileNameOverride);
-
-  if (!filePathResult.is_ok()) {
-    return MA_ERROR;
-  }
-
-  filePath_ = filePathResult.unwrap();
-
-  ma_encoder_config config = ma_encoder_config_init(
-      getFormat(fileProperties_),
-      getDataFormat(fileProperties_),
-      fileProperties_->channelCount,
-      fileProperties_->sampleRate);
-
-  encoder_ = std::make_unique<ma_encoder>();
-  result = ma_encoder_init_file(filePath_.c_str(), &config, encoder_.get());
-
-  return result;
-}
-
-bool MiniAudioFileWriter::isConverterRequired() {
-  return isConverterRequired_.load(std::memory_order_acquire);
-}
-
-} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioFileConcatenator.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioFileConcatenator.cpp
index 7ca4f296d..0997890d0 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioFileConcatenator.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioFileConcatenator.cpp
@@ -1,8 +1,8 @@
 #include <audioapi/core/utils/AudioFileConcatenator.h>
+#include <audioapi/encoding/OSRemux.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>
 
 #include <algorithm>
-#include <array>
 #include <cctype>
 #include <charconv>
 #include <cstdint>
@@ -14,94 +14,8 @@
 #include <utility>
 #include <vector>
 
-#if !RN_AUDIO_API_FFMPEG_DISABLED
-extern "C" {
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-#include <libavutil/avutil.h>
-#include <libavutil/channel_layout.h>
-#include <libavutil/dict.h>
-#include <libavutil/mathematics.h>
-}
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
-
 namespace audioapi {
 
-#if !RN_AUDIO_API_FFMPEG_DISABLED
-AVDictionaryGuard::~AVDictionaryGuard() {
-  av_dict_free(&dictionary_);
-}
-
-AVDictionary **AVDictionaryGuard::ptr() {
-  return &dictionary_;
-}
-
-InputFormatContext::InputFormatContext(
-    std::string filePath,
-    AVFormatContext *context,
-    int audioStreamIndex)
-    : filePath_(std::move(filePath)), context_(context), audioStreamIndex_(audioStreamIndex) {}
-
-InputFormatContext::InputFormatContext(InputFormatContext &&other) noexcept
-    : filePath_(std::move(other.filePath_)),
-      context_(std::exchange(other.context_, nullptr)),
-      audioStreamIndex_(std::exchange(other.audioStreamIndex_, -1)) {}
-
-InputFormatContext &InputFormatContext::operator=(InputFormatContext &&other) noexcept {
-  if (this != &other) {
-    close();
-    filePath_ = std::move(other.filePath_);
-    context_ = std::exchange(other.context_, nullptr);
-    audioStreamIndex_ = std::exchange(other.audioStreamIndex_, -1);
-  }
-  return *this;
-}
-
-InputFormatContext::~InputFormatContext() {
-  close();
-}
-
-AVFormatContext *InputFormatContext::context() const {
-  return context_;
-}
-
-AVStream *InputFormatContext::audioStream() const {
-  return context_->streams[audioStreamIndex_];
-}
-
-int InputFormatContext::audioStreamIndex() const {
-  return audioStreamIndex_;
-}
-
-const std::string &InputFormatContext::filePath() const {
-  return filePath_;
-}
-
-void InputFormatContext::close() {
-  if (context_ != nullptr) {
-    avformat_close_input(&context_);
-  }
-}
-
-OutputFormatContext::OutputFormatContext(AVFormatContext *context) : context_(context) {}
-
-OutputFormatContext::~OutputFormatContext() {
-  if (context_ == nullptr) {
-    return;
-  }
-
-  if (!(context_->oformat->flags & AVFMT_NOFILE) && context_->pb != nullptr) {
-    avio_closep(&context_->pb);
-  }
-
-  avformat_free_context(context_);
-}
-
-AVFormatContext *OutputFormatContext::get() const {
-  return context_;
-}
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
-
 namespace {
 
 constexpr const char *fileUrlPrefix = "file://";
@@ -198,12 +112,21 @@ bool isMiniaudioOutputPath(const std::string &path) {
   return hasExtension(path, {"wav"});
 }
 
-bool isFFmpegRemuxOutputPath(const std::string &path) {
+// M4A/MP4 remux via OS APIs. WAV stays on the miniaudio PCM path above.
+bool isOsRemuxOutputPath(const std::string &path) {
   return hasExtension(path, {"m4a", "mp4"});
 }
 
-bool isFFmpegOutputPath(const std::string &path) {
-  return isFFmpegRemuxOutputPath(path);
+bool extensionsCompatibleForRemux(const std::string &inputPath, const std::string &outputPath) {
+  const std::string inExt = lowercaseExtension(inputPath);
+  const std::string outExt = lowercaseExtension(outputPath);
+  if (inExt == outExt) {
+    return true;
+  }
+  // M4A and MP4 share the MPEG-4 audio container family.
+  const bool inMpeg4 = inExt == "m4a" || inExt == "mp4";
+  const bool outMpeg4 = outExt == "m4a" || outExt == "mp4";
+  return inMpeg4 && outMpeg4;
 }
 
 std::string parseMiniAudioError(ma_result errorCode) {
@@ -472,349 +395,19 @@ AudioFileConcatResult concatAudioFilesWithMiniAudio(
   return Ok(outputPath);
 }
 
-#if !RN_AUDIO_API_FFMPEG_DISABLED
-const char *getMuxerNameForOutputPath(const std::string &outputPath) {
-  const std::string extension = lowercaseExtension(outputPath);
-
-  if (extension == "m4a" || extension == "mp4") {
-    return "mp4";
-  }
-
-  return nullptr;
-}
-
-std::string parseFFmpegError(int errorCode) {
-  std::array<char, AV_ERROR_MAX_STRING_SIZE> errorBuffer{};
-
-  if (av_strerror(errorCode, errorBuffer.data(), sizeof(errorBuffer)) < 0) {
-    return "Unknown FFmpeg error: " + std::to_string(errorCode);
-  }
-
-  return {errorBuffer.data()};
-}
-
-int findAudioStreamIndex(AVFormatContext *formatContext) {
-  for (unsigned int i = 0; i < formatContext->nb_streams; ++i) {
-    if (formatContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
-      return static_cast<int>(i);
-    }
-  }
-  return -1;
-}
-
-bool hasUsableAudioParameters(const AVStream *stream) {
-  const auto *codecParameters = stream->codecpar;
-  return codecParameters->codec_id != AV_CODEC_ID_NONE && codecParameters->sample_rate > 0 &&
-      codecParameters->ch_layout.nb_channels > 0;
-}
-
-using InputOpenResult = Result<InputFormatContext, std::string>;
-
-InputOpenResult openInput(const std::string &filePath) {
-  AVFormatContext *rawContext = nullptr;
-  AVDictionaryGuard openOptions;
-  av_dict_set(openOptions.ptr(), "protocol_whitelist", "file", 0);
-
-  int result = avformat_open_input(&rawContext, filePath.c_str(), nullptr, openOptions.ptr());
-
-  if (result < 0) {
-    return Err("Failed to open input file '" + filePath + "': " + parseFFmpegError(result));
-  }
-
-  std::unique_ptr<AVFormatContext, void (*)(AVFormatContext *)> guard(
-      rawContext, [](AVFormatContext *context) {
-        if (context != nullptr) {
-          avformat_close_input(&context);
-        }
-      });
-
-  int audioStreamIndex = findAudioStreamIndex(rawContext);
-  if (audioStreamIndex < 0) {
-    return Err("Input file '" + filePath + "' does not contain an audio stream.");
-  }
-
-  if (!hasUsableAudioParameters(rawContext->streams[audioStreamIndex])) {
-    AVDictionaryGuard streamInfoOptions;
-    av_dict_set(streamInfoOptions.ptr(), "protocol_whitelist", "file", 0);
-
-    result = avformat_find_stream_info(rawContext, streamInfoOptions.ptr());
-    if (result < 0) {
-      return Err("Failed to read stream info from '" + filePath + "': " + parseFFmpegError(result));
-    }
-
-    audioStreamIndex = findAudioStreamIndex(rawContext);
-    if (audioStreamIndex < 0) {
-      return Err("Input file '" + filePath + "' does not contain an audio stream.");
-    }
-  }
-
-  if (!hasUsableAudioParameters(rawContext->streams[audioStreamIndex])) {
-    return Err("Input file '" + filePath + "' is missing required audio parameters.");
-  }
-
-  return Ok(InputFormatContext(filePath, guard.release(), audioStreamIndex));
-}
-
-AudioFileConcatResult validateCompatibleInput(
-    const InputFormatContext &input,
-    const InputFormatContext &reference) {
-  const auto *candidate = input.audioStream()->codecpar;
-  const auto *base = reference.audioStream()->codecpar;
-
-  if (std::strcmp(input.context()->iformat->name, reference.context()->iformat->name) != 0) {
-    return Err(
-        "Input file '" + input.filePath() +
-        "' uses a different container format than the first input.");
-  }
-
-  if (candidate->codec_type != base->codec_type || candidate->codec_id != base->codec_id) {
-    return Err("Input file '" + input.filePath() + "' uses a different audio codec.");
-  }
-
-  if (candidate->sample_rate != base->sample_rate) {
-    return Err("Input file '" + input.filePath() + "' uses a different sample rate.");
-  }
-
-  if (av_channel_layout_compare(&candidate->ch_layout, &base->ch_layout) != 0) {
-    return Err("Input file '" + input.filePath() + "' uses a different channel layout.");
-  }
-
-  if (candidate->format != base->format ||
-      candidate->bits_per_coded_sample != base->bits_per_coded_sample ||
-      candidate->bits_per_raw_sample != base->bits_per_raw_sample ||
-      candidate->profile != base->profile || candidate->level != base->level ||
-      candidate->block_align != base->block_align || candidate->frame_size != base->frame_size) {
-    return Err("Input file '" + input.filePath() + "' has incompatible audio parameters.");
-  }
-
-  if (candidate->extradata_size != base->extradata_size) {
-    return Err("Input file '" + input.filePath() + "' has incompatible codec extradata.");
-  }
-
-  if (candidate->extradata_size > 0 &&
-      std::memcmp(candidate->extradata, base->extradata, candidate->extradata_size) != 0) {
-    return Err("Input file '" + input.filePath() + "' has incompatible codec extradata.");
-  }
-
-  return Ok(input.filePath());
-}
-
-AudioFileConcatResult openAndValidateInputs(
+AudioFileConcatResult concatAudioFilesWithOsRemux(
     const std::vector<std::string> &inputPaths,
-    std::vector<InputFormatContext> &inputs) {
-  inputs.reserve(inputPaths.size());
-
+    const std::string &outputPath) {
   for (const auto &inputPath : inputPaths) {
-    auto inputResult = openInput(inputPath);
-    if (inputResult.is_err()) {
-      return Err(inputResult.unwrap_err());
-    }
-
-    inputs.emplace_back(std::move(inputResult).unwrap());
-
-    if (inputs.size() > 1) {
-      auto validationResult = validateCompatibleInput(inputs.back(), inputs.front());
-      if (validationResult.is_err()) {
-        return validationResult;
-      }
-    }
-  }
-
-  return Ok(std::string());
-}
-
-AudioFileConcatResult createOutput(
-    const std::string &outputPath,
-    const InputFormatContext &firstInput,
-    std::unique_ptr<OutputFormatContext> &output,
-    AVStream **outputStream) {
-  if (firstInput.context()->iformat->extensions != nullptr &&
-      av_match_ext(outputPath.c_str(), firstInput.context()->iformat->extensions) == 0) {
-    return Err("concatAudioFiles output path must use an extension compatible with the inputs.");
-  }
-
-  const char *muxerName = getMuxerNameForOutputPath(outputPath);
-  const AVOutputFormat *outputFormat = av_guess_format(muxerName, outputPath.c_str(), nullptr);
-  if (outputFormat == nullptr) {
-    return Err("Failed to determine output format for '" + outputPath + "'.");
-  }
-
-  AVFormatContext *rawOutputContext = nullptr;
-  int result = avformat_alloc_output_context2(
-      &rawOutputContext, outputFormat, muxerName, outputPath.c_str());
-
-  if (result < 0 || rawOutputContext == nullptr) {
-    return Err("Failed to allocate output context: " + parseFFmpegError(result));
-  }
-
-  output = std::make_unique<OutputFormatContext>(rawOutputContext);
-  *outputStream = avformat_new_stream(rawOutputContext, nullptr);
-
-  if (*outputStream == nullptr) {
-    return Err("Failed to create output audio stream.");
-  }
-
-  auto *inputStream = firstInput.audioStream();
-  result = avcodec_parameters_copy((*outputStream)->codecpar, inputStream->codecpar);
-  if (result < 0) {
-    return Err("Failed to copy audio stream parameters: " + parseFFmpegError(result));
-  }
-
-  (*outputStream)->codecpar->codec_tag = 0;
-  (*outputStream)->time_base = AVRational{.num = 1, .den = inputStream->codecpar->sample_rate};
-
-  if (!(rawOutputContext->oformat->flags & AVFMT_NOFILE)) {
-    result = avio_open(&rawOutputContext->pb, outputPath.c_str(), AVIO_FLAG_WRITE);
-    if (result < 0) {
-      return Err("Failed to open output file '" + outputPath + "': " + parseFFmpegError(result));
-    }
-  }
-
-  result = avformat_write_header(rawOutputContext, nullptr);
-  if (result < 0) {
-    return Err("Failed to write output header: " + parseFFmpegError(result));
-  }
-
-  return Ok(outputPath);
-}
-
-int64_t firstValidTimestamp(const AVPacket *packet) {
-  if (packet->dts != AV_NOPTS_VALUE) {
-    return packet->dts;
-  }
-  if (packet->pts != AV_NOPTS_VALUE) {
-    return packet->pts;
-  }
-  return 0;
-}
-
-int64_t packetEndTimestamp(const AVPacket *packet, AVRational outputTimeBase) {
-  int64_t endTimestamp = AV_NOPTS_VALUE;
-  if (packet->pts != AV_NOPTS_VALUE) {
-    endTimestamp = packet->pts;
-  }
-  if (packet->dts != AV_NOPTS_VALUE &&
-      (endTimestamp == AV_NOPTS_VALUE || packet->dts > endTimestamp)) {
-    endTimestamp = packet->dts;
-  }
-  if (endTimestamp == AV_NOPTS_VALUE) {
-    return AV_NOPTS_VALUE;
-  }
-  if (packet->duration > 0) {
-    endTimestamp += packet->duration;
-  }
-  return av_rescale_q(endTimestamp, outputTimeBase, outputTimeBase);
-}
-
-AudioFileConcatResult appendInputPackets(
-    InputFormatContext &input,
-    AVFormatContext *outputContext,
-    AVStream *outputStream,
-    int64_t &timestampOffset) {
-  auto *inputStream = input.audioStream();
-  const AVRational inputTimeBase = inputStream->time_base;
-  const AVRational outputTimeBase = outputStream->time_base;
-  AVPacket *packet = av_packet_alloc();
-
-  if (packet == nullptr) {
-    return Err("Failed to allocate FFmpeg packet.");
-  }
-
-  std::unique_ptr<AVPacket, void (*)(AVPacket *)> packetGuard(
-      packet, [](AVPacket *value) { av_packet_free(&value); });
-
-  int64_t baseTimestamp = AV_NOPTS_VALUE;
-  int64_t segmentEndTimestamp = timestampOffset;
-
-  while (true) {
-    int result = av_read_frame(input.context(), packet);
-    if (result == AVERROR_EOF) {
-      break;
-    }
-    if (result < 0) {
-      return Err(
-          "Failed to read packet from '" + input.filePath() + "': " + parseFFmpegError(result));
-    }
-
-    if (packet->stream_index != input.audioStreamIndex()) {
-      av_packet_unref(packet);
-      continue;
-    }
-
-    if (baseTimestamp == AV_NOPTS_VALUE) {
-      baseTimestamp = firstValidTimestamp(packet);
-    }
-
-    if (packet->pts != AV_NOPTS_VALUE) {
-      packet->pts = av_rescale_q(packet->pts - baseTimestamp, inputTimeBase, outputTimeBase) +
-          timestampOffset;
-    }
-    if (packet->dts != AV_NOPTS_VALUE) {
-      packet->dts = av_rescale_q(packet->dts - baseTimestamp, inputTimeBase, outputTimeBase) +
-          timestampOffset;
-    }
-    if (packet->duration > 0) {
-      packet->duration = av_rescale_q(packet->duration, inputTimeBase, outputTimeBase);
-    }
-    packet->pos = -1;
-    packet->stream_index = outputStream->index;
-
-    const int64_t packetEnd = packetEndTimestamp(packet, outputTimeBase);
-    if (packetEnd != AV_NOPTS_VALUE && packetEnd > segmentEndTimestamp) {
-      segmentEndTimestamp = packetEnd;
-    }
-
-    result = av_interleaved_write_frame(outputContext, packet);
-    if (result < 0) {
-      av_packet_unref(packet);
+    if (!extensionsCompatibleForRemux(inputPath, outputPath)) {
       return Err(
-          "Failed to write packet from '" + input.filePath() + "': " + parseFFmpegError(result));
+          "concatAudioFiles remux requires all input files to use the same container family as the output.");
     }
   }
 
-  if (inputStream->duration != AV_NOPTS_VALUE && inputStream->duration > 0) {
-    const int64_t streamEnd =
-        timestampOffset + av_rescale_q(inputStream->duration, inputTimeBase, outputTimeBase);
-    segmentEndTimestamp = std::max(segmentEndTimestamp, streamEnd);
-  }
-
-  timestampOffset = segmentEndTimestamp;
-  return Ok(input.filePath());
+  return remuxConcatAudioFiles(inputPaths, outputPath);
 }
 
-AudioFileConcatResult concatAudioFilesWithFFmpeg(
-    const std::vector<std::string> &inputPaths,
-    const std::string &outputPath) {
-  std::vector<InputFormatContext> inputs;
-  auto inputValidationResult = openAndValidateInputs(inputPaths, inputs);
-  if (inputValidationResult.is_err()) {
-    return inputValidationResult;
-  }
-
-  std::unique_ptr<OutputFormatContext> output;
-  AVStream *outputStream = nullptr;
-  auto outputResult = createOutput(outputPath, inputs.front(), output, &outputStream);
-  if (outputResult.is_err()) {
-    return outputResult;
-  }
-
-  int64_t timestampOffset = 0;
-  for (auto &input : inputs) {
-    auto appendResult = appendInputPackets(input, output->get(), outputStream, timestampOffset);
-    if (appendResult.is_err()) {
-      return appendResult;
-    }
-  }
-
-  int result = av_write_trailer(output->get());
-  if (result < 0) {
-    return Err("Failed to write output trailer: " + parseFFmpegError(result));
-  }
-
-  return Ok(outputPath);
-}
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
-
 } // namespace
 
 std::string normalizeFilePath(const std::string &path) {
@@ -846,17 +439,12 @@ AudioFileConcatResult concatAudioFiles(
         .map([&outputPath](const std::string &) { return outputPath; });
   }
 
-  if (!isFFmpegOutputPath(normalizedOutputPath)) {
-    return Err(
-        "concatAudioFiles supports WAV output with miniaudio and M4A/MP4 output with FFmpeg.");
+  if (isOsRemuxOutputPath(normalizedOutputPath)) {
+    return concatAudioFilesWithOsRemux(normalizedInputPaths, normalizedOutputPath)
+        .map([&outputPath](const std::string &) { return outputPath; });
   }
 
-#if RN_AUDIO_API_FFMPEG_DISABLED
-  return Err("FFmpeg is disabled, cannot concatenate M4A/MP4 audio files.");
-#else
-  return concatAudioFilesWithFFmpeg(normalizedInputPaths, normalizedOutputPath)
-      .map([&outputPath](const std::string &) { return outputPath; });
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
+  return Err("concatAudioFiles supports WAV and M4A/MP4 output.");
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioFileConcatenator.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioFileConcatenator.h
index 3d16cde57..1b4126de5 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioFileConcatenator.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/AudioFileConcatenator.h
@@ -7,12 +7,6 @@
 #include <string>
 #include <vector>
 
-#if !RN_AUDIO_API_FFMPEG_DISABLED
-struct AVDictionary;
-struct AVFormatContext;
-struct AVStream;
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
-
 namespace audioapi {
 
 using AudioFileConcatResult = Result<std::string, std::string>;
@@ -81,78 +75,6 @@ class MiniAudioEncoderGuard {
   bool initialized_{false};
 };
 
-#if !RN_AUDIO_API_FFMPEG_DISABLED
-class AVDictionaryGuard {
- public:
-  AVDictionaryGuard() = default;
-  AVDictionaryGuard(const AVDictionaryGuard &) = delete;
-  AVDictionaryGuard &operator=(const AVDictionaryGuard &) = delete;
-
-  // Releases the owned FFmpeg dictionary.
-  ~AVDictionaryGuard();
-
-  // Returns the dictionary pointer address expected by FFmpeg option APIs.
-  [[nodiscard]] AVDictionary **ptr();
-
- private:
-  AVDictionary *dictionary_{nullptr};
-};
-
-class InputFormatContext {
- public:
-  InputFormatContext() = default;
-
-  // Takes ownership of an opened FFmpeg input context and selected audio stream.
-  InputFormatContext(std::string filePath, AVFormatContext *context, int audioStreamIndex);
-
-  InputFormatContext(const InputFormatContext &) = delete;
-  InputFormatContext &operator=(const InputFormatContext &) = delete;
-
-  // Moves ownership without closing the transferred FFmpeg context.
-  InputFormatContext(InputFormatContext &&other) noexcept;
-  InputFormatContext &operator=(InputFormatContext &&other) noexcept;
-
-  // Closes the owned FFmpeg input context.
-  ~InputFormatContext();
-
-  // Returns the owned FFmpeg input context.
-  [[nodiscard]] AVFormatContext *context() const;
-
-  // Returns the selected audio stream from the input context.
-  [[nodiscard]] AVStream *audioStream() const;
-
-  // Returns the selected audio stream index from the input context.
-  [[nodiscard]] int audioStreamIndex() const;
-
-  // Returns the normalized file path represented by this input.
-  [[nodiscard]] const std::string &filePath() const;
-
- private:
-  void close();
-
-  std::string filePath_;
-  AVFormatContext *context_{nullptr};
-  int audioStreamIndex_{-1};
-};
-
-class OutputFormatContext {
- public:
-  // Takes ownership of an allocated FFmpeg output context.
-  explicit OutputFormatContext(AVFormatContext *context);
-  OutputFormatContext(const OutputFormatContext &) = delete;
-  OutputFormatContext &operator=(const OutputFormatContext &) = delete;
-
-  // Closes the output file handle and frees the owned FFmpeg output context.
-  ~OutputFormatContext();
-
-  // Returns the owned FFmpeg output context.
-  [[nodiscard]] AVFormatContext *get() const;
-
- private:
-  AVFormatContext *context_{nullptr};
-};
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
-
 // Concatenates compatible local audio files into a single output file.
 [[nodiscard]] AudioFileConcatResult concatAudioFiles(
     const std::vector<std::string> &inputPaths,
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/encoding/AudioEncoder.h b/packages/react-native-audio-api/common/cpp/audioapi/encoding/AudioEncoder.h
new file mode 100644
index 000000000..d6986a178
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/encoding/AudioEncoder.h
@@ -0,0 +1,85 @@
+#pragma once
+
+#include <audioapi/encoding/EncoderOutputSpec.h>
+#include <audioapi/encoding/StreamFormat.h>
+#include <audioapi/utils/AudioFileProperties.h>
+#include <audioapi/utils/Macros.h>
+#include <audioapi/utils/Result.hpp>
+
+#include <atomic>
+#include <cstddef>
+#include <memory>
+#include <string>
+#include <tuple>
+
+namespace audioapi {
+
+using OpenEncoderResult = Result<std::string, std::string>;
+using EncodeResult = Result<size_t, std::string>;
+using CloseEncoderResult = Result<std::tuple<double, double>, std::string>;
+
+/// Incremental audio encoder. `open`/`close` on the JS thread; `encode` on the
+/// file-writer worker. Platform implementations use system APIs only.
+class AudioEncoder {
+ public:
+  explicit AudioEncoder(const std::shared_ptr<AudioFileProperties> &fileProperties)
+      : fileProperties_(fileProperties) {}
+  virtual ~AudioEncoder() = default;
+  DELETE_COPY_AND_MOVE(AudioEncoder);
+
+  virtual OpenEncoderResult open(
+      const StreamFormat &inputFormat,
+      const EncoderOutputSpec &outputSpec,
+      size_t maxBufferSizeInFrames,
+      const std::string &filePath) = 0;
+
+  virtual EncodeResult encode(const void *data, int numFrames) = 0;
+
+  /// Flushes and closes the output file. Returns {sizeMB, durationSeconds}.
+  virtual CloseEncoderResult close() = 0;
+
+  [[nodiscard]] bool isOpen() const {
+    return isOpen_.load(std::memory_order_acquire);
+  }
+  [[nodiscard]] const std::string &getFilePath() const {
+    return filePath_;
+  }
+  [[nodiscard]] virtual size_t getFileSizeBytes() const = 0;
+
+ protected:
+  void markOpen() {
+    isOpen_.store(true, std::memory_order_release);
+  }
+  void markClosed() {
+    isOpen_.store(false, std::memory_order_release);
+  }
+
+  [[nodiscard]] double getEncodedDurationSeconds() const {
+    const double sampleRate =
+        fileProperties_ ? static_cast<double>(fileProperties_->sampleRate) : 0.0;
+    if (sampleRate <= 0.0) {
+      return 0.0;
+    }
+    return static_cast<double>(framesEncoded_.load(std::memory_order_acquire)) / sampleRate;
+  }
+
+  void resetFramesEncoded() {
+    framesEncoded_.store(0, std::memory_order_release);
+  }
+
+  void addEncodedFrames(size_t frames) {
+    framesEncoded_.fetch_add(frames, std::memory_order_acq_rel);
+  }
+
+  std::shared_ptr<AudioFileProperties> fileProperties_;
+  StreamFormat inputFormat_;
+  EncoderOutputSpec outputSpec_;
+  size_t maxBufferSizeInFrames_{0};
+  std::string filePath_;
+  std::atomic<size_t> framesEncoded_{0};
+
+ private:
+  std::atomic<bool> isOpen_{false};
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/encoding/EncoderCapabilities.cpp b/packages/react-native-audio-api/common/cpp/audioapi/encoding/EncoderCapabilities.cpp
new file mode 100644
index 000000000..481b1d00c
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/encoding/EncoderCapabilities.cpp
@@ -0,0 +1,103 @@
+#include <audioapi/encoding/EncoderCapabilities.h>
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+namespace audioapi {
+
+using Format = AudioFileProperties::Format;
+
+EncoderOutputSpec EncoderCapabilities::specForFormat(Format format) {
+  switch (format) {
+    case Format::WAV:
+      return {.container = AudioContainer::WAV, .codec = AudioCodec::PCM, .extension = "wav"};
+    case Format::CAF:
+      return {.container = AudioContainer::CAF, .codec = AudioCodec::PCM, .extension = "caf"};
+    case Format::M4A:
+      return {.container = AudioContainer::M4A, .codec = AudioCodec::AAC, .extension = "m4a"};
+    case Format::FLAC:
+      return {.container = AudioContainer::FLAC, .codec = AudioCodec::FLAC, .extension = "flac"};
+    case Format::AIFF:
+      return {.container = AudioContainer::AIFF, .codec = AudioCodec::PCM, .extension = "aiff"};
+    case Format::ALAC:
+      return {.container = AudioContainer::M4A, .codec = AudioCodec::ALAC, .extension = "m4a"};
+    case Format::OPUS_OGG:
+      return {.container = AudioContainer::OGG, .codec = AudioCodec::OPUS, .extension = "ogg"};
+    case Format::OPUS_WEBM:
+      return {.container = AudioContainer::WEBM, .codec = AudioCodec::OPUS, .extension = "webm"};
+    case Format::VORBIS_WEBM:
+      return {.container = AudioContainer::WEBM, .codec = AudioCodec::VORBIS, .extension = "webm"};
+    case Format::AMR_NB:
+      return {
+          .container = AudioContainer::THREE_GP, .codec = AudioCodec::AMR_NB, .extension = "3gp"};
+    case Format::AMR_WB:
+      return {
+          .container = AudioContainer::THREE_GP, .codec = AudioCodec::AMR_WB, .extension = "3gp"};
+    case Format::AAC_HE:
+      return {.container = AudioContainer::M4A, .codec = AudioCodec::AAC_HE, .extension = "m4a"};
+    case Format::AAC_ELD:
+      return {.container = AudioContainer::M4A, .codec = AudioCodec::AAC_ELD, .extension = "m4a"};
+    case Format::IMA4:
+      return {.container = AudioContainer::CAF, .codec = AudioCodec::IMA4, .extension = "caf"};
+    case Format::ULAW:
+      return {.container = AudioContainer::WAV, .codec = AudioCodec::ULAW, .extension = "wav"};
+    case Format::ALAW:
+      return {.container = AudioContainer::WAV, .codec = AudioCodec::ALAW, .extension = "wav"};
+    case Format::ILBC:
+      return {.container = AudioContainer::CAF, .codec = AudioCodec::ILBC, .extension = "caf"};
+  }
+  return {.container = AudioContainer::WAV, .codec = AudioCodec::PCM, .extension = "wav"};
+}
+
+std::vector<EncoderOutputSpec> EncoderCapabilities::probe() {
+#ifdef __APPLE__
+  return {
+      {.container = AudioContainer::WAV, .codec = AudioCodec::PCM, .extension = "wav"},
+      {.container = AudioContainer::CAF, .codec = AudioCodec::PCM, .extension = "caf"},
+      {.container = AudioContainer::AIFF, .codec = AudioCodec::PCM, .extension = "aiff"},
+      {.container = AudioContainer::M4A, .codec = AudioCodec::AAC, .extension = "m4a"},
+      {.container = AudioContainer::M4A, .codec = AudioCodec::AAC_HE, .extension = "m4a"},
+      {.container = AudioContainer::M4A, .codec = AudioCodec::AAC_ELD, .extension = "m4a"},
+      {.container = AudioContainer::M4A, .codec = AudioCodec::ALAC, .extension = "m4a"},
+      {.container = AudioContainer::FLAC, .codec = AudioCodec::FLAC, .extension = "flac"},
+      {.container = AudioContainer::CAF, .codec = AudioCodec::IMA4, .extension = "caf"},
+      {.container = AudioContainer::WAV, .codec = AudioCodec::ULAW, .extension = "wav"},
+      {.container = AudioContainer::WAV, .codec = AudioCodec::ALAW, .extension = "wav"},
+      {.container = AudioContainer::CAF, .codec = AudioCodec::ILBC, .extension = "caf"},
+  };
+#elif defined(__ANDROID__)
+  return {
+      {.container = AudioContainer::WAV, .codec = AudioCodec::PCM, .extension = "wav"},
+      {.container = AudioContainer::M4A, .codec = AudioCodec::AAC, .extension = "m4a"},
+      {.container = AudioContainer::FLAC, .codec = AudioCodec::FLAC, .extension = "flac"},
+      {.container = AudioContainer::OGG, .codec = AudioCodec::OPUS, .extension = "ogg"},
+      {.container = AudioContainer::WEBM, .codec = AudioCodec::OPUS, .extension = "webm"},
+      {.container = AudioContainer::WEBM, .codec = AudioCodec::VORBIS, .extension = "webm"},
+      {.container = AudioContainer::THREE_GP, .codec = AudioCodec::AMR_NB, .extension = "3gp"},
+      {.container = AudioContainer::THREE_GP, .codec = AudioCodec::AMR_WB, .extension = "3gp"},
+  };
+#else
+  return {};
+#endif
+}
+
+bool EncoderCapabilities::isSupported(AudioContainer container, AudioCodec codec) {
+  return std::ranges::any_of(probe(), [container, codec](const EncoderOutputSpec &spec) {
+    return spec.container == container && spec.codec == codec;
+  });
+}
+
+Result<EncoderOutputSpec, std::string> EncoderCapabilities::resolveOutputSpec(Format format) {
+  EncoderOutputSpec spec = specForFormat(format);
+  if (isSupported(spec.container, spec.codec)) {
+    return Result<EncoderOutputSpec, std::string>::Ok(spec);
+  }
+
+  std::string message = std::string(toString(spec.codec)) + " in " + toString(spec.container) +
+      " is not encodable via system APIs on this platform. Choose a format supported by the "
+      "device's system encoders.";
+  return Result<EncoderOutputSpec, std::string>::Err(message);
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/encoding/EncoderCapabilities.h b/packages/react-native-audio-api/common/cpp/audioapi/encoding/EncoderCapabilities.h
new file mode 100644
index 000000000..c6804eb44
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/encoding/EncoderCapabilities.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <audioapi/encoding/EncoderOutputSpec.h>
+#include <audioapi/utils/AudioFileProperties.h>
+#include <audioapi/utils/Result.hpp>
+
+#include <string>
+#include <vector>
+
+namespace audioapi {
+
+/// Declared system-API encoding capability set for the current platform.
+/// A device may still reject a format at `AudioEncoder::open()`.
+class EncoderCapabilities {
+ public:
+  static std::vector<EncoderOutputSpec> probe();
+
+  static bool isSupported(AudioContainer container, AudioCodec codec);
+
+  /// Container/codec/extension mapping for a file format (ignores platform support).
+  static EncoderOutputSpec specForFormat(AudioFileProperties::Format format);
+
+  /// Maps a format to a supported output spec, or an error if unavailable here.
+  static Result<EncoderOutputSpec, std::string> resolveOutputSpec(
+      AudioFileProperties::Format format);
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/encoding/EncoderOutputSpec.h b/packages/react-native-audio-api/common/cpp/audioapi/encoding/EncoderOutputSpec.h
new file mode 100644
index 000000000..3e7065116
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/encoding/EncoderOutputSpec.h
@@ -0,0 +1,103 @@
+#pragma once
+
+#include <string>
+
+namespace audioapi {
+
+enum class AudioCodec : uint8_t {
+  PCM,
+  AAC,
+  AAC_HE,
+  AAC_ELD,
+  AAC_HE_V2,
+  ALAC,
+  FLAC,
+  IMA4,
+  ULAW,
+  ALAW,
+  ILBC,
+  AMR_NB,
+  AMR_WB,
+  OPUS,
+  VORBIS,
+};
+
+enum class AudioContainer : uint8_t {
+  WAV,
+  CAF,
+  AIFF,
+  M4A,
+  MP4,
+  THREE_GP,
+  WEBM,
+  OGG,
+  FLAC,
+};
+
+struct EncoderOutputSpec {
+  AudioContainer container = AudioContainer::WAV;
+  AudioCodec codec = AudioCodec::PCM;
+  std::string extension = "wav";
+};
+
+inline const char *toString(AudioCodec codec) {
+  switch (codec) {
+    case AudioCodec::PCM:
+      return "PCM";
+    case AudioCodec::AAC:
+      return "AAC";
+    case AudioCodec::AAC_HE:
+      return "AAC-HE";
+    case AudioCodec::AAC_ELD:
+      return "AAC-ELD";
+    case AudioCodec::AAC_HE_V2:
+      return "AAC-HEv2";
+    case AudioCodec::ALAC:
+      return "ALAC";
+    case AudioCodec::FLAC:
+      return "FLAC";
+    case AudioCodec::IMA4:
+      return "IMA4";
+    case AudioCodec::ULAW:
+      return "u-law";
+    case AudioCodec::ALAW:
+      return "a-law";
+    case AudioCodec::ILBC:
+      return "iLBC";
+    case AudioCodec::AMR_NB:
+      return "AMR-NB";
+    case AudioCodec::AMR_WB:
+      return "AMR-WB";
+    case AudioCodec::OPUS:
+      return "Opus";
+    case AudioCodec::VORBIS:
+      return "Vorbis";
+  }
+  return "unknown";
+}
+
+inline const char *toString(AudioContainer container) {
+  switch (container) {
+    case AudioContainer::WAV:
+      return "WAV";
+    case AudioContainer::CAF:
+      return "CAF";
+    case AudioContainer::AIFF:
+      return "AIFF";
+    case AudioContainer::M4A:
+      return "M4A";
+    case AudioContainer::MP4:
+      return "MP4";
+    case AudioContainer::THREE_GP:
+      return "3GP";
+    case AudioContainer::WEBM:
+      return "WebM";
+    case AudioContainer::OGG:
+      return "OGG";
+    case AudioContainer::FLAC:
+      return "FLAC";
+  }
+  return "unknown";
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/encoding/OSEncoding.h b/packages/react-native-audio-api/common/cpp/audioapi/encoding/OSEncoding.h
new file mode 100644
index 000000000..0f5d7f51d
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/encoding/OSEncoding.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <audioapi/encoding/AudioEncoder.h>
+#include <audioapi/utils/AudioFileProperties.h>
+
+#include <memory>
+
+#if defined(__ANDROID__)
+#include <audioapi/AndroidEncoding.h>
+#define RN_AUDIO_API_HAS_OS_ENCODER 1
+namespace audioapi::os_encoder {
+using Encoder = android_encoder::AndroidEncoder;
+} // namespace audioapi::os_encoder
+#elif defined(__APPLE__) && !defined(RN_AUDIO_API_TEST)
+#include <audioapi/ios/core/utils/IOSEncoding.h>
+#define RN_AUDIO_API_HAS_OS_ENCODER 1
+namespace audioapi::os_encoder {
+using Encoder = ios_encoder::IOSEncoder;
+} // namespace audioapi::os_encoder
+#else
+#define RN_AUDIO_API_HAS_OS_ENCODER 0
+#endif
+
+namespace audioapi {
+
+inline std::shared_ptr<AudioEncoder> createOsEncoder(
+    const std::shared_ptr<AudioFileProperties> &fileProperties) {
+#if RN_AUDIO_API_HAS_OS_ENCODER
+  return std::make_shared<os_encoder::Encoder>(fileProperties);
+#else
+  (void)fileProperties;
+  return nullptr;
+#endif
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/encoding/OSRemux.h b/packages/react-native-audio-api/common/cpp/audioapi/encoding/OSRemux.h
new file mode 100644
index 000000000..20ba78e41
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/encoding/OSRemux.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <audioapi/utils/Result.hpp>
+
+#include <string>
+#include <vector>
+
+#if defined(__ANDROID__)
+#include <audioapi/AndroidRemux.h>
+#define RN_AUDIO_API_HAS_OS_REMUX 1
+#elif defined(__APPLE__) && !defined(RN_AUDIO_API_TEST)
+#include <audioapi/ios/core/utils/IOSRemux.h>
+#define RN_AUDIO_API_HAS_OS_REMUX 1
+#else
+#define RN_AUDIO_API_HAS_OS_REMUX 0
+#endif
+
+namespace audioapi {
+
+using AudioRemuxResult = Result<std::string, std::string>;
+
+inline AudioRemuxResult remuxConcatAudioFiles(
+    const std::vector<std::string> &inputPaths,
+    const std::string &outputPath) {
+#if defined(__ANDROID__)
+  return android_remux::concatAudioFiles(inputPaths, outputPath);
+#elif defined(__APPLE__) && !defined(RN_AUDIO_API_TEST)
+  return ios_remux::concatAudioFiles(inputPaths, outputPath);
+#else
+  (void)inputPaths;
+  (void)outputPath;
+  return Err("concatAudioFiles remux requires iOS or Android.");
+#endif
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/encoding/StreamFormat.h b/packages/react-native-audio-api/common/cpp/audioapi/encoding/StreamFormat.h
new file mode 100644
index 000000000..830f564b0
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/encoding/StreamFormat.h
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace audioapi {
+
+struct StreamFormat {
+  float sampleRate = 0.0f;
+  int channelCount = 0;
+  bool isInterleaved = true;
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioFileProperties.h b/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioFileProperties.h
index ccd694cfe..b33f97b19 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioFileProperties.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioFileProperties.h
@@ -20,11 +20,27 @@ class AudioFileProperties {
     Cache = 1,
   };
 
+  // Values must stay in sync with the TypeScript `FileFormat` enum in src/types.ts.
+  // Each value maps to a concrete container+codec via EncoderCapabilities.
+  // Availability is platform-dependent (see EncoderCapabilities::isSupported).
   enum class Format {
     WAV = 0,
     CAF = 1,
     M4A = 2,
     FLAC = 3,
+    AIFF = 4,
+    ALAC = 5,
+    OPUS_OGG = 6,
+    OPUS_WEBM = 7,
+    VORBIS_WEBM = 8,
+    AMR_NB = 9,
+    AMR_WB = 10,
+    AAC_HE = 11,
+    AAC_ELD = 12,
+    IMA4 = 13,
+    ULAW = 14,
+    ALAW = 15,
+    ILBC = 16,
   };
 
   enum class IOSAudioQuality {
diff --git a/packages/react-native-audio-api/common/cpp/test/src/encoding/EncoderCapabilitiesTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/encoding/EncoderCapabilitiesTest.cpp
new file mode 100644
index 000000000..87d6ca307
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/test/src/encoding/EncoderCapabilitiesTest.cpp
@@ -0,0 +1,102 @@
+#include <audioapi/encoding/EncoderCapabilities.h>
+#include <audioapi/encoding/EncoderOutputSpec.h>
+#include <audioapi/encoding/StreamFormat.h>
+#include <audioapi/utils/AudioFileProperties.h>
+#include <gtest/gtest.h>
+
+#include <cctype>
+#include <string>
+#include <vector>
+
+using namespace audioapi;
+using Format = AudioFileProperties::Format;
+
+// NOLINTBEGIN
+
+namespace {
+
+const std::vector<Format> kAllFormats = {
+    Format::WAV,
+    Format::CAF,
+    Format::M4A,
+    Format::FLAC,
+    Format::AIFF,
+    Format::ALAC,
+    Format::OPUS_OGG,
+    Format::OPUS_WEBM,
+    Format::VORBIS_WEBM,
+    Format::AMR_NB,
+    Format::AMR_WB,
+    Format::AAC_HE,
+    Format::AAC_ELD,
+    Format::IMA4,
+    Format::ULAW,
+    Format::ALAW,
+    Format::ILBC,
+};
+
+} // namespace
+
+TEST(EncoderCapabilitiesTest, SpecForFormatMapsKnownFormats) {
+  EXPECT_EQ(EncoderCapabilities::specForFormat(Format::WAV).container, AudioContainer::WAV);
+  EXPECT_EQ(EncoderCapabilities::specForFormat(Format::WAV).codec, AudioCodec::PCM);
+  EXPECT_EQ(EncoderCapabilities::specForFormat(Format::WAV).extension, "wav");
+
+  EXPECT_EQ(EncoderCapabilities::specForFormat(Format::M4A).container, AudioContainer::M4A);
+  EXPECT_EQ(EncoderCapabilities::specForFormat(Format::M4A).codec, AudioCodec::AAC);
+
+  EXPECT_EQ(EncoderCapabilities::specForFormat(Format::OPUS_WEBM).container, AudioContainer::WEBM);
+  EXPECT_EQ(EncoderCapabilities::specForFormat(Format::OPUS_WEBM).codec, AudioCodec::OPUS);
+
+  EXPECT_EQ(EncoderCapabilities::specForFormat(Format::FLAC).container, AudioContainer::FLAC);
+  EXPECT_EQ(EncoderCapabilities::specForFormat(Format::FLAC).codec, AudioCodec::FLAC);
+}
+
+TEST(EncoderCapabilitiesTest, ExtensionsAreLowercaseAndNonEmpty) {
+  for (Format format : kAllFormats) {
+    const std::string ext = EncoderCapabilities::specForFormat(format).extension;
+    ASSERT_FALSE(ext.empty());
+    for (char c : ext) {
+      EXPECT_FALSE(std::isupper(static_cast<unsigned char>(c))) << "extension: " << ext;
+    }
+  }
+}
+
+TEST(EncoderCapabilitiesTest, ResolveMatchesIsSupported) {
+  for (Format format : kAllFormats) {
+    const EncoderOutputSpec spec = EncoderCapabilities::specForFormat(format);
+    const bool supported = EncoderCapabilities::isSupported(spec.container, spec.codec);
+    auto resolved = EncoderCapabilities::resolveOutputSpec(format);
+
+    EXPECT_EQ(resolved.is_ok(), supported) << "format index: " << static_cast<int>(format);
+    if (resolved.is_ok()) {
+      EXPECT_EQ(resolved.unwrap().container, spec.container);
+      EXPECT_EQ(resolved.unwrap().codec, spec.codec);
+    }
+  }
+}
+
+TEST(EncoderCapabilitiesTest, ProbeEntriesAreSupported) {
+  for (const auto &spec : EncoderCapabilities::probe()) {
+    EXPECT_TRUE(EncoderCapabilities::isSupported(spec.container, spec.codec))
+        << toString(spec.codec) << " in " << toString(spec.container);
+  }
+}
+
+#if defined(__APPLE__)
+TEST(EncoderCapabilitiesTest, ApplePlatformSupportsCoreFormats) {
+  EXPECT_TRUE(EncoderCapabilities::isSupported(AudioContainer::WAV, AudioCodec::PCM));
+  EXPECT_TRUE(EncoderCapabilities::isSupported(AudioContainer::CAF, AudioCodec::PCM));
+  EXPECT_TRUE(EncoderCapabilities::isSupported(AudioContainer::M4A, AudioCodec::AAC));
+  EXPECT_FALSE(EncoderCapabilities::isSupported(AudioContainer::WEBM, AudioCodec::OPUS));
+}
+#elif defined(__ANDROID__)
+TEST(EncoderCapabilitiesTest, AndroidPlatformSupportsCoreFormats) {
+  EXPECT_TRUE(EncoderCapabilities::isSupported(AudioContainer::WAV, AudioCodec::PCM));
+  EXPECT_TRUE(EncoderCapabilities::isSupported(AudioContainer::M4A, AudioCodec::AAC));
+  EXPECT_TRUE(EncoderCapabilities::isSupported(AudioContainer::WEBM, AudioCodec::OPUS));
+  EXPECT_FALSE(EncoderCapabilities::isSupported(AudioContainer::CAF, AudioCodec::PCM));
+}
+#endif
+
+// NOLINTEND
diff --git a/packages/react-native-audio-api/common/cpp/test/src/utils/AudioFileConcatenatorTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/utils/AudioFileConcatenatorTest.cpp
index 02919a238..0240c0bf4 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/utils/AudioFileConcatenatorTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/utils/AudioFileConcatenatorTest.cpp
@@ -164,23 +164,14 @@ TEST(AudioFileConcatenatorTest, RejectsNonFileOutputProtocol) {
       "concatAudioFiles output path must be a local file path or file:// URL.");
 }
 
-TEST(AudioFileConcatenatorTest, ReturnsDisabledErrorForM4AWhenFFmpegIsUnavailable) {
+TEST(AudioFileConcatenatorTest, ReturnsUnavailableErrorForM4AOnDesktop) {
   auto result = concatAudioFiles({"/tmp/input.m4a"}, "/tmp/output.m4a");
 
   EXPECT_TRUE(result.is_err());
-  EXPECT_EQ(result.unwrap_err(), "FFmpeg is disabled, cannot concatenate M4A/MP4 audio files.");
+  EXPECT_EQ(result.unwrap_err(), "concatAudioFiles remux requires iOS or Android.");
 }
 
-TEST(AudioFileConcatenatorTest, RejectsFLACOutputAsUnsupported) {
-  auto result = concatAudioFiles({"/tmp/input.flac"}, "/tmp/output.flac");
-
-  EXPECT_TRUE(result.is_err());
-  EXPECT_EQ(
-      result.unwrap_err(),
-      "concatAudioFiles supports WAV output with miniaudio and M4A/MP4 output with FFmpeg.");
-}
-
-TEST(AudioFileConcatenatorTest, ConcatenatesWavFilesWithMiniaudioWhenFFmpegIsUnavailable) {
+TEST(AudioFileConcatenatorTest, ConcatenatesWavFilesWithMiniaudio) {
   const std::string inputA = testFilePath("audio-concat-a.wav");
   const std::string inputB = testFilePath("audio-concat-b.wav");
   const std::string output = testFilePath("audio-concat-output.wav");
@@ -225,13 +216,25 @@ TEST(AudioFileConcatenatorTest, RejectsWavOutputThatWouldExceedRiffLimit) {
   removeFile(output);
 }
 
-TEST(AudioFileConcatenatorTest, RejectsUnsupportedOutputFormatWhenFFmpegIsUnavailable) {
+TEST(AudioFileConcatenatorTest, RejectsUnsupportedOutputFormat) {
   auto result = concatAudioFiles({"/tmp/input.ogg"}, "/tmp/output.ogg");
 
   EXPECT_TRUE(result.is_err());
-  EXPECT_EQ(
-      result.unwrap_err(),
-      "concatAudioFiles supports WAV output with miniaudio and M4A/MP4 output with FFmpeg.");
+  EXPECT_EQ(result.unwrap_err(), "concatAudioFiles supports WAV and M4A/MP4 output.");
+}
+
+TEST(AudioFileConcatenatorTest, RejectsFLACOutputAsUnsupported) {
+  auto result = concatAudioFiles({"/tmp/input.flac"}, "/tmp/output.flac");
+
+  EXPECT_TRUE(result.is_err());
+  EXPECT_EQ(result.unwrap_err(), "concatAudioFiles supports WAV and M4A/MP4 output.");
+}
+
+TEST(AudioFileConcatenatorTest, RejectsMismatchedRemuxExtensions) {
+  auto result = concatAudioFiles({"/tmp/input.m4a"}, "/tmp/output.caf");
+
+  EXPECT_TRUE(result.is_err());
+  EXPECT_EQ(result.unwrap_err(), "concatAudioFiles supports WAV and M4A/MP4 output.");
 }
 
 // NOLINTEND
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileOptions.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileOptions.mm
index fa59558cd..3b95459bf 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileOptions.mm
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileOptions.mm
@@ -1,6 +1,7 @@
 #import <AVFoundation/AVFoundation.h>
 #import <Foundation/Foundation.h>
 
+#include <audioapi/encoding/EncoderCapabilities.h>
 #include <audioapi/ios/core/utils/FileOptions.h>
 #include <audioapi/utils/AudioFileProperties.h>
 
@@ -68,22 +69,8 @@ NSInteger getFlacCompressionLevel(const std::shared_ptr<AudioFileProperties> &pr
 /// @returns NSString representing the file extension.
 NSString *getFileExtension(const std::shared_ptr<AudioFileProperties> &properties)
 {
-  switch (properties->format) {
-    case AudioFileProperties::Format::WAV:
-      return @"wav";
-
-    case AudioFileProperties::Format::CAF:
-      return @"caf";
-
-    case AudioFileProperties::Format::M4A:
-      return @"m4a";
-
-    case AudioFileProperties::Format::FLAC:
-      return @"flac";
-
-    default:
-      return @"wav";
-  }
+  EncoderOutputSpec spec = EncoderCapabilities::specForFormat(properties->format);
+  return [NSString stringWithUTF8String:spec.extension.c_str()];
 }
 
 /// @brief Retrieves the bit depth from AudioFileProperties.
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSEncoding.h b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSEncoding.h
new file mode 100644
index 000000000..a61ec2978
--- /dev/null
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSEncoding.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <audioapi/encoding/AudioEncoder.h>
+#include <audioapi/utils/Result.hpp>
+
+#include <memory>
+#include <string>
+
+namespace audioapi::ios_encoder {
+
+struct IOSEncoderState;
+
+/// iOS system-API encoder backed by AVAudioFile + AVAudioConverter.
+class IOSEncoder : public AudioEncoder {
+ public:
+  explicit IOSEncoder(const std::shared_ptr<AudioFileProperties> &fileProperties);
+  ~IOSEncoder() override;
+
+  OpenEncoderResult open(
+      const StreamFormat &inputFormat,
+      const EncoderOutputSpec &outputSpec,
+      size_t maxBufferSizeInFrames,
+      const std::string &filePath) override;
+
+  EncodeResult encode(const void *data, int numFrames) override;
+
+  CloseEncoderResult close() override;
+
+  [[nodiscard]] size_t getFileSizeBytes() const override;
+
+ private:
+  std::unique_ptr<IOSEncoderState> impl_;
+};
+
+} // namespace audioapi::ios_encoder
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSEncoding.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSEncoding.mm
new file mode 100644
index 000000000..af30e37d7
--- /dev/null
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSEncoding.mm
@@ -0,0 +1,320 @@
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+#include <audioapi/encoding/EncoderOutputSpec.h>
+#include <audioapi/ios/core/utils/FileOptions.h>
+#include <audioapi/ios/core/utils/IOSEncoding.h>
+#include <audioapi/utils/AudioFileProperties.h>
+#include <audioapi/utils/UnitConversion.h>
+
+#include <algorithm>
+#include <limits>
+#include <string>
+
+namespace audioapi::ios_encoder {
+
+struct IOSEncoderState {
+  NSURL *fileURL = nil;
+  AVAudioFile *audioFile = nil;
+  AVAudioFormat *inputFormat = nil;
+  AVAudioConverter *converter = nil;
+  AVAudioPCMBuffer *converterInputBuffer = nil;
+  AVAudioPCMBuffer *converterOutputBuffer = nil;
+  int inputChannelCount = 0;
+};
+
+static AudioFormatID audioFormatIdForCodec(AudioCodec codec)
+{
+  switch (codec) {
+    case AudioCodec::PCM:
+      return kAudioFormatLinearPCM;
+    case AudioCodec::AAC:
+      return kAudioFormatMPEG4AAC;
+    case AudioCodec::AAC_HE:
+      return kAudioFormatMPEG4AAC_HE;
+    case AudioCodec::AAC_ELD:
+      return kAudioFormatMPEG4AAC_ELD;
+    case AudioCodec::AAC_HE_V2:
+      return kAudioFormatMPEG4AAC_HE_V2;
+    case AudioCodec::ALAC:
+      return kAudioFormatAppleLossless;
+    case AudioCodec::FLAC:
+      return kAudioFormatFLAC;
+    case AudioCodec::IMA4:
+      return kAudioFormatAppleIMA4;
+    case AudioCodec::ULAW:
+      return kAudioFormatULaw;
+    case AudioCodec::ALAW:
+      return kAudioFormatALaw;
+    case AudioCodec::ILBC:
+      return kAudioFormatiLBC;
+    default:
+      return kAudioFormatLinearPCM;
+  }
+}
+
+static NSDictionary *buildFileSettings(
+    const std::shared_ptr<AudioFileProperties> &properties,
+    const EncoderOutputSpec &outputSpec)
+{
+  AudioFormatID formatId = audioFormatIdForCodec(outputSpec.codec);
+  NSMutableDictionary *settings = [NSMutableDictionary dictionary];
+
+  settings[AVFormatIDKey] = @(formatId);
+  settings[AVSampleRateKey] = @(properties->sampleRate);
+  settings[AVNumberOfChannelsKey] = @(properties->channelCount);
+  settings[AVEncoderAudioQualityKey] = @(ios::fileoptions::getQuality(properties));
+
+  const bool isAac = formatId == kAudioFormatMPEG4AAC || formatId == kAudioFormatMPEG4AAC_HE ||
+      formatId == kAudioFormatMPEG4AAC_ELD || formatId == kAudioFormatMPEG4AAC_HE_V2;
+
+  if (isAac && properties->bitRate > 0) {
+    settings[AVEncoderBitRateKey] = @(properties->bitRate);
+  }
+
+  if (formatId == kAudioFormatLinearPCM) {
+    NSInteger bitDepth = ios::fileoptions::getBitDepth(properties);
+    settings[AVLinearPCMBitDepthKey] = @(bitDepth);
+    settings[AVLinearPCMIsFloatKey] = @(bitDepth == 32);
+    settings[AVLinearPCMIsBigEndianKey] = @(NO);
+    settings[AVLinearPCMIsNonInterleaved] = @(NO);
+  }
+
+  if (formatId == kAudioFormatFLAC) {
+    settings[@"FLACCompressionLevel"] = @(ios::fileoptions::getFlacCompressionLevel(properties));
+  }
+
+  return settings;
+}
+
+IOSEncoder::IOSEncoder(const std::shared_ptr<AudioFileProperties> &fileProperties)
+    : AudioEncoder(fileProperties), impl_(std::make_unique<IOSEncoderState>())
+{
+}
+
+IOSEncoder::~IOSEncoder()
+{
+  @autoreleasepool {
+    impl_->audioFile = nil;
+    impl_->converter = nil;
+    impl_->converterInputBuffer = nil;
+    impl_->converterOutputBuffer = nil;
+    impl_->inputFormat = nil;
+    impl_->fileURL = nil;
+  }
+}
+
+OpenEncoderResult IOSEncoder::open(
+    const StreamFormat &inputFormat,
+    const EncoderOutputSpec &outputSpec,
+    size_t maxBufferSizeInFrames,
+    const std::string &filePath)
+{
+  @autoreleasepool {
+    if (isOpen()) {
+      return OpenEncoderResult::Err("Encoder already open");
+    }
+    if (inputFormat.sampleRate <= 0 || inputFormat.channelCount <= 0) {
+      return OpenEncoderResult::Err(
+          "Invalid input format: sampleRate and channelCount must be greater than 0");
+    }
+    if (fileProperties_->sampleRate <= 0 || fileProperties_->channelCount <= 0) {
+      return OpenEncoderResult::Err(
+          "Invalid file properties: sampleRate and channelCount must be greater than 0");
+    }
+
+    inputFormat_ = inputFormat;
+    outputSpec_ = outputSpec;
+    maxBufferSizeInFrames_ = maxBufferSizeInFrames;
+    filePath_ = filePath;
+    resetFramesEncoded();
+
+    impl_->inputChannelCount = inputFormat.channelCount;
+    impl_->fileURL = [NSURL fileURLWithPath:[NSString stringWithUTF8String:filePath.c_str()]];
+
+    impl_->inputFormat =
+        [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
+                                         sampleRate:inputFormat.sampleRate
+                                           channels:(AVAudioChannelCount)inputFormat.channelCount
+                                        interleaved:inputFormat.isInterleaved ? YES : NO];
+    if (impl_->inputFormat == nil) {
+      return OpenEncoderResult::Err("Failed to build input AVAudioFormat");
+    }
+
+    NSError *error = nil;
+    NSDictionary *settings = buildFileSettings(fileProperties_, outputSpec);
+    impl_->audioFile = [[AVAudioFile alloc] initForWriting:impl_->fileURL
+                                                  settings:settings
+                                              commonFormat:AVAudioPCMFormatFloat32
+                                               interleaved:impl_->inputFormat.interleaved
+                                                     error:&error];
+    if (error != nil || impl_->audioFile == nil) {
+      return OpenEncoderResult::Err(
+          std::string("Error creating audio file for writing: ") +
+          (error != nil ? [[error debugDescription] UTF8String] : "unknown"));
+    }
+
+    impl_->converter =
+        [[AVAudioConverter alloc] initFromFormat:impl_->inputFormat
+                                        toFormat:[impl_->audioFile processingFormat]];
+    if (impl_->converter == nil) {
+      impl_->audioFile = nil;
+      return OpenEncoderResult::Err("Failed to create AVAudioConverter");
+    }
+    impl_->converter.sampleRateConverterAlgorithm = AVSampleRateConverterAlgorithm_Normal;
+    impl_->converter.sampleRateConverterQuality = AVAudioQualityMax;
+    impl_->converter.primeMethod = AVAudioConverterPrimeMethod_None;
+
+    size_t outputCapacity = std::max(
+        static_cast<float>(maxBufferSizeInFrames),
+        fileProperties_->sampleRate / inputFormat.sampleRate * maxBufferSizeInFrames);
+
+    impl_->converterInputBuffer =
+        [[AVAudioPCMBuffer alloc] initWithPCMFormat:impl_->inputFormat
+                                      frameCapacity:(AVAudioFrameCount)maxBufferSizeInFrames];
+    impl_->converterOutputBuffer =
+        [[AVAudioPCMBuffer alloc] initWithPCMFormat:[impl_->audioFile processingFormat]
+                                      frameCapacity:(AVAudioFrameCount)outputCapacity];
+
+    if (impl_->converterInputBuffer == nil || impl_->converterOutputBuffer == nil) {
+      impl_->audioFile = nil;
+      impl_->converter = nil;
+      return OpenEncoderResult::Err("Failed to allocate converter buffers");
+    }
+
+    markOpen();
+    return OpenEncoderResult::Ok(filePath_);
+  }
+}
+
+EncodeResult IOSEncoder::encode(const void *data, int numFrames)
+{
+  if (!isOpen() || impl_->audioFile == nil) {
+    return EncodeResult::Err("Encoder is not open");
+  }
+  const auto *audioBufferList = static_cast<const AudioBufferList *>(data);
+  if (audioBufferList == nullptr || numFrames <= 0) {
+    return EncodeResult::Err("Invalid encode input");
+  }
+
+  @autoreleasepool {
+    NSError *error = nil;
+
+    UInt32 buffersToCopy = std::min<UInt32>(
+        audioBufferList->mNumberBuffers,
+        impl_->converterInputBuffer.mutableAudioBufferList->mNumberBuffers);
+    for (UInt32 i = 0; i < buffersToCopy; ++i) {
+      memcpy(
+          impl_->converterInputBuffer.mutableAudioBufferList->mBuffers[i].mData,
+          audioBufferList->mBuffers[i].mData,
+          audioBufferList->mBuffers[i].mDataByteSize);
+    }
+    impl_->converterInputBuffer.frameLength = numFrames;
+
+    AVAudioFormat *fileFormat = [impl_->audioFile processingFormat];
+    const bool formatsMatch = impl_->inputFormat.sampleRate == fileFormat.sampleRate &&
+        impl_->inputFormat.channelCount == fileFormat.channelCount &&
+        impl_->inputFormat.isInterleaved == fileFormat.isInterleaved;
+
+    if (formatsMatch) {
+      [impl_->audioFile writeFromBuffer:impl_->converterInputBuffer error:&error];
+      if (error != nil) {
+        return EncodeResult::Err(
+            std::string("Error writing audio data to file: ") +
+            [[error debugDescription] UTF8String]);
+      }
+      addEncodedFrames(static_cast<size_t>(numFrames));
+      return EncodeResult::Ok(static_cast<size_t>(numFrames));
+    }
+
+    __block BOOL handedOff = NO;
+    AVAudioConverterInputBlock inputBlock = ^AVAudioBuffer *_Nullable(
+        AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
+    {
+      if (handedOff) {
+        *outStatus = AVAudioConverterInputStatus_NoDataNow;
+        return nil;
+      }
+      handedOff = YES;
+      *outStatus = AVAudioConverterInputStatus_HaveData;
+      return impl_->converterInputBuffer;
+    };
+
+    [impl_->converter convertToBuffer:impl_->converterOutputBuffer
+                                error:&error
+                   withInputFromBlock:inputBlock];
+    if (error != nil) {
+      return EncodeResult::Err(
+          std::string("Error during audio conversion: ") + [[error debugDescription] UTF8String]);
+    }
+
+    AVAudioFrameCount producedFrames = impl_->converterOutputBuffer.frameLength;
+    if (producedFrames == 0) {
+      return EncodeResult::Ok(static_cast<size_t>(numFrames));
+    }
+
+    [impl_->audioFile writeFromBuffer:impl_->converterOutputBuffer error:&error];
+    if (error != nil) {
+      return EncodeResult::Err(
+          std::string("Error writing audio data to file: ") +
+          [[error debugDescription] UTF8String]);
+    }
+
+    addEncodedFrames(static_cast<size_t>(producedFrames));
+    return EncodeResult::Ok(static_cast<size_t>(numFrames));
+  }
+}
+
+CloseEncoderResult IOSEncoder::close()
+{
+  @autoreleasepool {
+    if (!isOpen() || impl_->audioFile == nil) {
+      return CloseEncoderResult::Err("Encoder is not open");
+    }
+    markClosed();
+
+    NSURL *fileURL = impl_->fileURL;
+
+    // AVAudioFile finalizes the file on deallocation.
+    impl_->audioFile = nil;
+    impl_->converter = nil;
+    impl_->converterInputBuffer = nil;
+    impl_->converterOutputBuffer = nil;
+    impl_->inputFormat = nil;
+
+    double durationSeconds = CMTimeGetSeconds([[AVURLAsset URLAssetWithURL:fileURL
+                                                                   options:nil] duration]);
+
+    NSError *error = nil;
+    double fileSizeMB = static_cast<double>([[[NSFileManager defaultManager]
+                            attributesOfItemAtPath:[fileURL path]
+                                             error:&error] fileSize]) /
+        MB_IN_BYTES;
+    if (error != nil) {
+      fileSizeMB = 0.0;
+    }
+
+    impl_->fileURL = nil;
+    resetFramesEncoded();
+
+    return CloseEncoderResult::Ok(std::make_tuple(fileSizeMB, durationSeconds));
+  }
+}
+
+size_t IOSEncoder::getFileSizeBytes() const
+{
+  @autoreleasepool {
+    if (impl_->fileURL == nil) {
+      return 0;
+    }
+    NSError *error = nil;
+    NSDictionary *attrs =
+        [[NSFileManager defaultManager] attributesOfItemAtPath:[impl_->fileURL path] error:&error];
+    if (error != nil || attrs == nil) {
+      return 0;
+    }
+    return static_cast<size_t>([attrs fileSize]);
+  }
+}
+
+} // namespace audioapi::ios_encoder
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSFileWriter.h b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSFileWriter.h
index 572fd8460..18b81555c 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSFileWriter.h
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSFileWriter.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <audioapi/core/utils/AudioFileWriter.h>
+#include <audioapi/encoding/AudioEncoder.h>
 #include <audioapi/ios/core/utils/OwnedAudioBufferList.h>
 #include <audioapi/utils/Result.hpp>
 #include <audioapi/utils/SlotFreeList.hpp>
@@ -15,9 +16,7 @@
 #ifndef __OBJC__ // when compiled as C++
 typedef struct objc_object NSURL;
 typedef struct objc_object NSString;
-typedef struct objc_object AVAudioFile;
 typedef struct objc_object AVAudioFormat;
-typedef struct objc_object AVAudioConverter;
 #endif // __OBJC__
 
 struct WriterData {
@@ -30,6 +29,7 @@ namespace audioapi {
 class AudioFileProperties;
 class AudioEventHandlerRegistry;
 
+/// iOS recorder file writer; encodes via AudioEncoder on a worker thread.
 class IOSFileWriter : public AudioFileWriter {
  public:
   IOSFileWriter(
@@ -50,16 +50,10 @@ class IOSFileWriter : public AudioFileWriter {
   size_t getFileSizeBytes() const override;
 
  protected:
-  size_t converterInputBufferSize_;
-  size_t converterOutputBufferSize_;
-
-  AVAudioFile *audioFile_;
   AVAudioFormat *bufferFormat_;
-  AVAudioConverter *converter_;
-  NSURL *fileURL_;
-
-  AVAudioPCMBuffer *converterInputBuffer_;
-  AVAudioPCMBuffer *converterOutputBuffer_;
+  std::string filePath_;
+  double inputSampleRate_{0.0};
+  std::unique_ptr<AudioEncoder> encoder_;
 
  private:
   using FreeList = slots::SlotFreeList<FILE_WRITER_POOL_SIZE>;
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSFileWriter.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSFileWriter.mm
index 1b6662279..8e02e07b2 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSFileWriter.mm
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSFileWriter.mm
@@ -1,13 +1,15 @@
 #import <AVFoundation/AVFoundation.h>
 #import <Foundation/Foundation.h>
 
+#include <audioapi/encoding/EncoderCapabilities.h>
+#include <audioapi/encoding/StreamFormat.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/ios/core/utils/FileOptions.h>
+#include <audioapi/ios/core/utils/IOSEncoding.h>
 #include <audioapi/ios/core/utils/IOSFileWriter.h>
 #include <audioapi/ios/core/utils/OwnedAudioBufferList.h>
 #include <audioapi/utils/AudioFileProperties.h>
 #include <audioapi/utils/Result.hpp>
-#include <audioapi/utils/UnitConversion.h>
 #include <utility>
 
 namespace audioapi {
@@ -31,86 +33,63 @@
     inputBufferPool_.clear();
     inputBufferBytesPerBuffer_ = 0;
 
-    fileURL_ = nil;
-    audioFile_ = nil;
-    converter_ = nil;
+    encoder_.reset();
     bufferFormat_ = nil;
   }
 }
 
-/// @brief Opens an audio file for writing with the specified buffer format and maximum input buffer length.
-/// This method initializes the AVAudioFile and AVAudioConverter for audio data writing and conversion.
+/// @brief Opens an audio file for writing with the specified buffer format and
+/// maximum input buffer length. Resolves the output path, creates the encoder
+/// and preallocates the audio-thread → worker buffer pool.
 /// This method should be called from the JS thread only.
-/// @param bufferFormat The audio format of the input buffer.
-/// @param maxInputBufferLength The maximum length of the input buffer in frames.
-/// @returns An OpenFileResult indicating success with the file path or an error message.
 OpenFileResult IOSFileWriter::openFile(
     AVAudioFormat *bufferFormat,
     size_t maxInputBufferLength,
     const std::string &fileNameOverride)
 {
   @autoreleasepool {
-    if (audioFile_ != nil) {
+    if (encoder_ != nullptr) {
       return OpenFileResult::Err("file already open");
     }
 
     framesWritten_.store(0, std::memory_order_release);
     bufferFormat_ = bufferFormat;
-
-    NSError *error = nil;
-    NSDictionary *settings = ios::fileoptions::getFileSettings(fileProperties_);
-    fileURL_ = ios::fileoptions::getFileURL(fileProperties_, fileNameOverride);
+    inputSampleRate_ = bufferFormat.sampleRate;
 
     if (fileProperties_->sampleRate == 0 || fileProperties_->channelCount == 0) {
       return OpenFileResult::Err(
           "Invalid file properties: sampleRate and channelCount must be greater than 0");
     }
-
     if (bufferFormat.sampleRate == 0 || bufferFormat.channelCount == 0) {
       return OpenFileResult::Err(
           "Invalid input format: sampleRate and channelCount must be greater than 0");
     }
 
-    audioFile_ = [[AVAudioFile alloc] initForWriting:fileURL_
-                                            settings:settings
-                                        commonFormat:AVAudioPCMFormatFloat32
-                                         interleaved:bufferFormat.interleaved
-                                               error:&error];
-
-    if (error != nil) {
-      return OpenFileResult::Err(
-          std::string("Error creating audio file for writing: ") +
-          [[error debugDescription] UTF8String]);
+    auto specResult = EncoderCapabilities::resolveOutputSpec(fileProperties_->format);
+    if (specResult.is_err()) {
+      return OpenFileResult::Err(specResult.unwrap_err());
     }
+    EncoderOutputSpec outputSpec = specResult.unwrap();
+
+    NSURL *fileURL = ios::fileoptions::getFileURL(fileProperties_, fileNameOverride);
+    filePath_ = [[fileURL path] UTF8String];
+
+    StreamFormat inputFormat{
+        .sampleRate = static_cast<float>(bufferFormat.sampleRate),
+        .channelCount = static_cast<int>(bufferFormat.channelCount),
+        .isInterleaved = bufferFormat.isInterleaved != NO,
+    };
 
-    converter_ = [[AVAudioConverter alloc] initFromFormat:bufferFormat
-                                                 toFormat:[audioFile_ processingFormat]];
-    converter_.sampleRateConverterAlgorithm = AVSampleRateConverterAlgorithm_Normal;
-    converter_.sampleRateConverterQuality = AVAudioQualityMax;
-    converter_.primeMethod = AVAudioConverterPrimeMethod_None;
-
-    converterInputBufferSize_ = maxInputBufferLength;
-    converterOutputBufferSize_ = std::max(
-        (double)maxInputBufferLength,
-        fileProperties_->sampleRate / bufferFormat.sampleRate * maxInputBufferLength);
-
-    converterInputBuffer_ =
-        [[AVAudioPCMBuffer alloc] initWithPCMFormat:bufferFormat
-                                      frameCapacity:(AVAudioFrameCount)maxInputBufferLength];
-    converterOutputBuffer_ =
-        [[AVAudioPCMBuffer alloc] initWithPCMFormat:[audioFile_ processingFormat]
-                                      frameCapacity:(AVAudioFrameCount)converterOutputBufferSize_];
-
-    if (converterInputBuffer_ == nil || converterOutputBuffer_ == nil || audioFile_ == nil ||
-        converter_ == nil) {
-      rollbackFailedOpen();
-      return OpenFileResult::Err("Error creating converter buffers");
+    auto encoder = std::make_unique<ios_encoder::IOSEncoder>(fileProperties_);
+    auto openResult = encoder->open(inputFormat, outputSpec, maxInputBufferLength, filePath_);
+    if (openResult.is_err()) {
+      return OpenFileResult::Err(openResult.unwrap_err());
     }
+    encoder_ = std::move(encoder);
 
     auto offloaderLambda = [this](WriterData data) {
       taskOffloaderFunction(data);
     };
-
     offloader_ = std::make_unique<task_offloader::TaskOffloader<
         WriterData,
         FILE_WRITER_SPSC_OVERFLOW_STRATEGY,
@@ -120,8 +99,8 @@
     inputBufferPool_.reserve(FILE_WRITER_POOL_SIZE);
     auto bufferCount =
         static_cast<UInt32>(bufferFormat_.isInterleaved ? 1 : bufferFormat_.channelCount);
-    auto bytesPerBuffer = static_cast<UInt32>(
-        converterInputBufferSize_ * bufferFormat_.streamDescription->mBytesPerFrame);
+    auto bytesPerBuffer =
+        static_cast<UInt32>(maxInputBufferLength * bufferFormat_.streamDescription->mBytesPerFrame);
     inputBufferBytesPerBuffer_ = bytesPerBuffer;
     for (size_t i = 0; i < FILE_WRITER_POOL_SIZE; ++i) {
       OwnedAudioBufferListPtr buffer(allocateOwnedAudioBufferList(bufferCount, bytesPerBuffer));
@@ -136,7 +115,7 @@
     freeSlots_->seed();
 
     isFileOpen_.store(true, std::memory_order_release);
-    return OpenFileResult::Ok([[fileURL_ path] UTF8String]);
+    return OpenFileResult::Ok(filePath_);
   }
 }
 
@@ -147,69 +126,50 @@
   inputBufferPool_.clear();
   inputBufferBytesPerBuffer_ = 0;
 
-  audioFile_ = nil;
-  converter_ = nil;
-  converterInputBuffer_ = nil;
-  converterOutputBuffer_ = nil;
-  bufferFormat_ = nil;
-
-  if (fileURL_ != nil) {
-    [[NSFileManager defaultManager] removeItemAtURL:fileURL_ error:nil];
-    fileURL_ = nil;
+  if (encoder_ != nullptr) {
+    encoder_->close();
+    encoder_.reset();
   }
+  bufferFormat_ = nil;
 
   framesWritten_.store(0, std::memory_order_release);
   isFileOpen_.store(false, std::memory_order_release);
 }
 
 /// @brief Closes the currently open audio file and finalizes writing.
-/// This method retrieves the final file duration and size before closing.
 /// This method should be called from the JS thread only.
-/// @returns A CloseFileResult indicating success with file duration and size or an error message.
 CloseFileResult IOSFileWriter::closeFile()
 {
   @autoreleasepool {
-    NSError *error;
-    std::string filePath = [[fileURL_ path] UTF8String];
-
-    if (!isFileOpen() || audioFile_ == nil) {
-      return CloseFileResult::Err("file is not open: " + filePath);
+    if (!isFileOpen() || encoder_ == nullptr) {
+      return CloseFileResult::Err("file is not open: " + filePath_);
     }
 
     isFileOpen_.store(false, std::memory_order_release);
 
+    // Drain the worker queue before finalizing the encoder below.
     offloader_.reset();
     freeSlots_.reset();
     inputBufferPool_.clear();
     inputBufferBytesPerBuffer_ = 0;
 
-    // AVAudioFile automatically finalizes the file when deallocated
-    audioFile_ = nil;
-
-    double fileDuration = CMTimeGetSeconds([[AVURLAsset URLAssetWithURL:fileURL_
-                                                                options:nil] duration]);
-    double fileSizeBytesMb = static_cast<double>([[[NSFileManager defaultManager]
-                                 attributesOfItemAtPath:fileURL_.path
-                                                  error:&error] fileSize]) /
-        MB_IN_BYTES;
-
-    if (error != nil) {
-      NSLog(@"⚠️ closeFile: error while retrieving file size");
-      fileSizeBytesMb = 0;
-    }
-
-    fileURL_ = nil;
+    auto closeResult = encoder_->close();
+    encoder_.reset();
+    bufferFormat_ = nil;
     framesWritten_.store(0, std::memory_order_release);
 
-    return CloseFileResult::Ok(std::make_tuple(fileSizeBytesMb, fileDuration));
+    if (closeResult.is_err()) {
+      return CloseFileResult::Err(closeResult.unwrap_err());
+    }
+    return CloseFileResult::Ok(closeResult.unwrap());
   }
 }
 
-/// @brief Writes audio data to the open audio file, performing format conversion if necessary.
-/// This method should be called from the audio thread.
+/// @brief Copies audio data into an owned buffer and hands it to the worker
+/// thread. This method is called on the audio thread.
 void IOSFileWriter::writeAudioData(const AudioBufferList *audioBufferList, int numFrames)
 {
-  if (!isFileOpen() || audioFile_ == nil) {
+  if (!isFileOpen() || encoder_ == nullptr) {
     return;
   }
   if (offloader_ == nullptr || freeSlots_ == nullptr || inputBufferPool_.empty() ||
@@ -233,9 +193,6 @@
   }
 
   WriterData writerData{.slot = slot.value(), .numFrames = numFrames};
-  // send() cannot block here: we hold a slot from a pool of FILE_WRITER_POOL_SIZE,
-  // and the channel is sized one larger,
-  // so the ring always has room while any slot is in flight.
   offloader_->getSender()->send(writerData);
 }
 
@@ -245,107 +202,42 @@
   if (slot == FreeList::kSentinel) {
     return;
   }
-  if (slot >= inputBufferPool_.size() || freeSlots_ == nullptr) {
+  if (slot >= inputBufferPool_.size() || freeSlots_ == nullptr || encoder_ == nullptr) {
     return;
   }
   auto *audioBufferList = inputBufferPool_[slot].get();
-  @autoreleasepool {
-    NSError *error = nil;
-
-    for (size_t i = 0; i < bufferFormat_.channelCount; ++i) {
-      memcpy(
-          converterInputBuffer_.mutableAudioBufferList->mBuffers[i].mData,
-          audioBufferList->mBuffers[i].mData,
-          audioBufferList->mBuffers[i].mDataByteSize);
-    }
-
-    freeSlots_->release(slot);
-    converterInputBuffer_.frameLength = numFrames;
-
-    AVAudioFormat *fileFormat = [audioFile_ processingFormat];
 
-    if (bufferFormat_.sampleRate == fileFormat.sampleRate &&
-        bufferFormat_.channelCount == fileFormat.channelCount &&
-        bufferFormat_.isInterleaved == fileFormat.isInterleaved) {
-      [audioFile_ writeFromBuffer:converterInputBuffer_ error:&error];
+  auto result = encoder_->encode(audioBufferList, numFrames);
+  freeSlots_->release(slot);
 
-      if (error != nil) {
-        invokeOnErrorCallback(
-            std::string("Error writing audio data to file, native error: ") +
-            [[error debugDescription] UTF8String]);
-        return;
-      }
-
-      framesWritten_.fetch_add(numFrames, std::memory_order_acq_rel);
-      return;
-    }
-
-    __block BOOL handedOff = false;
-    AVAudioConverterInputBlock inputBlock = ^AVAudioBuffer *_Nullable(
-        AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
-    {
-      if (handedOff) {
-        *outStatus = AVAudioConverterInputStatus_NoDataNow;
-        return nil;
-      }
-
-      handedOff = true;
-      *outStatus = AVAudioConverterInputStatus_HaveData;
-      return converterInputBuffer_;
-    };
-
-    [converter_ convertToBuffer:converterOutputBuffer_ error:&error withInputFromBlock:inputBlock];
-
-    if (error != nil) {
-      invokeOnErrorCallback(
-          std::string("Error during audio conversion, native error: ") +
-          [[error debugDescription] UTF8String]);
-      return;
-    }
-
-    AVAudioFrameCount producedFrames = converterOutputBuffer_.frameLength;
-    if (producedFrames == 0) {
-      return;
-    }
-
-    [audioFile_ writeFromBuffer:converterOutputBuffer_ error:&error];
-
-    if (error != nil) {
-      invokeOnErrorCallback(
-          std::string("Error writing audio data to file, native error: ") +
-          [[error debugDescription] UTF8String]);
-      return;
-    }
-
-    framesWritten_.fetch_add(producedFrames, std::memory_order_acq_rel);
+  if (result.is_err()) {
+    invokeOnErrorCallback(result.unwrap_err());
+    return;
   }
+
+  framesWritten_.fetch_add(numFrames, std::memory_order_acq_rel);
 }
 
 double IOSFileWriter::getCurrentDuration() const
 {
-  return static_cast<double>(framesWritten_.load(std::memory_order_acquire)) /
-      fileProperties_->sampleRate;
+  double sampleRate = inputSampleRate_ > 0 ? inputSampleRate_ : fileProperties_->sampleRate;
+  if (sampleRate <= 0) {
+    return 0.0;
+  }
+  return static_cast<double>(framesWritten_.load(std::memory_order_acquire)) / sampleRate;
 }
 
 std::string IOSFileWriter::getFilePath() const
 {
-  return [[fileURL_ path] UTF8String];
+  return filePath_;
 }
 
 size_t IOSFileWriter::getFileSizeBytes() const
 {
-  @autoreleasepool {
-    if (fileURL_ == nil) {
-      return 0;
-    }
-    NSError *error = nil;
-    NSDictionary *attrs = [[NSFileManager defaultManager] attributesOfItemAtPath:[fileURL_ path]
-                                                                           error:&error];
-    if (error != nil || attrs == nil) {
-      return 0;
-    }
-    return static_cast<size_t>([attrs fileSize]);
+  if (encoder_ == nullptr) {
+    return 0;
   }
+  return encoder_->getFileSizeBytes();
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSRemux.h b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSRemux.h
new file mode 100644
index 000000000..b61e94dc0
--- /dev/null
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSRemux.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <audioapi/utils/Result.hpp>
+
+#include <string>
+#include <vector>
+
+namespace audioapi::ios_remux {
+
+using IOSRemuxResult = Result<std::string, std::string>;
+
+/// Joins AAC-in-M4A/MP4 via AVMutableComposition (re-encodes; passthrough fails
+/// on rotated recorder segments).
+[[nodiscard]] IOSRemuxResult concatAudioFiles(
+    const std::vector<std::string> &inputPaths,
+    const std::string &outputPath);
+
+} // namespace audioapi::ios_remux
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSRemux.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSRemux.mm
new file mode 100644
index 000000000..f8d6c441a
--- /dev/null
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/IOSRemux.mm
@@ -0,0 +1,210 @@
+#import <AVFoundation/AVFoundation.h>
+#import <CoreMedia/CoreMedia.h>
+#import <Foundation/Foundation.h>
+
+#include <audioapi/ios/core/utils/IOSRemux.h>
+
+#include <cctype>
+#include <string>
+
+namespace audioapi::ios_remux {
+namespace {
+
+struct AudioFormatFingerprint {
+  AudioFormatID formatId{0};
+  double sampleRate{0.0};
+  UInt32 channelCount{0};
+};
+
+[[nodiscard]] NSString *nsStringFromPath(const std::string &path)
+{
+  return [[NSString alloc] initWithBytes:path.data()
+                                  length:path.size()
+                                encoding:NSUTF8StringEncoding];
+}
+
+[[nodiscard]] std::string lowercaseExtension(const std::string &path)
+{
+  const auto dot = path.find_last_of('.');
+  if (dot == std::string::npos) {
+    return "";
+  }
+  std::string extension = path.substr(dot + 1);
+  for (char &c : extension) {
+    c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+  }
+  return extension;
+}
+
+[[nodiscard]] bool isAacFormatId(AudioFormatID formatId)
+{
+  return formatId == kAudioFormatMPEG4AAC || formatId == kAudioFormatMPEG4AAC_HE ||
+      formatId == kAudioFormatMPEG4AAC_HE_V2 || formatId == kAudioFormatMPEG4AAC_ELD;
+}
+
+[[nodiscard]] AVFileType fileTypeForExtension(const std::string &extension)
+{
+  if (extension == "mp4") {
+    return AVFileTypeMPEG4;
+  }
+  return AVFileTypeAppleM4A;
+}
+
+[[nodiscard]] IOSRemuxResult
+extractFingerprint(AVAssetTrack *track, AudioFormatFingerprint &out, const std::string &filePath)
+{
+  NSArray *descriptions = track.formatDescriptions;
+  if (descriptions == nil || descriptions.count == 0) {
+    return Err("Input file '" + filePath + "' is missing audio format descriptions.");
+  }
+
+  const auto *formatDescription = (__bridge CMAudioFormatDescriptionRef)descriptions[0];
+  const AudioStreamBasicDescription *asbd =
+      CMAudioFormatDescriptionGetStreamBasicDescription(formatDescription);
+  if (asbd == nullptr) {
+    return Err("Input file '" + filePath + "' is missing audio stream basic description.");
+  }
+
+  out.formatId = asbd->mFormatID;
+  out.sampleRate = asbd->mSampleRate;
+  out.channelCount = asbd->mChannelsPerFrame;
+  return Ok(filePath);
+}
+
+[[nodiscard]] IOSRemuxResult validateCompatible(
+    const AudioFormatFingerprint &candidate,
+    const AudioFormatFingerprint &reference,
+    const std::string &filePath)
+{
+  if (candidate.formatId != reference.formatId) {
+    return Err("Input file '" + filePath + "' uses a different audio codec.");
+  }
+  if (candidate.sampleRate != reference.sampleRate) {
+    return Err("Input file '" + filePath + "' uses a different sample rate.");
+  }
+  if (candidate.channelCount != reference.channelCount) {
+    return Err("Input file '" + filePath + "' uses a different channel layout.");
+  }
+  return Ok(filePath);
+}
+
+} // namespace
+
+IOSRemuxResult concatAudioFiles(
+    const std::vector<std::string> &inputPaths,
+    const std::string &outputPath)
+{
+  @autoreleasepool {
+    if (inputPaths.empty()) {
+      return Err("concatAudioFiles requires at least one input path.");
+    }
+
+    NSDictionary *assetOptions = @{AVURLAssetPreferPreciseDurationAndTimingKey : @YES};
+    AVMutableComposition *composition = [AVMutableComposition composition];
+    AVMutableCompositionTrack *compositionTrack =
+        [composition addMutableTrackWithMediaType:AVMediaTypeAudio
+                                 preferredTrackID:kCMPersistentTrackID_Invalid];
+    if (compositionTrack == nil) {
+      return Err("Failed to create AVMutableComposition audio track.");
+    }
+
+    AudioFormatFingerprint referenceFingerprint;
+    bool hasReference = false;
+    CMTime cursor = kCMTimeZero;
+
+    for (const auto &path : inputPaths) {
+      NSURL *url = [NSURL fileURLWithPath:nsStringFromPath(path)];
+      if (url == nil) {
+        return Err("Failed to create file URL for '" + path + "'.");
+      }
+
+      AVURLAsset *asset = [AVURLAsset URLAssetWithURL:url options:assetOptions];
+      NSArray<AVAssetTrack *> *audioTracks = [asset tracksWithMediaType:AVMediaTypeAudio];
+      if (audioTracks.count == 0) {
+        return Err("Input file '" + path + "' does not contain an audio stream.");
+      }
+
+      AVAssetTrack *audioTrack = audioTracks.firstObject;
+      AudioFormatFingerprint fingerprint;
+      auto fingerprintResult = extractFingerprint(audioTrack, fingerprint, path);
+      if (fingerprintResult.is_err()) {
+        return fingerprintResult;
+      }
+
+      if (!isAacFormatId(fingerprint.formatId)) {
+        return Err(
+            "Input file '" + path + "' is not AAC-in-M4A/MP4; only AAC concat is supported.");
+      }
+
+      if (!hasReference) {
+        referenceFingerprint = fingerprint;
+        hasReference = true;
+      } else {
+        auto validation = validateCompatible(fingerprint, referenceFingerprint, path);
+        if (validation.is_err()) {
+          return validation;
+        }
+      }
+
+      NSError *insertError = nil;
+      const CMTimeRange timeRange = CMTimeRangeMake(kCMTimeZero, asset.duration);
+      const BOOL inserted = [compositionTrack insertTimeRange:timeRange
+                                                      ofTrack:audioTrack
+                                                       atTime:cursor
+                                                        error:&insertError];
+      if (!inserted) {
+        NSString *message = insertError.localizedDescription ?: @"unknown error";
+        return Err(
+            "Failed to insert '" + path + "' into composition: " + std::string(message.UTF8String));
+      }
+
+      cursor = CMTimeAdd(cursor, asset.duration);
+    }
+
+    NSURL *outputURL = [NSURL fileURLWithPath:nsStringFromPath(outputPath)];
+    if (outputURL == nil) {
+      return Err("Failed to create output file URL for '" + outputPath + "'.");
+    }
+    [[NSFileManager defaultManager] removeItemAtURL:outputURL error:nil];
+
+    // AAC-in-M4A is re-encoded once through AVAssetExportPresetAppleM4A. Passthrough
+    // export and raw compressed-sample remux both fail on rotated recorder segments
+    // (different format descriptions / priming), so this is the reliable path. It
+    // stays FFmpeg-free — encoding is done by AVFoundation.
+    AVAssetExportSession *exporter =
+        [[AVAssetExportSession alloc] initWithAsset:composition
+                                         presetName:AVAssetExportPresetAppleM4A];
+    if (exporter == nil) {
+      return Err("Failed to create AVAssetExportSession for AAC concat.");
+    }
+
+    exporter.outputURL = outputURL;
+    exporter.outputFileType = fileTypeForExtension(lowercaseExtension(outputPath));
+
+    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+    __block AVAssetExportSessionStatus exportStatus = AVAssetExportSessionStatusUnknown;
+    __block NSString *exportErrorMessage = nil;
+
+    [exporter exportAsynchronouslyWithCompletionHandler:^{
+      exportStatus = exporter.status;
+      if (exporter.error != nil) {
+        exportErrorMessage = exporter.error.localizedDescription;
+      }
+      dispatch_semaphore_signal(semaphore);
+    }];
+
+    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
+
+    if (exportStatus != AVAssetExportSessionStatusCompleted) {
+      std::string message = "Failed to export concatenated audio";
+      if (exportErrorMessage != nil) {
+        message += ": " + std::string(exportErrorMessage.UTF8String);
+      }
+      return Err(message);
+    }
+
+    return Ok(outputPath);
+  }
+}
+
+} // namespace audioapi::ios_remux
diff --git a/packages/react-native-audio-api/scripts/check-audio-file-properties-enum-sync.sh b/packages/react-native-audio-api/scripts/check-audio-file-properties-enum-sync.sh
new file mode 100755
index 000000000..6acf573f8
--- /dev/null
+++ b/packages/react-native-audio-api/scripts/check-audio-file-properties-enum-sync.sh
@@ -0,0 +1,125 @@
+#!/bin/bash
+
+# Verify AudioFileProperties enums stay in sync with TypeScript counterparts.
+# Numeric values cross the JSI boundary via static_cast, so order + assigned
+# integers must match even when naming style differs (WAV vs Wav).
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PACKAGE_DIR="$(dirname "$SCRIPT_DIR")"
+
+CPP_FILE="$PACKAGE_DIR/common/cpp/audioapi/utils/AudioFileProperties.h"
+TS_FILE="$PACKAGE_DIR/src/types.ts"
+
+FAILED=0
+
+if [ ! -f "$CPP_FILE" ]; then
+  echo "❌ Error: C++ file not found: $CPP_FILE"
+  exit 1
+fi
+
+if [ ! -f "$TS_FILE" ]; then
+  echo "❌ Error: TypeScript file not found: $TS_FILE"
+  exit 1
+fi
+
+# Extract "Name=Value" lines from a C++ nested enum class.
+extract_cpp_enum() {
+  local enum_name="$1"
+  sed -n "/enum class ${enum_name} {/,/};/p" "$CPP_FILE" |
+    grep -E '^\s*[A-Za-z_][A-Za-z0-9_]*[[:space:]]*=' |
+    sed -E 's/^[[:space:]]*([A-Za-z_][A-Za-z0-9_]*)[[:space:]]*=[[:space:]]*([0-9]+).*/\1=\2/' |
+    sed 's/[[:space:]]*$//'
+}
+
+# Extract "Name=Value" lines from a TypeScript export enum.
+extract_ts_enum() {
+  local enum_name="$1"
+  sed -n "/export enum ${enum_name} {/,/^}/p" "$TS_FILE" |
+    grep -E '^\s*[A-Za-z_][A-Za-z0-9_]*[[:space:]]*=' |
+    sed -E 's/^[[:space:]]*([A-Za-z_][A-Za-z0-9_]*)[[:space:]]*=[[:space:]]*([0-9]+).*/\1=\2/' |
+    sed 's/[[:space:]]*$//'
+}
+
+# Compare numeric values in declaration order (names may differ in style).
+compare_enum_values() {
+  local label="$1"
+  local cpp_pairs="$2"
+  local ts_pairs="$3"
+
+  local cpp_values ts_values
+  cpp_values=$(echo "$cpp_pairs" | sed 's/.*=//')
+  ts_values=$(echo "$ts_pairs" | sed 's/.*=//')
+
+  if [ "$cpp_values" = "$ts_values" ]; then
+    local count
+    count=$(echo "$cpp_values" | grep -c . || true)
+    echo "✅ ${label} values are in sync (${count} entries)."
+  else
+    echo "❌ ${label} values are NOT in sync!"
+    echo ""
+    echo "C++ ($CPP_FILE):"
+    echo "$cpp_pairs" | nl
+    echo ""
+    echo "TypeScript ($TS_FILE):"
+    echo "$ts_pairs" | nl
+    echo ""
+    echo "Value differences:"
+    diff <(echo "$cpp_values") <(echo "$ts_values") || true
+    echo ""
+    FAILED=1
+  fi
+}
+
+# Compare Name=Value pairs when both sides use the same identifiers.
+compare_enum_pairs() {
+  local label="$1"
+  local cpp_pairs="$2"
+  local ts_pairs="$3"
+
+  if [ "$cpp_pairs" = "$ts_pairs" ]; then
+    local count
+    count=$(echo "$cpp_pairs" | grep -c . || true)
+    echo "✅ ${label} enums are in sync (${count} entries)."
+  else
+    echo "❌ ${label} enums are NOT in sync!"
+    echo ""
+    echo "C++ ($CPP_FILE):"
+    echo "$cpp_pairs" | nl
+    echo ""
+    echo "TypeScript ($TS_FILE):"
+    echo "$ts_pairs" | nl
+    echo ""
+    echo "Differences:"
+    diff <(echo "$cpp_pairs") <(echo "$ts_pairs") || true
+    echo ""
+    FAILED=1
+  fi
+}
+
+compare_enum_values \
+  "FileFormat / AudioFileProperties::Format" \
+  "$(extract_cpp_enum Format)" \
+  "$(extract_ts_enum FileFormat)"
+
+compare_enum_pairs \
+  "FileDirectory" \
+  "$(extract_cpp_enum FileDirectory)" \
+  "$(extract_ts_enum FileDirectory)"
+
+compare_enum_pairs \
+  "BitDepth" \
+  "$(extract_cpp_enum BitDepth)" \
+  "$(extract_ts_enum BitDepth)"
+
+compare_enum_pairs \
+  "IOSAudioQuality" \
+  "$(extract_cpp_enum IOSAudioQuality)" \
+  "$(extract_ts_enum IOSAudioQuality)"
+
+if [ "$FAILED" -ne 0 ]; then
+  exit 1
+fi
+
+exit 0
diff --git a/packages/react-native-audio-api/scripts/check-enum-sync.sh b/packages/react-native-audio-api/scripts/check-enum-sync.sh
new file mode 100755
index 000000000..8957d7baf
--- /dev/null
+++ b/packages/react-native-audio-api/scripts/check-enum-sync.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+
+# Runs all cross-language enum sync checks required for this package.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+bash "$SCRIPT_DIR/check-audio-events-sync.sh"
+bash "$SCRIPT_DIR/check-audio-file-properties-enum-sync.sh"
diff --git a/packages/react-native-audio-api/src/types.ts b/packages/react-native-audio-api/src/types.ts
index 42ff4d907..3b6feac55 100644
--- a/packages/react-native-audio-api/src/types.ts
+++ b/packages/react-native-audio-api/src/types.ts
@@ -60,11 +60,27 @@ export enum FileDirectory {
   Cache = 1,
 }
 
+// Values must stay in sync with the C++ `AudioFileProperties::Format` enum.
+// Support is platform-dependent; unsupported formats fail when recording starts.
+// See the audio recorder docs for the per-platform system-encoder matrix.
 export enum FileFormat {
   Wav = 0,
   Caf = 1,
   M4A = 2,
   Flac = 3,
+  Aiff = 4,
+  Alac = 5,
+  OpusOgg = 6,
+  OpusWebm = 7,
+  VorbisWebm = 8,
+  AmrNb = 9,
+  AmrWb = 10,
+  AacHe = 11,
+  AacEld = 12,
+  Ima4 = 13,
+  Ulaw = 14,
+  Alaw = 15,
+  Ilbc = 16,
 }
 
 export enum IOSAudioQuality {
diff --git a/packages/react-native-audio-api/src/utils/flags.ts b/packages/react-native-audio-api/src/utils/flags.ts
index c1a88a603..6e2917fa5 100644
--- a/packages/react-native-audio-api/src/utils/flags.ts
+++ b/packages/react-native-audio-api/src/utils/flags.ts
@@ -3,9 +3,8 @@ import { NativeAudioAPIModule } from '../specs';
 /**
  * Returns whether the native build includes FFmpeg.
  *
- * When `false`, streaming, remote URL metadata, several decode/playback paths,
- * M4A concatenation, and Android non-WAV recording are unavailable. See the
- * runtime flags docs for the full feature matrix.
+ * When `false`, streaming, remote URL metadata, and several decode/playback
+ * paths are unavailable.
  */
 export function isFfmpegEnabled(): boolean {
   return NativeAudioAPIModule.isFfmpegEnabled();