react-native-video-trim 8.1.1 → 8.1.2

package/README.md

@@ -567,6 +567,7 @@ These options only apply when `type: 'audio'`. The waveform replaces the thumbna
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
 | `enableHapticFeedback` | `boolean` | `true` | Enable haptic feedback |
+| `enableEditTools` | `boolean` | `true` | Show the top toolbar of edit tools (flip, rotate, crop, mute, speed, undo, redo). Set to `false` to hide the entire toolbar. Video only |
 | `closeWhenFinish` | `boolean` | `true` | Close editor when done |
 | `enablePreciseTrimming` | `boolean` | `false` | Re-encode for frame-accurate cuts (slower, see [Precise Frame Trimming](#precise-frame-trimming)) |
 | `changeStatusBarColorOnOpen` | `boolean` | `false` | Change status bar color (Android only) |
@@ -760,6 +761,21 @@ The editor includes built-in transform controls — horizontal flip, 90° left r
 
 When any transform is applied, FFmpeg automatically re-encodes the video using the platform's hardware encoder (`h264_videotoolbox` on iOS, `h264_mediacodec` on Android) at the source bitrate to preserve quality. No additional configuration is needed.
 
+### 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.
+
+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.
+
+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.
+
+> 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.
+
 ### Precise Frame Trimming
 
 By default, trimming uses FFmpeg's stream copy (`-c copy`), which is very fast but can only cut at keyframes. The actual start/end points may drift by several seconds from what the user selected.

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

@@ -634,111 +634,117 @@ open class BaseVideoTrimModule internal constructor(
       options.getBoolean("enablePreciseTrimming")
     val needsReEncode = enablePrecise || speed != 1.0
 
-    val cmds = mutableListOf(
-      "-ss",
-      "${startTime}ms",
-      "-to",
-      "${endTime}ms",
+    // Headless trim still benefits from the encoder fallback chain whenever it
+    // re-encodes (hardware encoder failures are device-specific, not path-specific).
+    // No-op log/stats/progress callbacks because headless trim returns via Promise
+    // rather than emitting events.
+    val onSuccess: () -> Unit = {
+      val duration = endTime - startTime
+      val result = Arguments.createMap()
+      result.putString("outputPath", resolvedOutputFile)
+      result.putDouble("startTime", startTime)
+      result.putDouble("endTime", endTime)
+      result.putDouble("duration", duration)
+      result.putBoolean("success", true)
+
+      if (options?.getBoolean("saveToPhoto") == true && options.getString("type") == "video") {
+        Log.d(TAG, "Android trim: saveToPhoto is true, attempting to save to gallery")
+        try {
+          StorageUtil.saveToGallery(reactApplicationContext, resolvedOutputFile)
+          Log.d(TAG, "Edited video saved to Photo Library successfully.")
+          if (options.getBoolean("removeAfterSavedToPhoto")) {
+            Log.d(TAG, "Removing file after successful save to photo")
+            StorageUtil.deleteFile(resolvedOutputFile)
+          }
+          promise.resolve(result)
+        } catch (e: IOException) {
+          e.printStackTrace()
+          if (options.getBoolean("removeAfterFailedToSavePhoto")) {
+            Log.d(TAG, "Removing file after failed save to photo")
+            StorageUtil.deleteFile(resolvedOutputFile)
+          }
+          promise.reject(
+            Exception("Failed to save edited video to Photo Library: " + e.localizedMessage)
+          )
+        }
+      } else {
+        Log.d(TAG, "Android trim: saveToPhoto is false or not video type, resolving with structured result")
+        promise.resolve(result)
+      }
+    }
+
+    val callbacks = VideoTrimmerUtil.TrimCallbacks(
+      onLog = { msg -> msg.getString("message")?.let { Log.d(TAG, it) } },
+      onStatistics = { /* headless trim does not surface statistics */ },
+      onProgress = { /* headless trim does not surface progress */ },
+      onSuccess = onSuccess,
+      onCancel = {
+        println("FFmpeg command was cancelled")
+        promise.reject(Exception("FFmpeg command was cancelled"))
+      },
+      onError = { errorMessage, _ ->
+        Log.d(TAG, errorMessage)
+        promise.reject(Exception(errorMessage))
+      },
     )
 
-    if (needsReEncode) {
-      var bitrateStr = "10M"
-      try {
-        val retriever = MediaMetadataRetriever()
-        retriever.setDataSource(reactApplicationContext, Uri.parse(url))
-        val bitrate = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE)
-          ?.toLongOrNull() ?: 0L
-        if (bitrate > 0) bitrateStr = "$bitrate"
-        retriever.release()
-      } catch (_: Exception) {}
+    if (!needsReEncode) {
+      // Stream copy: no encoder is opened so the fallback chain doesn't apply.
+      val cmds = mutableListOf(
+        "-ss", "${startTime}ms",
+        "-to", "${endTime}ms",
+        "-i", url,
+      )
+      if (removeAudio) {
+        cmds.addAll(listOf("-c:v", "copy", "-an"))
+      } else {
+        cmds.addAll(listOf("-c", "copy"))
+      }
+      cmds.addAll(listOf("-metadata", "creation_time=$formattedDateTime", resolvedOutputFile))
+      VideoTrimmerUtil.executeWithEncoderFallback(
+        encoderConfigs = listOf(emptyList()),
+        buildCommand = { cmds.toTypedArray() },
+        videoDurationMs = 0,
+        callbacks = callbacks,
+      )
+      return
+    }
+
+    var bitrateStr = "10M"
+    try {
+      val retriever = MediaMetadataRetriever()
+      retriever.setDataSource(reactApplicationContext, Uri.parse(url))
+      val bitrate = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE)
+        ?.toLongOrNull() ?: 0L
+      if (bitrate > 0) bitrateStr = "$bitrate"
+      retriever.release()
+    } catch (_: Exception) {}
 
-      cmds.addAll(listOf("-i", url))
+    val buildCommand: (List<String>) -> Array<String> = { encoderArgs ->
+      val cmds = mutableListOf(
+        "-ss", "${startTime}ms",
+        "-to", "${endTime}ms",
+        "-i", url,
+      )
       if (speed != 1.0) {
         cmds.addAll(listOf("-vf", "setpts=${1.0 / speed}*PTS"))
       }
-      cmds.addAll(listOf("-c:v", "h264_mediacodec", "-b:v", bitrateStr))
+      cmds.addAll(encoderArgs)
       when {
         removeAudio -> cmds.add("-an")
         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))
-    } else {
-      cmds.addAll(listOf("-i", url))
-      if (removeAudio) {
-        cmds.addAll(listOf("-c:v", "copy", "-an"))
-      } else {
-        cmds.addAll(listOf("-c", "copy"))
-      }
-      cmds.addAll(listOf("-metadata", "creation_time=$formattedDateTime", resolvedOutputFile))
+      cmds.toTypedArray()
     }
 
-    Log.d(TAG, "Command: ${cmds.joinToString(" ")}")
-
-    FFmpegKit.executeWithArgumentsAsync(cmds.toTypedArray(), { session ->
-      val state = session.state
-      val returnCode = session.returnCode
-      UiThreadUtil.runOnUiThread {
-        when {
-          ReturnCode.isSuccess(returnCode) -> {
-            val duration = endTime - startTime
-            val result = Arguments.createMap()
-
-            result.putString("outputPath", resolvedOutputFile)
-            result.putDouble("startTime", startTime)
-            result.putDouble("endTime", endTime)
-            result.putDouble("duration", duration)
-            result.putBoolean("success", true)
-
-            if (options?.getBoolean("saveToPhoto") == true && options.getString("type") == "video") {
-              Log.d(TAG, "Android trim: saveToPhoto is true, attempting to save to gallery")
-              try {
-                StorageUtil.saveToGallery(reactApplicationContext, resolvedOutputFile)
-                Log.d(TAG, "Edited video saved to Photo Library successfully.")
-                if (options.getBoolean("removeAfterSavedToPhoto")) {
-                  Log.d(TAG, "Removing file after successful save to photo")
-                  StorageUtil.deleteFile(resolvedOutputFile)
-                }
-
-                promise.resolve(result)
-              } catch (e: IOException) {
-                e.printStackTrace()
-
-                if (options.getBoolean("removeAfterFailedToSavePhoto")) {
-                  Log.d(TAG, "Removing file after failed save to photo")
-                  StorageUtil.deleteFile(resolvedOutputFile)
-                }
-
-                promise.reject(
-                  Exception("Failed to save edited video to Photo Library: " + e.localizedMessage)
-                )
-              }
-            } else {
-              Log.d(TAG, "Android trim: saveToPhoto is false or not video type, resolving with structured result")
-
-              promise.resolve(result)
-            }
-          }
-          ReturnCode.isCancel(returnCode) -> {
-            println("FFmpeg command was cancelled")
-            promise.reject(
-              Exception("FFmpeg command was cancelled with code $returnCode")
-            )
-          }
-          else -> {
-            val errorMessage = String.format("Command failed with state %s and rc %s.%s", state, returnCode, session.getFailStackTrace())
-            Log.d(TAG, errorMessage)
-            promise.reject(
-              Exception(errorMessage)
-            )
-          }
-        }
-      }
-    }, { log ->
-      Log.d(TAG, "FFmpeg process started with log ${log.message}")
-    }, { statistics ->
-      // Handle statistics if needed
-    })
+    VideoTrimmerUtil.executeWithEncoderFallback(
+      encoderConfigs = VideoTrimmerUtil.reEncodeEncoderConfigs(bitrateStr),
+      buildCommand = buildCommand,
+      videoDurationMs = 0,
+      callbacks = callbacks,
+    )
   }
 
   // Extracts a single video frame as JPEG/PNG. Output goes to the cache directory.

package/android/src/main/java/com/videotrim/enums/ErrorCode.kt

@@ -2,6 +2,7 @@ package com.videotrim.enums
 
 enum class ErrorCode {
   TRIMMING_FAILED,
+  HARDWARE_ENCODER_FAILED,
   FAIL_TO_GET_VIDEO_INFO,
   FAIL_TO_INITIALIZE_AUDIO_PLAYER,
   FAIL_TO_LOAD_MEDIA,

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

@@ -10,6 +10,7 @@ import com.arthenica.ffmpegkit.FFmpegSession
 import com.arthenica.ffmpegkit.ReturnCode
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.bridge.WritableMap
 import com.videotrim.enums.ErrorCode
 import com.videotrim.interfaces.VideoTrimListener
 import iknow.android.utils.DeviceUtil
@@ -21,6 +22,28 @@ import java.util.Date
 import java.util.TimeZone
 import kotlin.math.roundToInt
 
+/**
+ * Handle returned from FFmpeg trim invocations that own an encoder-fallback chain.
+ *
+ * A single trim request may span multiple FFmpeg sessions when the first encoder
+ * (typically [h264_mediacodec]) fails at configure-time on a quirky hardware
+ * encoder and we retry with a software fallback. The handle tracks the currently
+ * running session so callers can cancel without caring which attempt is active.
+ */
+class TrimSession {
+  @Volatile private var currentSession: FFmpegSession? = null
+  @Volatile internal var cancelled = false
+
+  internal fun setCurrentSession(session: FFmpegSession?) {
+    currentSession = session
+  }
+
+  fun cancel() {
+    cancelled = true
+    currentSession?.cancel()
+  }
+}
+
 object VideoTrimmerUtil {
 
   private val TAG: String = VideoTrimmerUtil::class.java.simpleName
@@ -53,6 +76,186 @@ object VideoTrimmerUtil {
     return filters.joinToString(",")
   }
 
+  /**
+   * Encoder fallback chain used when a re-encode is required. Tried in order
+   * until one succeeds at FFmpeg's configure() step.
+   *
+   *  1. `h264_mediacodec` — Android's hardware H.264 encoder. Fastest and the
+   *     default. Fails on some quirky Qualcomm/MediaTek implementations with
+   *     `MediaCodec configure failed` (see "Android encoder compatibility" in
+   *     README).
+   *  2. `mpeg4` — software MPEG-4 Part 2 (Simple Profile). Always available in
+   *     every FFmpegKit build, succeeds on every device. Produces larger files
+   *     at lower visual quality than H.264, used only as a last resort when
+   *     the hardware encoder rejects the configuration.
+   *
+   * The chain only matters for the re-encode branch (transform/crop/precise/
+   * speed); the default stream-copy path doesn't open an encoder at all.
+   */
+  internal fun reEncodeEncoderConfigs(bitrateStr: String): List<List<String>> = listOf(
+    listOf("-c:v", "h264_mediacodec", "-b:v", bitrateStr),
+    listOf("-c:v", "mpeg4", "-q:v", "3")
+  )
+
+  /**
+   * Scan an FFmpeg session's log for signatures that indicate the hardware
+   * H.264 encoder (MediaCodec) refused to configure on this device. These
+   * lines come from FFmpeg's mediacodec wrapper:
+   *
+   *   `[amediacodec @ ...] android.media.MediaCodec$CodecException: Error 0xffffffc3`
+   *   `[h264_mediacodec @ ...] MediaCodec configure failed, Generic error in an external library`
+   *
+   * When this happens we re-issue the command with the next encoder in the
+   * fallback chain instead of surfacing the failure to the user.
+   */
+  internal fun classifyFFmpegError(session: FFmpegSession): ErrorCode {
+    val logs = try { session.allLogsAsString ?: "" } catch (_: Exception) { "" }
+    val hardwareEncoderSignals = listOf(
+      "MediaCodec configure failed",
+      "Error initializing output stream",
+    )
+    val matchedHardwareSignal = hardwareEncoderSignals.any { logs.contains(it) }
+    if (matchedHardwareSignal && logs.contains("mediacodec")) {
+      return ErrorCode.HARDWARE_ENCODER_FAILED
+    }
+    return ErrorCode.TRIMMING_FAILED
+  }
+
+  /**
+   * Callbacks used by [executeWithEncoderFallback]. Per-attempt log and
+   * statistics are forwarded as-is; the success/cancel/error callbacks fire
+   * exactly once for the overall trim request after the fallback chain
+   * settles.
+   */
+  internal class TrimCallbacks(
+    val onLog: (WritableMap) -> Unit,
+    val onStatistics: (WritableMap) -> Unit,
+    val onProgress: (Int) -> Unit,
+    val onSuccess: () -> Unit,
+    val onCancel: () -> Unit,
+    val onError: (String, ErrorCode) -> Unit,
+  )
+
+  /**
+   * Execute an FFmpeg trim command with an encoder-fallback chain.
+   *
+   * The command is built lazily per attempt by [buildCommand], which receives
+   * the current encoder args (e.g. `-c:v h264_mediacodec -b:v 8000000`) and
+   * returns the full argv. This lets each attempt swap only the encoder
+   * portion while reusing the same input/filter/output args.
+   *
+   * On non-success non-cancel completion, the session log is scanned via
+   * [classifyFFmpegError]. If it looks like a hardware encoder rejection and
+   * there are more encoders in the chain, we silently retry. Otherwise the
+   * error is surfaced via [TrimCallbacks.onError] with the classified code.
+   *
+   * Returns a [TrimSession] handle whose [TrimSession.cancel] cancels the
+   * currently running attempt and prevents any further attempts.
+   */
+  internal fun executeWithEncoderFallback(
+    encoderConfigs: List<List<String>>,
+    buildCommand: (encoderArgs: List<String>) -> Array<String>,
+    videoDurationMs: Int,
+    callbacks: TrimCallbacks,
+  ): TrimSession {
+    val trimSession = TrimSession()
+    runAttempt(trimSession, encoderConfigs.iterator(), buildCommand, videoDurationMs, callbacks)
+    return trimSession
+  }
+
+  private fun runAttempt(
+    trimSession: TrimSession,
+    encoderIterator: Iterator<List<String>>,
+    buildCommand: (encoderArgs: List<String>) -> Array<String>,
+    videoDurationMs: Int,
+    callbacks: TrimCallbacks,
+  ) {
+    if (trimSession.cancelled) {
+      UiThreadUtil.runOnUiThread { callbacks.onCancel() }
+      return
+    }
+    if (!encoderIterator.hasNext()) {
+      // 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)
+      }
+      return
+    }
+
+    val encoderArgs = encoderIterator.next()
+    val command = buildCommand(encoderArgs)
+    val cmdStr = "Command: ${command.joinToString(" ")}"
+    Log.d(TAG, cmdStr)
+    val cmdMap = Arguments.createMap()
+    cmdMap.putString("message", cmdStr)
+    callbacks.onLog(cmdMap)
+
+    val session = FFmpegKit.executeWithArgumentsAsync(command, { session ->
+      val state = session.state
+      val returnCode = session.returnCode
+      UiThreadUtil.runOnUiThread {
+        when {
+          ReturnCode.isSuccess(returnCode) -> callbacks.onSuccess()
+          ReturnCode.isCancel(returnCode) -> callbacks.onCancel()
+          else -> {
+            val classified = classifyFFmpegError(session)
+            if (classified == ErrorCode.HARDWARE_ENCODER_FAILED && encoderIterator.hasNext()) {
+              // Log fallback decision via the existing onLog channel so consumers
+              // can observe quality degradation without a new dedicated event.
+              val notice = Arguments.createMap()
+              notice.putString(
+                "message",
+                "Hardware encoder failed; retrying with software encoder fallback"
+              )
+              callbacks.onLog(notice)
+              runAttempt(trimSession, encoderIterator, buildCommand, videoDurationMs, callbacks)
+            } else {
+              val errorMessage =
+                "Command failed with state $state and rc $returnCode.${session.failStackTrace}"
+              callbacks.onError(errorMessage, classified)
+            }
+          }
+        }
+      }
+    }, { log ->
+      Log.d(TAG, "FFmpeg process started with log ${log.message}")
+      val map = Arguments.createMap()
+      map.putInt("level", log.level.value)
+      map.putString("message", log.message)
+      map.putDouble("sessionId", log.sessionId.toDouble())
+      map.putString("logStr", log.toString())
+      UiThreadUtil.runOnUiThread { callbacks.onLog(map) }
+    }, { statistics ->
+      val timeInMilliseconds = statistics.time.toInt()
+      if (timeInMilliseconds > 0 && videoDurationMs > 0) {
+        val completePercentage = (timeInMilliseconds * 100) / videoDurationMs
+        UiThreadUtil.runOnUiThread {
+          callbacks.onProgress(completePercentage.coerceIn(0, 100))
+        }
+      }
+      val map = Arguments.createMap()
+      map.putDouble("sessionId", statistics.sessionId.toDouble())
+      map.putInt("videoFrameNumber", statistics.videoFrameNumber)
+      map.putDouble("videoFps", statistics.videoFps.toDouble())
+      map.putDouble("videoQuality", statistics.videoQuality.toDouble())
+      map.putDouble("size", statistics.size.toDouble())
+      map.putDouble("time", statistics.time)
+      map.putDouble("bitrate", statistics.bitrate.toDouble())
+      map.putDouble("speed", statistics.speed.toDouble())
+      map.putString("statisticsStr", statistics.toString())
+      UiThreadUtil.runOnUiThread { callbacks.onStatistics(map) }
+    })
+
+    trimSession.setCurrentSession(session)
+
+    // If cancel arrived between the iterator check and session start, cancel
+    // immediately so the FFmpeg session won't run to completion.
+    if (trimSession.cancelled) {
+      session.cancel()
+    }
+  }
+
   fun trim(
     inputFile: String,
     outputFile: String,
@@ -69,154 +272,110 @@ object VideoTrimmerUtil {
     removeAudio: Boolean,
     speed: Double,
     callback: VideoTrimListener
-  ): FFmpegSession {
+  ): TrimSession {
     val currentDate = Date()
     @SuppressLint("SimpleDateFormat")
     val dateFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ")
     dateFormat.timeZone = TimeZone.getTimeZone("UTC")
     val formattedDateTime = dateFormat.format(currentDate)
 
-    val cmds = mutableListOf<String>()
-    cmds.add("-ss")
-    cmds.add("${startMs}ms")
-    cmds.add("-to")
-    cmds.add("${endMs}ms")
-
     val hasUserTransform = userRotationCount != 0 || userIsFlipped
     // Re-encode is required when: (1) user applied flip/rotate, (2) user cropped, or
     // (3) enablePreciseTrimming is on, or (4) speed != 1.0. In those cases, -c copy
     // won't work because either we need video filters or we need frame-accurate cut points.
     val needsReEncode = hasUserTransform || cropNormalized != null || enablePreciseTrimming || speed != 1.0
 
-    if (needsReEncode) {
-      val videoFilters = mutableListOf<String>()
+    val callbacks = TrimCallbacks(
+      onLog = { callback.onLog(it) },
+      onStatistics = { callback.onStatistics(it) },
+      onProgress = { callback.onTrimmingProgress(it) },
+      onSuccess = { callback.onFinishTrim(outputFile, startMs, endMs, videoDuration) },
+      onCancel = { callback.onCancelTrim() },
+      onError = { msg, code -> callback.onError(msg, code) },
+    )
 
-      when (userRotationCount) {
-        1 -> videoFilters.add("transpose=2")
-        2 -> { videoFilters.add("transpose=2"); videoFilters.add("transpose=2") }
-        3 -> videoFilters.add("transpose=1")
-      }
-      if (userIsFlipped) {
-        videoFilters.add("hflip")
+    if (!needsReEncode) {
+      // Stream copy: no re-encoding, extremely fast but only cuts at keyframes.
+      // No encoder is opened so the fallback chain doesn't apply — single attempt.
+      val cmds = mutableListOf("-ss", "${startMs}ms", "-to", "${endMs}ms", "-i", inputFile)
+      if (removeAudio) {
+        cmds.addAll(listOf("-c:v", "copy", "-an"))
+      } else {
+        cmds.addAll(listOf("-c", "copy"))
       }
+      cmds.addAll(listOf("-metadata", "creation_time=$formattedDateTime", outputFile))
+      return executeWithEncoderFallback(
+        encoderConfigs = listOf(emptyList()),
+        buildCommand = { cmds.toTypedArray() },
+        videoDurationMs = videoDuration,
+        callbacks = callbacks,
+      )
+    }
 
-      // Convert normalized crop rect [0..1] to pixel coordinates in the post-rotation frame.
-      if (cropNormalized != null && videoWidth > 0 && videoHeight > 0) {
-        val postW: Int
-        val postH: Int
-        // After 90°/270° rotation the width and height are swapped.
-        if (userRotationCount % 2 != 0) {
-          postW = videoHeight; postH = videoWidth
-        } else {
-          postW = videoWidth; postH = videoHeight
-        }
-        val cx = (cropNormalized.left * postW).roundToInt()
-        val cy = (cropNormalized.top * postH).roundToInt()
-        var cw = (cropNormalized.width() * postW).roundToInt()
-        var ch = (cropNormalized.height() * postH).roundToInt()
-        // H.264 requires even dimensions; round down to nearest even number.
-        cw = cw and 1.inv()
-        ch = ch and 1.inv()
-        if (cw > 0 && ch > 0) {
-          videoFilters.add("crop=$cw:$ch:$cx:$cy")
-        }
+    // Build the video filters once. They're encoder-independent.
+    val videoFilters = mutableListOf<String>()
+    when (userRotationCount) {
+      1 -> videoFilters.add("transpose=2")
+      2 -> { videoFilters.add("transpose=2"); videoFilters.add("transpose=2") }
+      3 -> videoFilters.add("transpose=1")
+    }
+    if (userIsFlipped) {
+      videoFilters.add("hflip")
+    }
+    // Convert normalized crop rect [0..1] to pixel coordinates in the post-rotation frame.
+    if (cropNormalized != null && videoWidth > 0 && videoHeight > 0) {
+      val postW: Int
+      val postH: Int
+      // After 90°/270° rotation the width and height are swapped.
+      if (userRotationCount % 2 != 0) {
+        postW = videoHeight; postH = videoWidth
+      } else {
+        postW = videoWidth; postH = videoHeight
       }
-
-      if (speed != 1.0) {
-        videoFilters.add("setpts=${1.0 / speed}*PTS")
+      val cx = (cropNormalized.left * postW).roundToInt()
+      val cy = (cropNormalized.top * postH).roundToInt()
+      var cw = (cropNormalized.width() * postW).roundToInt()
+      var ch = (cropNormalized.height() * postH).roundToInt()
+      // H.264 requires even dimensions; round down to nearest even number.
+      cw = cw and 1.inv()
+      ch = ch and 1.inv()
+      if (cw > 0 && ch > 0) {
+        videoFilters.add("crop=$cw:$ch:$cx:$cy")
       }
+    }
+    if (speed != 1.0) {
+      videoFilters.add("setpts=${1.0 / speed}*PTS")
+    }
+    val filterString = videoFilters.joinToString(",")
 
-      val filterString = videoFilters.joinToString(",")
-      // Preserve source quality by matching the original bitrate. Falls back to 10 Mbps.
-      val bitrateStr = if (videoBitrate > 0) "$videoBitrate" else "10M"
+    // Preserve source quality by matching the original bitrate. Falls back to 10 Mbps.
+    val bitrateStr = if (videoBitrate > 0) "$videoBitrate" else "10M"
 
-      cmds.addAll(listOf("-i", inputFile))
+    // Note: Android FFmpegKit auto-rotates by default, so no -noautorotate is needed.
+    // The transpose filters above only handle user-initiated rotation, not source metadata.
+    val buildCommand: (List<String>) -> Array<String> = { encoderArgs ->
+      val cmds = mutableListOf("-ss", "${startMs}ms", "-to", "${endMs}ms", "-i", inputFile)
       // When enablePreciseTrimming is the only reason for re-encode (no transforms),
       // videoFilters is empty — skip -vf entirely to avoid FFmpeg error on empty filter.
       if (filterString.isNotEmpty()) {
         cmds.addAll(listOf("-vf", filterString))
       }
-      // h264_mediacodec: Android's hardware H.264 encoder — fast and energy-efficient.
-      // Note: Android FFmpegKit auto-rotates by default, so no -noautorotate is needed.
-      // The transpose filters above only handle user-initiated rotation, not source metadata.
-      cmds.addAll(listOf("-c:v", "h264_mediacodec", "-b:v", bitrateStr))
+      cmds.addAll(encoderArgs)
       when {
         removeAudio -> cmds.add("-an")
         speed != 1.0 -> cmds.addAll(listOf("-af", buildAtempoChain(speed)))
         else -> cmds.addAll(listOf("-c:a", "copy"))
       }
       cmds.addAll(listOf("-metadata", "creation_time=$formattedDateTime", outputFile))
-    } else {
-      // Stream copy: no re-encoding, extremely fast but only cuts at keyframes.
-      cmds.addAll(listOf("-i", inputFile))
-      if (removeAudio) {
-        cmds.addAll(listOf("-c:v", "copy", "-an"))
-      } else {
-        cmds.addAll(listOf("-c", "copy"))
-      }
-      cmds.addAll(listOf("-metadata", "creation_time=$formattedDateTime", outputFile))
+      cmds.toTypedArray()
     }
 
-    val command = cmds.toTypedArray()
-    val cmdStr = "Command: ${command.joinToString(" ")}"
-
-    Log.d(TAG, cmdStr)
-
-    val m = Arguments.createMap()
-    m.putString("message", cmdStr)
-    callback.onLog(m)
-
-    return FFmpegKit.executeWithArgumentsAsync(command, { session ->
-      val state = session.state
-      val returnCode = session.returnCode
-      UiThreadUtil.runOnUiThread {
-        when {
-          ReturnCode.isSuccess(returnCode) -> {
-            callback.onFinishTrim(outputFile, startMs, endMs, videoDuration)
-          }
-          ReturnCode.isCancel(returnCode) -> {
-            callback.onCancelTrim()
-          }
-          else -> {
-            val errorMessage = "Command failed with state $state and rc $returnCode.${session.failStackTrace}"
-            callback.onError(errorMessage, ErrorCode.TRIMMING_FAILED)
-          }
-        }
-      }
-    }, { log ->
-      Log.d(TAG, "FFmpeg process started with log ${log.message}")
-
-      val map = Arguments.createMap()
-      map.putInt("level", log.level.value)
-      map.putString("message", log.message)
-      map.putDouble("sessionId", log.sessionId.toDouble())
-      map.putString("logStr", log.toString())
-      UiThreadUtil.runOnUiThread {
-        callback.onLog(map)
-      }
-    }, { statistics ->
-      val timeInMilliseconds = statistics.time.toInt()
-      if (timeInMilliseconds > 0) {
-        val completePercentage = (timeInMilliseconds * 100) / videoDuration
-        UiThreadUtil.runOnUiThread {
-          callback.onTrimmingProgress(completePercentage.coerceIn(0, 100))
-        }
-      }
-
-      val map = Arguments.createMap()
-      map.putDouble("sessionId", statistics.sessionId.toDouble())
-      map.putInt("videoFrameNumber", statistics.videoFrameNumber)
-      map.putDouble("videoFps", statistics.videoFps.toDouble())
-      map.putDouble("videoQuality", statistics.videoQuality.toDouble())
-      map.putDouble("size", statistics.size.toDouble())
-      map.putDouble("time", statistics.time)
-      map.putDouble("bitrate", statistics.bitrate.toDouble())
-      map.putDouble("speed", statistics.speed.toDouble())
-      map.putString("statisticsStr", statistics.toString())
-      UiThreadUtil.runOnUiThread {
-        callback.onStatistics(map)
-      }
-    })
+    return executeWithEncoderFallback(
+      encoderConfigs = reEncodeEncoderConfigs(bitrateStr),
+      buildCommand = buildCommand,
+      videoDurationMs = videoDuration,
+      callbacks = callbacks,
+    )
   }
 
   fun shootVideoThumbInBackground(

package/android/src/main/java/com/videotrim/widgets/VideoTrimmerView.kt

@@ -39,7 +39,6 @@ import android.widget.TextView
 
 import androidx.appcompat.app.AlertDialog
 
-import com.arthenica.ffmpegkit.FFmpegSession
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.UiThreadUtil.runOnUiThread
@@ -172,7 +171,7 @@ class VideoTrimmerView(
   private var jumpToPositionOnLoad = 0L
   private lateinit var headerView: FrameLayout
   private lateinit var headerText: TextView
-  private var ffmpegSession: FFmpegSession? = null
+  private var trimSession: com.videotrim.utils.TrimSession? = null
   private var alertOnFailToLoad = true
   private var alertOnFailTitle = "Error"
   private var alertOnFailMessage = "Fail to load media. Possibly invalid file or no network connection"
@@ -692,7 +691,7 @@ class VideoTrimmerView(
         ?.toLongOrNull() ?: 0L
     }
     val effectiveRemoveAudio = isMuted || configRemoveAudio
-    ffmpegSession = VideoTrimmerUtil.trim(
+    trimSession = VideoTrimmerUtil.trim(
       mSourceUri.toString(),
       StorageUtil.getOutputPath(mContext, mOutputExt),
       mDuration,
@@ -712,8 +711,8 @@ class VideoTrimmerView(
   }
 
   fun onCancelTrimClicked() {
-    if (ffmpegSession != null) {
-      ffmpegSession!!.cancel()
+    if (trimSession != null) {
+      trimSession!!.cancel()
     } else {
       mOnTrimVideoListener.onCancelTrim()
     }

package/ios/ErrorCode.swift

@@ -9,6 +9,7 @@ import Foundation
 
 enum ErrorCode: String {
     case trimmingFailed = "TRIMMING_FAILED"
+    case hardwareEncoderFailed = "HARDWARE_ENCODER_FAILED"
     case failToLoadMedia = "FAIL_TO_LOAD_MEDIA"
     case failToSaveToPhoto = "FAIL_TO_SAVE_TO_PHOTO"
     case failToShare = "FAIL_TO_SHARE"

package/ios/VideoTrim.swift

@@ -571,7 +571,8 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
         self.emitEventToJS("onCancelTrimming", eventData: nil)
       } else {
         // FAILURE
-        self.onError(message: "Command failed with state \(String(describing: FFmpegKitConfig.sessionState(toString: state ?? .failed))) and rc \(String(describing: returnCode)).\(String(describing: session?.getFailStackTrace()))", code: .trimmingFailed)
+        let classified = VideoTrim.classifyFFmpegError(session: session)
+        self.onError(message: "Command failed with state \(String(describing: FFmpegKitConfig.sessionState(toString: state ?? .failed))) and rc \(String(describing: returnCode)).\(String(describing: session?.getFailStackTrace()))", code: classified)
         shouldCloseEditor = self.closeWhenFinish
       }
       
@@ -904,6 +905,32 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
     ]
     self.emitEventToJS("onError", eventData: eventPayload)
   }
+
+  /// Scan an FFmpeg session's log for signatures that indicate the hardware
+  /// video encoder (`h264_videotoolbox`) refused to configure on this device.
+  /// VideoToolbox failures are extremely rare on supported iOS hardware — Apple
+  /// controls the entire stack and regression-tests it — but the classifier
+  /// exists for API parity with Android (where the same hardware-encoder bug is
+  /// common and reproducible) and to give consumers a more actionable
+  /// `errorCode` than the generic `TRIMMING_FAILED` if it ever happens.
+  ///
+  /// Detected signals:
+  ///   - `VTCompressionSession` errors
+  ///   - `Error initializing output stream` / `Error while opening encoder`
+  ///     combined with a `videotoolbox` mention in the same session log
+  static func classifyFFmpegError(session: FFmpegSession?) -> ErrorCode {
+    let logs = session?.getAllLogsAsString() ?? ""
+    let hardwareEncoderSignals = [
+      "VTCompressionSession",
+      "Error initializing output stream",
+      "Error while opening encoder",
+    ]
+    let matchedHardwareSignal = hardwareEncoderSignals.contains { logs.contains($0) }
+    if matchedHardwareSignal && logs.localizedCaseInsensitiveContains("videotoolbox") {
+      return .hardwareEncoderFailed
+    }
+    return .trimmingFailed
+  }
 }
 
 // MARK: @objc instance methods

package/package.json

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