react-native-photo-video-editor 0.1.1 → 0.2.1

package/ios/Video/Export/VideoExporter.swift

@@ -131,6 +131,10 @@ final class VideoExporter {
       }
     }
 
+    let cropPlan = VideoCropGeometry.plan(size:CGSize(width:renderWidth,height:renderHeight),state:state.crop,includeCrop:true)
+    transform = transform.concatenating(cropPlan.transform)
+    renderWidth = cropPlan.size.width; renderHeight = cropPlan.size.height
+
     let videoComposition = AVMutableVideoComposition()
     videoComposition.renderSize = CGSize(width: renderWidth, height: renderHeight)
     videoComposition.frameDuration = CMTime(value: 1, timescale: 30)
@@ -145,7 +149,12 @@ final class VideoExporter {
     if !layers.isEmpty {
       let renderSize = CGSize(width: renderWidth, height: renderHeight)
       let longestEdge = max(renderSize.width, renderSize.height)
-      let overlayScale = min(1, 1280 / max(longestEdge, 1))
+      // Geometry is independent of this cap: each overlay surface below is a full-`renderSize`
+      // CALayer with `contentsGravity = .resizeAspect`, so a smaller (same-aspect) image is scaled
+      // back up to cover the whole frame. The cap only trades sharpness for peak memory. (Android's
+      // Media3 path has no such scale-to-fit — it composites overlay textures 1:1 in pixels — which
+      // is why `VideoExporter.kt` has to restore the same invariant explicitly via OverlaySettings.)
+      let overlayScale = min(1, 2560 / max(longestEdge, 1))
       let overlayRenderSize = CGSize(
         width: max(2, floor(renderSize.width * overlayScale)),
         height: max(2, floor(renderSize.height * overlayScale))

package/ios/Video/Render/VideoCropGeometry.swift

@@ -0,0 +1,48 @@
+import AVFoundation
+import CoreGraphics
+
+/// Used by AVPlayer's video composition and export's layer instruction. This is the single source
+/// of truth `videoMediaBounds()`/`videoNaturalSize` (in `PhotoVideoEditorViewController`) both derive
+/// their size from, so overlay-relative coordinates stay consistent between preview and the real
+/// composed frame — do not introduce a second, independently-computed size for either of those.
+///
+/// Known gap (not currently reachable from the UI — the video tool rail only exposes Crop/Text/
+/// Stickers, not a whole-video "Rotate" tool): `VideoTransformState.rotationDegrees` (the top-level
+/// rotate field, distinct from this function's `state.rotationDegrees`, which is the CROP sub-state's
+/// own rotation) is applied to the player view as a cosmetic `.transform` only in
+/// `applyVideoPreviewTransform` and never passed into this function, while `VideoExporter` bakes it
+/// into the real output frame (swapping width/height for 90/270°). If that tool is ever wired back up,
+/// `plan()` must also account for it, or preview and export will disagree.
+enum VideoCropGeometry {
+  static func plan(size: CGSize, state: PhotoTransformState, includeCrop: Bool) -> (transform:CGAffineTransform,size:CGSize) {
+    let quarter = CGAffineTransform(rotationAngle:CGFloat(state.rotationDegrees) * .pi/180)
+    let oriented = CGRect(origin:.zero,size:size).applying(quarter)
+    let w = abs(oriented.width).rounded(), h = abs(oriented.height).rounded()
+    var transform = quarter.concatenating(CGAffineTransform(translationX:-oriented.minX,y:-oriented.minY))
+    if state.straightenDegrees != 0 {
+      let scale = CropGeometry.fillScale(width:w,height:h,degrees:state.straightenDegrees)
+      transform = transform.concatenating(CGAffineTransform(translationX:-w/2,y:-h/2))
+        .concatenating(CGAffineTransform(rotationAngle:state.straightenDegrees * .pi/180))
+        .concatenating(CGAffineTransform(scaleX:scale,y:scale))
+        .concatenating(CGAffineTransform(translationX:w/2,y:h/2))
+    }
+    guard includeCrop else { return (transform,CGSize(width:w,height:h)) }
+    let left = (state.cropLeft*w).rounded(), top = (state.cropTop*h).rounded()
+    let width = max(2,(state.cropRight*w).rounded()-left), height = max(2,(state.cropBottom*h).rounded()-top)
+    transform = transform.concatenating(CGAffineTransform(translationX:-left,y:-top))
+    return (transform,CGSize(width:width,height:height))
+  }
+
+  static func previewComposition(asset: AVAsset, state: PhotoTransformState, includeCrop: Bool) -> AVVideoComposition? {
+    guard let track = asset.tracks(withMediaType:.video).first else { return nil }
+    let upright = track.naturalSize.applying(track.preferredTransform)
+    let plan = plan(size:CGSize(width:abs(upright.width),height:abs(upright.height)),state:state,includeCrop:includeCrop)
+    let composition = AVMutableVideoComposition()
+    composition.renderSize = plan.size; composition.frameDuration = CMTime(value:1,timescale:30)
+    let instruction = AVMutableVideoCompositionInstruction(); instruction.timeRange = CMTimeRange(start:.zero,duration:asset.duration)
+    let layer = AVMutableVideoCompositionLayerInstruction(assetTrack:track)
+    layer.setTransform(track.preferredTransform.concatenating(plan.transform),at:.zero)
+    instruction.layerInstructions = [layer]; composition.instructions = [instruction]
+    return composition
+  }
+}

package/ios/Video/Render/VideoTransformState.swift

@@ -8,6 +8,7 @@ import CoreGraphics
 /// `AVMutableComposition` concatenating every clip — see `VideoEditSession`).
 struct VideoTransformState: Equatable {
   var rotationDegrees: Int = 0
+  var crop = PhotoTransformState()
   var aspectRatio: CGFloat?
   var coverFrameMs: Int64 = 0
   /// Preview-only for now: cycled via the Speed tool. Export does not yet honor this — see docs/video-editor.md.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-photo-video-editor",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Native photo and video editor for React Native, powered by Kotlin and Swift.",
   "main": "./lib/module/index.js",
   "module": "./lib/module/index.js",