munim-ffmpeg 0.4.2 → 0.5.1

package/NitroMunimFfmpeg.podspec

@@ -30,7 +30,8 @@ Pod::Spec.new do |s|
   s.pod_target_xcconfig = {
     "HEADER_SEARCH_PATHS" => "\"$(PODS_TARGET_SRCROOT)/ios\"",
   }
-  s.frameworks = "AudioToolbox", "VideoToolbox", "CoreMedia", "AVFoundation", "CoreVideo", "Security"
+  # CoreText and CoreGraphics are libass's font provider on iOS.
+  s.frameworks = "AudioToolbox", "VideoToolbox", "CoreMedia", "AVFoundation", "CoreVideo", "Security", "CoreText", "CoreGraphics"
   s.libraries = "bz2", "z", "iconv", "c++"
 
   # Must be public so CocoaPods puts it in the module umbrella, which is how the

package/README.md

@@ -112,7 +112,8 @@
 - 📱 **iOS and Android:** Native implementations in Swift and Kotlin
 - 🧬 **Nitro Modules:** Generated high-performance native bindings
 - 🚀 **Expo compatible:** Autolinking, config plugin, and an Expo development example
-- 🧪 **Capability discovery:** Ask the bundled build which encoders and decoders it actually has
+- 🧪 **Capability discovery:** Ask the bundled build which encoders, decoders, muxers, demuxers, filters, and protocols it actually has
+- 💬 **Subtitle burn-in:** libass renders ASS/SSA and SRT subtitles — styling, positioning, outlines, shadows, and proper Arabic/Urdu shaping via HarfBuzz and FriBidi
 - 🎯 **TypeScript:** Complete public callback and result types
 - 🗂️ **16 KB Android pages:** Built with the alignment Google Play requires
 
@@ -129,9 +130,10 @@
 | Cancel one FFmpeg session    | ✅              | ✅              | Pass the positive safe-integer ID received by `execute`'s `onSessionCreated`. The native dependency does not expose FFprobe cancellation.               |
 | Cancel all FFmpeg sessions   | ✅              | ✅              | Use `cancelAll()` or call `cancel()` without an ID.                                                                                                     |
 | Expo Go                      | ❌              | ❌              | A native development build is required.                                                                                                                 |
