munim-ffmpeg 0.2.0 → 0.3.0

package/NitroMunimFfmpeg.podspec

@@ -18,25 +18,30 @@ Pod::Spec.new do |s|
     "ios/**/*.{swift}",
     # Autolinking/Registration (Objective-C++)
     "ios/**/*.{m,mm}",
+    # C core that drives FFmpeg's in-process command-line tools
+    "ios/*.h",
     # Implementation (C++ objects)
     "cpp/**/*.{hpp,cpp}",
   ]
 
+  # FFmpeg 9 and the in-process fftools core. Downloaded by
+  # scripts/fetch-binaries.mjs on install, or built by scripts/ffmpeg/build-all.sh.
+  s.vendored_frameworks = "ios/MunimFFmpeg.xcframework"
+  s.pod_target_xcconfig = {
+    "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/ios\"",
+  }
+  s.frameworks = "AudioToolbox", "VideoToolbox", "CoreMedia", "AVFoundation", "CoreVideo", "Security"
+  s.libraries = "bz2", "z", "iconv", "c++"
+
+  # Must be public so CocoaPods puts it in the module umbrella, which is how the
+  # Swift implementation sees the C core.
+  s.public_header_files = "ios/munim_ffmpeg_core.h"
+
   load 'nitrogen/generated/ios/NitroMunimFfmpeg+autolinking.rb'
   add_nitrogen_files(s)
 
   s.dependency 'React-jsi'
   s.dependency 'React-callinvoker'
-  s.dependency 'ffmpeg-kit-ios-full-gpl-alt', '6.0'
-
-  # ffmpeg-kit 6.0 declares negative Level values with an unsigned backing type.
-  # Xcode 26 rejects that header when Nitro enables Swift C++ interoperability.
-  # The script locates Level.h by globbing, so it survives a change of FFmpegKit pod.
-  s.script_phase = {
-    :name => 'Patch FFmpegKit Level enum for Xcode 26',
-    :script => '"${RUBY_EXECUTABLE:-/usr/bin/ruby}" "${PODS_TARGET_SRCROOT}/scripts/patch-ffmpegkit-level.rb"',
-    :execution_position => :before_compile,
-  }
 
   install_modules_dependencies(s)
 end

package/README.md

@@ -61,7 +61,7 @@
 
 **Designed for Expo development builds and bare React Native.** This package contains native code and cannot run in Expo Go.
 
