react-native-compressor 1.8.16 → 1.8.18

package/ios/Audio/AudioHelper.swift

@@ -0,0 +1,49 @@
+//
+//  AudioHelper.swift
+//  react-native-compressor
+//
+//  Created by Numan on 12/11/2023.
+//
+
+import AVFoundation
+
+class AudioHelper {
+    
+    static func getAudioBitrate(path: String) -> Int {
+        let audioURL = URL(fileURLWithPath: path)
+        let avAsset = AVURLAsset(url: audioURL)
+        let keys: Set<URLResourceKey> = [.totalFileSizeKey, .fileSizeKey]
+        let resourceValues = try? audioURL.resourceValues(forKeys: keys)
+        let fileSize = resourceValues?.fileSize ?? resourceValues?.totalFileSize
+
+        // Calculate bitrate in kbps
+        if let fileSize = fileSize, avAsset.duration.seconds > 0 {
+            return Int(Double(fileSize) * 8 / avAsset.duration.seconds)
+        }
+        return 0
+    }
+    
+    static func getDestinationBitrateByQuality(path: String, quality: String) -> Int {
+            let originalBitrate = getAudioBitrate(path: path)
+            var destinationBitrate = originalBitrate
+            print("source bitrate: \(originalBitrate)")
+
+            // Calculate the percentage of the original bitrate relative to the range 64000 to 320000
+            let percentage = Double(originalBitrate - 64000) / Double(320000 - 64000)
+
+            switch quality.lowercased() {
+            case "low":
+                destinationBitrate = max(64000, Int(Double(originalBitrate) * 0.3))
+            case "medium":
+                // Set destination bitrate to 60% of the original bitrate
+                destinationBitrate = Int(Double(originalBitrate) * 0.5)
+            case "high":
+                // Set destination bitrate to 80% of the original bitrate
+                destinationBitrate = min(320000,Int(Double(originalBitrate) * 0.7))
+            default:
+                print("Invalid quality level. Please enter 'low', 'medium', or 'high'.")
+            }
+            
+            return destinationBitrate
+        }
+}

package/ios/Audio/AudioMain.swift

@@ -5,16 +5,21 @@
 //  Created by Numan on 10/09/2023.
 //
 
-import Foundation
+
 import AVFoundation
