react-native-video-trim 8.1.4 → 8.1.6

package/README.md

@@ -763,16 +763,32 @@ When any transform is applied, FFmpeg automatically re-encodes the video using t
 
 ### Android encoder compatibility (auto fallback)
 
-On Android, a small number of devices ship a hardware H.264 encoder (`h264_mediacodec`) that refuses to configure for valid H.264 inputs — typically with `MediaCodec configure failed, Generic error in an external library` (e.g. LG G8 ThinQ on Snapdragon 855, and other older Qualcomm/MediaTek chipsets). This affects only the re-encode path (transform / crop / `enablePreciseTrimming` / non-`1.0` speed); plain trims use stream copy and never touch an encoder.
+On Android, a small number of devices ship a hardware H.264 encoder (`h264_mediacodec`) that refuses to configure for valid H.264 inputs — typically with `MediaCodec configure failed, Generic error in an external library` (e.g. LG G8 ThinQ on Snapdragon 855, certain Samsung Galaxy models, and other older Qualcomm/MediaTek chipsets). This affects every code path that re-encodes video.
 
 The library handles this automatically with a two-step encoder fallback chain:
 
 1. `h264_mediacodec` — hardware H.264, fast, default. Used on every device first.
 2. `mpeg4 -q:v 3` — software MPEG-4 Part 2, always available. Only used if attempt 1 fails at `configure()` with a hardware-encoder signature. Lower visual quality and larger files than H.264, but guaranteed to work.
 
+The fallback is wired into every Android API that opens a video encoder:
+
+| API | Goes through fallback? |
+|-----|------------------------|
+| `showEditor` save (when transform / crop / `enablePreciseTrimming` / speed) | Yes |
+| `trim` (when `enablePreciseTrimming` or `speed != 1.0`) | Yes |
+| `trim` (plain — stream copy `-c copy`) | N/A, no encoder is opened |
+| `compress` | Yes (always re-encodes) |
+| `merge` | Yes (always re-encodes) |
+| `extractAudio` | N/A, no video encoder (`-vn`) |
+| `getFrameAt` | N/A, uses `MediaMetadataRetriever` |
+| `toGif` | N/A, uses the GIF encoder, not `h264_mediacodec` |
+
 No configuration is needed — the fallback is transparent. When a retry happens, a notice is emitted via the existing `onLog` event (`Hardware encoder failed; retrying with software encoder fallback`) so you can observe quality degradation if you want to log it.
 
-If every attempt in the chain fails, `onError` is emitted with `errorCode: "HARDWARE_ENCODER_FAILED"` (instead of the generic `"TRIMMING_FAILED"`) so apps can present a more specific message or telemetry.
+If every attempt in the chain fails:
+
+- **Editor save**: `onError` is emitted with `errorCode: "HARDWARE_ENCODER_FAILED"` (instead of the generic `"TRIMMING_FAILED"`).
+- **Headless APIs (`trim` / `compress` / `merge`)**: the Promise rejects with the original error message format (`"Compression failed: rc N\n<logs>"` etc.) including the full FFmpeg log of the final attempt for debugging.
 
 > iOS does not need this fallback — `h264_videotoolbox` runs against Apple's single-vendor stack and has no known reproducible configure-time failures on supported devices. The `HARDWARE_ENCODER_FAILED` `errorCode` is still emitted on iOS as a defensive measure if the rare VideoToolbox failure does occur.
 

package/android/src/main/java/com/videotrim/BaseVideoTrimModule.kt

