chore: return same uri if any compression fail + code optimization

Author: numandev1

ios/Video/VideoCompressor.swift

@@ -259,37 +259,19 @@ func makeValidUri(filePath: String) -> String {
       }
 
     func autoCompressionHelper(url: URL, options: [String: Any], onProgress: @escaping (Float) -> Void,  onCompletion: @escaping (URL) -> Void, onFailure: @escaping (Error) -> Void){
-        var bitRate=options["bitrate"] as! Float?;
-        var tmpURL = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
-          .appendingPathComponent(ProcessInfo().globallyUniqueString)
-          .appendingPathExtension("mp4")
-        tmpURL = URL(string:makeValidUri(filePath: tmpURL.absoluteString))!
-        
         let maxSize:Float = options["maxSize"] as! Float;
-        var _bitRate=bitRate;
+    
         let asset = AVAsset(url: url)
         guard asset.tracks.count >= 1 else {
           let error = CompressionError(message: "Invalid video URL, no track found")
           onFailure(error)
           return
         }
-        var videoTrackIndex: Int = 0;
-        let trackLength = asset.tracks.count;
-        if(trackLength==2)
-        {
-            if(asset.tracks[0].mediaType.rawValue=="soun")
-            {
-                videoTrackIndex=1;
-            }
-        }
-        let track = asset.tracks[videoTrackIndex];
-        let exporter = NextLevelSessionExporter(withAsset: asset)
-        exporter.outputURL = tmpURL
-        exporter.outputFileType = AVFileType.mp4
+        let track = getVideoTrack(asset: asset);
 
         let videoSize = track.naturalSize.applying(track.preferredTransform);
-        var actualWidth = Float(abs(videoSize.width))
-        var actualHeight = Float(abs(videoSize.height))
+        let actualWidth = Float(abs(videoSize.width))
+        let actualHeight = Float(abs(videoSize.height))
 
         let bitrate=Float(abs(track.estimatedDataRate));
         let scale:Float = actualWidth > actualHeight ? (Float(maxSize) / actualWidth) : (Float(maxSize) / actualHeight);
@@ -301,63 +283,17 @@ func makeValidUri(filePath: String) -> String {
             originalBitrate: Int(bitrate),
             height: Int(resultHeight), width: Int(resultWidth)
             );
-      
-
-        let compressionDict: [String: Any] = [
-          AVVideoAverageBitRateKey: videoBitRate,
-          AVVideoProfileLevelKey: AVVideoProfileLevelH264HighAutoLevel,
-        ]
-        exporter.optimizeForNetworkUse = true;
-        exporter.videoOutputConfiguration = [
-          AVVideoCodecKey: AVVideoCodecType.h264,
-          AVVideoWidthKey:  resultWidth,
-          AVVideoHeightKey:  resultHeight,
-          AVVideoScalingModeKey: AVVideoScalingModeResizeAspectFill,
-          AVVideoCompressionPropertiesKey: compressionDict
-        ]
-        exporter.audioOutputConfiguration = [
-          AVFormatIDKey: kAudioFormatMPEG4AAC,
-          AVEncoderBitRateKey: NSNumber(integerLiteral: 128000),
-          AVNumberOfChannelsKey: NSNumber(integerLiteral: 2),
-          AVSampleRateKey: NSNumber(value: Float(44100))
-        ]
-        
 
-        exporter.export(progressHandler: { (progress) in
-            let _progress:Float=progress*100;
-            if(Int(_progress)==self.videoCompressionCounter)
-            {
-            self.videoCompressionCounter=Int(_progress)+self.videoCompressionThreshold
+        exportVideoHelper(url: url, asset: asset, bitRate: videoBitRate, resultWidth: resultWidth, resultHeight: resultHeight) { progress in
             onProgress(progress)
-            }
-            
-        }, completionHandler: { result in
-            self.videoCompressionCounter=0;
-          switch result {
-          case .success(let status):
-            switch status {
-            case .completed:
-              onCompletion(exporter.outputURL!)
-              break
-            default:
-              let error = CompressionError(message: "Compression didn't complete")
-              onFailure(error)
-              break
-            }
-            break
-          case .failure(let error):
+        } onCompletion: { outputURL in
+            onCompletion(outputURL)
+        } onFailure: { error in
             onFailure(error)
-            break
-          }
-        })
+        }
       }
 
