react-native-video-trim 8.1.3 → 8.1.5

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

@@ -682,7 +682,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))
       },
@@ -863,6 +863,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 +877,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 +885,57 @@ 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"))
+      }
+      cmds.addAll(listOf("-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 +1007,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 +1023,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 +1060,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/ios/VideoTrim.swift

@@ -382,22 +382,13 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
     let needsReEncode = hasUserTransform || cropNorm != nil || enablePreciseTrimming || needsSpeed
     
     if needsReEncode, let vc = vc {
-      // -noautorotate disables FFmpeg's automatic rotation, so we must manually
-      // compensate for the source video's rotation metadata via transpose filters.
-      if let asset = vc.asset,
-         let videoTrack = asset.tracks(withMediaType: .video).first {
-        let t = videoTrack.preferredTransform
-        let sourceAngle = atan2(t.b, t.a)
-        if abs(sourceAngle - .pi / 2) < 0.1 {
-          videoFilters.append("transpose=1")
-        } else if abs(sourceAngle + .pi / 2) < 0.1 {
-          videoFilters.append("transpose=2")
-        } else if abs(abs(sourceAngle) - .pi) < 0.1 {
-          videoFilters.append("transpose=1")
-          videoFilters.append("transpose=1")
-        }
-      }
-      
+      // Let FFmpeg autorotate the source (note: NO -noautorotate below). Autorotate bakes
+      // the source rotation matrix into upright, display-orientation pixels AND strips the
+      // matrix from the output. The previous approach (-noautorotate + a manual source-
+      // compensation transpose) baked the pixels but left the source rotation matrix on the
+      // output, so on ffmpeg-kit 6 every rotation-tagged portrait clip came out
+      // double-rotated (sideways). User rotate/flip and crop below operate on the already-
+      // upright autorotated frame, so their math is unchanged.
       switch vc.rotationCount {
       case 1: videoFilters.append("transpose=2")
       case 2:
@@ -464,9 +455,9 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
         }
       }
       
-      // -noautorotate: we handle rotation via explicit transpose filters above,
-      // so FFmpeg must not auto-rotate or the output will be double-rotated.
-      cmds.append("-noautorotate")
+      // NOTE: intentionally NO -noautorotate. FFmpeg autorotates the input so the source
+      // rotation is baked into the pixels and the output carries no stale rotation matrix
+      // (otherwise rotation-tagged portrait clips are double-rotated -> sideways on ffmpeg-kit 6).
       cmds.append(contentsOf: ["-i", inputFile.path])
       // When enablePreciseTrimming is the only reason for re-encode (no transforms),
       // videoFilters is empty — skip -vf entirely to avoid FFmpeg error on empty filter.

package/package.json

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