react-native-compressor 1.8.15 → 1.8.17

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
+    }
+}
+
+

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

@@ -0,0 +1,239 @@
+// Copyright AudioKit. All Rights Reserved. Revision History at http://github.com/AudioKit/AudioKit/
+
+import AVFoundation
+
+// MARK: - internal helper functions
+
+extension FormatConverter {
+    func convertToPCM(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
+        }
+        var format: AudioFileTypeID
+
+        switch outputFormat {
+        case .aif:
+            format = kAudioFileAIFFType
+        case .wav:
+            format = kAudioFileWAVEType
+        case .caf:
+            format = kAudioFileCAFType
+        default:
+            completionHandler?(Self.createError(message: "Output file must be caf, wav or aif."))
+            return
+        }
+
+        var inputFile: ExtAudioFileRef?
+        var outputFile: ExtAudioFileRef?
+
+        func closeFiles() {
+            if let strongFile = inputFile {
+                if noErr != ExtAudioFileDispose(strongFile) {
+                    print("Error disposing input file, could have a memory leak")
+                }
+            }
+            inputFile = nil
+
+            if let strongFile = outputFile {
+                if noErr != ExtAudioFileDispose(strongFile) {
+                    print("Error disposing output file, could have a memory leak")
+                }
+            }
+            outputFile = nil
+        }
+
+        // make sure these are closed on any exit to avoid leaking the file objects
+        defer {
+            closeFiles()
+        }
+
+        if noErr != ExtAudioFileOpenURL(inputURL as CFURL, &inputFile) {
+            completionHandler?(Self.createError(message: "Unable to open the input file."))
+            return
+        }
+
+        guard let strongInputFile = inputFile else {
+            completionHandler?(Self.createError(message: "Unable to open the input file."))
+            return
+        }
+
+        var inputDescription = AudioStreamBasicDescription()
+        var inputDescriptionSize = UInt32(MemoryLayout.stride(ofValue: inputDescription))
+
+        if noErr != ExtAudioFileGetProperty(strongInputFile,
+                                            kExtAudioFileProperty_FileDataFormat,
+                                            &inputDescriptionSize,
+                                            &inputDescription)
+        {
+            completionHandler?(Self.createError(message: "Unable to get the input file data format."))
+            return
+        }
+
+        var outputDescription = createOutputDescription(options: options,
+                                                        outputFormatID: format,
+                                                        inputDescription: inputDescription)
+
+        let inputFormat = AudioFileFormat(rawValue: inputURL.pathExtension.lowercased()) ?? .unknown
+
+        guard inputFormat != outputFormat ||
+            outputDescription.mSampleRate != inputDescription.mSampleRate ||
+            outputDescription.mChannelsPerFrame != inputDescription.mChannelsPerFrame ||
+            outputDescription.mBitsPerChannel != inputDescription.mBitsPerChannel
+        else {
+            print("No conversion is needed, formats are the same. Copying to", outputURL)
+            // just copy it?
+            do {
+                try FileManager.default.copyItem(at: inputURL, to: outputURL)
+                completionHandler?(nil)
+            } catch let err as NSError {
+                print(err)
+            }
+            return
+        }
+
+        // Create destination file
+        if noErr != ExtAudioFileCreateWithURL(outputURL as CFURL,
+                                              format,
+                                              &outputDescription,
+                                              nil,
+                                              AudioFileFlags.eraseFile.rawValue, // overwrite old file if present
+                                              &outputFile)
+        {
+            completionProxy(error: Self.createError(message: "Unable to create output file at \(outputURL.path). " +
+                                "dstFormat \(outputDescription)"),
+            completionHandler: completionHandler)
+            return
+        }
+
+        guard let strongOutputFile = outputFile else {
+            completionProxy(error: Self.createError(message: "Output file is nil."),
+                            completionHandler: completionHandler)
+            return
+        }
+
+        // The format must be linear PCM (kAudioFormatLinearPCM).
+        // You must set this in order to encode or decode a non-PCM file data format.
+        // You may set this on PCM files to specify the data format used in your calls
+        // to read/write.
+        if noErr != ExtAudioFileSetProperty(strongInputFile,
+                                            kExtAudioFileProperty_ClientDataFormat,
+                                            inputDescriptionSize,
+                                            &outputDescription)
+        {
+            completionProxy(error: Self.createError(message: "Unable to set data format on input file."),
+                            completionHandler: completionHandler)
+            return
+        }
+
+        if noErr != ExtAudioFileSetProperty(strongOutputFile,
+                                            kExtAudioFileProperty_ClientDataFormat,
+                                            inputDescriptionSize,
+                                            &outputDescription)
+        {
+            completionProxy(error: Self.createError(message: "Unable to set the output file data format."),
+                            completionHandler: completionHandler)
+            return
+        }
+        let bufferByteSize: UInt32 = 32768
+        var srcBuffer = [UInt8](repeating: 0, count: Int(bufferByteSize))
+        var sourceFrameOffset: UInt32 = 0
+
+        srcBuffer.withUnsafeMutableBytes { body in
+            while true {
+                let mBuffer = AudioBuffer(mNumberChannels: inputDescription.mChannelsPerFrame,
+                                          mDataByteSize: bufferByteSize,
+                                          mData: body.baseAddress)
+
+                var fillBufList = AudioBufferList(mNumberBuffers: 1,
+                                                  mBuffers: mBuffer)
+                var frameCount: UInt32 = 0
+
+                if outputDescription.mBytesPerFrame > 0 {
+                    frameCount = bufferByteSize / outputDescription.mBytesPerFrame
+                }
+
+                if noErr != ExtAudioFileRead(strongInputFile,
+                                             &frameCount,
+                                             &fillBufList)
+                {
+                    completionProxy(error: Self.createError(message: "Error reading from the input file."),
+                                    completionHandler: completionHandler)
+                    return
+                }
+                // EOF
+                if frameCount == 0 { break }
+
+                sourceFrameOffset += frameCount
+
+                if noErr != ExtAudioFileWrite(strongOutputFile,
+                                              frameCount,
+                                              &fillBufList)
+                {
+                    completionProxy(error: Self.createError(message: "Error reading from the output file."),
+                                    completionHandler: completionHandler)
+                    return
+                }
+            }
+        }
+
+        closeFiles()
+
+        // no errors
+        completionHandler?(nil)
+    }
+
+    func createOutputDescription(options: Options,
+                                 outputFormatID: AudioFormatID,
+                                 inputDescription: AudioStreamBasicDescription) -> AudioStreamBasicDescription
+    {
+        let mFormatID: AudioFormatID = kAudioFormatLinearPCM
+
+        let mSampleRate = options.sampleRate ?? inputDescription.mSampleRate
+        let mChannelsPerFrame = options.channels ?? inputDescription.mChannelsPerFrame
+        var mBitsPerChannel = options.bitDepth ?? inputDescription.mBitsPerChannel
+
+        // For example: don't allow upsampling to 24bit if the src is 16
+        if options.bitDepthRule == .lessThanOrEqual, mBitsPerChannel > inputDescription.mBitsPerChannel {
+            mBitsPerChannel = inputDescription.mBitsPerChannel
+        }
+
+        var mBytesPerFrame = mBitsPerChannel * mChannelsPerFrame / 8
+        var mBytesPerPacket = options.bitDepth == nil ? inputDescription.mBytesPerPacket : mBytesPerFrame
+
+        if mBitsPerChannel == 0 {
+            mBitsPerChannel = 16
+            mBytesPerPacket = 2 * mChannelsPerFrame
+            mBytesPerFrame = 2 * mChannelsPerFrame
+        }
+
+        var mFormatFlags: AudioFormatFlags = kLinearPCMFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger
+        if outputFormatID == kAudioFileAIFFType {
+            mFormatFlags = mFormatFlags | kLinearPCMFormatFlagIsBigEndian
+        }
+
+        if outputFormatID == kAudioFileWAVEType, mBitsPerChannel == 8 {
+            // if is 8 BIT PER CHANNEL, remove kAudioFormatFlagIsSignedInteger
+            mFormatFlags &= ~kAudioFormatFlagIsSignedInteger
+        }
+
+        return AudioStreamBasicDescription(mSampleRate: mSampleRate,
+                                           mFormatID: mFormatID,
+                                           mFormatFlags: mFormatFlags,
+                                           mBytesPerPacket: mBytesPerPacket,
+                                           mFramesPerPacket: 1,
+                                           mBytesPerFrame: mBytesPerFrame,
+                                           mChannelsPerFrame: mChannelsPerFrame,
+                                           mBitsPerChannel: mBitsPerChannel,
+                                           mReserved: 0)
+    }
+}

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

@@ -0,0 +1,103 @@
+// Copyright AudioKit. All Rights Reserved. Revision History at http://github.com/AudioKit/AudioKit/
+
+import AVFoundation
+
+extension FormatConverter {
+    class func createError(message: String, code: Int = 1) -> NSError {
+        let userInfo = [NSLocalizedDescriptionKey: message]
+        return NSError(domain: "com.audiodesigndesk.FormatConverter.error",
+                       code: code,
+                       userInfo: userInfo)
+    }
+}
+
+public extension FormatConverter {
+    /// Is this file a PCM file?
+    /// - Parameters:
+    ///   - url: The URL to parse
+    ///   - ignorePathExtension: Do a deep parse rather than rely on the path extension
+    /// - Returns: Bool or nil if it couldn't be determined
+    class func isPCM(url: URL, ignorePathExtension _: Bool = false) -> Bool? {
+        guard let value = isCompressed(url: url) else { return nil }
+        return !value
+    }
+
+    /// Compressed format or not
+    class func isCompressed(url: URL, ignorePathExtension: Bool = false) -> Bool? {
+        guard !ignorePathExtension else {
+            return isCompressedExt(url: url)
+        }
+        let ext = url.pathExtension.lowercased()
+
+        switch ext {
+        case "wav", "bwf", "aif", "aiff", "caf":
+            return false
+
+        case "m4a", "mp3", "mp4", "m4v", "mpg", "flac", "ogg":
+            return true
+
+        default:
+            // if the file extension is missing or unknown, open the file and check it
+            return isCompressedExt(url: url) ?? false
+        }
+    }
+
+    private class func isCompressedExt(url: URL) -> Bool? {
+        var inputFile: ExtAudioFileRef?
+
+        func closeFiles() {
+            if let strongFile = inputFile {
+                // print("🗑 Disposing input", inputURL.path)
+                if noErr != ExtAudioFileDispose(strongFile) {
+                    print("Error disposing input file, could have a memory leak")
+                }
+            }
+            inputFile = nil
+        }
+
+        // make sure these are closed on any exit
+        defer {
+            closeFiles()
+        }
+
+        if noErr != ExtAudioFileOpenURL(url as CFURL,
+                                        &inputFile)
+        {
+            print("Unable to open", url.lastPathComponent)
+            return nil
+        }
+
+        guard let strongInputFile = inputFile else {
+            return nil
+        }
+
+        var inputDescription = AudioStreamBasicDescription()
+        var inputDescriptionSize = UInt32(MemoryLayout.stride(ofValue: inputDescription))
+
+        if noErr != ExtAudioFileGetProperty(strongInputFile,
+                                            kExtAudioFileProperty_FileDataFormat,
+                                            &inputDescriptionSize,
+                                            &inputDescription) {}
+
+        let mFormatID = inputDescription.mFormatID
+
+        switch mFormatID {
+        case kAudioFormatLinearPCM,
+             kAudioFormatAppleLossless: return false
+        default:
+            // basically all other format IDs are compressed
+            return true
+        }
+    }
+}
+
+extension Comparable {
+    // ie: 5.clamped(to: 7...10)
+    // ie: 5.0.clamped(to: 7.0...10.0)
+    // ie: "a".clamped(to: "b"..."h")
+    /// **OTCore:**
+    /// Returns the value clamped to the passed range.
+    @inlinable func clamped(to limits: ClosedRange<Self>) -> Self {
+        min(max(self, limits.lowerBound), limits.upperBound)
+    }
+}