munim-ffmpeg 0.1.1 → 0.3.0

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/app.plugin.js

@@ -1,8 +1,28 @@
-const { withGradleProperties } = require('expo/config-plugins')
+const fs = require('node:fs')
+const path = require('node:path')
+const {
+  withDangerousMod,
+  withGradleProperties,
+} = require('expo/config-plugins')
 
 const PICK_FIRSTS_PROPERTY = 'android.packagingOptions.pickFirsts'
 const CXX_SHARED_LIBRARY = '**/libc++_shared.so'
 
+const PODFILE_MARKER = '# munim-ffmpeg: allow arm64 iOS Simulator builds'
+const PODFILE_SNIPPET = `    ${PODFILE_MARKER}
+    # The FFmpegKit pod excludes arm64 from Simulator builds, which breaks Apple
+    # Silicon Macs even though its xcframework ships an arm64 Simulator slice.
+    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
+`
+
 function withAndroidPackaging(config) {
   return withGradleProperties(config, (gradleConfig) => {
     const existing = gradleConfig.modResults.find(
@@ -30,8 +50,44 @@ function withAndroidPackaging(config) {
   })
 }
 
+function withSimulatorArchitectures(config) {
+  return withDangerousMod(config, [
+    'ios',
+    (modConfig) => {
+      const podfilePath = path.join(
+        modConfig.modRequest.platformProjectRoot,
+        'Podfile'
+      )
+
+      if (!fs.existsSync(podfilePath)) return modConfig
+
+      const contents = fs.readFileSync(podfilePath, 'utf8')
+      if (contents.includes(PODFILE_MARKER)) return modConfig
+
+      const postInstall = /^([ \t]*)post_install do \|(\w+)\|[ \t]*$/m
+      const match = contents.match(postInstall)
+
+      if (!match) {
+        console.warn(
+          'munim-ffmpeg: no post_install block found in the Podfile; arm64 Simulator builds may fail.'
+        )
+        return modConfig
+      }
+
+      const snippet = PODFILE_SNIPPET.replace(/\binstaller\b/g, match[2])
+      const patched = contents.replace(
+        postInstall,
+        (line) => `${line}\n${snippet}`
+      )
+
+      fs.writeFileSync(podfilePath, patched)
+      return modConfig
+    },
+  ])
+}
+
 module.exports = function withMunimFfmpeg(config) {
-  return withAndroidPackaging(config)
+  return withSimulatorArchitectures(withAndroidPackaging(config))
 }
 
 module.exports.default = module.exports

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)
 
-    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())
-        )
+    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)
       }
-    )
-    if let session {
-      onSessionCreated?(Double(session.getId()))
+
+      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,
+          startedAt: startedAt
+        )
+      )
     }
 
     return promise
@@ -53,23 +122,20 @@ final class HybridMunimFfmpeg: HybridMunimFfmpegSpec {
     onSessionCreated: ((_ sessionId: Double) -> Void)?
   ) throws -> Promise<FFmpegSessionResult> {
     let promise = Promise<FFmpegSessionResult>()
+    let sessionId = nextSession()
+    onSessionCreated?(sessionId)
 
-    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()))
+    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,40 +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()
+    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: String(describing: session.getState()).lowercased(),
-      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):