@movementinfra/expo-twostep-video 0.1.0

package/ios/TwoStepVideo/Core/VideoTransformer.swift

@@ -0,0 +1,365 @@
+import Foundation
+import AVFoundation
+import CoreImage
+
+/// Handles video transformation operations including mirroring and speed adjustment
+public class VideoTransformer {
+
+    /// Mirror axis options
+    public enum MirrorAxis {
+        /// Mirror horizontally (flip left-right)
+        case horizontal
+        /// Mirror vertically (flip top-bottom)
+        case vertical
+        /// Mirror both axes
+        case both
+    }
+
+    /// Initialize a new VideoTransformer
+    public init() {}
+
+    // MARK: - Mirroring
+
+    /// Create a mirrored composition from a video asset
+    /// - Parameters:
+    ///   - asset: The video asset to mirror
+    ///   - axis: The axis to mirror on
+    ///   - timeRange: Optional time range to apply (nil = full video)
+    /// - Returns: A tuple of (composition, videoComposition) for export
+    /// - Throws: VideoEditingError if mirroring fails
+    public func mirror(
+        asset: VideoAsset,
+        axis: MirrorAxis,
+        timeRange: TimeRange? = nil
+    ) async throws -> (AVMutableComposition, AVMutableVideoComposition) {
+        let videoTracks = try await asset.avAsset.loadTracks(withMediaType: .video)
+        guard let sourceVideoTrack = videoTracks.first else {
+            throw VideoEditingError.noVideoTrack
+        }
+
+        let composition = AVMutableComposition()
+
+        // Determine time range
+        let effectiveRange: CMTimeRange
+        if let timeRange = timeRange {
+            try timeRange.validate(against: asset)
+            effectiveRange = timeRange.cmTimeRange
+        } else {
+            effectiveRange = CMTimeRange(start: .zero, duration: asset.duration)
+        }
+
+        // Add video track
+        guard let compositionVideoTrack = composition.addMutableTrack(
+            withMediaType: .video,
+            preferredTrackID: kCMPersistentTrackID_Invalid
+        ) else {
+            throw VideoEditingError.compositionFailed(
+                reason: "Failed to add video track to composition"
+            )
+        }
+
+        do {
+            try compositionVideoTrack.insertTimeRange(
+                effectiveRange,
+                of: sourceVideoTrack,
+                at: .zero
+            )
+        } catch {
+            throw VideoEditingError.compositionFailed(
+                reason: "Failed to insert video track: \(error.localizedDescription)"
+            )
+        }
+
+        // Add audio track if present
+        let audioTracks = try? await asset.avAsset.loadTracks(withMediaType: .audio)
+        if let sourceAudioTrack = audioTracks?.first {
+            if let compositionAudioTrack = composition.addMutableTrack(
+                withMediaType: .audio,
+                preferredTrackID: kCMPersistentTrackID_Invalid
+            ) {
+                try? compositionAudioTrack.insertTimeRange(
+                    effectiveRange,
+                    of: sourceAudioTrack,
+                    at: .zero
+                )
+            }
+        }
+
+        // Get video properties
+        let preferredTransform = try await sourceVideoTrack.load(.preferredTransform)
+        let naturalSize = try await sourceVideoTrack.load(.naturalSize)
+
+        // Calculate the actual render size accounting for the transform
+        let transformedSize = naturalSize.applying(preferredTransform)
+        let renderSize = CGSize(
+            width: abs(transformedSize.width),
+            height: abs(transformedSize.height)
+        )
+
+        // Create video composition for mirroring
+        let videoComposition = AVMutableVideoComposition()
+        videoComposition.renderSize = renderSize
+
+        // Get frame rate
+        let frameRate = try await sourceVideoTrack.load(.nominalFrameRate)
+        videoComposition.frameDuration = CMTime(value: 1, timescale: CMTimeScale(frameRate > 0 ? frameRate : 30))
+
+        // Create instruction
+        let instruction = AVMutableVideoCompositionInstruction()
+        instruction.timeRange = CMTimeRange(start: .zero, duration: composition.duration)
+
+        // Create layer instruction with mirror transform
+        let layerInstruction = AVMutableVideoCompositionLayerInstruction(assetTrack: compositionVideoTrack)
+
+        let mirrorTransform = createMirrorTransform(
+            axis: axis,
+            size: renderSize,
+            originalTransform: preferredTransform
+        )
+
+        layerInstruction.setTransform(mirrorTransform, at: .zero)
+
+        instruction.layerInstructions = [layerInstruction]
+        videoComposition.instructions = [instruction]
+
+        return (composition, videoComposition)
+    }
+
+    // MARK: - Speed Adjustment
+
+    /// Create a composition with adjusted playback speed
+    /// - Parameters:
+    ///   - asset: The video asset to adjust
+    ///   - speed: Speed multiplier (0.25 = 4x slower, 2.0 = 2x faster, etc.)
+    ///   - timeRange: Optional time range to apply (nil = full video)
+    ///   - preservesPitch: Whether to preserve audio pitch when changing speed (default: true)
+    /// - Returns: A composition with adjusted speed
+    /// - Throws: VideoEditingError if speed adjustment fails
+    public func adjustSpeed(
+        asset: VideoAsset,
+        speed: Float,
+        timeRange: TimeRange? = nil,
+        preservesPitch: Bool = true
+    ) async throws -> AVMutableComposition {
+        guard speed > 0 else {
+            throw VideoEditingError.invalidConfiguration(
+                reason: "Speed must be greater than 0"
+            )
+        }
+
+        guard speed >= 0.0625 && speed <= 16.0 else {
+            throw VideoEditingError.invalidConfiguration(
+                reason: "Speed must be between 0.0625 (1/16x) and 16.0 (16x)"
+            )
+        }
+
+        let videoTracks = try await asset.avAsset.loadTracks(withMediaType: .video)
+        guard let sourceVideoTrack = videoTracks.first else {
+            throw VideoEditingError.noVideoTrack
+        }
+
+        let composition = AVMutableComposition()
+
+        // Determine time range
+        let effectiveRange: CMTimeRange
+        if let timeRange = timeRange {
+            try timeRange.validate(against: asset)
+            effectiveRange = timeRange.cmTimeRange
+        } else {
+            effectiveRange = CMTimeRange(start: .zero, duration: asset.duration)
+        }
+
+        // Add video track
+        guard let compositionVideoTrack = composition.addMutableTrack(
+            withMediaType: .video,
+            preferredTrackID: kCMPersistentTrackID_Invalid
+        ) else {
+            throw VideoEditingError.compositionFailed(
+                reason: "Failed to add video track to composition"
+            )
+        }
+
+        do {
+            try compositionVideoTrack.insertTimeRange(
+                effectiveRange,
+                of: sourceVideoTrack,
+                at: .zero
+            )
+
+            // Preserve the original transform
+            let preferredTransform = try await sourceVideoTrack.load(.preferredTransform)
+            compositionVideoTrack.preferredTransform = preferredTransform
+        } catch {
+            throw VideoEditingError.compositionFailed(
+                reason: "Failed to insert video track: \(error.localizedDescription)"
+            )
+        }
+
+        // Add audio track if present
+        let audioTracks = try? await asset.avAsset.loadTracks(withMediaType: .audio)
+        if let sourceAudioTrack = audioTracks?.first {
+            if let compositionAudioTrack = composition.addMutableTrack(
+                withMediaType: .audio,
+                preferredTrackID: kCMPersistentTrackID_Invalid
+            ) {
+                try? compositionAudioTrack.insertTimeRange(
+                    effectiveRange,
+                    of: sourceAudioTrack,
+                    at: .zero
+                )
+            }
+        }
+
+        // Calculate the new duration
+        let originalDuration = effectiveRange.duration
+        let newDuration = CMTimeMultiplyByFloat64(originalDuration, multiplier: Float64(1.0 / speed))
+
+        // Scale the time range for all tracks in the composition
+        let compositionVideoTracks = composition.tracks(withMediaType: .video)
+        let compositionAudioTracks = composition.tracks(withMediaType: .audio)
+
+        for track in compositionVideoTracks {
+            track.scaleTimeRange(
+                CMTimeRange(start: .zero, duration: originalDuration),
+                toDuration: newDuration
+            )
+        }
+
+        for track in compositionAudioTracks {
+            track.scaleTimeRange(
+                CMTimeRange(start: .zero, duration: originalDuration),
+                toDuration: newDuration
+            )
+        }
+
+        return composition
+    }
+
+    /// Create a composition with adjusted speed and optional mirroring
+    /// - Parameters:
+    ///   - asset: The video asset to transform
+    ///   - speed: Speed multiplier
+    ///   - mirrorAxis: Optional mirror axis
+    ///   - timeRange: Optional time range
+    /// - Returns: A tuple of (composition, optional videoComposition)
+    /// - Throws: VideoEditingError if transformation fails
+    public func transform(
+        asset: VideoAsset,
+        speed: Float = 1.0,
+        mirrorAxis: MirrorAxis? = nil,
+        timeRange: TimeRange? = nil
+    ) async throws -> (AVMutableComposition, AVMutableVideoComposition?) {
+        // First apply mirroring if needed
+        if let axis = mirrorAxis {
+            let (composition, videoComposition) = try await mirror(
+                asset: asset,
+                axis: axis,
+                timeRange: timeRange
+            )
+
+            // Then apply speed adjustment if needed
+            if speed != 1.0 {
+                let originalDuration = composition.duration
+                let newDuration = CMTimeMultiplyByFloat64(originalDuration, multiplier: Float64(1.0 / speed))
+
+                for track in composition.tracks {
+                    track.scaleTimeRange(
+                        CMTimeRange(start: .zero, duration: originalDuration),
+                        toDuration: newDuration
+                    )
+                }
+
+                // Update video composition instruction time range
+                if let instruction = videoComposition.instructions.first as? AVMutableVideoCompositionInstruction {
+                    instruction.timeRange = CMTimeRange(start: .zero, duration: newDuration)
+                }
+            }
+
+            return (composition, videoComposition)
+        } else if speed != 1.0 {
+            // Only speed adjustment
+            let composition = try await adjustSpeed(
+                asset: asset,
+                speed: speed,
+                timeRange: timeRange
+            )
+            return (composition, nil)
+        } else if let timeRange = timeRange {
+            // Just trimming
+            let videoTracks = try await asset.avAsset.loadTracks(withMediaType: .video)
+            guard let sourceVideoTrack = videoTracks.first else {
+                throw VideoEditingError.noVideoTrack
+            }
+
+            let composition = AVMutableComposition()
+            try timeRange.validate(against: asset)
+
+            guard let compositionVideoTrack = composition.addMutableTrack(
+                withMediaType: .video,
+                preferredTrackID: kCMPersistentTrackID_Invalid
+            ) else {
+                throw VideoEditingError.compositionFailed(reason: "Failed to add video track")
+            }
+
+            try compositionVideoTrack.insertTimeRange(
+                timeRange.cmTimeRange,
+                of: sourceVideoTrack,
+                at: .zero
+            )
+
+            let preferredTransform = try await sourceVideoTrack.load(.preferredTransform)
+            compositionVideoTrack.preferredTransform = preferredTransform
+
+            let audioTracks = try? await asset.avAsset.loadTracks(withMediaType: .audio)
+            if let sourceAudioTrack = audioTracks?.first {
+                if let compositionAudioTrack = composition.addMutableTrack(
+                    withMediaType: .audio,
+                    preferredTrackID: kCMPersistentTrackID_Invalid
+                ) {
+                    try? compositionAudioTrack.insertTimeRange(
+                        timeRange.cmTimeRange,
+                        of: sourceAudioTrack,
+                        at: .zero
+                    )
+                }
+            }
+
+            return (composition, nil)
+        } else {
+            // No transformation needed, create a simple copy composition
+            throw VideoEditingError.invalidConfiguration(
+                reason: "No transformation specified"
+            )
+        }
+    }
+
+    // MARK: - Private Helpers
+
+    /// Create the transform matrix for mirroring
+    private func createMirrorTransform(
+        axis: MirrorAxis,
+        size: CGSize,
+        originalTransform: CGAffineTransform
+    ) -> CGAffineTransform {
+        var transform = originalTransform
+
+        switch axis {
+        case .horizontal:
+            // Flip horizontally: scale x by -1, translate to compensate
+            transform = transform.concatenating(CGAffineTransform(scaleX: -1, y: 1))
+            transform = transform.concatenating(CGAffineTransform(translationX: size.width, y: 0))
+
+        case .vertical:
+            // Flip vertically: scale y by -1, translate to compensate
+            transform = transform.concatenating(CGAffineTransform(scaleX: 1, y: -1))
+            transform = transform.concatenating(CGAffineTransform(translationX: 0, y: size.height))
+
+        case .both:
+            // Flip both axes
+            transform = transform.concatenating(CGAffineTransform(scaleX: -1, y: -1))
+            transform = transform.concatenating(CGAffineTransform(translationX: size.width, y: size.height))
+        }
+
+        return transform
+    }
+}