-| Capability discovery         | ✅              | ✅              | `listEncoders()`, `listDecoders()`, and `pickEncoder()` report what the bundled build supports.                                                          |
-| H.264 encoding               | VideoToolbox    | libx264         | The builds differ; use `pickEncoder(['libx264', 'h264_videotoolbox'])` instead of hard-coding an encoder.                                                |
-| Remote HTTP(S) inputs        | ✅              | ✅              | Both builds link GnuTLS. Remote server behaviour still varies; prefer local files for predictable app workflows.                                         |
+| Capability discovery         | ✅              | ✅              | `listEncoders()`, `listDecoders()`, `listMuxers()`, `listDemuxers()`, `listFilters()`, `listProtocols()`, and `pickEncoder()` report what the bundled build supports. |
+| Subtitle burn-in             | ✅              | ✅              | libass with system fonts: Core Text on iOS, fontconfig over `/system/fonts` on Android.                                                                  |
+| H.264 encoding               | VideoToolbox    | MediaCodec      | Hardware on both, `libopenh264` as the software fallback; use `pickEncoder(['h264_videotoolbox', 'h264_mediacodec', 'libopenh264'])` instead of hard-coding an encoder. |
+| Remote HTTP(S) inputs        | ✅              | ✅              | iOS links SecureTransport, Android links mbedTLS. Remote server behaviour still varies; prefer local files for predictable app workflows.                 |
 
 Codec availability is determined by the native FFmpeg builds described in [Bundled FFmpeg builds](#bundled-ffmpeg-builds). Do not assume every FFmpeg codec or external library is present.
 
@@ -177,13 +179,13 @@ Both platforms run **FFmpeg 9.0.1**, built from [ffmpeg.org](https://www.ffmpeg.
 | TLS | SecureTransport | mbedTLS |
 | Minimum | iOS 15.1 | API 24, 16 KB pages |
 
-Linked libraries, identical on both: **LAME** (MP3), **Opus**, **libvpx** (VP8/VP9), **dav1d** (AV1 decoding), **openh264** (software H.264), plus everything FFmpeg builds natively.
+Linked libraries, identical on both: **LAME** (MP3), **Opus**, **libvpx** (VP8/VP9), **dav1d** (AV1 decoding), **openh264** (software H.264), **libass** with **FreeType**, **HarfBuzz**, and **FriBidi** (subtitle rendering and text shaping), plus everything FFmpeg builds natively. Android additionally links **fontconfig** and **expat** so libass can discover the system fonts; iOS uses Core Text for the same job.
 
 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: 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`.
+Verified by running the example's device suite: iOS reports 187 encoders, Android 185. Everything FFmpeg builds natively (`aac`, `alac`, `flac`, `mpeg4`, `mjpeg`, `png`, `gif`, `pcm_*`, …) is on both, as are `libmp3lame`, `libopus`, `libvpx`, and `libvpx-vp9`.
 
 H.264 and HEVC come from the platform's hardware encoder, which is faster and uses less power than a software encoder. `libopenh264` is there as a software H.264 fallback for anywhere hardware encoding is unavailable — an emulator, for instance:
 
@@ -463,6 +465,31 @@ Returns the decoder names the bundled FFmpeg build can read.
 function listDecoders(): Promise<string[]>
 ```
 
+### `listMuxers()` / `listDemuxers()`
+
+Return the container formats the bundled FFmpeg build can write and read, e.g. `mp4`, `matroska`, `webm`. Cached after the first call.
+
+```typescript
+function listMuxers(): Promise<string[]>
+function listDemuxers(): Promise<string[]>
+```
+
+### `listFilters()`
+
+Returns the filter names the bundled FFmpeg build provides, e.g. `subtitles`, `ass`, `drawtext`, `scale`.
+
+```typescript
+function listFilters(): Promise<string[]>
+```
+
+### `listProtocols()`
+
+Returns the protocol names the bundled FFmpeg build provides, e.g. `file`, `https`, `concat`.
+
+```typescript
+function listProtocols(): Promise<string[]>
+```
+
 ### `pickEncoder(candidates)`
 
 Returns the first name in `candidates` that the build provides, or `undefined` when none are available. Use it to write one command that runs on both platforms.
@@ -540,11 +567,12 @@ if (!result.success) {
 ```typescript
 import { execute, pickEncoder } from 'munim-ffmpeg'
 
-const encoder = await pickEncoder(['libx264', 'h264_videotoolbox'])
+const encoder = await pickEncoder(['h264_videotoolbox', 'h264_mediacodec', 'libopenh264'])
 if (!encoder) throw new Error('No H.264 encoder available in this build')
 
-// -preset is an x264 option; VideoToolbox rejects it.
-const quality = encoder === 'libx264' ? ['-preset', 'veryfast', '-crf', '23'] : ['-b:v', '2M']
+// MediaCodec wants NV12 input; the others take planar YUV.
+const pixelFormat = encoder === 'h264_mediacodec' ? 'nv12' : 'yuv420p'
+const quality = ['-b:v', '2M', '-pix_fmt', pixelFormat]
 
 const result = await execute([
   '-y',
@@ -580,6 +608,58 @@ const result = await execute([
 ])
 ```
 
+### Burn subtitles into a video
+
+The bundled builds include libass with FreeType, HarfBuzz, and FriBidi, so ASS/SSA styling and complex scripts (Arabic, Urdu, and other RTL or shaped text) render correctly. System fonts are found automatically — through Core Text on iOS and through fontconfig scanning `/system/fonts` on Android.
+
+```typescript
+import { execute, normalizePath } from 'munim-ffmpeg'
+
+// ASS/SSA keeps its embedded styling: fonts, colours, outlines,
+// shadows, positioning, karaoke — everything the format supports.
+await execute([
+  '-y',
+  '-i', inputPath,
+  '-vf', `ass=filename=${normalizePath(subtitlePath)}`,
+  '-c:a', 'copy',
+  outputPath,
+])
+
+// SRT can be styled at burn time with force_style.
+await execute([
+  '-y',
+  '-i', inputPath,
+  '-vf', `subtitles=filename=${normalizePath(srtPath)}:force_style='Fontsize=28,PrimaryColour=&H00FFFF00,Outline=2'`,
+  '-c:a', 'copy',
+  outputPath,
+])
+```
+
+To ship your own fonts instead of relying on the device's, put them in a directory and add `:fontsdir=/path/to/fonts` to the filter. Note that filter arguments are colon-separated, so a path containing `:` must be escaped — app sandbox paths on both platforms are safe as-is.
+
+### Work with MKV and multiple tracks
+
+Matroska muxing and demuxing is compiled in, along with FFmpeg's standard `-map` stream selection and `-c copy` remuxing:
+
+```typescript
+import { execute } from 'munim-ffmpeg'
+
+// Bundle one video, two audio languages, and a subtitle track into MKV.
+await execute([
+  '-y',
+  '-i', videoPath, '-i', urduAudioPath, '-i', subtitlePath,
+  '-map', '0:v:0', '-map', '0:a:0', '-map', '1:a:0', '-map', '2:s:0',
+  '-c:v', 'copy', '-c:a', 'aac', '-c:s', 'srt',
+  '-metadata:s:a:1', 'language=urd',
+  outputMkvPath,
+])
+
+// Extract the second audio track without re-encoding.
+await execute([
+  '-y', '-i', outputMkvPath, '-map', '0:a:1', '-c', 'copy', trackPath,
+])
+```
+
 ### Cancel a long-running command
 
 ```typescript
@@ -632,7 +712,7 @@ if (result.success) {
 
 The JavaScript, TypeScript, Swift, Kotlin, C core, and generated Nitro bridge in this repository are Apache-2.0.
 
-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. The external libraries it links are LAME (LGPL), Opus (BSD), libvpx (BSD), dav1d (BSD), openh264 (BSD 2-clause), and mbedTLS (Apache-2.0) on Android.
+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. The external libraries it links are LAME (LGPL), Opus (BSD), libvpx (BSD), dav1d (BSD), openh264 (BSD 2-clause), libass (ISC), FreeType (FTL, BSD-style with credit), HarfBuzz (MIT-style), FriBidi (LGPL), and, on Android only, mbedTLS (Apache-2.0), fontconfig (MIT-style), and expat (MIT). None of them change the LGPL story.
 
 > **A note on H.264 patents.** Hardware encoders are covered by the licences device manufacturers already pay for. Software H.264 encoding through `libopenh264` is not: Cisco's royalty coverage applies to *their* prebuilt binary, and this package builds openh264 from source. If you ship software H.264 encoding at scale, check where you stand with AVC licensing. Hardware encoders avoid the question entirely, which is why `pickEncoder` should list them first.
 
@@ -662,7 +742,7 @@ Rebuild the native app after installing both `munim-ffmpeg` and `react-native-ni
 
 ### A codec or filter is missing
 
-Native FFmpeg variants do not bundle every codec, filter, or third-party library, and the iOS and Android builds are not identical. Call `listEncoders()` or `listDecoders()` to see what the running build actually has, and prefer `pickEncoder()` over a hard-coded name. `libx264` in particular exists only on Android — see [Bundled FFmpeg builds](#bundled-ffmpeg-builds).
+Native FFmpeg variants do not bundle every codec, filter, or third-party library, and the iOS and Android builds are not identical. Call `listEncoders()`, `listDecoders()`, `listMuxers()`, `listDemuxers()`, `listFilters()`, or `listProtocols()` to see what the running build actually has, and prefer `pickEncoder()` over a hard-coded name. There is no `libx264` in these LGPL builds — H.264 comes from the platform's hardware encoder or `libopenh264` — see [Bundled FFmpeg builds](#bundled-ffmpeg-builds).
 
 ### The Promise resolved but the command failed
 

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

@@ -1,7 +1,58 @@
 package com.margelo.nitro.munimffmpeg
 
+import android.system.Os
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
+import java.io.File
+
+/**
+ * Per-run callback target. The JNI bridge holds a global reference to this
+ * object for the duration of its execution and the native core only routes
+ * callbacks to whichever session actually holds the execution lock, so
+ * concurrently submitted sessions never see each other's logs.
+ */
+@Keep
+@DoNotStrip
+class FFmpegSession(
+  private val logSink: ((String) -> Unit)?,
+  private val statisticsSink: ((
+    timeMs: Double,
+    sizeBytes: Double,
+    bitrateKbits: Double,
+    speed: Double,
+    videoFrameNumber: Double,
+    fps: Double,
+    quality: Double,
+  ) -> Unit)?,
+) {
+  private val buffer = StringBuilder()
+
+  val output: String
+    get() = synchronized(buffer) { buffer.toString() }
+
+  // FFmpeg logs from several of its own threads at once, so the buffer needs
+  // the lock even though each session belongs to a single execution.
+  @Keep
+  @DoNotStrip
+  fun onLog(message: String) {
+    synchronized(buffer) { buffer.append(message) }
+    logSink?.invoke(message)
+  }
+
+  @Keep
+  @DoNotStrip
+  fun onStatistics(
+    timeMs: Double,
+    sizeBytes: Double,
+    bitrateKbits: Double,
+    speed: Double,
+    videoFrameNumber: Double,
+    fps: Double,
+    quality: Double,
+  ) {
+    statisticsSink?.invoke(timeMs, sizeBytes, bitrateKbits, speed, videoFrameNumber, fps, quality)
+  }
+}
 
 /**
  * Thin wrapper over FFmpeg 9's own command-line tools, compiled to run inside
@@ -15,6 +66,7 @@ import com.facebook.proguard.annotations.DoNotStrip
 @DoNotStrip
 object FFmpegNative {
   init {
+    configureFontconfig()
     System.loadLibrary("munimffmpeg9")
   }
 
@@ -23,64 +75,50 @@ object FFmpegNative {
 
   external fun nativeVersion(): String
 
-  external fun nativeExecute(arguments: Array<String>, stdoutPath: String): Int
+  external fun nativeExecute(
+    arguments: Array<String>,
+    stdoutPath: String,
+    session: FFmpegSession,
+  ): Int
 
-  external fun nativeExecuteProbe(arguments: Array<String>, outputPath: String): Int
+  external fun nativeExecuteProbe(
+    arguments: Array<String>,
+    outputPath: String,
+    session: FFmpegSession,
+  ): 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,
-  )
+  /**
+   * libass discovers fonts through fontconfig, and Android has no fonts.conf,
+   * so one pointing at the system font directories is written to the app's
+   * cache and exported before FFmpeg first runs. Without it, `subtitles=` and
+   * `drawtext` render nothing. Apps that manage their own fontconfig setup can
+   * set FONTCONFIG_FILE first; it is never overwritten.
+   */
+  private fun configureFontconfig() {
+    runCatching {
+      if (!System.getenv("FONTCONFIG_FILE").isNullOrEmpty()) return
 
-  @Volatile
-  private var logSink: ((String) -> Unit)? = null
+      val root = File(System.getProperty("java.io.tmpdir"), "munim-ffmpeg-fontconfig")
+      val cache = File(root, "cache")
+      cache.mkdirs()
 
-  @Volatile
-  private var statisticsSink: ((Statistics) -> Unit)? = null
+      val configuration = File(root, "fonts.conf")
+      configuration.writeText(
+        """
+        <?xml version="1.0"?>
+        <!DOCTYPE fontconfig SYSTEM "fonts.dtd">
+        <fontconfig>
+          <dir>/system/fonts</dir>
+          <dir>/system/font</dir>
+          <dir>/product/fonts</dir>
+          <cachedir>${cache.absolutePath}</cachedir>
+        </fontconfig>
+        """.trimIndent()
+      )
 
-  fun <T> withCallbacks(
-    onLog: ((String) -> Unit)?,
-    onStatistics: ((Statistics) -> Unit)?,
-    body: () -> T,
-  ): T {
-    logSink = onLog
-    statisticsSink = onStatistics
-    try {
-      return body()
-    } finally {
-      logSink = null
-      statisticsSink = null
+      Os.setenv("FONTCONFIG_FILE", configuration.absolutePath, true)
     }
   }
-
-  @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

@@ -53,37 +53,21 @@ class HybridMunimFfmpeg : HybridMunimFfmpegSpec() {
     onSessionCreated?.invoke(sessionId)
 
     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.timeMs,
-            statistics.sizeBytes,
-            statistics.bitrateKbits,
-            statistics.speed,
-            statistics.videoFrameNumber,
-            statistics.fps,
-            statistics.quality,
-          )
-        },
-      ) {
-        FFmpegNative.nativeExecute(arguments_, stdout.absolutePath)
-      }
+      val session = FFmpegSession(
+        logSink = { message -> onLog?.invoke(message) },
+        statisticsSink = onStatistics,
+      )
+      val returnCode = FFmpegNative.nativeExecute(arguments_, stdout.absolutePath, session)
 
       val printed = runCatching { stdout.readText() }.getOrDefault("")
       stdout.delete()
-      output.append(printed)
 
-      result(sessionId, returnCode, output.toString(), System.currentTimeMillis() - startedAt)
+      result(sessionId, returnCode, session.output + printed, System.currentTimeMillis() - startedAt)
     }
   }
 
@@ -138,19 +122,15 @@ class HybridMunimFfmpeg : HybridMunimFfmpegSpec() {
   ): 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 session = FFmpegSession(
+        logSink = { message -> onLog?.invoke(message) },
+        statisticsSink = null,
+      )
+      val returnCode =
+        FFmpegNative.nativeExecuteProbe(arguments, destination.absolutePath, session)
 
       val report = destination.readText()
-      return returnCode to report.ifEmpty { logs.toString() }
+      return returnCode to report.ifEmpty { session.output }
     } finally {
       destination.delete()
     }

package/ios/HybridMunimFfmpeg.swift

@@ -1,21 +1,39 @@
 import Foundation
 import NitroModules
 
-/// 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 = ""
+/// Per-run callback target, handed to the core as the context pointer. The
+/// core only routes callbacks to whichever session actually holds its
+/// execution lock, so concurrently submitted sessions never see each other's
+/// logs.
+private final class Session {
+  let onLog: ((String) -> Void)?
+  let onStatistics: ((Double, Double, Double, Double, Double, Double, Double) -> Void)?
+  private var buffer = ""
+  // FFmpeg logs from several of its own threads at once, so the buffer needs
+  // the lock even though each session belongs to a single execution.
+  private let lock = NSLock()
+
+  init(
+    onLog: ((String) -> Void)?,
+    onStatistics: ((Double, Double, Double, Double, Double, Double, Double) -> Void)? = nil
+  ) {
+    self.onLog = onLog
+    self.onStatistics = onStatistics
+  }
+
+  func append(_ text: String) {
+    lock.lock()
+    buffer += text
+    lock.unlock()
+  }
+
+  var output: String {
+    lock.lock()
+    defer { lock.unlock() }
+    return buffer
   }
 }
 
-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.
@@ -25,16 +43,17 @@ private let executionQueue = DispatchQueue(
   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)
-}
+private let installCallbacks: Void = munim_ffmpeg_set_callbacks({ context, message in
+  guard let context, let message else { return }
+  let session = Unmanaged<Session>.fromOpaque(context).takeUnretainedValue()
+  let text = String(cString: message)
+  session.append(text)
+  session.onLog?(text)
+}, { context, timeMs, sizeBytes, bitrate, speed, frame, fps, quality in
+  guard let context else { return }
+  let session = Unmanaged<Session>.fromOpaque(context).takeUnretainedValue()
+  session.onStatistics?(timeMs, sizeBytes, bitrate, speed, frame, fps, quality)
+}, nil)
 
 final class HybridMunimFfmpeg: HybridMunimFfmpegSpec {
   private var sessionCounter: Double = 0
@@ -88,26 +107,28 @@ final class HybridMunimFfmpeg: HybridMunimFfmpegSpec {
       // 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
+      _ = installCallbacks
+      let session = Session(onLog: onLog, onStatistics: onStatistics)
 
-      let returnCode = withArrayOfCStrings(arguments_) { argv in
-        munim_ffmpeg_execute(Int32(arguments_.count), argv, printedPath)
+      let returnCode = withExtendedLifetime(session) {
+        withArrayOfCStrings(arguments_) { argv in
+          munim_ffmpeg_execute_ctx(
+            Int32(arguments_.count),
+            argv,
+            printedPath,
+            Unmanaged.passUnretained(session).toOpaque()
+          )
+        }
       }
 
       let printed = (try? String(contentsOfFile: printedPath, encoding: .utf8)) ?? ""
       try? FileManager.default.removeItem(atPath: printedPath)
 
-      let output = active.output + printed
-      active.reset()
-
       promise.resolve(
         withResult: self.result(
           sessionId: sessionId,
           returnCode: returnCode,
-          output: output,
+          output: session.output + printed,
           startedAt: startedAt
         )
       )
@@ -178,21 +199,24 @@ final class HybridMunimFfmpeg: HybridMunimFfmpegSpec {
   ) -> (Int32, String) {
     let destination = temporaryFile()
 
-    installCallbacks()
-    active.reset()
-    active.onLog = onLog
+    _ = installCallbacks
+    let session = Session(onLog: onLog)
 
-    let returnCode = withArrayOfCStrings(arguments) { argv in
-      munim_ffmpeg_probe(Int32(arguments.count), argv, destination)
+    let returnCode = withExtendedLifetime(session) {
+      withArrayOfCStrings(arguments) { argv in
+        munim_ffmpeg_probe_ctx(
+          Int32(arguments.count),
+          argv,
+          destination,
+          Unmanaged.passUnretained(session).toOpaque()
+        )
+      }
     }
 
     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)
+    return (returnCode, report.isEmpty ? session.output : report)
   }
 
   func cancel(sessionId: Double?) throws {

package/ios/munim_ffmpeg_core.h

@@ -21,7 +21,12 @@ typedef void (*munim_statistics_callback)(void *context, double time_ms,
 /** 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. */
+/**
+ * Installs the callback functions. `context` is the default value handed to
+ * them; an execution started through one of the `_ctx` variants overrides it
+ * for exactly as long as that execution holds the core's lock, which is how
+ * callers waiting concurrently keep their callbacks apart.
+ */
 void munim_ffmpeg_set_callbacks(munim_log_callback on_log,
                                 munim_statistics_callback on_statistics,
                                 void *context);
@@ -38,10 +43,18 @@ void munim_ffmpeg_set_callbacks(munim_log_callback on_log,
 int munim_ffmpeg_execute(int argc, const char *const *argv,
                          const char *stdout_path);
 
+/** Like munim_ffmpeg_execute, with a per-run callback context. */
+int munim_ffmpeg_execute_ctx(int argc, const char *const *argv,
+                             const char *stdout_path, void *session);
+
 /** Runs `ffprobe`, writing its report to `output_path` via `-o`. */
 int munim_ffmpeg_probe(int argc, const char *const *argv,
                        const char *output_path);
 
+/** Like munim_ffmpeg_probe, with a per-run callback context. */
+int munim_ffmpeg_probe_ctx(int argc, const char *const *argv,
+                           const char *output_path, void *session);
+
 /**
  * Requests cancellation of the running execution, and of any execution already
  * queued behind it.

package/lib/index.d.ts

@@ -21,6 +21,14 @@ export declare function getFFmpegVersion(): string;
 export declare function listEncoders(): Promise<string[]>;
 /** Decoder names the bundled FFmpeg build can read, e.g. `h264`. */
 export declare function listDecoders(): Promise<string[]>;
+/** Container formats the bundled FFmpeg build can write, e.g. `matroska`. */
+export declare function listMuxers(): Promise<string[]>;
+/** Container formats the bundled FFmpeg build can read, e.g. `matroska`. */
+export declare function listDemuxers(): Promise<string[]>;
+/** Filter names the bundled FFmpeg build provides, e.g. `subtitles`. */
+export declare function listFilters(): Promise<string[]>;
+/** Protocol names the bundled FFmpeg build provides, e.g. `https`. */
+export declare function listProtocols(): Promise<string[]>;
 /**
  * Returns the first available encoder from `candidates`, so one command can
  * run on both platforms:

package/lib/index.js

@@ -39,9 +39,9 @@ export function cancelAll() {
 export function getFFmpegVersion() {
     return MunimFfmpeg.ffmpegVersion;
 }
-// The bundled FFmpeg builds differ per platform: Android ships libx264/libx265,
-// iOS ships the VideoToolbox hardware encoders instead. Asking the binary what
-// it supports is more reliable than hard-coding a per-platform table.
+// The bundled FFmpeg builds differ per platform: Android ships the MediaCodec
+// hardware encoders, iOS ships VideoToolbox. Asking the binary what it
+// supports is more reliable than hard-coding a per-platform table.
 const codecCache = new Map();
 function listCodecs(flag) {
     const cached = codecCache.get(flag);
@@ -76,6 +76,80 @@ export function listEncoders() {
 export function listDecoders() {
     return listCodecs('-decoders');
 }
+// Muxers, demuxers and filters print with different flag columns than codecs,
+// and protocols use indented sections instead of a table, so each report gets
+// its own parser. All of them are cached like the codec lists.
+const reportCache = new Map();
+function listReport(flag, parse) {
+    const cached = reportCache.get(flag);
+    if (cached)
+        return cached;
+    const request = execute(['-hide_banner', flag])
+        .then((result) => {
+        if (!result.success) {
+            throw new Error(result.failStackTrace ?? result.output);
+        }
+        return parse(result.output);
+    })
+        .catch((error) => {
+        reportCache.delete(flag);
+        throw error;
+    });
+    reportCache.set(flag, request);
+    return request;
+}
+// `-muxers`/`-demuxers` entries look like ` E  mp4  MP4 (MPEG-4 Part 14)`
+// below a `--` separator line.
+function parseFormats(output) {
+    const body = output.split(/^\s*-+\s*$/m).pop() ?? '';
+    return body
+        .split('\n')
+        .map((line) => line.trim().split(/\s+/))
+        .filter((columns) => columns.length >= 2 && /^[DE.]{1,2}$/.test(columns[0]))
+        .flatMap((columns) => columns[1].split(','));
+}
+// `-filters` entries look like ` TS scale  V->V  Scale the input video.`
+// The flag column has held two or three characters across FFmpeg releases.
+function parseFilters(output) {
+    return output
+        .split('\n')
+        .map((line) => line.trim().split(/\s+/))
+        .filter((columns) => columns.length >= 3 &&
+        /^[TSC.]{2,3}$/.test(columns[0]) &&
+        /->/.test(columns[2]))
+        .map((columns) => columns[1]);
+}
+// `-protocols` prints `Input:` and `Output:` sections of indented names.
+function parseProtocols(output) {
+    const names = new Set();
+    let inSection = false;
+    for (const line of output.split('\n')) {
+        if (/^(Input|Output):/.test(line.trim())) {
+            inSection = true;
+            continue;
+        }
+        const name = line.trim();
+        if (inSection && /^[a-z0-9_]+$/.test(name))
+            names.add(name);
+    }
+    return [...names];
+}
+/** Container formats the bundled FFmpeg build can write, e.g. `matroska`. */
+export function listMuxers() {
+    return listReport('-muxers', parseFormats);
+}
+/** Container formats the bundled FFmpeg build can read, e.g. `matroska`. */
+export function listDemuxers() {
+    return listReport('-demuxers', parseFormats);
+}
+/** Filter names the bundled FFmpeg build provides, e.g. `subtitles`. */
+export function listFilters() {
+    return listReport('-filters', parseFilters);
+}
+/** Protocol names the bundled FFmpeg build provides, e.g. `https`. */
+export function listProtocols() {
+    return listReport('-protocols', parseProtocols);
+}
 /**
  * Returns the first available encoder from `candidates`, so one command can
  * run on both platforms:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "munim-ffmpeg",
-  "version": "0.4.2",
+  "version": "0.5.1",
   "description": "Fast FFmpeg and FFprobe for Expo and React Native, powered by Nitro Modules",
   "main": "lib/index",
   "module": "lib/index",
@@ -78,6 +78,11 @@
   "workspaces": [
     "example"
   ],
+  "overrides": {
+    "xcode": {
+      "uuid": "^11.1.1"
+    }
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/munimtechnologies/munim-ffmpeg.git"

package/scripts/binaries.json

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

package/src/index.ts

@@ -84,9 +84,9 @@ export function getFFmpegVersion(): string {
   return MunimFfmpeg.ffmpegVersion
 }
 
-// The bundled FFmpeg builds differ per platform: Android ships libx264/libx265,
-// iOS ships the VideoToolbox hardware encoders instead. Asking the binary what
-// it supports is more reliable than hard-coding a per-platform table.
+// The bundled FFmpeg builds differ per platform: Android ships the MediaCodec
+// hardware encoders, iOS ships VideoToolbox. Asking the binary what it
+// supports is more reliable than hard-coding a per-platform table.
 const codecCache = new Map<string, Promise<string[]>>()
 
 function listCodecs(flag: '-encoders' | '-decoders'): Promise<string[]> {
@@ -129,6 +129,97 @@ export function listDecoders(): Promise<string[]> {
   return listCodecs('-decoders')
 }
 
+// Muxers, demuxers and filters print with different flag columns than codecs,
+// and protocols use indented sections instead of a table, so each report gets
+// its own parser. All of them are cached like the codec lists.
+const reportCache = new Map<string, Promise<string[]>>()
+
+function listReport(
+  flag: string,
+  parse: (output: string) => string[]
+): Promise<string[]> {
+  const cached = reportCache.get(flag)
+  if (cached) return cached
+
+  const request = execute(['-hide_banner', flag])
+    .then((result) => {
+      if (!result.success) {
+        throw new Error(result.failStackTrace ?? result.output)
+      }
+      return parse(result.output)
+    })
+    .catch((error) => {
+      reportCache.delete(flag)
+      throw error
+    })
+
+  reportCache.set(flag, request)
+  return request
+}
+
+// `-muxers`/`-demuxers` entries look like ` E  mp4  MP4 (MPEG-4 Part 14)`
+// below a `--` separator line.
+function parseFormats(output: string): string[] {
+  const body = output.split(/^\s*-+\s*$/m).pop() ?? ''
+  return body
+    .split('\n')
+    .map((line) => line.trim().split(/\s+/))
+    .filter(
+      (columns) => columns.length >= 2 && /^[DE.]{1,2}$/.test(columns[0]!)
+    )
+    .flatMap((columns) => columns[1]!.split(','))
+}
+
+// `-filters` entries look like ` TS scale  V->V  Scale the input video.`
+// The flag column has held two or three characters across FFmpeg releases.
+function parseFilters(output: string): string[] {
+  return output
+    .split('\n')
+    .map((line) => line.trim().split(/\s+/))
+    .filter(
+      (columns) =>
+        columns.length >= 3 &&
+        /^[TSC.]{2,3}$/.test(columns[0]!) &&
+        /->/.test(columns[2]!)
+    )
+    .map((columns) => columns[1]!)
+}
+
+// `-protocols` prints `Input:` and `Output:` sections of indented names.
+function parseProtocols(output: string): string[] {
+  const names = new Set<string>()
+  let inSection = false
+  for (const line of output.split('\n')) {
+    if (/^(Input|Output):/.test(line.trim())) {
+      inSection = true
+      continue
+    }
+    const name = line.trim()
+    if (inSection && /^[a-z0-9_]+$/.test(name)) names.add(name)
+  }
+  return [...names]
+}
+
+/** Container formats the bundled FFmpeg build can write, e.g. `matroska`. */
+export function listMuxers(): Promise<string[]> {
+  return listReport('-muxers', parseFormats)
+}
+
+/** Container formats the bundled FFmpeg build can read, e.g. `matroska`. */
+export function listDemuxers(): Promise<string[]> {
+  return listReport('-demuxers', parseFormats)
+}
+
+/** Filter names the bundled FFmpeg build provides, e.g. `subtitles`. */
+export function listFilters(): Promise<string[]> {
+  return listReport('-filters', parseFilters)
+}
+
+/** Protocol names the bundled FFmpeg build provides, e.g. `https`. */
+export function listProtocols(): Promise<string[]> {
+  return listReport('-protocols', parseProtocols)
+}
+
 /**
  * Returns the first available encoder from `candidates`, so one command can
  * run on both platforms: