Input standardization 3

Standardize via export session

Author: andrewjl-mux

Sources/MuxUploadSDK/InputStandardization/UploadInputStandardizationWorker.swift

@@ -5,9 +5,64 @@
 import AVFoundation
 import Foundation
 
+protocol Standardizable { }
+
+extension AVAsset: Standardizable { }
+
+enum StandardizationResult {
+    case success(standardizedAsset: AVAsset)
+    case failure(error: Error)
+}
+
+enum StandardizationStrategy {
+    // Prefer using export session whenever possible
+    case exportSession
+}
+
 class UploadInputStandardizationWorker {
 
     var sourceInput: AVAsset?
 
     var standardizedInput: AVAsset?
+
+    func standardize(
+        sourceAsset: AVAsset,
+        outputURL: URL,
+        completion: @escaping (AVAsset, AVAsset?, URL?, Bool) -> ()
+    ) {
+
+        let availableExportPresets = AVAssetExportSession.allExportPresets()
+
+        guard availableExportPresets.contains(where: {
+            $0 == AVAssetExportPreset1280x720
+        }) else {
+            // TODO: Use VideoToolbox if export preset unavailable
+            completion(sourceAsset, nil, nil, false)
+            return
+        }
+
+        guard let exportSession = AVAssetExportSession(
+            asset: sourceAsset,
+            presetName: AVAssetExportPreset1280x720
+        ) else {
+            // TODO: Use VideoToolbox if export session fails to initialize
+            completion(sourceAsset, nil, nil, false)
+            return
+        }
+
+        exportSession.outputFileType = .mp4
+        exportSession.outputURL = outputURL
+
+        // TODO: Use Swift Concurrency
+        exportSession.exportAsynchronously {
+            if let exportError = exportSession.error {
+                completion(sourceAsset, nil, nil, false)
+            } else if let standardizedAssetURL = exportSession.outputURL {
+                let standardizedAsset = AVAsset(url: standardizedAssetURL)
+                completion(sourceAsset, standardizedAsset, outputURL, true)
+            } else {
+                completion(sourceAsset, nil, nil, false)
+            }
+        }
+    }
 }

Sources/MuxUploadSDK/InputStandardization/UploadInputStandardizer.swift

@@ -6,5 +6,31 @@ import AVFoundation
 import Foundation
 
 class UploadInputStandardizer {
-    
+    var workers: [String: UploadInputStandardizationWorker] = [:]
+
+    var fileManager: FileManager = .default
+
+    func standardize(
+        id: String,
+        sourceAsset: AVAsset,
+        completion: @escaping (AVAsset, AVAsset?, URL?, Bool) -> ()
+    ) {
+        let worker = UploadInputStandardizationWorker()
+
+        // TODO: inject Date() for testing purposes
+        let outputFileName = "upload-\(Date().timeIntervalSince1970)"
+
+        let temporaryDirectory = fileManager.temporaryDirectory
+        let temporaryOutputURL = URL(
+            fileURLWithPath: outputFileName,
+            relativeTo: temporaryDirectory
+        )
+
+        worker.standardize(
+            sourceAsset: sourceAsset,
+            outputURL: temporaryOutputURL,
+            completion: completion
+        )
+        workers[id] = worker
+    }
 }

Sources/MuxUploadSDK/PublicAPI/MuxUpload.swift

@@ -474,6 +474,8 @@ public final class MuxUpload : Hashable, Equatable {
 
                 switch inspectionResult {
                 case .inspectionFailure:
+                    // TODO: Request upload confirmation
+                    // before proceeding
                     self.startNetworkTransport(videoFile: videoFile)
                 case .standard:
                     self.startNetworkTransport(videoFile: videoFile)
@@ -488,8 +490,21 @@ public final class MuxUpload : Hashable, Equatable {
                     """
                     )
 
-                    // Skip format standardization
-                    self.startNetworkTransport(videoFile: videoFile)
+                    self.inputStandardizer.standardize(
+                        id: self.id,
+                        sourceAsset: AVAsset(url: videoFile)
+                    ) { sourceAsset, standardizedAsset, outputURL, success in
+
+                        if let outputURL, success {
+                            self.startNetworkTransport(
+                                videoFile: outputURL
+                            )
+                        } else {
+                            self.startNetworkTransport(
+                                videoFile: videoFile
+                            )
+                        }
+                    }
                 }
             }
         }