package/ios/TwoStepVideo/Core/VideoTrimmer.swift

@@ -0,0 +1,300 @@
+import Foundation
+import AVFoundation
+
+/// Handles video trimming operations
+public class VideoTrimmer {
+
+    /// Initialize a new VideoTrimmer
+    public init() {}
+
+    /// Trim a video asset to the specified time range
+    /// This creates a new composition with only the specified time range
+    /// - Parameters:
+    ///   - asset: The video asset to trim
+    ///   - timeRange: The time range to extract
+    /// - Returns: An AVMutableComposition containing the trimmed video
+    /// - Throws: VideoEditingError if trimming fails
+    public func trim(
+        asset: VideoAsset,
+        to timeRange: TimeRange
+    ) async throws -> AVMutableComposition {
+        // Validate the time range
+        try timeRange.validate(against: asset)
+
+        let composition = AVMutableComposition()
+
+        do {
+            // Add video track
+            try await addVideoTrack(
+                from: asset,
+                to: composition,
+                timeRange: timeRange
+            )
+
+            // Add audio track if present
+            if asset.hasAudio {
+                try await addAudioTrack(
+                    from: asset,
+                    to: composition,
+                    timeRange: timeRange
+                )
+            }
+
+            return composition
+
+        } catch let error as VideoEditingError {
+            throw error
+        } catch {
+            throw VideoEditingError.compositionFailed(
+                reason: "Failed to create trimmed composition: \(error.localizedDescription)"
+            )
+        }
+    }
+
+    /// Create a composition with multiple trimmed segments
+    /// - Parameters:
+    ///   - asset: The video asset to trim
+    ///   - timeRanges: Array of time ranges to extract and concatenate
+    /// - Returns: An AVMutableComposition containing all segments
+    /// - Throws: VideoEditingError if trimming fails
+    public func trim(
+        asset: VideoAsset,
+        to timeRanges: [TimeRange]
+    ) async throws -> AVMutableComposition {
+        guard !timeRanges.isEmpty else {
+            throw VideoEditingError.invalidConfiguration(
+                reason: "At least one time range must be provided"
+            )
+        }
+
+        // Validate all time ranges
+        for timeRange in timeRanges {
+            try timeRange.validate(against: asset)
+        }
+
+        let composition = AVMutableComposition()
+
+        // Track the current insert time in the composition
+        var currentTime = CMTime.zero
+
+        do {
+            for timeRange in timeRanges {
+                // Add video segment
+                currentTime = try await addVideoTrack(
+                    from: asset,
+                    to: composition,
+                    timeRange: timeRange,
+                    atTime: currentTime
+                )
+
+                // Add audio segment if present
+                if asset.hasAudio {
+                    _ = try await addAudioTrack(
+                        from: asset,
+                        to: composition,
+                        timeRange: timeRange,
+                        atTime: CMTimeSubtract(currentTime, timeRange.duration)
+                    )
+                }
+            }
+
+            return composition
+
+        } catch let error as VideoEditingError {
+            throw error
+        } catch {
+            throw VideoEditingError.compositionFailed(
+                reason: "Failed to create multi-segment composition: \(error.localizedDescription)"
+            )
+        }
+    }
+
+    /// Create a looped composition from a video segment
+    /// - Parameters:
+    ///   - asset: The video asset to loop
+    ///   - loopConfig: Configuration specifying the segment and loop count
+    /// - Returns: An AVMutableComposition containing the looped video
+    /// - Throws: VideoEditingError if looping fails
+    public func loop(
+        asset: VideoAsset,
+        configuration loopConfig: LoopConfiguration
+    ) async throws -> AVMutableComposition {
+        // Validate the loop configuration
+        try loopConfig.validate(against: asset)
+
+        let composition = AVMutableComposition()
+
+        do {
+            var currentTime = CMTime.zero
+
+            // Insert the segment multiple times
+            for _ in 0..<loopConfig.totalPlays {
+                // Add video segment
+                currentTime = try await addVideoTrack(
+                    from: asset,
+                    to: composition,
+                    timeRange: loopConfig.timeRange,
+                    atTime: currentTime
+                )
+
+                // Reset to previous position for audio
+                let audioInsertTime = CMTimeSubtract(currentTime, loopConfig.timeRange.duration)
+
+                // Add audio segment if present
+                if asset.hasAudio {
+                    _ = try await addAudioTrack(
+                        from: asset,
+                        to: composition,
+                        timeRange: loopConfig.timeRange,
+                        atTime: audioInsertTime
+                    )
+                }
+            }
+
+            return composition
+
+        } catch let error as VideoEditingError {
+            throw error
+        } catch {
+            throw VideoEditingError.compositionFailed(
+                reason: "Failed to create looped composition: \(error.localizedDescription)"
+            )
+        }
+    }
+
+    /// Create a looped composition with additional options
+    /// - Parameters:
+    ///   - asset: The video asset to loop
+    ///   - startTime: Start time of the segment to loop (in seconds)
+    ///   - endTime: End time of the segment to loop (in seconds)
+    ///   - loopCount: Number of times to repeat the segment
+    /// - Returns: An AVMutableComposition containing the looped video
+    /// - Throws: VideoEditingError if looping fails
+    public func loop(
+        asset: VideoAsset,
+        startTime: Double,
+        endTime: Double,
+        loopCount: Int
+    ) async throws -> AVMutableComposition {
+        let config = try LoopConfiguration.fromSeconds(
+            start: startTime,
+            end: endTime,
+            loopCount: loopCount
+        )
+        return try await loop(asset: asset, configuration: config)
+    }
+
+    /// Get thumbnail images from a video at specific times
+    /// - Parameters:
+    ///   - asset: The video asset
+    ///   - times: Array of times to extract thumbnails
+    ///   - size: Desired size for thumbnails (maintains aspect ratio)
+    /// - Returns: Array of CGImage thumbnails
+    /// - Throws: VideoEditingError if thumbnail generation fails
+    public func generateThumbnails(
+        from asset: VideoAsset,
+        at times: [CMTime],
+        size: CGSize = CGSize(width: 200, height: 200)
+    ) async throws -> [CGImage] {
+        let generator = AVAssetImageGenerator(asset: asset.avAsset)
+        generator.appliesPreferredTrackTransform = true
+        generator.maximumSize = size
+
+        var images: [CGImage] = []
+
+        for time in times {
+            do {
+                let cgImage = try await generator.image(at: time).image
+                images.append(cgImage)
+            } catch {
+                throw VideoEditingError.compositionFailed(
+                    reason: "Failed to generate thumbnail at \(CMTimeGetSeconds(time))s: \(error.localizedDescription)"
+                )
+            }
+        }
+
+        return images
+    }
+
+    // MARK: - Private Helper Methods
+
+    /// Add a video track to the composition
+    @discardableResult
+    private func addVideoTrack(
+        from asset: VideoAsset,
+        to composition: AVMutableComposition,
+        timeRange: TimeRange,
+        atTime insertTime: CMTime = .zero
+    ) async throws -> CMTime {
+        let videoTracks = try await asset.avAsset.loadTracks(withMediaType: .video)
+        guard let sourceVideoTrack = videoTracks.first else {
+            throw VideoEditingError.noVideoTrack
+        }
+
+        guard let compositionVideoTrack = composition.addMutableTrack(
+            withMediaType: .video,
+            preferredTrackID: kCMPersistentTrackID_Invalid
+        ) else {
+            throw VideoEditingError.compositionFailed(
+                reason: "Failed to add video track to composition"
+            )
+        }
+
+        do {
+            try compositionVideoTrack.insertTimeRange(
+                timeRange.cmTimeRange,
+                of: sourceVideoTrack,
+                at: insertTime
+            )
+
+            // Preserve the original video track's preferred transform
+            let preferredTransform = try await sourceVideoTrack.load(.preferredTransform)
+            compositionVideoTrack.preferredTransform = preferredTransform
+
+            return CMTimeAdd(insertTime, timeRange.duration)
+
+        } catch {
+            throw VideoEditingError.compositionFailed(
+                reason: "Failed to insert video track: \(error.localizedDescription)"
+            )
+        }
+    }
+
+    /// Add an audio track to the composition
+    @discardableResult
+    private func addAudioTrack(
+        from asset: VideoAsset,
+        to composition: AVMutableComposition,
+        timeRange: TimeRange,
+        atTime insertTime: CMTime = .zero
+    ) async throws -> CMTime {
+        let audioTracks = try await asset.avAsset.loadTracks(withMediaType: .audio)
+        guard let sourceAudioTrack = audioTracks.first else {
+            throw VideoEditingError.noAudioTrack
+        }
+
+        guard let compositionAudioTrack = composition.addMutableTrack(
+            withMediaType: .audio,
+            preferredTrackID: kCMPersistentTrackID_Invalid
+        ) else {
+            throw VideoEditingError.compositionFailed(
+                reason: "Failed to add audio track to composition"
+            )
+        }
+
+        do {
+            try compositionAudioTrack.insertTimeRange(
+                timeRange.cmTimeRange,
+                of: sourceAudioTrack,
+                at: insertTime
+            )
+
+            return CMTimeAdd(insertTime, timeRange.duration)
+
+        } catch {
+            throw VideoEditingError.compositionFailed(
+                reason: "Failed to insert audio track: \(error.localizedDescription)"
+            )
+        }
+    }
+}