-
     func manualCompressionHelper(url: URL, bitRate: Float?, onProgress: @escaping (Float) -> Void,  onCompletion: @escaping (URL) -> Void, onFailure: @escaping (Error) -> Void){
-        var tmpURL = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
-          .appendingPathComponent(ProcessInfo().globallyUniqueString)
-          .appendingPathExtension("mp4")
-        tmpURL = URL(string:makeValidUri(filePath: tmpURL.absoluteString))!
 
         var _bitRate=bitRate;
         let asset = AVAsset(url: url)
@@ -366,19 +302,7 @@ func makeValidUri(filePath: String) -> String {
           onFailure(error)
           return
         }
-        var videoTrackIndex: Int = 0;
-        let trackLength = asset.tracks.count;
-        if(trackLength==2)
-        {
-            if(asset.tracks[0].mediaType.rawValue=="soun")
-            {
-                videoTrackIndex=1;
-            }
-        }
-        let track = asset.tracks[videoTrackIndex];
-        let exporter = NextLevelSessionExporter(withAsset: asset)
-        exporter.outputURL = tmpURL
-        exporter.outputFileType = AVFileType.mp4
+        let track = getVideoTrack(asset: asset);
 
         let videoSize = track.naturalSize.applying(track.preferredTransform);
         var width = Float(abs(videoSize.width))
@@ -399,15 +323,34 @@ func makeValidUri(filePath: String) -> String {
 
         let videoBitRate = _bitRate ?? height*width*1.5
 
+        exportVideoHelper(url: url, asset: asset, bitRate: Int(videoBitRate), resultWidth: width, resultHeight: height) { progress in
+            onProgress(progress)
+        } onCompletion: { outputURL in
+            onCompletion(outputURL)
+        } onFailure: { error in
+            onFailure(error)
+        }
+      }
+    
+    func exportVideoHelper(url: URL,asset: AVAsset, bitRate: Int,resultWidth:Float,resultHeight:Float, onProgress: @escaping (Float) -> Void,  onCompletion: @escaping (URL) -> Void, onFailure: @escaping (Error) -> Void){
+        var tmpURL = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
+          .appendingPathComponent(ProcessInfo().globallyUniqueString)
+          .appendingPathExtension("mp4")
+        tmpURL = URL(string:makeValidUri(filePath: tmpURL.absoluteString))!
+        
+        let exporter = NextLevelSessionExporter(withAsset: asset)
+        exporter.outputURL = tmpURL
+        exporter.outputFileType = AVFileType.mp4
+        
         let compressionDict: [String: Any] = [
-          AVVideoAverageBitRateKey: videoBitRate,
+          AVVideoAverageBitRateKey: bitRate,
           AVVideoProfileLevelKey: AVVideoProfileLevelH264HighAutoLevel,
         ]
         exporter.optimizeForNetworkUse = true;
         exporter.videoOutputConfiguration = [
           AVVideoCodecKey: AVVideoCodecType.h264,
-          AVVideoWidthKey:  width,
-          AVVideoHeightKey:  height,
+          AVVideoWidthKey:  resultWidth,
+          AVVideoHeightKey:  resultHeight,
           AVVideoScalingModeKey: AVVideoScalingModeResizeAspectFill,
           AVVideoCompressionPropertiesKey: compressionDict
         ]
@@ -436,15 +379,31 @@ func makeValidUri(filePath: String) -> String {
               onCompletion(exporter.outputURL!)
               break
             default:
-              let error = CompressionError(message: "Compression didn't complete")
-              onFailure(error)
+//              let error = CompressionError(message: "Compression didn't complete")
+//              onFailure(error)
+                onCompletion(url)
               break
             }
             break
           case .failure(let error):
-            onFailure(error)
+//            onFailure(error)
+            onCompletion(url)
             break
           }
         })
-      }
+    }
+    
+    func getVideoTrack(asset: AVAsset) -> AVAssetTrack {
+        var videoTrackIndex: Int = 0;
+        let trackLength = asset.tracks.count;
+        if(trackLength==2)
+        {
+            if(asset.tracks[0].mediaType.rawValue=="soun")
+            {
+                videoTrackIndex=1;
+            }
+        }
+        let track = asset.tracks[videoTrackIndex];
+        return track;
+        }
     }