munim-ffmpeg 0.5.0 → 0.5.1

package/README.md

@@ -132,8 +132,8 @@
 | Expo Go                      | ❌              | ❌              | A native development build is required.                                                                                                                 |
 | 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    | 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.                                         |
+| 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.
 
@@ -567,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',
@@ -741,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

@@ -5,6 +5,55 @@ 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
  * the app process.
@@ -21,6 +70,25 @@ object FFmpegNative {
     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,
+    session: FFmpegSession,
+  ): Int
+
+  external fun nativeExecuteProbe(
+    arguments: Array<String>,
+    outputPath: String,
+    session: FFmpegSession,
+  ): Int
+
+  external fun nativeCancel()
+
   /**
    * 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
@@ -53,70 +121,4 @@ object FFmpegNative {
       Os.setenv("FONTCONFIG_FILE", configuration.absolutePath, true)
     }
   }
-
-  /** 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

@@ -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.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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "munim-ffmpeg",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Fast FFmpeg and FFprobe for Expo and React Native, powered by Nitro Modules",
   "main": "lib/index",
   "module": "lib/index",

package/scripts/binaries.json

@@ -1,5 +1,5 @@
 {
   "archive": "munim-ffmpeg-binaries.tar.gz",
-  "sha256": "05bb0a21348ae3958ca8b06fe6e31bfe2048277f6c6a4720271ce53a8973b653",
+  "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[]> {