react-native-video-trim 6.2.2 → 7.0.0

package/ios/VideoTrim.swift

@@ -1,5 +1,6 @@
 import React
 import Photos
+import AVFoundation
 import ffmpegkit
 
 let FILE_PREFIX = "trimmedVideo"
@@ -49,14 +50,12 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
       return editorConfig?["removeAfterFailedToShare"] as! Bool
     }
   }
-  private var enableRotation: Bool {
-    get {
-      return editorConfig?["enableRotation"] as! Bool
-    }
-  }
-  private var rotationAngle: Double {
+  
+  /// When true, forces re-encoding even when no transforms are applied,
+  /// giving frame-accurate trim points instead of keyframe-aligned cuts.
+  private var enablePreciseTrimming: Bool {
     get {
-      return editorConfig?["rotationAngle"] as! Double
+      return editorConfig?["enablePreciseTrimming"] as? Bool ?? false
     }
   }
   
@@ -293,7 +292,7 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
           dialogMessage.overrideUserInterfaceStyle = .dark
           
           // Create OK button with action handler
-          let ok = UIAlertAction(title: self.cancelDialogConfirmText, style: .destructive, handler: { (action) -> Void in
+          let ok = UIAlertAction(title: self.cancelTrimmingDialogConfirmText, style: .destructive, handler: { (action) -> Void in
             
             if let ffmpegSession = ffmpegSession {
               ffmpegSession.cancel()
@@ -307,7 +306,7 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
           })
           
           // Create Cancel button with action handlder
-          let cancel = UIAlertAction(title: self.cancelDialogCancelText, style: .cancel)
+          let cancel = UIAlertAction(title: self.cancelTrimmingDialogCancelText, style: .cancel)
           
           //Add OK and Cancel button to an Alert object
           dialogMessage.addAction(ok)
@@ -343,19 +342,126 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
       "\(endTime * 1000)ms",
     ]
     
-    if enableRotation {
-      cmds.append(contentsOf: ["-display_rotation", "\(rotationAngle)"])
+    var videoFilters: [String] = []
+    let hasUserTransform = vc != nil && (vc!.rotationCount != 0 || vc!.isFlipped)
+    let cropNorm = vc?.cropNormalizedRect
+    // Re-encode is required when: (1) user applied flip/rotate, (2) user cropped, or
+    // (3) enablePreciseTrimming is on. In all three cases, -c copy won't work because
+    // either we need video filters or we need frame-accurate cut points.
+    let needsReEncode = hasUserTransform || cropNorm != nil || enablePreciseTrimming
+    
+    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")
+        }
+      }
+      
+      switch vc.rotationCount {
+      case 1: videoFilters.append("transpose=2")
+      case 2:
+        videoFilters.append("transpose=2")
+        videoFilters.append("transpose=2")
+      case 3: videoFilters.append("transpose=1")
+      default: break
+      }
+      if vc.isFlipped {
+        videoFilters.append("hflip")
+      }
+      
+      if let cn = cropNorm, let asset = vc.asset,
+         let track = asset.tracks(withMediaType: .video).first {
+        let raw = track.naturalSize
+        let pt = track.preferredTransform
+        let angle = atan2(pt.b, pt.a)
+        let isSrcRotated = abs(angle - .pi / 2) < 0.1 || abs(angle + .pi / 2) < 0.1
+        let corrected = isSrcRotated
+            ? CGSize(width: raw.height, height: raw.width)
+            : raw
+        
+        let postW: CGFloat
+        let postH: CGFloat
+        if vc.rotationCount % 2 != 0 {
+          postW = corrected.height
+          postH = corrected.width
+        } else {
+          postW = corrected.width
+          postH = corrected.height
+        }
+        
+        let cx = Int(round(cn.origin.x * postW))
+        let cy = Int(round(cn.origin.y * postH))
+        var cw = Int(round(cn.size.width * postW))
+        var ch = Int(round(cn.size.height * postH))
+        // H.264 requires even dimensions; round down to nearest even number.
+        cw = cw & ~1
+        ch = ch & ~1
+        if cw > 0 && ch > 0 {
+          videoFilters.append("crop=\(cw):\(ch):\(cx):\(cy)")
+        }
+      }
     }
     
-    cmds.append(contentsOf: [
-      "-i",
-      inputFile.path,
-      "-c",
-      "copy",
-      "-metadata",
-      "creation_time=\(dateTime)",
-      outputFile!.path
-    ])
+    guard let outputFile = outputFile else {
+      self.onError(message: "Output file path is nil", code: .trimmingFailed)
+      return
+    }
+
+    if needsReEncode {
+      // Preserve source quality by matching the original bitrate. Falls back to 10 Mbps
+      // if the track's estimated data rate is unavailable.
+      var bitrateStr = "10M"
+      if let asset = vc?.asset,
+         let videoTrack = asset.tracks(withMediaType: .video).first {
+        let bitrate = Int(videoTrack.estimatedDataRate)
+        if bitrate > 0 {
+          bitrateStr = "\(bitrate)"
+        }
+      }
+      
+      // -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")
+      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.
+      if !videoFilters.isEmpty {
+        cmds.append(contentsOf: ["-vf", videoFilters.joined(separator: ",")])
+      }
+      // h264_videotoolbox: Apple's hardware H.264 encoder — fast and energy-efficient.
+      cmds.append(contentsOf: [
+        "-c:v",
+        "h264_videotoolbox",
+        "-b:v",
+        bitrateStr,
+        "-c:a",
+        "copy",
+        "-metadata",
+        "creation_time=\(dateTime)",
+        outputFile.path
+      ])
+    } else {
+      // Stream copy: no re-encoding, extremely fast but only cuts at keyframes.
+      cmds.append(contentsOf: [
+        "-i",
+        inputFile.path,
+        "-c",
+        "copy",
+        "-metadata",
+        "creation_time=\(dateTime)",
+        outputFile.path
+      ])
+    }
     
     print("Command: ", cmds.joined(separator: " "))
     
@@ -372,7 +478,7 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
       var shouldCloseEditor = false
       
       if ReturnCode.isSuccess(returnCode) {
-        let eventPayload: [String: Any] = ["outputPath": self.outputFile!.absoluteString, "startTime": (startTime * 1000).rounded(), "endTime": (endTime * 1000).rounded(), "duration": (videoDuration * 1000).rounded()]
+        let eventPayload: [String: Any] = ["outputPath": outputFile.absoluteString, "startTime": (startTime * 1000).rounded(), "endTime": (endTime * 1000).rounded(), "duration": (videoDuration * 1000).rounded()]
         self.emitEventToJS("onFinishTrimming", eventData: eventPayload)
         
         if (self.saveToPhoto && isVideoType) {
@@ -383,19 +489,19 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
             }
             
             PHPhotoLibrary.shared().performChanges({
-              let request = PHAssetChangeRequest.creationRequestForAssetFromVideo(atFileURL: self.outputFile!)
+              let request = PHAssetChangeRequest.creationRequestForAssetFromVideo(atFileURL: outputFile)
               request?.creationDate = Date()
             }) { success, error in
               if success {
                 print("Edited video saved to Photo Library successfully.")
                 
                 if self.removeAfterSavedToPhoto {
-                  let _ = VideoTrim.deleteFile(url: self.outputFile!)
+                  let _ = VideoTrim.deleteFile(url: outputFile)
                 }
               } else {
                 self.onError(message: "Failed to save edited video to Photo Library: \(error?.localizedDescription ?? "Unknown error")", code: .failToSaveToPhoto)
                 if self.removeAfterFailedToSavePhoto {
-                  let _ = VideoTrim.deleteFile(url: self.outputFile!)
+                  let _ = VideoTrim.deleteFile(url: outputFile)
                 }
               }
             }
@@ -404,7 +510,7 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
           DispatchQueue.main.async {
             progressAlert.dismiss(animated: true) {
               self.isTrimming = false
-              self.saveFileToFilesApp(fileURL: self.outputFile!)
+              self.saveFileToFilesApp(fileURL: outputFile)
             }
           }
           return
@@ -412,7 +518,7 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
           DispatchQueue.main.async {
             progressAlert.dismiss(animated: true) {
               self.isTrimming = false
-              self.shareFile(fileURL: self.outputFile!)
+              self.shareFile(fileURL: outputFile)
             }
           }
           return
@@ -479,9 +585,7 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
   // New Arch
   @objc(trim:url:config:)
   public func _trim(inputFile: String, config: NSDictionary, completion: @escaping ([String: Any]) -> Void) {
-    let destPath = URL(string: inputFile)
-    
-    guard let destPath = destPath else {
+    guard let destPath = URL(string: inputFile) ?? URL(fileURLWithPath: inputFile) as URL? else {
       let result = [
         "success": false,
         "message": "Invalid input file path",
@@ -512,20 +616,48 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
       "\(endTime)ms",
     ]
     
-    if let enableRotation = config["enableRotation"] as? Bool, enableRotation {
-      let rotationAngle = config["rotationAngle"] as? Double ?? 0
-      cmds.append(contentsOf: ["-display_rotation", "\(rotationAngle)"])
-    }
+    // Headless trim: no editor UI, so no transforms (flip/rotate/crop) are possible.
+    // The only reason to re-encode here is enablePreciseTrimming for frame-accurate cuts.
+    let enablePrecise = config["enablePreciseTrimming"] as? Bool ?? false
     
-    cmds.append(contentsOf: [
-      "-i",
-      destPath.path,
-      "-c",
-      "copy",
-      "-metadata",
-      "creation_time=\(dateTime)",
-      outputFile.path
-    ])
+    if enablePrecise {
+      // Match source bitrate to preserve quality; fall back to 10 Mbps.
+      var bitrateStr = "10M"
+      let asset = AVURLAsset(url: destPath)
+      if let videoTrack = asset.tracks(withMediaType: .video).first {
+        let bitrate = Int(videoTrack.estimatedDataRate)
+        if bitrate > 0 {
+          bitrateStr = "\(bitrate)"
+        }
+      }
+      
+      // No -noautorotate here: headless trim has no manual rotation filters,
+      // so FFmpeg's auto-rotation produces the correct output orientation.
+      cmds.append(contentsOf: [
+        "-i",
+        destPath.path,
+        "-c:v",
+        "h264_videotoolbox",
+        "-b:v",
+        bitrateStr,
+        "-c:a",
+        "copy",
+        "-metadata",
+        "creation_time=\(dateTime)",
+        outputFile.path
+      ])
+    } else {
+      // Stream copy: no re-encoding, extremely fast but only cuts at keyframes.
+      cmds.append(contentsOf: [
+        "-i",
+        destPath.path,
+        "-c",
+        "copy",
+        "-metadata",
+        "creation_time=\(dateTime)",
+        outputFile.path
+      ])
+    }
     
     print("Command: ", cmds.joined(separator: " "))
     
@@ -677,21 +809,21 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
           print(message)
           self.onError(message: message, code: .failToShare)
           
-          if self.removeAfterFailedToShare {
-            let _ = VideoTrim.deleteFile(url: self.outputFile!)
+          if self.removeAfterFailedToShare, let outputFile = self.outputFile {
+            let _ = VideoTrim.deleteFile(url: outputFile)
           }
           return
         }
         
         if completed {
           print("User completed the sharing activity")
-          if self.removeAfterShared {
-            let _ = VideoTrim.deleteFile(url: self.outputFile!)
+          if self.removeAfterShared, let outputFile = self.outputFile {
+            let _ = VideoTrim.deleteFile(url: outputFile)
           }
         } else {
           print("User cancelled or failed to complete the sharing activity")
-          if self.removeAfterFailedToShare {
-            let _ = VideoTrim.deleteFile(url: self.outputFile!)
+          if self.removeAfterFailedToShare, let outputFile = self.outputFile {
+            let _ = VideoTrim.deleteFile(url: outputFile)
           }
         }
         
@@ -727,10 +859,8 @@ extension VideoTrim {
     editorConfig = config
     print("Show editor called with URI: \(uri)")
     
-    let destPath = URL(string: uri)
-    print("Destination Path: \(destPath!.absoluteString), path: \(destPath!.path)")
-    
-    guard let destPath = destPath else { return }
+    guard let destPath = URL(string: uri) ?? URL(fileURLWithPath: uri) as URL? else { return }
+    print("Destination Path: \(destPath.absoluteString), path: \(destPath.path)")
     
     DispatchQueue.main.async {
       self.vc = VideoTrimmerViewController()
@@ -773,8 +903,9 @@ extension VideoTrim {
       let isVideoType = (config["type"] as? String ?? "video") == "video"
       
       vc.saveBtnClicked = {(selectedRange: CMTimeRange) in
+        guard let asset = vc.asset else { return }
         if !self.enableSaveDialog {
-          self.trim(viewController: vc,inputFile: destPath, videoDuration: self.vc!.asset!.duration.seconds, startTime: selectedRange.start.seconds, endTime: selectedRange.end.seconds, isVideoType: isVideoType)
+          self.trim(viewController: vc,inputFile: destPath, videoDuration: asset.duration.seconds, startTime: selectedRange.start.seconds, endTime: selectedRange.end.seconds, isVideoType: isVideoType)
           return
         }
         
@@ -784,7 +915,7 @@ extension VideoTrim {
         
         // Create OK button with action handler
         let ok = UIAlertAction(title: self.saveDialogConfirmText, style: .default, handler: { (action) -> Void in
-          self.trim(viewController: vc,inputFile: destPath, videoDuration: vc.asset!.duration.seconds, startTime: selectedRange.start.seconds, endTime: selectedRange.end.seconds, isVideoType: isVideoType)
+          self.trim(viewController: vc,inputFile: destPath, videoDuration: asset.duration.seconds, startTime: selectedRange.start.seconds, endTime: selectedRange.end.seconds, isVideoType: isVideoType)
         })
         
         // Create Cancel button with action handlder
@@ -829,6 +960,7 @@ extension VideoTrim {
       vc.dismiss(animated: true, completion: {
         self.emitEventToJS("onHide", eventData: nil)
         self.isShowing = false
+        self.vc = nil
       })
     }
 
@@ -885,7 +1017,8 @@ extension VideoTrim {
   // New Arch
   @objc(deleteFile:)
   public static func deleteFile(uri: String) -> Bool {
-    let state = deleteFile(url: URL(string: uri)!)
+    guard let url = URL(string: uri) else { return false }
+    let state = deleteFile(url: url)
     return state == 0
   }
   
@@ -918,7 +1051,10 @@ extension VideoTrim {
   // New Arch
   @objc(isValidFile:url:)
   public static func isValidFile(url: String, completion: @escaping ([String: Any]) -> Void) -> Void {
-    let fileURL = URL(string: url)!
+    guard let fileURL = URL(string: url) ?? URL(fileURLWithPath: url) as URL? else {
+      completion(["isValid": false, "fileType": "unknown", "duration": -1])
+      return
+    }
     checkFileValidity(url: fileURL) { isValid, fileType, duration in
       if isValid {
         print("Valid \(fileType) file with duration: \(duration) milliseconds")
@@ -1018,8 +1154,9 @@ extension VideoTrim {
     
     vc?.asset = loader.asset
     
+    let duration = loader.asset?.duration.seconds ?? 0
     let eventPayload: [String: Any] = [
-      "duration": loader.asset!.duration.seconds * 1000,
+      "duration": duration * 1000,
     ]
     self.emitEventToJS("onLoad", eventData: eventPayload)
   }
@@ -1029,15 +1166,15 @@ extension VideoTrim {
 // MARK: DocumentPicker delegate
 extension VideoTrim {
   public func documentPicker(_ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
-    if removeAfterSavedToDocuments {
-      let _ = VideoTrim.deleteFile(url: outputFile!)
+    if removeAfterSavedToDocuments, let outputFile = self.outputFile {
+      let _ = VideoTrim.deleteFile(url: outputFile)
     }
     closeEditor()
   }
   
   public func documentPickerWasCancelled(_ controller: UIDocumentPickerViewController) {
-    if removeAfterFailedToSaveDocuments {
-      let _ = VideoTrim.deleteFile(url: outputFile!)
+    if removeAfterFailedToSaveDocuments, let outputFile = self.outputFile {
+      let _ = VideoTrim.deleteFile(url: outputFile)
     }
     closeEditor()
   }

package/ios/VideoTrimmer.swift

@@ -446,17 +446,15 @@ import AVFoundation
             self.thumbnails.removeAll(where: {uuidsToRemove.contains($0.uuid)})
         })
         
-        var seenIndex = 0
         generator.requestedTimeToleranceBefore = .zero
         generator.requestedTimeToleranceAfter = .zero
         generator.generateCGImagesAsynchronously(forTimes: times) { requestedTime, cgImage, actualTime, result, error in
             DispatchQueue.main.async {
-                seenIndex += 1
-                
                 guard let cgImage = cgImage else {return}
+                guard let index = newThumbnails.firstIndex(where: { CMTimeCompare($0.time, requestedTime) == 0 }) else {return}
                 let image = UIImage(cgImage: cgImage)
                 
-                let imageView = newThumbnails[seenIndex - 1].imageView
+                let imageView = newThumbnails[index].imageView
                 UIView.transition(with: imageView, duration: 0.25, options: [.transitionCrossDissolve], animations: {
                     imageView.image = image
                 })