-> **Licensing note:** The JavaScript and Nitro bridge are Apache-2.0. The bundled native FFmpeg builds are not: the Android artifact is **GPLv3** (it links x264, x265, and xvid) and the iOS artifact is **LGPLv3**. Distributing either carries obligations. Read [Bundled FFmpeg builds](#bundled-ffmpeg-builds) before shipping.
+> **Licensing note:** The JavaScript, Swift, Kotlin, and Nitro bridge are Apache-2.0. The bundled FFmpeg is **LGPLv3** on both platforms — it deliberately excludes x264, x265, and xvid, so your app does not inherit GPL obligations. See [Licensing](#licensing).
 
 ## Table of contents
 
@@ -92,7 +92,8 @@
 
 ### FFmpeg execution
 
-- 🎬 **Argument-array commands:** Avoid platform-specific shell parsing and quoting
+- 🎬 **Argument-array commands:** FFmpeg's own CLI code paths, without shell parsing or quoting
+- 🆕 **FFmpeg 9.0.1:** The current upstream release, identical on both platforms
 - ⚡ **Asynchronous sessions:** Keep the React Native thread responsive during native work
 - 📝 **Live logs:** Receive FFmpeg output as it is produced
 - 📈 **Encoding statistics:** Track time, size, bitrate, speed, frames, FPS, and quality
@@ -112,7 +113,7 @@
 - 🚀 **Expo compatible:** Autolinking, config plugin, and an Expo development example
 - 🧪 **Capability discovery:** Ask the bundled build which encoders and decoders it actually has
 - 🎯 **TypeScript:** Complete public callback and result types
-- 🗂️ **16 KB Android support:** Uses a maintained FFmpegKit-compatible Android artifact with 16 KB page-size support
+- 🗂️ **16 KB Android pages:** Built with the alignment Google Play requires
 
 ## Platform support matrix
 
@@ -135,53 +136,46 @@ Codec availability is determined by the native FFmpeg builds described in [Bundl
 
 ## Bundled FFmpeg builds
 
-FFmpegKit was retired upstream in 2025 and its official binaries were withdrawn, so this package depends on maintained community rebuilds. The two platforms are **not** the same build:
+Both platforms run **FFmpeg 9.0.1**, built from [ffmpeg.org](https://www.ffmpeg.org/) by the scripts in [`scripts/ffmpeg/`](./scripts/ffmpeg). There is no FFmpegKit here: that project was retired in 2025 and pinned to FFmpeg 6.0.
 
 | | iOS | Android |
 | --- | --- | --- |
-| Artifact | `ffmpeg-kit-ios-full-gpl-alt` 6.0 | `io.github.jamaismagic.ffmpeg:ffmpeg-kit-main-16kb` 6.1.7 |
-| FFmpeg | n6.0 | n6.1.4 |
-| Effective license | LGPLv3 | **GPLv3** |
+| FFmpeg | 9.0.1 | 9.0.1 |
+| Architectures | arm64 device, arm64 + x86_64 simulator | arm64-v8a, armeabi-v7a, x86_64 |
 | Hardware codecs | VideoToolbox, AudioToolbox | MediaCodec |
-| 16 KB page size | n/a | ✅ (required by Google Play) |
+| TLS | SecureTransport | mbedTLS |
+| Minimum | iOS 15.1 | API 24, 16 KB pages |
 
-Despite its name, the iOS pod ships FFmpeg's non-GPL configuration: it has no `libx264`, `libx265`, or `libxvid`. No public GPL build of FFmpegKit for iOS exists since the upstream retirement.
+Linked libraries, identical on both: **LAME** (MP3), **Opus**, **libvpx** (VP8/VP9), **dav1d** (AV1 decoding), plus everything FFmpeg builds natively.
+
+FFmpeg's own `ffmpeg` and `ffprobe` tools are compiled to run inside your app process, so the argument arrays you pass are handled by the real command-line code paths rather than a reimplementation.
 
 ### Encoders
 
-Verified by running the example's device suite on both platforms: iOS reports 201 encoders, Android 196, with 181 in common. Everything FFmpeg builds natively (`aac`, `alac`, `flac`, `mpeg4`, `mjpeg`, `png`, `gif`, `pcm_*`, …) is available on both, as are `libmp3lame`, `libopus`, `libvpx` (VP8), and `libvpx-vp9`.
+Verified by running the example's device suite: iOS reports 186 encoders, Android 184. Everything FFmpeg builds natively (`aac`, `alac`, `flac`, `mpeg4`, `mjpeg`, `png`, `gif`, `pcm_*`, …) is on both, as are `libmp3lame`, `libopus`, `libvpx`, and `libvpx-vp9`.
 
-The differences that matter:
+H.264 and HEVC come from the platform's hardware encoder, which is faster and smaller than bundling x264 — and keeps the package LGPL:
 
 | Encoder | iOS | Android |
 | --- | --- | --- |
-| `libx264` / `libx264rgb` (H.264, software) | ❌ | ✅ |
-| `libx265` (HEVC, software) | ❌ | ✅ |
 | `h264_videotoolbox`, `hevc_videotoolbox`, `prores_videotoolbox` | ✅ | ❌ |
-| `h264_mediacodec`, `hevc_mediacodec`, `vp8_mediacodec`, `vp9_mediacodec`, `av1_mediacodec` | ❌ | ✅ |
-| `libkvazaar` (HEVC, software) | ✅ | ❌ |
-| `libtheora`, `libvorbis`, `libwebp` | ✅ | ❌ |
-| `libspeex`, `libshine`, `libtwolame`, `libilbc`, `libopencore_amrnb`, `libvo_amrwbenc` | ✅ | ❌ |
-| `aac_at`, `alac_at`, `ilbc_at` (AudioToolbox) | ✅ | ❌ |
-
-iOS additionally links libass, so subtitle burn-in filters work there but not on Android.
+| `h264_mediacodec`, `hevc_mediacodec`, `vp8_mediacodec`, `vp9_mediacodec` | ❌ | ✅ |
+| `aac_at`, `alac_at` (AudioToolbox) | ✅ | ❌ |
 
-Both platforms can encode H.264 and HEVC — just not with the same encoder name. Resolve it at runtime instead of branching on `Platform.OS`:
+Resolve the name at runtime instead of branching on `Platform.OS`:
 
 ```typescript
 import { execute, pickEncoder } from 'munim-ffmpeg'
 
-const h264 = await pickEncoder(['libx264', 'h264_videotoolbox'])
+const h264 = await pickEncoder(['h264_videotoolbox', 'h264_mediacodec'])
 if (!h264) throw new Error('No H.264 encoder in this build')
 
 await execute(['-y', '-i', inputPath, '-c:v', h264, outputPath])
 ```
 
-Decoding is far more uniform: both builds decode H.264, HEVC, VP8/VP9, AV1 (`libdav1d`), MPEG-4, MP3, AAC, Vorbis, Opus, FLAC, and the usual container formats. Both link GnuTLS, so `https://` inputs work.
+Two things to know about hardware encoders: they want NV12 input on Android (`-pix_fmt nv12`) and planar YUV on iOS, and they reject very small frames — 176×144 is the smallest size that works everywhere.
 
-The Android build is compiled with `--disable-indev=lavfi`, so `-f lavfi -i testsrc=...` and other virtual inputs are iOS-only. Feed real files or raw frames instead.
-
-> **Avoid the `-full` and `-full-gpl` Android artifacts.** Their `libavdevice.so` references hidapi symbols that nothing in the package provides, so FFmpegKit fails to initialise at runtime with `UnsatisfiedLinkError: cannot locate symbol "PLATFORM_hid_write"`.
+Decoding is uniform: H.264, HEVC, VP8/VP9, AV1, MPEG-4, MP3, AAC, Vorbis, Opus, FLAC and the usual containers, on both platforms. Both link TLS, so `https://` inputs work.
 
 ## 📦 Installation
 
@@ -201,7 +195,7 @@ pod install
 cd ..
 ```
 
-FFmpegKit and React Native both provide `libc++_shared.so`. Resolve that duplicate in the Android application module:
+FFmpeg and React Native both provide `libc++_shared.so`. Resolve that duplicate in the Android application module:
 
 ```groovy
 android {
@@ -229,7 +223,7 @@ The package includes an Expo config plugin. If your project manages its plugin l
 }
 ```
 
-The plugin also configures Android to select one shared C++ runtime when React Native and FFmpegKit contribute the same `libc++_shared.so` path.
+The plugin also configures Android to select one shared C++ runtime when React Native and FFmpeg contribute the same `libc++_shared.so` path.
 
 Create a native development build after installation:
 
@@ -244,6 +238,25 @@ You can also create an [EAS development build](https://docs.expo.dev/develop/dev
 
 > **Important:** `munim-ffmpeg` cannot run in Expo Go because Expo Go does not include this package's native libraries.
 
+### Native binaries
+
+The FFmpeg libraries are around 200 MB across all six architectures, which does not belong in an npm tarball, so they are downloaded from the matching GitHub release when the package installs and verified against the checksum in `scripts/binaries.json`.
+
+If your environment blocks install scripts (`npm install --ignore-scripts`), fetch them explicitly:
+
+```bash
+npx munim-ffmpeg-fetch-binaries
+```
+
+Behind a proxy or an air-gapped mirror, point the fetcher somewhere else:
+
+```bash
+MUNIM_FFMPEG_BINARIES_URL=https://internal.example.com/munim-ffmpeg-binaries.tar.gz \
+  npx munim-ffmpeg-fetch-binaries
+```
+
+Or build them yourself — see [`scripts/ffmpeg/README.md`](./scripts/ffmpeg/README.md).
+
 ### Requirements
 
 - React Native with the New Architecture enabled
@@ -580,25 +593,15 @@ if (result.success) {
 
 ## Licensing
 
-The JavaScript, TypeScript, Swift, Kotlin, and generated Nitro bridge code in this repository are Apache-2.0. The native FFmpeg binaries are not, and the two platforms differ:
-
-| Platform | Native dependency | Version | Effective license |
-| -------- | ----------------- | ------- | ----------------- |
-| iOS      | `ffmpeg-kit-ios-full-gpl-alt` | 6.0 | LGPLv3 (`--enable-version3`, no GPL libraries linked) |
-| Android  | `io.github.jamaismagic.ffmpeg:ffmpeg-kit-main-16kb` | 6.1.7 | **GPLv3** (`--enable-gpl` with x264 and x265) |
+The JavaScript, TypeScript, Swift, Kotlin, C core, and generated Nitro bridge in this repository are Apache-2.0.
 
-The Android artifact's published Maven metadata claims LGPL-3.0. That metadata is wrong: the shipped `libavcodec.so` is configured with `--enable-gpl` and the AAR bundles the x264 and x265 license notices. Treat the Android build as GPLv3.
+The bundled FFmpeg 9.0.1 is **LGPLv3**, on both platforms. It is configured without `--enable-gpl`, so no x264, x265, xvid, or vid.stab: H.264 and HEVC encoding come from VideoToolbox and MediaCodec instead. The external libraries it does link are LAME (LGPL), Opus (BSD), libvpx (BSD), dav1d (BSD), and mbedTLS (Apache-2.0) on Android.
 
-Distributing an Android application built against it can trigger GPLv3 source, license, and redistribution obligations for your application. If that does not suit your product, replace the Android dependency in `android/build.gradle` with a non-GPL FFmpegKit artifact; H.264 encoding then relies on `h264_mediacodec`.
+In practice that means your application does **not** inherit GPL obligations. LGPL still applies: the FFmpeg libraries are linked and their license and notices must be conveyed with your app, and users must be able to relink against a modified FFmpeg. The exact configuration used is recorded in [`scripts/ffmpeg/build-ios.sh`](./scripts/ffmpeg/build-ios.sh) and [`build-android.sh`](./scripts/ffmpeg/build-android.sh), and the binaries can be reproduced from them.
 
-Before distributing an application:
+If you need x264 or x265, add `--enable-gpl --enable-libx264 --enable-libx265` to those scripts and rebuild — but then your application does inherit GPLv3.
 
-1. Review the license and notices shipped by each native dependency.
-2. Identify the codecs and linked libraries your product actually uses.
-3. Follow the applicable LGPL, GPL, attribution, relinking, and source-offer requirements.
-4. Reassess licensing whenever you replace a native dependency.
-
-See [FFmpeg legal guidance](https://ffmpeg.org/legal.html). This section is an engineering reminder, not legal advice.
+See [FFmpeg legal guidance](https://ffmpeg.org/legal.html). This section is an engineering summary, not legal advice.
 
 ## 🔍 Troubleshooting
 
@@ -628,31 +631,15 @@ Inspect `result.success`, `result.cancelled`, `result.returnCode`, `result.outpu
 
 ### iOS pod or build errors
 
-Run `pod install` after installation and rebuild from a clean native development build. The package includes a narrowly scoped Xcode 26 compatibility patch for the FFmpegKit `Level` enum, which Nitro's Swift/C++ bridge otherwise rejects. The patch locates the header by globbing, so it keeps working if you swap the FFmpegKit pod.
-
-### `building for iOS Simulator, but linking ... built for iOS`
-
-The FFmpegKit pod tells consuming apps to exclude `arm64` from Simulator builds, which breaks Apple Silicon Macs even though its xcframework contains an `arm64` Simulator slice. The Expo config plugin removes that exclusion automatically. In a bare React Native app, add the same fix to your `Podfile`:
-
-```ruby
-post_install do |installer|
-  installer.pods_project.build_configurations.each do |config|
-    config.build_settings.delete('EXCLUDED_ARCHS[sdk=iphonesimulator*]')
-  end
-  installer.aggregate_targets.each do |aggregate_target|
-    aggregate_target.xcconfigs.each do |config_name, xcconfig|
-      xcconfig.attributes.delete('EXCLUDED_ARCHS[sdk=iphonesimulator*]')
-      xcconfig.save_as(Pathname.new(aggregate_target.xcconfig_path(config_name)))
-    end
-  end
-end
-```
+Run `pod install` after installation and rebuild from a clean native development build. If the linker cannot find `MunimFFmpeg.xcframework`, the native binaries were not downloaded — run `npx munim-ffmpeg-fetch-binaries`.
 
 ### Android build errors
 
 Use Android API 24 or newer, JDK 17, and the React Native New Architecture. Clear stale Gradle build output after changing native dependency versions.
 
-If the build fails on duplicate `libc++_shared.so`, make sure the config plugin ran (Expo) or add `android.packagingOptions.pickFirsts=**/libc++_shared.so` to `gradle.properties` (bare React Native). FFmpegKit and React Native both ship that library.
+If the build fails on duplicate `libc++_shared.so`, make sure the config plugin ran (Expo) or add `android.packagingOptions.pickFirsts=**/libc++_shared.so` to `gradle.properties` (bare React Native).
+
+If `System.loadLibrary` cannot find `munimffmpeg9`, the native binaries were not downloaded — run `npx munim-ffmpeg-fetch-binaries`.
 
 ## Development
 
@@ -677,6 +664,15 @@ npm run example:android
 
 FFmpeg encoding is slow in a simulator or emulator; run the suite on a physical device.
 
+### Rebuilding FFmpeg
+
+```bash
+npm run binaries:build     # every architecture, ~40 minutes
+npm run binaries:package   # bundles them and records the checksum
+```
+
+See [`scripts/ffmpeg/README.md`](./scripts/ffmpeg/README.md) for what the build does and the platform quirks it works around.
+
 ### Releasing
 
 Releases run locally from a clean `main`; this repository does not use GitHub Actions.
@@ -686,7 +682,7 @@ npm run check
 npm run release:local
 ```
 
-`release:local` runs semantic-release with the npm token from the macOS Keychain and the GitHub CLI token, so commit messages must follow Conventional Commits.
+`release:local` runs semantic-release with the npm token from the macOS Keychain and the GitHub CLI token, so commit messages must follow Conventional Commits. It also uploads `dist-binaries/munim-ffmpeg-binaries.tar.gz` to the GitHub release, which is where `postinstall` fetches it from — so run `npm run binaries:package` first.
 
 ## 👏 Contributing
 

package/android/build.gradle

@@ -139,9 +139,6 @@ dependencies {
   // Add a dependency on NitroModules
   implementation project(":react-native-nitro-modules")
 
-  // Maintained FFmpegKit-compatible Android artifact with 16 KB page support.
-  // Do not move to the `-full`/`-full-gpl` variants: their libavdevice.so
-  // references hidapi symbols that nothing provides, so FFmpegKit fails to load
-  // at runtime with UnsatisfiedLinkError.
-  implementation "io.github.jamaismagic.ffmpeg:ffmpeg-kit-main-16kb:6.1.7"
+  // FFmpeg 9 and the in-process fftools core ship as prebuilt .so files in
+  // src/main/jniLibs; see scripts/ffmpeg/ for the build.
 }

package/android/src/main/java/com/margelo/nitro/munimffmpeg/FFmpegNative.kt

@@ -0,0 +1,86 @@
+package com.margelo.nitro.munimffmpeg
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Thin wrapper over FFmpeg 9's own command-line tools, compiled to run inside
+ * the app process.
+ *
+ * fftools keeps its parsed command in file-scope globals, so exactly one
+ * execution runs at a time; the native core serialises callers and cancels
+ * anything still queued when [nativeCancel] is called.
+ */
+@Keep
+@DoNotStrip
+object FFmpegNative {
+  init {
+    System.loadLibrary("munimffmpeg9")
+  }
+
+  /** Return code the tools report when a run was cancelled. */
+  const val CANCELLED = 255
+
+  external fun nativeVersion(): String
+
+  external fun nativeExecute(arguments: Array<String>, stdoutPath: String): Int
+
+  external fun nativeExecuteProbe(arguments: Array<String>, outputPath: String): Int
+
+  external fun nativeCancel()
+
+  data class Statistics(
+    val timeMs: Double,
+    val sizeBytes: Double,
+    val bitrateKbits: Double,
+    val speed: Double,
+    val videoFrameNumber: Double,
+    val fps: Double,
+    val quality: Double,
+  )
+
+  @Volatile
+  private var logSink: ((String) -> Unit)? = null
+
+  @Volatile
+  private var statisticsSink: ((Statistics) -> Unit)? = null
+
+  fun <T> withCallbacks(
+    onLog: ((String) -> Unit)?,
+    onStatistics: ((Statistics) -> Unit)?,
+    body: () -> T,
+  ): T {
+    logSink = onLog
+    statisticsSink = onStatistics
+    try {
+      return body()
+    } finally {
+      logSink = null
+      statisticsSink = null
+    }
+  }
+
+  @JvmStatic
+  @Keep
+  @DoNotStrip
+  fun onLog(message: String) {
+    logSink?.invoke(message)
+  }
+
+  @JvmStatic
+  @Keep
+  @DoNotStrip
+  fun onStatistics(
+    timeMs: Double,
+    sizeBytes: Double,
+    bitrateKbits: Double,
+    speed: Double,
+    videoFrameNumber: Double,
+    fps: Double,
+    quality: Double,
+  ) {
+    statisticsSink?.invoke(
+      Statistics(timeMs, sizeBytes, bitrateKbits, speed, videoFrameNumber, fps, quality)
+    )
+  }
+}

package/android/src/main/java/com/margelo/nitro/munimffmpeg/HybridMunimFfmpeg.kt

@@ -1,19 +1,39 @@
 package com.margelo.nitro.munimffmpeg
 
 import androidx.annotation.Keep
-import com.arthenica.ffmpegkit.FFmpegKit
-import com.arthenica.ffmpegkit.FFmpegKitConfig
-import com.arthenica.ffmpegkit.FFprobeKit
-import com.arthenica.ffmpegkit.ReturnCode
-import com.arthenica.ffmpegkit.Session
 import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.core.Promise
+import java.io.File
+import java.util.concurrent.atomic.AtomicLong
 
 @Keep
 @DoNotStrip
 class HybridMunimFfmpeg : HybridMunimFfmpegSpec() {
   override val ffmpegVersion: String
-    get() = FFmpegKitConfig.getFFmpegVersion()
+    get() = FFmpegNative.nativeVersion()
+
+  private val sessions = AtomicLong(0)
+
+  private fun nextSession() = sessions.incrementAndGet().toDouble()
+
+  private fun result(
+    sessionId: Double,
+    returnCode: Int,
+    output: String,
+    durationMs: Long,
+  ): FFmpegSessionResult {
+    val cancelled = returnCode == FFmpegNative.CANCELLED
+    return FFmpegSessionResult(
+      sessionId = sessionId,
+      returnCode = returnCode.toDouble(),
+      success = returnCode == 0,
+      cancelled = cancelled,
+      state = "completed",
+      durationMs = durationMs.toDouble(),
+      output = output,
+      failStackTrace = null,
+    )
+  }
 
   override fun execute(
     arguments_: Array<String>,
@@ -29,31 +49,42 @@ class HybridMunimFfmpeg : HybridMunimFfmpegSpec() {
     ) -> Unit)?,
     onSessionCreated: ((sessionId: Double) -> Unit)?,
   ): Promise<FFmpegSessionResult> {
-    val promise = Promise<FFmpegSessionResult>()
+    val sessionId = nextSession()
+    onSessionCreated?.invoke(sessionId)
 
-    try {
-      val session = FFmpegKit.executeWithArgumentsAsync(
-        arguments_,
-        { session -> promise.resolve(session.toResult()) },
-        { log -> onLog?.invoke(log.message) },
-        { statistics ->
+    return Promise.async {
+      val output = StringBuilder()
+      val startedAt = System.currentTimeMillis()
+      // ffmpeg prints reports such as -encoders and -protocols to stdout rather
+      // than through its logger, so it is captured to a file and appended.
+      val stdout = File.createTempFile("munim-ffmpeg", ".txt")
+
+      val returnCode = FFmpegNative.withCallbacks(
+        onLog = { message ->
+          output.append(message)
+          onLog?.invoke(message)
+        },
+        onStatistics = { statistics ->
           onStatistics?.invoke(
-            statistics.time,
-            statistics.size.toDouble(),
-            statistics.bitrate,
+            statistics.timeMs,
+            statistics.sizeBytes,
+            statistics.bitrateKbits,
             statistics.speed,
-            statistics.videoFrameNumber.toDouble(),
-            statistics.videoFps.toDouble(),
-            statistics.videoQuality.toDouble(),
+            statistics.videoFrameNumber,
+            statistics.fps,
+            statistics.quality,
           )
         },
-      )
-      onSessionCreated?.invoke(session.sessionId.toDouble())
-    } catch (error: Throwable) {
-      promise.reject(error)
-    }
+      ) {
+        FFmpegNative.nativeExecute(arguments_, stdout.absolutePath)
+      }
+
+      val printed = runCatching { stdout.readText() }.getOrDefault("")
+      stdout.delete()
+      output.append(printed)
 
-    return promise
+      result(sessionId, returnCode, output.toString(), System.currentTimeMillis() - startedAt)
+    }
   }
 
   override fun probe(
@@ -61,25 +92,19 @@ class HybridMunimFfmpeg : HybridMunimFfmpegSpec() {
     onLog: ((message: String) -> Unit)?,
     onSessionCreated: ((sessionId: Double) -> Unit)?,
   ): Promise<FFmpegSessionResult> {
-    val promise = Promise<FFmpegSessionResult>()
+    val sessionId = nextSession()
+    onSessionCreated?.invoke(sessionId)
 
-    try {
-      val session = FFprobeKit.executeWithArgumentsAsync(
-        arguments_,
-        { session -> promise.resolve(session.toResult()) },
-        { log -> onLog?.invoke(log.message) },
-      )
-      onSessionCreated?.invoke(session.sessionId.toDouble())
-    } catch (error: Throwable) {
-      promise.reject(error)
+    return Promise.async {
+      val startedAt = System.currentTimeMillis()
+      val (returnCode, report) = runProbe(arguments_, onLog)
+      result(sessionId, returnCode, report, System.currentTimeMillis() - startedAt)
     }
-
-    return promise
   }
 
   override fun getMediaInformation(path: String): Promise<String> {
     return Promise.async {
-      val session = FFprobeKit.executeWithArguments(
+      val (returnCode, report) = runProbe(
         arrayOf(
           "-v",
           "error",
@@ -90,25 +115,49 @@ class HybridMunimFfmpeg : HybridMunimFfmpegSpec() {
           "-show_chapters",
           path,
         ),
+        null,
       )
-      val returnCode = session.returnCode
 
-      if (!ReturnCode.isSuccess(returnCode)) {
+      if (returnCode != 0) {
         throw IllegalStateException(
-          session.failStackTrace ?: session.output.ifEmpty {
-            "FFprobe failed with return code ${returnCode?.value ?: -1}"
-          },
+          report.ifEmpty { "FFprobe failed with return code $returnCode" }
         )
       }
 
-      session.output
+      report
+    }
+  }
+
+  /**
+   * ffprobe writes its report to stdout, which is not reachable from an app, so
+   * it is pointed at a temporary file with `-o` and read back.
+   */
+  private fun runProbe(
+    arguments: Array<String>,
+    onLog: ((message: String) -> Unit)?,
+  ): Pair<Int, String> {
+    val destination = File.createTempFile("munim-ffprobe", ".txt")
+    try {
+      val logs = StringBuilder()
+      val returnCode = FFmpegNative.withCallbacks(
+        onLog = { message ->
+          logs.append(message)
+          onLog?.invoke(message)
+        },
+        onStatistics = null,
+      ) {
+        FFmpegNative.nativeExecuteProbe(arguments, destination.absolutePath)
+      }
+
+      val report = destination.readText()
+      return returnCode to report.ifEmpty { logs.toString() }
+    } finally {
+      destination.delete()
     }
   }
 
   override fun cancel(sessionId: Double?) {
-    if (sessionId == null) {
-      FFmpegKit.cancel()
-    } else {
+    if (sessionId != null) {
       require(
         sessionId.isFinite() &&
           sessionId > 0 &&
@@ -117,25 +166,13 @@ class HybridMunimFfmpeg : HybridMunimFfmpegSpec() {
       ) {
         "Invalid FFmpeg session ID: $sessionId. Expected a positive safe integer."
       }
-      FFmpegKit.cancel(sessionId.toLong())
     }
+    // Only one execution runs at a time, so a targeted cancel and cancelAll()
+    // are the same operation.
+    FFmpegNative.nativeCancel()
   }
 
   override fun cancelAll() {
-    FFmpegKit.cancel()
-  }
-
-  private fun Session.toResult(): FFmpegSessionResult {
-    val code = returnCode
-    return FFmpegSessionResult(
-      sessionId = sessionId.toDouble(),
-      returnCode = (code?.value ?: -1).toDouble(),
-      success = ReturnCode.isSuccess(code),
-      cancelled = ReturnCode.isCancel(code),
-      state = state.name.lowercase(),
-      durationMs = duration.toDouble(),
-      output = output,
-      failStackTrace = failStackTrace,
-    )
+    FFmpegNative.nativeCancel()
   }
 }

package/ios/Bridge.h

@@ -2,7 +2,10 @@
 //  Bridge.h
 //  NitroMunimFfmpeg
 //
-//  Created by Marc Rousavy on 22.07.24.
+//  Objective-C bridging header: exposes the C core that drives FFmpeg 9's
+//  in-process command-line tools to the Swift implementation.
 //
 
 #pragma once
+
+#include "munim_ffmpeg_core.h"

package/ios/HybridMunimFfmpeg.swift

@@ -1,9 +1,75 @@
+import Foundation
 import NitroModules
-import ffmpegkit
+
+/// Callbacks for the execution currently holding the core's lock. The core
+/// serialises executions, so a single slot is enough.
+private final class ActiveSession {
+  var onLog: ((String) -> Void)?
+  var onStatistics: ((Double, Double, Double, Double, Double, Double, Double) -> Void)?
+  var output = ""
+
+  func reset() {
+    onLog = nil
+    onStatistics = nil
+    output = ""
+  }
+}
+
+private let active = ActiveSession()
+// Concurrent on purpose: the C core serialises executions behind its own lock,
+// and a request that is waiting there can still be cancelled. A serial queue
+// would hold the second call outside the core, where cancelAll() cannot see it.
+private let executionQueue = DispatchQueue(
+  label: "com.munimtech.ffmpeg",
+  qos: .userInitiated,
+  attributes: .concurrent
+)
+
+private func installCallbacks() {
+  munim_ffmpeg_set_callbacks({ _, message in
+    guard let message else { return }
+    let text = String(cString: message)
+    active.output += text
+    active.onLog?(text)
+  }, { _, timeMs, sizeBytes, bitrate, speed, frame, fps, quality in
+    active.onStatistics?(timeMs, sizeBytes, bitrate, speed, frame, fps, quality)
+  }, nil)
+}
 
 final class HybridMunimFfmpeg: HybridMunimFfmpegSpec {
+  private var sessionCounter: Double = 0
+
   var ffmpegVersion: String {
-    FFmpegKitConfig.getFFmpegVersion()
+    String(cString: munim_ffmpeg_version())
+  }
+
+  private func nextSession() -> Double {
+    sessionCounter += 1
+    return sessionCounter
+  }
+
+  private static func temporaryFile() -> String {
+    FileManager.default.temporaryDirectory
+      .appendingPathComponent("munim-ffmpeg-\(UUID().uuidString)")
+      .path
+  }
+
+  private func result(
+    sessionId: Double,
+    returnCode: Int32,
+    output: String,
+    startedAt: Date
+  ) -> FFmpegSessionResult {
+    FFmpegSessionResult(
+      sessionId: sessionId,
+      returnCode: Double(returnCode),
+      success: returnCode == 0,
+      cancelled: returnCode == Int32(MUNIM_FFMPEG_CANCELLED),
+      state: "completed",
+      durationMs: Date().timeIntervalSince(startedAt) * 1000,
+      output: output,
+      failStackTrace: nil
+    )
   }
 
   func execute(
@@ -13,35 +79,38 @@ final class HybridMunimFfmpeg: HybridMunimFfmpegSpec {
     onSessionCreated: ((_ sessionId: Double) -> Void)?
   ) throws -> Promise<FFmpegSessionResult> {
     let promise = Promise<FFmpegSessionResult>()
+    let sessionId = nextSession()
+    onSessionCreated?(sessionId)
+
+    executionQueue.async {
+      let startedAt = Date()
+      // ffmpeg prints reports such as -encoders to stdout rather than through
+      // its logger, so it is captured to a file and appended to the output.
+      let printedPath = Self.temporaryFile()
+
+      installCallbacks()
+      active.reset()
+      active.onLog = onLog
+      active.onStatistics = onStatistics
+
+      let returnCode = withArrayOfCStrings(arguments_) { argv in
+        munim_ffmpeg_execute(Int32(arguments_.count), argv, printedPath)
+      }
+
+      let printed = (try? String(contentsOfFile: printedPath, encoding: .utf8)) ?? ""
+      try? FileManager.default.removeItem(atPath: printedPath)
 
-    let session = FFmpegKit.execute(
-      withArgumentsAsync: arguments_,
-      withCompleteCallback: { session in
-        guard let session else {
-          promise.reject(withError: MunimFfmpegError.missingSession)
-          return
-        }
-        promise.resolve(withResult: Self.result(from: session))
-      },
-      withLogCallback: { log in
-        guard let message = log?.getMessage() else { return }
-        onLog?(message)
-      },
-      withStatisticsCallback: { statistics in
-        guard let statistics else { return }
-        onStatistics?(
-          statistics.getTime(),
-          Double(statistics.getSize()),
-          statistics.getBitrate(),
-          statistics.getSpeed(),
-          Double(statistics.getVideoFrameNumber()),
-          Double(statistics.getVideoFps()),
-          Double(statistics.getVideoQuality())
+      let output = active.output + printed
+      active.reset()
+
+      promise.resolve(
+        withResult: self.result(
+          sessionId: sessionId,
+          returnCode: returnCode,
+          output: output,
+          startedAt: startedAt
         )
-      }
-    )
-    if let session {
-      onSessionCreated?(Double(session.getId()))
+      )
     }
 
     return promise
@@ -53,23 +122,20 @@ final class HybridMunimFfmpeg: HybridMunimFfmpegSpec {
     onSessionCreated: ((_ sessionId: Double) -> Void)?
   ) throws -> Promise<FFmpegSessionResult> {
     let promise = Promise<FFmpegSessionResult>()
-
-    let session = FFprobeKit.execute(
-      withArgumentsAsync: arguments_,
-      withCompleteCallback: { session in
-        guard let session else {
-          promise.reject(withError: MunimFfmpegError.missingSession)
-          return
-        }
-        promise.resolve(withResult: Self.result(from: session))
-      },
-      withLogCallback: { log in
-        guard let message = log?.getMessage() else { return }
-        onLog?(message)
-      }
-    )
-    if let session {
-      onSessionCreated?(Double(session.getId()))
+    let sessionId = nextSession()
+    onSessionCreated?(sessionId)
+
+    executionQueue.async {
+      let startedAt = Date()
+      let (returnCode, report) = Self.runProbe(arguments_, onLog: onLog)
+      promise.resolve(
+        withResult: self.result(
+          sessionId: sessionId,
+          returnCode: returnCode,
+          output: report,
+          startedAt: startedAt
+        )
+      )
     }
 
     return promise
@@ -77,37 +143,58 @@ final class HybridMunimFfmpeg: HybridMunimFfmpegSpec {
 
   func getMediaInformation(path: String) throws -> Promise<String> {
     let promise = Promise<String>()
-    let arguments = [
-      "-v",
-      "error",
-      "-print_format",
-      "json",
-      "-show_format",
-      "-show_streams",
-      "-show_chapters",
-      path,
-    ]
-
-    FFprobeKit.execute(
-      withArgumentsAsync: arguments,
-      withCompleteCallback: { session in
-        guard let session else {
-          promise.reject(withError: MunimFfmpegError.missingSession)
-          return
-        }
-        let returnCode = session.getReturnCode()
-        guard ReturnCode.isSuccess(returnCode) else {
-          let message = session.getFailStackTrace() ?? session.getOutput() ?? "FFprobe failed"
-          promise.reject(withError: MunimFfmpegError.executionFailed(message))
-          return
-        }
-        promise.resolve(withResult: session.getOutput() ?? "{}")
+
+    executionQueue.async {
+      let (returnCode, report) = Self.runProbe(
+        [
+          "-v", "error",
+          "-print_format", "json",
+          "-show_format", "-show_streams", "-show_chapters",
+          path,
+        ],
+        onLog: nil
+      )
+
+      if returnCode != 0 {
+        promise.reject(
+          withError: MunimFfmpegError.executionFailed(
+            report.isEmpty ? "FFprobe failed with return code \(returnCode)" : report
+          )
+        )
+        return
       }
-    )
+
+      promise.resolve(withResult: report)
+    }
 
     return promise
   }
 
+  /// ffprobe writes its report to stdout, which is not reachable from an app,
+  /// so it is pointed at a temporary file with `-o` and read back.
+  private static func runProbe(
+    _ arguments: [String],
+    onLog: ((String) -> Void)?
+  ) -> (Int32, String) {
+    let destination = temporaryFile()
+
+    installCallbacks()
+    active.reset()
+    active.onLog = onLog
+
+    let returnCode = withArrayOfCStrings(arguments) { argv in
+      munim_ffmpeg_probe(Int32(arguments.count), argv, destination)
+    }
+
+    let report = (try? String(contentsOfFile: destination, encoding: .utf8)) ?? ""
+    try? FileManager.default.removeItem(atPath: destination)
+
+    let logs = active.output
+    active.reset()
+
+    return (returnCode, report.isEmpty ? logs : report)
+  }
+
   func cancel(sessionId: Double?) throws {
     if let sessionId {
       guard
@@ -118,52 +205,39 @@ final class HybridMunimFfmpeg: HybridMunimFfmpegSpec {
       else {
         throw MunimFfmpegError.invalidSessionId(sessionId)
       }
-      FFmpegKit.cancel(Int(sessionId))
-    } else {
-      FFmpegKit.cancel()
     }
+    // One execution runs at a time, so cancelling a specific session and
+    // cancelling everything are the same operation.
+    munim_ffmpeg_cancel()
   }
 
   func cancelAll() throws {
-    FFmpegKit.cancel()
-  }
-
-  // `String(describing:)` on the imported NS_ENUM yields "sessionstate(rawvalue: 3)".
-  // Android reports the Java enum name, so map to the same lowercase names here.
-  private static func stateName(_ state: SessionState) -> String {
-    switch state {
-    case .created: return "created"
-    case .running: return "running"
-    case .failed: return "failed"
-    case .completed: return "completed"
-    @unknown default: return "unknown"
-    }
+    munim_ffmpeg_cancel()
   }
+}
 
-  private static func result(from session: Session) -> FFmpegSessionResult {
-    let returnCode = session.getReturnCode()
-    return FFmpegSessionResult(
-      sessionId: Double(session.getId()),
-      returnCode: Double(returnCode?.getValue() ?? -1),
-      success: ReturnCode.isSuccess(returnCode),
-      cancelled: ReturnCode.isCancel(returnCode),
-      state: Self.stateName(session.getState()),
-      durationMs: Double(session.getDuration()),
-      output: session.getOutput() ?? "",
-      failStackTrace: session.getFailStackTrace()
-    )
+/// Builds a C `argv` that stays valid for the duration of `body`.
+private func withArrayOfCStrings<R>(
+  _ values: [String],
+  _ body: (UnsafePointer<UnsafePointer<CChar>?>?) -> R
+) -> R {
+  var pointers = values.map { strdup($0) }
+  defer { pointers.forEach { free($0) } }
+
+  return pointers.withUnsafeMutableBufferPointer { buffer in
+    buffer.baseAddress!.withMemoryRebound(
+      to: UnsafePointer<CChar>?.self,
+      capacity: buffer.count
+    ) { body($0) }
   }
 }
 
 private enum MunimFfmpegError: LocalizedError {
-  case missingSession
   case executionFailed(String)
   case invalidSessionId(Double)
 
   var errorDescription: String? {
     switch self {
-    case .missingSession:
-      return "FFmpegKit did not return a session."
     case .executionFailed(let message):
       return message
     case .invalidSessionId(let sessionId):

package/ios/munim_ffmpeg_core.h

@@ -0,0 +1,58 @@
+/*
+ * Platform-neutral core for running FFmpeg 9's own command-line tools inside an
+ * app process. The Android JNI bridge and the iOS Swift layer both sit on top
+ * of this.
+ */
+#ifndef MUNIM_FFMPEG_CORE_H
+#define MUNIM_FFMPEG_CORE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*munim_log_callback)(void *context, const char *message);
+
+typedef void (*munim_statistics_callback)(void *context, double time_ms,
+                                          double size_bytes,
+                                          double bitrate_kbits, double speed,
+                                          double video_frame_number, double fps,
+                                          double quality);
+
+/** Version string of the linked FFmpeg, e.g. "9.0.1". */
+const char *munim_ffmpeg_version(void);
+
+/** Callbacks apply to whichever execution is currently running. */
+void munim_ffmpeg_set_callbacks(munim_log_callback on_log,
+                                munim_statistics_callback on_statistics,
+                                void *context);
+
+/**
+ * Runs `ffmpeg` with the given arguments; `argv[0]` is supplied internally.
+ *
+ * `stdout_path` receives anything the tool prints rather than logs, such as the
+ * `-encoders` and `-protocols` reports. Pass NULL to discard it.
+ *
+ * fftools keeps its parsed command in file-scope globals, so calls are
+ * serialised: a second execution waits for the first to finish.
+ */
+int munim_ffmpeg_execute(int argc, const char *const *argv,
+                         const char *stdout_path);
+
+/** Runs `ffprobe`, writing its report to `output_path` via `-o`. */
+int munim_ffmpeg_probe(int argc, const char *const *argv,
+                       const char *output_path);
+
+/**
+ * Requests cancellation of the running execution, and of any execution already
+ * queued behind it.
+ */
+void munim_ffmpeg_cancel(void);
+
+/** Return code reported when a run was cancelled. */
+#define MUNIM_FFMPEG_CANCELLED 255
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MUNIM_FFMPEG_CORE_H */

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "munim-ffmpeg",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Fast FFmpeg and FFprobe for Expo and React Native, powered by Nitro Modules",
   "main": "lib/index",
   "module": "lib/index",
   "types": "lib/index.d.ts",
+  "bin": {
+    "munim-ffmpeg-fetch-binaries": "scripts/fetch-binaries.mjs"
+  },
   "react-native": "src/index",
   "source": "src/index",
   "files": [
@@ -16,7 +19,7 @@
     "android/gradle.properties",
     "android/fix-prefab.gradle",
     "android/CMakeLists.txt",
-    "android/src",
+    "android/src/main/java",
     "cpp",
     "ios/**/*.h",
     "ios/**/*.m",
@@ -28,7 +31,10 @@
     "*.podspec",
     "README.md",
     "LICENSE",
-    "scripts/patch-ffmpegkit-level.rb"
+    "android/src/main/cpp",
+    "android/src/main/AndroidManifest.xml",
+    "scripts/fetch-binaries.mjs",
+    "scripts/binaries.json"
   ],
   "scripts": {
     "typecheck": "tsc --noEmit",
@@ -44,7 +50,10 @@
     "example:ios": "npm --workspace example run ios",
     "example:android": "npm --workspace example run android",
     "release:local": "node scripts/release-local.mjs",
-    "format": "prettier --write \"**/*.{ts,tsx,js,cjs,mjs,json,md}\""
+    "format": "prettier --write \"**/*.{ts,tsx,js,cjs,mjs,json,md}\"",
+    "postinstall": "node scripts/fetch-binaries.mjs",
+    "binaries:build": "scripts/ffmpeg/fetch-source.sh && scripts/ffmpeg/build-all.sh",
+    "binaries:package": "scripts/ffmpeg/package.sh"
   },
   "keywords": [
     "react-native",

package/scripts/binaries.json

@@ -0,0 +1,5 @@
+{
+  "archive": "munim-ffmpeg-binaries.tar.gz",
+  "sha256": "5d3a286633c584ffb2ef9dec091695f5ba8f8db88187058df7143ef258e15beb",
+  "ffmpeg": "9.0.1"
+}

package/scripts/fetch-binaries.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+/*
+ * Downloads the prebuilt FFmpeg binaries for this version of munim-ffmpeg.
+ *
+ * They are not published to npm: the bundle is ~200 MB of static libraries and
+ * shared objects, which does not belong in a registry tarball. It ships as a
+ * GitHub release asset instead, pinned by the checksum in scripts/binaries.json
+ * so a build cannot silently pick up different bytes.
+ *
+ * Runs from postinstall, and can be re-run by hand:
+ *   npx munim-ffmpeg-fetch-binaries
+ */
+import { createHash } from 'node:crypto'
+import { createWriteStream } from 'node:fs'
+import { mkdir, readFile, rm, stat } from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { pipeline } from 'node:stream/promises'
+import { fileURLToPath } from 'node:url'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const run = promisify(execFile)
+const require = createRequire(import.meta.url)
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+
+const REPOSITORY = 'munimtechnologies/munim-ffmpeg'
+const MARKERS = [
+  'ios/MunimFFmpeg.xcframework',
+  'android/src/main/jniLibs/arm64-v8a/libmunimffmpeg9.so',
+]
+
+async function exists(target) {
+  try {
+    await stat(target)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function alreadyInstalled() {
+  for (const marker of MARKERS) {
+    if (!(await exists(path.join(root, marker)))) return false
+  }
+  return true
+}
+
+async function download(url, destination) {
+  const response = await fetch(url, { redirect: 'follow' })
+  if (!response.ok) {
+    throw new Error(`${response.status} ${response.statusText} for ${url}`)
+  }
+  await pipeline(response.body, createWriteStream(destination))
+}
+
+async function checksum(file) {
+  const hash = createHash('sha256')
+  hash.update(await readFile(file))
+  return hash.digest('hex')
+}
+
+async function main() {
+  const manifest = require(path.join(root, 'scripts', 'binaries.json'))
+  const { version } = require(path.join(root, 'package.json'))
+
+  if (await alreadyInstalled()) {
+    console.log(
+      `munim-ffmpeg: FFmpeg ${manifest.ffmpeg} binaries already present`
+    )
+    return
+  }
+
+  const url =
+    process.env.MUNIM_FFMPEG_BINARIES_URL ??
+    `https://github.com/${REPOSITORY}/releases/download/v${version}/${manifest.archive}`
+
+  const cache = path.join(root, '.binaries-cache')
+  await mkdir(cache, { recursive: true })
+  const archive = path.join(cache, manifest.archive)
+
+  console.log(`munim-ffmpeg: downloading FFmpeg ${manifest.ffmpeg} binaries…`)
+  await download(url, archive)
+
+  const actual = await checksum(archive)
+  if (actual !== manifest.sha256) {
+    await rm(cache, { force: true, recursive: true })
+    throw new Error(
+      `checksum mismatch for ${manifest.archive}\n  expected ${manifest.sha256}\n  received ${actual}`
+    )
+  }
+
+  await run('tar', ['xzf', archive, '-C', root])
+  await rm(cache, { force: true, recursive: true })
+
+  if (!(await alreadyInstalled())) {
+    throw new Error('the archive did not contain the expected binaries')
+  }
+
+  console.log(`munim-ffmpeg: FFmpeg ${manifest.ffmpeg} binaries installed`)
+}
+
+main().catch((error) => {
+  console.error(`
+munim-ffmpeg: could not install the native FFmpeg binaries.
+
+  ${error.message}
+
+The package cannot build without them. Options:
+  • re-run:            npx munim-ffmpeg-fetch-binaries
+  • use a mirror:      MUNIM_FFMPEG_BINARIES_URL=<url> npx munim-ffmpeg-fetch-binaries
+  • build them:        see scripts/ffmpeg/README.md
+`)
+  process.exitCode = 1
+})

package/scripts/patch-ffmpegkit-level.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-require 'tempfile'
-
-# FFmpegKit 6.0 declares `Level` with an unsigned backing type while assigning
-# negative values to it. Clang accepts that in Objective-C, but Xcode 26 rejects
-# the header once Nitro turns on Swift/C++ interoperability, so every vendored
-# and copied copy of Level.h is rewritten to a signed enum before compiling.
-#
-# The header is located by globbing rather than by pod name: the FFmpegKit
-# republishes lay their xcframeworks out differently (`<pod>/ffmpegkit.xcframework`
-# versus `<pod>/xcframeworks/ffmpegkit.xcframework`), and the pod itself may be
-# swapped for another variant.
-pods_root = ENV.fetch('PODS_ROOT')
-build_products = ENV.fetch('PODS_CONFIGURATION_BUILD_DIR')
-
-headers = [pods_root, build_products]
-          .flat_map { |root| Dir.glob(File.join(root, '**', 'ffmpegkit.framework', 'Headers', 'Level.h')) }
-          .uniq
-          .select { |path| File.file?(path) }
-
-abort('munim-ffmpeg: could not find the expected FFmpegKit Level.h') if headers.empty?
-
-unsigned_declaration = 'NS_ENUM(NSUInteger, Level)'
-signed_declaration = 'NS_ENUM(NSInteger, Level)'
-
-headers.each do |header|
-  contents = File.binread(header)
-  next if contents.include?(signed_declaration) && !contents.include?(unsigned_declaration)
-
-  occurrences = contents.scan(unsigned_declaration).length
-  abort("munim-ffmpeg: unexpected Level enum declaration in #{header}") unless occurrences == 1
-
-  patched = contents.sub(unsigned_declaration, signed_declaration)
-  Tempfile.create(['Level', '.h'], File.dirname(header)) do |temporary|
-    temporary.binmode
-    temporary.write(patched)
-    temporary.flush
-    FileUtils.chmod(File.stat(header).mode, temporary.path)
-    FileUtils.mv(temporary.path, header)
-  end
-end