+
+
+
 let AlAsset_Library_Scheme = "assets-library"
 class AudioMain{
     static func compress_audio(_ fileUrl: String, optionMap: NSDictionary, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
         do {
             var fileUrl = fileUrl
+            
             if fileUrl.hasPrefix("file://") {
                 fileUrl = fileUrl.replacingOccurrences(of: "file://", with: "")
             }
+          
             let fileManager = FileManager.default
             var isDir: ObjCBool = false
             if !fileManager.fileExists(atPath: fileUrl, isDirectory: &isDir) || isDir.boolValue {
@@ -23,93 +28,52 @@ class AudioMain{
                 return
             }
             
-            let assetOptions: [String: Any] = [AVURLAssetPreferPreciseDurationAndTimingKey: true]
-            let asset = AVURLAsset(url: URL(fileURLWithPath: fileUrl), options: assetOptions)
-            let quality = optionMap["quality"] as? String ?? ""
-            let qualityConstant = getAudioQualityConstant(quality)
-            auto_compress_helper(asset, qualityConstant: qualityConstant) { mp3Path, finished in
-                if finished {
-                    resolve("file://\(mp3Path ?? "")")
-                } else {
-                    reject("Error", "Something went wrong", nil)
-                }
-            }
-        } catch {
-            reject(error.localizedDescription, error.localizedDescription, nil)
-        }
-    }
-    
-    static func getAudioQualityConstant(_ quality: String) -> String {
-        let audioQualityArray = ["low", "medium", "high"]
-        if let index = audioQualityArray.firstIndex(of: quality) {
-            switch index {
-            case 0:
-                return AVAssetExportPresetLowQuality
-            case 1:
-                return AVAssetExportPresetMediumQuality
-            case 2:
-                return AVAssetExportPresetHighestQuality
-            default:
-                return AVAssetExportPresetMediumQuality
+            let audioOptions = AudioOptions.fromDictionary((optionMap as! [String : Any]))
+            let outputMp3Path = "file://\(Utils.generateCacheFilePath("m4a"))"
+            
+            let oldUfileUrlRL = URL(string: fileUrl)!
+            let newURL = URL(string: outputMp3Path)!
+            
+            var options = FormatConverter.Options()
+            
+            if(audioOptions.samplerate != -1){
+                options.sampleRate = Double(audioOptions.samplerate)
             }
-        }
-        return AVAssetExportPresetMediumQuality
-    }
-    
-    static func auto_compress_helper(_ avAsset: AVURLAsset, qualityConstant: String, complete completeCallback: @escaping (_ mp3Path: String?, _ finished: Bool) -> Void) {
-        var path: String
-        if avAsset.url.scheme == AlAsset_Library_Scheme {
-            path = avAsset.url.query ?? ""
-            if path.isEmpty {
-                completeCallback(nil, false)
-                return
+            
+            if(audioOptions.bitrate != -1){
+                options.bitRate = UInt32(audioOptions.bitrate)
             }
-        } else {
-            path = avAsset.url.path
-            if path.isEmpty || !FileManager.default.fileExists(atPath: path) {
-                completeCallback(nil, false)
-                return
+            else
+            {
+                let bitrate = AudioHelper.getDestinationBitrateByQuality(path: fileUrl,quality: audioOptions.quality)
+                print("output bitrate: \(bitrate)")
+                options.bitRate = UInt32(bitrate)
             }
-        }
-        
-        let mp3Path = Utils.generateCacheFilePath("m4a")
-        
-        if FileManager.default.fileExists(atPath: mp3Path) {
-            completeCallback(mp3Path, true)
-            return
-        }
-        
-        let compatiblePresets = AVAssetExportSession.exportPresets(compatibleWith: avAsset)
-        
-        if compatiblePresets.contains(qualityConstant) {
-            let exportSession = AVAssetExportSession(asset: avAsset, presetName: AVAssetExportPresetAppleM4A)
             
-            let mp3Url = URL(fileURLWithPath: mp3Path)
-            exportSession?.outputURL = mp3Url
-            exportSession?.shouldOptimizeForNetworkUse = true
-            exportSession?.outputFileType = .m4a
             
-            exportSession?.exportAsynchronously(completionHandler: {
-                var finished = false
-                switch exportSession?.status {
-                case .failed:
-                    print("AVAssetExportSessionStatusFailed, error: \(exportSession?.error?.localizedDescription ?? "").")
-                case .cancelled:
-                    print("AVAssetExportSessionStatusCancelled.")
-                case .completed:
-                    print("AVAssetExportSessionStatusCompleted.")
-                    finished = true
-                case .unknown:
-                    print("AVAssetExportSessionStatusUnknown")
-                case .waiting:
-                    print("AVAssetExportSessionStatusWaiting")
-                case .exporting:
-                    print("AVAssetExportSessionStatusExporting")
-                default:
-                    break
+            if(audioOptions.channels != -1){
+                options.channels = UInt32(audioOptions.channels)
+            }
+         
+            options.format = .m4a
+            options.eraseFile = false
+            options.bitDepthRule = .any
+             
+            let converter = FormatConverter(inputURL: oldUfileUrlRL, outputURL: newURL, options: options)
+            converter.start { error in
+            // check to see if error isn't nil, otherwise you're good
+                if((error) != nil)
+                {
+                    print("error=> \(error?.localizedDescription)")
+                    reject(error?.localizedDescription,error?.localizedDescription, error)
+                    return
                 }
-                completeCallback(mp3Path, finished)
-            })
+               
+                resolve(newURL.absoluteString)
+            }
+            
+        } catch {
+            reject(error.localizedDescription, error.localizedDescription, nil)
         }
     }
 }

package/ios/Audio/AudioOptions.swift

@@ -0,0 +1,37 @@
+class AudioOptions: NSObject {
+    static func fromDictionary(_ dictionary: [String: Any]?) -> AudioOptions {
+        let options = AudioOptions()
+        
+        guard let dictionary = dictionary else {
+            return options
+        }
+        
+        for (key, value) in dictionary {
+            switch key {
+            case "quality":
+                options.quality = (value as? String) ?? "medium"
+            case "bitrate":
+                options.bitrate = (value as? Int) ?? -1
+            case "samplerate":
+                options.samplerate = (value as? Int) ?? -1
+            case "channels":
+                options.channels = (value as? Int) ?? -1
+           
+            default:
+                break
+            }
+        }
+        
+        return options
+    }
+
+    var quality: String = "medium"
+    var bitrate: Int = -1
+    var samplerate: Int = -1
+    var channels: Int = -1
+   
+    
+    override init() {
+        super.init()
+    }
+}

package/ios/Audio/FormatConverter/FormatConverter+Compressed.swift

@@ -0,0 +1,326 @@
+// Copyright AudioKit. All Rights Reserved. Revision History at http://github.com/AudioKit/AudioKit/
+
+import AVFoundation
+
+// MARK: - internal helper functions
+
+
+public extension AVURLAsset {
+    /// Audio format for  the file in the URL asset
+    var audioFormat: AVAudioFormat? {
+        // pull the input format out of the audio file...
+        if let source = try? AVAudioFile(forReading: url) {
+            return source.fileFormat
+
+            // if that fails it might be a video, so check the tracks for audio
+        } else {
+            let audioTracks = tracks.filter { $0.mediaType == .audio }
+
+            guard !audioTracks.isEmpty else { return nil }
+
+            let formatDescriptions = audioTracks.compactMap {
+                $0.formatDescriptions as? [CMFormatDescription]
+            }.reduce([], +)
+
+            let audioFormats: [AVAudioFormat] = formatDescriptions.compactMap {
+                AVAudioFormat(cmAudioFormatDescription: $0)
+            }
+            return audioFormats.first
+        }
+    }
+}
+
+
+extension FormatConverter {
+    /// Example of the most simplistic AVFoundation conversion.
+    /// With this approach you can't really specify any settings other than the limited presets.
+    /// No sample rate conversion in this. This isn't used in the public methods but is here
+    /// for example.
+    ///
+    /// see `AVAssetExportSession`:
+    /// *Prior to initializing an instance of AVAssetExportSession, you can invoke
+    /// +allExportPresets to obtain the complete list of presets available. Use
+    /// +exportPresetsCompatibleWithAsset: to obtain a list of presets that are compatible
+    /// with a specific AVAsset.*
+    ///
+    /// This is no longer used in this class as it's not possible to convert sample rate or other
+    /// required options. It will use the next function instead
+    func convertCompressed(presetName: String, completionHandler: FormatConverterCallback? = nil) {
+        guard let inputURL = inputURL else {
+            completionHandler?(Self.createError(message: "Input file can't be nil."))
+            return
+        }
+        guard let outputURL = outputURL else {
+            completionHandler?(Self.createError(message: "Output file can't be nil."))
+            return
+        }
+
+        let asset = AVURLAsset(url: inputURL)
+        guard let session = AVAssetExportSession(asset: asset,
+                                                 presetName: presetName) else { return }
+
+        session.determineCompatibleFileTypes { list in
+
+            guard let outputFileType: AVFileType = list.first else {
+                let error = Self.createError(message: "Unable to determine a compatible file type from \(inputURL.path)")
+                completionHandler?(error)
+                return
+            }
+
+            // session.progress could be sent out via a delegate for this session
+            session.outputURL = outputURL
+            session.outputFileType = outputFileType
+            session.exportAsynchronously {
+                completionHandler?(session.error)
+            }
+        }
+    }
+
+    /// Convert to compressed first creating a tmp file to PCM to allow more flexible conversion
+    /// options to work.
+    func convertCompressed(completionHandler: FormatConverterCallback? = nil) {
+        guard let inputURL = inputURL else {
+            completionHandler?(Self.createError(message: "Input file can't be nil."))
+            return
+        }
+        guard let outputURL = outputURL else {
+            completionHandler?(Self.createError(message: "Output file can't be nil."))
+            return
+        }
+
+        guard let options = options else {
+            completionHandler?(Self.createError(message: "Options can't be nil."))
+            return
+        }
+
+        let tempName = outputURL.deletingPathExtension().lastPathComponent + "_TEMP.wav"
+        let tempFile = outputURL.deletingLastPathComponent().appendingPathComponent(tempName)
+
+        var tempOptions = FormatConverter.Options()
+        tempOptions.bitDepthRule = .lessThanOrEqual
+        tempOptions.bitDepth = 24
+        tempOptions.sampleRate = options.sampleRate
+        tempOptions.channels = options.channels
+        tempOptions.format = .wav
+
+        let tempConverter = FormatConverter(inputURL: inputURL,
+                                            outputURL: tempFile,
+                                            options: tempOptions)
+
+        tempConverter.start { error in
+            if let error = error {
+                completionHandler?(Self.createError(message: "Failed to convert input to PCM: \(error.localizedDescription)"))
+                return
+            }
+
+            self.inputURL = tempFile
+
+            self.convertPCMToCompressed { error in
+                try? FileManager.default.removeItem(at: tempFile)
+                completionHandler?(error)
+            }
+        }
+    }
+
+    /// The AVFoundation way. *This doesn't currently handle compressed input - only compressed output.*
+    func convertPCMToCompressed(completionHandler: FormatConverterCallback? = nil) {
+        guard let inputURL = inputURL else {
+            completionHandler?(Self.createError(message: "Input file can't be nil."))
+            return
+        }
+        guard let outputURL = outputURL else {
+            completionHandler?(Self.createError(message: "Output file can't be nil."))
+            return
+        }
+
+        guard let options = options, let outputFormat = options.format else {
+            completionHandler?(Self.createError(message: "Options can't be nil."))
+            return
+        }
+
+        // verify outputFormat
+        guard FormatConverter.outputFormats.contains(outputFormat) else {
+            completionHandler?(Self.createError(message: "The output file format isn't able to be produced by this class."))
+            return
+        }
+
+        let asset = AVURLAsset(url: inputURL)
+        do {
+            self.reader = try AVAssetReader(asset: asset)
+
+        } catch let err as NSError {
+            completionHandler?(err)
+            return
+        }
+
+        guard let reader = reader else {
+            completionHandler?(Self.createError(message: "Unable to setup the AVAssetReader."))
+            return
+        }
+
+        guard let inputFormat = asset.audioFormat else {
+            completionHandler?(Self.createError(message: "Unable to read the input file format."))
+            return
+        }
+
+        var format: AVFileType
+        var formatKey: AudioFormatID
+
+        switch outputFormat {
+        case .m4a, .mp4:
+            format = .m4a
+            formatKey = kAudioFormatMPEG4AAC
+        case .aif:
+            format = .aiff
+            formatKey = kAudioFormatLinearPCM
+        case .caf:
+            format = .caf
+            formatKey = kAudioFormatLinearPCM
+        case .wav:
+            format = .wav
+            formatKey = kAudioFormatLinearPCM
+        default:
+            print("Unsupported output format: \(outputFormat)")
+            return
+        }
+
+        do {
+            self.writer = try AVAssetWriter(outputURL: outputURL, fileType: format)
+        } catch let err as NSError {
+            completionHandler?(err)
+            return
+        }
+
+        guard let writer = writer else {
+            completionHandler?(Self.createError(message: "Unable to setup the AVAssetWriter."))
+            return
+        }
+
+        // 1. chosen option. 2. same as input file. 3. 16 bit
+        // optional in case of compressed audio. That said, the other conversion methods are actually used in
+        // that case
+        let bitDepth = (options.bitDepth ?? inputFormat.settings[AVLinearPCMBitDepthKey] ?? 16) as Any
+        var isFloat = false
+        if let intDepth = bitDepth as? Int {
+            isFloat = intDepth == 32
+        }
+
+        var sampleRate = options.sampleRate ?? inputFormat.sampleRate
+        let channels = options.channels ?? inputFormat.channelCount
+
+        if sampleRate == 0 {
+            print("Sample rate can't be 0 - assigning to default format of 48k. inputFormat is", inputFormat)
+            sampleRate = 48000
+        }
+        var outputSettings: [String: Any]?
+
+        // Note: AVAssetReaderOutput does not currently support compressed audio
+        if formatKey == kAudioFormatMPEG4AAC {
+            if sampleRate > 48000 {
+                sampleRate = 48000
+            }
+            // mono should be 1/2 the shown bitrate
+            let perChannel = channels == 1 ? 2 : 1
+
+            // reset these for m4a:
+            outputSettings = [
+                AVFormatIDKey: formatKey,
+                AVSampleRateKey: sampleRate,
+                AVNumberOfChannelsKey: channels,
+                AVEncoderBitRateKey: Int(options.bitRate) / perChannel,
+                AVEncoderBitRateStrategyKey: AVAudioBitRateStrategy_Constant,
+            ]
+        } else {
+            outputSettings = [
+                AVFormatIDKey: formatKey,
+                AVSampleRateKey: sampleRate,
+                AVNumberOfChannelsKey: channels,
+                AVLinearPCMBitDepthKey: bitDepth,
+                AVLinearPCMIsFloatKey: isFloat,
+                AVLinearPCMIsBigEndianKey: format != .wav,
+                AVLinearPCMIsNonInterleaved: !(options.isInterleaved ?? inputFormat.isInterleaved),
+            ]
+        }
+
+        let hint = asset.audioFormat?.formatDescription
+
+        let writerInput = AVAssetWriterInput(mediaType: .audio, outputSettings: outputSettings, sourceFormatHint: hint)
+        writer.add(writerInput)
+
+        guard let track = asset.tracks(withMediaType: .audio).first else {
+            completionProxy(error: Self.createError(message: "No audio was found in the input file."),
+                            completionHandler: completionHandler)
+            return
+        }
+
+        let readerOutput = AVAssetReaderTrackOutput(track: track, outputSettings: nil)
+        guard reader.canAdd(readerOutput) else {
+            completionProxy(error: Self.createError(message: "Unable to add reader output."),
+                            completionHandler: completionHandler)
+            return
+        }
+        reader.add(readerOutput)
+
+        if !writer.startWriting() {
+            print("Failed to start writing. Error:", writer.error?.localizedDescription)
+            completionProxy(error: writer.error,
+                            completionHandler: completionHandler)
+            return
+        }
+
+        writer.startSession(atSourceTime: CMTime.zero)
+
+        if !reader.startReading() {
+            print("Failed to start reading. Error:", reader.error?.localizedDescription)
+            completionProxy(error: reader.error,
+                            completionHandler: completionHandler)
+            return
+        }
+
+        let queue = DispatchQueue(label: "com.audiodesigndesk.ADD.FormatConverter.convertAsset")
+
+        // session.progress could be sent out via a delegate for this session
+        writerInput.requestMediaDataWhenReady(on: queue, using: {
+            var processing = true // safety flag to prevent runaway loops if errors
+
+            while writerInput.isReadyForMoreMediaData, processing {
+                if reader.status == .reading,
+                   let buffer = readerOutput.copyNextSampleBuffer()
+                {
+                    writerInput.append(buffer)
+
+                } else {
+                    writerInput.markAsFinished()
+
+                    switch reader.status {
+                    case .failed:
+                        print("Conversion failed with error", reader.error)
+                        writer.cancelWriting()
+                        self.completionProxy(error: reader.error, completionHandler: completionHandler)
+                    case .cancelled:
+                        print("Conversion cancelled")
+                        self.completionProxy(error: Self.createError(message: "Process canceled"),
+                                             completionHandler: completionHandler)
+                    case .completed:
+                        writer.finishWriting {
+                            switch writer.status {
+                            case .failed:
+                                print("Conversion failed at finishWriting")
+                                self.completionProxy(error: writer.error,
+                                                     completionHandler: completionHandler)
+                            default:
+                                // no errors
+                                completionHandler?(nil)
+                            }
+                        }
+                    default:
+                        break
+                    }
+                    processing = false
+                }
+            }
+        }) // requestMediaDataWhenReady
+    }
+}
+
+