@@ -68,7 +68,6 @@ open class BaseVideoTrimModule internal constructor(
   private val sendEvent: (eventName: String, params: WritableMap?) -> Unit
 ) : VideoTrimListener, LifecycleEventListener {
 
-  private var isInit: Boolean = false
   private var trimmerView: VideoTrimmerView? = null
   private var alertDialog: AlertDialog? = null
   private var mProgressDialog: AlertDialog? = null
@@ -84,6 +83,10 @@ open class BaseVideoTrimModule internal constructor(
   private var pendingSaveToDocumentsFile: File? = null
 
   init {
+    // Initialize BaseUtils eagerly so DeviceUtil / VideoTrimmerUtil static
+    // fields resolve correctly even when a headless API (compress, toGif,
+    // merge, …) is called before showEditor has ever been opened.
+    BaseUtils.init(reactApplicationContext)
     reactApplicationContext.addLifecycleEventListener(this)
 
     val mActivityEventListener = object : BaseActivityEventListener() {
@@ -190,11 +193,6 @@ open class BaseVideoTrimModule internal constructor(
       onError("Activity is not available", ErrorCode.UNKNOWN)
       return
     }
-    if (!isInit) {
-      init()
-      isInit = true
-    }
-
     // here is NOT main thread, we need to create VideoTrimmerView on UI thread, so that later we can update it using same thread
     UiThreadUtil.runOnUiThread {
       trimmerView = VideoTrimmerView(reactApplicationContext, editorConfig, null)
@@ -290,12 +288,6 @@ open class BaseVideoTrimModule internal constructor(
     }
   }
 
-  private fun init() {
-    isInit = true
-    // we have to init this before create videoTrimmerView
-    BaseUtils.init(reactApplicationContext)
-  }
-
   override fun onHostResume() {
     Log.d(TAG, "onHostResume: ")
   }
@@ -682,7 +674,7 @@ open class BaseVideoTrimModule internal constructor(
         println("FFmpeg command was cancelled")
         promise.reject(Exception("FFmpeg command was cancelled"))
       },
-      onError = { errorMessage, _ ->
+      onError = { errorMessage, _, _ ->
         Log.d(TAG, errorMessage)
         promise.reject(Exception(errorMessage))
       },
@@ -741,7 +733,9 @@ open class BaseVideoTrimModule internal constructor(
         speed != 1.0 -> cmds.addAll(listOf("-af", VideoTrimmerUtil.buildAtempoChain(speed)))
         else -> cmds.addAll(listOf("-c:a", "copy"))
       }
-      cmds.addAll(listOf("-metadata", "creation_time=$formattedDateTime", resolvedOutputFile))
+      // Same high-tbr fix as compress: prevents duplicate DTS on sources like Pixel 7
+      // recordings (45k tbr) when re-encoding with h264_mediacodec.
+      cmds.addAll(listOf("-fps_mode", "vfr", "-metadata", "creation_time=$formattedDateTime", resolvedOutputFile))
       cmds.toTypedArray()
     }
 
@@ -863,6 +857,9 @@ open class BaseVideoTrimModule internal constructor(
   // Re-encodes video with h264_mediacodec (hardware) at the requested quality/bitrate.
   // Uses preset bitrate tiers for quality levels since Android's MediaCodec does not
   // support CRF-style quality control like VideoToolbox's -global_quality on iOS.
+  // Routed through VideoTrimmerUtil.executeWithEncoderFallback so the encoder
+  // fallback chain (h264_mediacodec → mpeg4) covers this path too — see README's
+  // "Android encoder compatibility" section.
   fun compress(url: String, options: ReadableMap?, promise: Promise) {
     val quality = options?.getString("quality") ?: "medium"
     val bitrate = options?.getDouble("bitrate") ?: -1.0
@@ -874,9 +871,7 @@ open class BaseVideoTrimModule internal constructor(
 
     val outputFile = StorageUtil.getCacheOutputPath(reactApplicationContext, outputExt)
 
-    val cmds = mutableListOf("-i", url)
     val videoFilters = mutableListOf<String>()
-
     if (width > 0 && height > 0) {
       videoFilters.add("scale=$width:$height")
     } else if (width > 0) {
@@ -884,50 +879,61 @@ open class BaseVideoTrimModule internal constructor(
     } else if (height > 0) {
       videoFilters.add("scale=-2:$height")
     }
+    val filterString = videoFilters.joinToString(",")
 
-    if (videoFilters.isNotEmpty()) {
-      cmds.addAll(listOf("-vf", videoFilters.joinToString(",")))
+    val bitrateStr = if (bitrate > 0) "${bitrate.toLong()}" else when (quality) {
+      "low" -> "500K"
+      "high" -> "5M"
+      else -> "2M"
     }
 
-    cmds.addAll(listOf("-c:v", "h264_mediacodec"))
-
-    if (bitrate > 0) {
-      cmds.addAll(listOf("-b:v", "${bitrate.toLong()}"))
-    } else {
-      val bv = when (quality) {
-        "low" -> "500K"
-        "high" -> "5M"
-        else -> "2M"
+    val buildCommand: (List<String>) -> Array<String> = { encoderArgs ->
+      val cmds = mutableListOf("-i", url)
+      if (filterString.isNotEmpty()) {
+        cmds.addAll(listOf("-vf", filterString))
       }
-      cmds.addAll(listOf("-b:v", bv))
-    }
-
-    if (frameRate > 0) {
-      cmds.addAll(listOf("-r", "$frameRate"))
-    }
-
-    if (removeAudio) {
-      cmds.add("-an")
-    } else {
-      cmds.addAll(listOf("-c:a", "aac"))
+      cmds.addAll(encoderArgs)
+      if (frameRate > 0) {
+        cmds.addAll(listOf("-r", "$frameRate"))
+      }
+      if (removeAudio) {
+        cmds.add("-an")
+      } else {
+        cmds.addAll(listOf("-c:a", "aac"))
+      }
+      // -fps_mode vfr prevents frame duplication / non-monotonic DTS errors that
+      // occur when the source has an unusually high time-base (e.g. Pixel 7 recordings
+      // with 45k tbr). Without this, h264_mediacodec tries to encode at the tbr rate,
+      // producing hundreds of duplicate frames and then a fatal muxer DTS collision.
+      cmds.addAll(listOf("-fps_mode", "vfr", "-y", outputFile))
+      cmds.toTypedArray()
     }
 
-    cmds.addAll(listOf("-y", outputFile))
-    Log.d(TAG, "compress command: ${cmds.joinToString(" ")}")
+    val callbacks = VideoTrimmerUtil.TrimCallbacks(
+      onLog = { msg -> msg.getString("message")?.let { Log.d(TAG, "compress: $it") } },
+      onStatistics = { /* compress does not surface statistics */ },
+      onProgress = { /* compress does not surface progress */ },
+      onSuccess = {
+        val result = Arguments.createMap()
+        result.putString("outputPath", outputFile)
+        promise.resolve(result)
+      },
+      onCancel = { promise.reject(Exception("Compression was cancelled")) },
+      onError = { _, _, session ->
+        // Preserve the original error message shape: "Compression failed: rc N\n<full logs>"
+        // so consumers matching on this prefix continue to work.
+        val returnCode = session?.returnCode
+        val logs = session?.allLogsAsString ?: ""
+        promise.reject(Exception("Compression failed: rc $returnCode\n$logs"))
+      },
+    )
 
-    FFmpegKit.executeWithArgumentsAsync(cmds.toTypedArray(), { session ->
-      val returnCode = session.returnCode
-      UiThreadUtil.runOnUiThread {
-        if (ReturnCode.isSuccess(returnCode)) {
-          val result = Arguments.createMap()
-          result.putString("outputPath", outputFile)
-          promise.resolve(result)
-        } else {
-          val logs = session.allLogsAsString ?: ""
-          promise.reject(Exception("Compression failed: rc $returnCode\n$logs"))
-        }
-      }
-    }, null, null)
+    VideoTrimmerUtil.executeWithEncoderFallback(
+      encoderConfigs = VideoTrimmerUtil.reEncodeEncoderConfigs(bitrateStr),
+      buildCommand = buildCommand,
+      videoDurationMs = 0,
+      callbacks = callbacks,
+    )
   }
 
   // Two-pass GIF conversion: pass 1 generates an optimal color palette (palettegen),
@@ -999,6 +1005,10 @@ open class BaseVideoTrimModule internal constructor(
   // detected bitrate as the output target so quality matches the best source clip.
   // Falls back to 10 Mbps if no bitrate can be read.
   //
+  // Routed through VideoTrimmerUtil.executeWithEncoderFallback so the encoder
+  // fallback chain (h264_mediacodec → mpeg4) covers this path too — see README's
+  // "Android encoder compatibility" section.
+  //
   // Limitation: only supports local file paths. Remote URLs are not supported because the
   // default FFmpegKit build does not include OpenSSL (--disable-openssl).
   fun merge(urls: ReadableArray, options: ReadableMap?, promise: Promise) {
@@ -1011,11 +1021,11 @@ open class BaseVideoTrimModule internal constructor(
       return
     }
 
-    val cmds = mutableListOf<String>()
+    val inputArgs = mutableListOf<String>()
     var maxBitrate = 0L
     for (i in 0 until n) {
       val urlStr = urls.getString(i) ?: continue
-      cmds.addAll(listOf("-i", urlStr))
+      inputArgs.addAll(listOf("-i", urlStr))
       try {
         val retriever = MediaMetadataRetriever()
         retriever.setDataSource(reactApplicationContext, Uri.parse(urlStr))
@@ -1048,38 +1058,55 @@ open class BaseVideoTrimModule internal constructor(
     val concatInputs = (0 until n).joinToString("") { "[v$it][$it:a:0]" }
     val filterComplex = "$scaleParts;${concatInputs}concat=n=$n:v=1:a=1[outv][outa]"
 
-    cmds.addAll(listOf(
-      "-filter_complex", filterComplex,
-      "-map", "[outv]", "-map", "[outa]",
-      "-c:v", "h264_mediacodec", "-b:v", bitrateStr,
-      "-c:a", "aac",
-      "-y", outputFile
-    ))
-    Log.d(TAG, "merge command: ${cmds.joinToString(" ")}")
-
-    FFmpegKit.executeWithArgumentsAsync(cmds.toTypedArray(), { session ->
-      val returnCode = session.returnCode
-      UiThreadUtil.runOnUiThread {
-        if (ReturnCode.isSuccess(returnCode)) {
-          var duration = 0.0
-          try {
-            val retriever = MediaMetadataRetriever()
-            retriever.setDataSource(outputFile)
-            duration = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)?.toDoubleOrNull() ?: 0.0
-            retriever.release()
-          } catch (_: Exception) {
-          }
+    val buildCommand: (List<String>) -> Array<String> = { encoderArgs ->
+      val cmds = mutableListOf<String>()
+      cmds.addAll(inputArgs)
+      cmds.addAll(listOf(
+        "-filter_complex", filterComplex,
+        "-map", "[outv]", "-map", "[outa]",
+      ))
+      cmds.addAll(encoderArgs)
+      cmds.addAll(listOf(
+        "-c:a", "aac",
+        "-y", outputFile,
+      ))
+      cmds.toTypedArray()
+    }
 
-          val result = Arguments.createMap()
-          result.putString("outputPath", outputFile)
-          result.putDouble("duration", duration)
-          promise.resolve(result)
-        } else {
-          val logs = session.allLogsAsString ?: ""
-          promise.reject(Exception("Merge failed: rc $returnCode\n$logs"))
+    val callbacks = VideoTrimmerUtil.TrimCallbacks(
+      onLog = { msg -> msg.getString("message")?.let { Log.d(TAG, "merge: $it") } },
+      onStatistics = { /* merge does not surface statistics */ },
+      onProgress = { /* merge does not surface progress */ },
+      onSuccess = {
+        var duration = 0.0
+        try {
+          val retriever = MediaMetadataRetriever()
+          retriever.setDataSource(outputFile)
+          duration = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)?.toDoubleOrNull() ?: 0.0
+          retriever.release()
+        } catch (_: Exception) {
         }
-      }
-    }, null, null)
+        val result = Arguments.createMap()
+        result.putString("outputPath", outputFile)
+        result.putDouble("duration", duration)
+        promise.resolve(result)
+      },
+      onCancel = { promise.reject(Exception("Merge was cancelled")) },
+      onError = { _, _, session ->
+        // Preserve the original error message shape: "Merge failed: rc N\n<full logs>"
+        // so consumers matching on this prefix continue to work.
+        val returnCode = session?.returnCode
+        val logs = session?.allLogsAsString ?: ""
+        promise.reject(Exception("Merge failed: rc $returnCode\n$logs"))
+      },
+    )
+
+    VideoTrimmerUtil.executeWithEncoderFallback(
+      encoderConfigs = VideoTrimmerUtil.reEncodeEncoderConfigs(bitrateStr),
+      buildCommand = buildCommand,
+      videoDurationMs = 0,
+      callbacks = callbacks,
+    )
   }
 
   private fun saveFileToExternalStorage(file: File) {

package/android/src/main/java/com/videotrim/utils/VideoTrimmerUtil.kt

@@ -126,6 +126,13 @@ object VideoTrimmerUtil {
    * statistics are forwarded as-is; the success/cancel/error callbacks fire
    * exactly once for the overall trim request after the fallback chain
    * settles.
+   *
+   * The error callback receives a default message ("Command failed with
+   * state ... and rc ...") plus the final attempt's [FFmpegSession] so
+   * callers that surface custom error formats (e.g. headless APIs that
+   * include `allLogsAsString` in the Promise rejection) can build their
+   * own message instead. Pass `null`-safe access since the session may be
+   * unavailable in edge cases.
    */
   internal class TrimCallbacks(
     val onLog: (WritableMap) -> Unit,
@@ -133,7 +140,7 @@ object VideoTrimmerUtil {
     val onProgress: (Int) -> Unit,
     val onSuccess: () -> Unit,
     val onCancel: () -> Unit,
-    val onError: (String, ErrorCode) -> Unit,
+    val onError: (message: String, code: ErrorCode, session: FFmpegSession?) -> Unit,
   )
 
   /**
@@ -178,7 +185,7 @@ object VideoTrimmerUtil {
       // Should be unreachable because we only retry on HARDWARE_ENCODER_FAILED;
       // any non-retryable error is surfaced before exhausting the iterator.
       UiThreadUtil.runOnUiThread {
-        callbacks.onError("Encoder fallback chain exhausted", ErrorCode.TRIMMING_FAILED)
+        callbacks.onError("Encoder fallback chain exhausted", ErrorCode.TRIMMING_FAILED, null)
       }
       return
     }
@@ -213,7 +220,7 @@ object VideoTrimmerUtil {
             } else {
               val errorMessage =
                 "Command failed with state $state and rc $returnCode.${session.failStackTrace}"
-              callbacks.onError(errorMessage, classified)
+              callbacks.onError(errorMessage, classified, session)
             }
           }
         }
@@ -291,7 +298,7 @@ object VideoTrimmerUtil {
       onProgress = { callback.onTrimmingProgress(it) },
       onSuccess = { callback.onFinishTrim(outputFile, startMs, endMs, videoDuration) },
       onCancel = { callback.onCancelTrim() },
-      onError = { msg, code -> callback.onError(msg, code) },
+      onError = { msg, code, _ -> callback.onError(msg, code) },
     )
 
     if (!needsReEncode) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-video-trim",
-  "version": "8.1.4",
+  "version": "8.1.6",
   "description": "Video trimmer for your React Native app",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",