@siteed/expo-audio-studio 2.18.6 → 3.0.1

package/ios/AudioProcessor.swift

@@ -1,1151 +0,0 @@
-// packages/expo-audio-stream/ios/AudioProcessor.swift
-
-import Foundation
-import Accelerate
-import AVFoundation
-import QuartzCore
-
-// Constants
-private let SILENCE_THRESHOLD_RMS: Float = 0.01
-
-public struct TrimResult {
-    let uri: String
-    let filename: String
-    let durationMs: Double
-    let size: Int64
-    let sampleRate: Int
-    let channels: Int
-    let bitDepth: Int
-    let mimeType: String
-    let requestedFormat: String
-    let actualFormat: String
-    let compression: [String: Any]?
-
-    init(
-        uri: String,
-        filename: String,
-        durationMs: Double,
-        size: Int64,
-        sampleRate: Int,
-        channels: Int,
-        bitDepth: Int,
-        mimeType: String,
-        requestedFormat: String,
-        actualFormat: String,
-        compression: [String: Any]?
-    ) {
-        self.uri = uri
-        self.filename = filename
-        self.durationMs = durationMs
-        self.size = size
-        self.sampleRate = sampleRate
-        self.channels = channels
-        self.bitDepth = bitDepth
-        self.mimeType = mimeType
-        self.requestedFormat = requestedFormat
-        self.actualFormat = actualFormat
-        self.compression = compression
-    }
-
-    func toDictionary() -> [String: Any] {
-        var dict: [String: Any] = [
-            "uri": uri,
-            "filename": filename,
-            "durationMs": durationMs,
-            "size": size,
-            "sampleRate": sampleRate,
-            "channels": channels,
-            "bitDepth": bitDepth,
-            "mimeType": mimeType,
-            "requestedFormat": requestedFormat,
-            "actualFormat": actualFormat
-        ]
-        if let compression = compression {
-            dict["compression"] = compression
-        }
-        return dict
-    }
-}
-
-public class AudioProcessor {
-    public private(set) var audioFile: AVAudioFile?
-    private var result: (Any) -> Void
-    private var reject: (String, String) -> Void
-    private var waveformData = Array<Float>()
-    private var progress: Float = 0.0
-    private var channelCount: Int = 1
-    private var currentProgress: Float = 0.0
-    private let extractionQueue = DispatchQueue(label: "AudioProcessor", attributes: .concurrent)
-    private var _abortExtraction: Bool = false
-        
-    // Add a counter for unique IDs
-    private var uniqueIdCounter = 0
-
-    public var abortExtraction: Bool {
-        get { _abortExtraction }
-        set { _abortExtraction = newValue }
-    }
-    
-    // Initializer for file-based processing
-    public init(url: URL, resolve: @escaping (Any) -> Void, reject: @escaping (String, String) -> Void) throws {
-        self.audioFile = try AVAudioFile(forReading: url)
-        self.result = resolve
-        self.reject = reject
-    }
-    
-    // Initializer for buffer-based processing
-    public init(resolve: @escaping (Any) -> Void, reject: @escaping (String, String) -> Void) {
-        self.result = resolve
-        self.reject = reject
-    }
-    
-    
-    deinit {
-        audioFile = nil
-    }
-    
-    /// Error types for AudioProcessor
-    public enum AudioProcessorError: Error {
-        case fileInitializationFailed(String)
-        case bufferCreationFailed
-        case audioReadError(String)
-    }
-    
-    
-    /// Extracts and processes audio data from the audio file.
-    /// - Parameters:
-    ///   - numberOfSamples: The number of samples to extract (for waveform).
-    ///   - offset: The offset to start reading from (in samples).
-    ///   - length: The length of the audio to read (in samples).
-    ///   - segmentDurationMs: The duration of each segment in milliseconds.
-    ///   - featureOptions: The features to extract.
-    ///   - bitDepth: The bit depth of the audio data.
-    ///   - numberOfChannels: The number of channels in the audio data.
-    ///   - position: The position to start reading from (in bytes).
-    ///   - byteLength: The length of the audio to read (in bytes).
-    /// - Returns: An `AudioAnalysisData` object containing the extracted features.
-    public func processAudioData(
-        numberOfSamples: Int?, 
-        offset: Int? = 0, 
-        length: UInt? = nil, 
-        segmentDurationMs: Int = 100, // Default 100ms
-        featureOptions: [String: Bool],
-        bitDepth: Int,
-        numberOfChannels: Int,
-        position: Int? = nil,
-        byteLength: Int? = nil
-    ) -> AudioAnalysisData? {
-        guard let audioFile = audioFile else {
-            reject("FILE_NOT_INITIALIZED", "Audio file is not initialized.")
-            return nil
-        }
-        
-        let totalFrameCount = AVAudioFrameCount(audioFile.length)
-        var framesPerBuffer: AVAudioFrameCount
-        let _: Int // Changed from actualPointsPerSecond
-        
-        NSLog("""
-            [AudioProcessor] Starting audio processing:
-            - totalFrameCount: \(totalFrameCount)
-            - bitDepth: \(bitDepth)
-            - numberOfChannels: \(numberOfChannels)
-            - position: \(position ?? -1)
-            - byteLength: \(byteLength ?? -1)
-            - offset: \(offset ?? -1)
-            - length: \(length ?? 0)
-        """)
-        
-        // Use position/byteLength if provided, otherwise fall back to offset/length
-        let effectiveOffset: Int64 = if let position = position {
-            Int64(position / (bitDepth / 8) / numberOfChannels)
-        } else {
-            Int64(offset ?? 0)
-        }
-        
-        let effectiveLength: Int64 = if let byteLength = byteLength {
-            Int64(byteLength / (bitDepth / 8) / numberOfChannels)
-        } else if let length = length {
-            Int64(length)
-        } else {
-            Int64(totalFrameCount) - effectiveOffset
-        }
-        
-        NSLog("""
-            [AudioProcessor] Calculated frame positions:
-            - effectiveOffset: \(effectiveOffset)
-            - effectiveLength: \(effectiveLength)
-            - expectedEndFrame: \(effectiveOffset + effectiveLength)
-            - totalFrameCount: \(totalFrameCount)
-        """)
-        
-        // Validate frame boundaries
-        if effectiveOffset < 0 || effectiveOffset >= Int64(totalFrameCount) {
-            NSLog("[AudioProcessor] ERROR: Invalid offset value")
-            reject("INVALID_OFFSET", "Offset value (\(effectiveOffset)) is outside valid range [0, \(totalFrameCount)]")
-            return nil
-        }
-        
-        if effectiveLength <= 0 {
-            NSLog("[AudioProcessor] ERROR: Invalid length value")
-            reject("INVALID_LENGTH", "Length value (\(effectiveLength)) must be positive")
-            return nil
-        }
-        
-        if effectiveOffset + effectiveLength > Int64(totalFrameCount) {
-            NSLog("[AudioProcessor] ERROR: Requested range exceeds file length")
-            reject("INVALID_RANGE", "Requested range [\(effectiveOffset), \(effectiveOffset + effectiveLength)] exceeds file length \(totalFrameCount)")
-            return nil
-        }
-        
-        var startFrame: AVAudioFramePosition = effectiveOffset
-        let endFrame: AVAudioFramePosition = effectiveOffset + effectiveLength
-        
-        // Calculate frames per segment based on segment duration
-        let framesPerSegment = AVAudioFrameCount(Float(audioFile.fileFormat.sampleRate) * Float(segmentDurationMs) / 1000.0)
-        
-        if let numberOfSamples = numberOfSamples {
-            framesPerBuffer = AVAudioFrameCount(max(1, effectiveLength / Int64(numberOfSamples)))
-        } else {
-            framesPerBuffer = framesPerSegment
-        }
-        
-        guard let buffer = AVAudioPCMBuffer(pcmFormat: audioFile.processingFormat, frameCapacity: framesPerBuffer) else {
-            reject("BUFFER_CREATION_FAILED", "Failed to create AVAudioPCMBuffer.")
-            return nil
-        }
-        
-        channelCount = Int(audioFile.processingFormat.channelCount)
-        let _ = Array(repeating: [Float](repeating: 0, count: Int(framesPerBuffer)), count: channelCount) // Changed from var data
-        
-        var channelData = [Float]()
-        while startFrame < endFrame {
-            let remainingFrames = endFrame - startFrame
-            let currentFramesPerBuffer = min(AVAudioFrameCount(framesPerBuffer), AVAudioFrameCount(remainingFrames))
-            
-            if currentFramesPerBuffer <= 0 {
-                break
-            }
-            
-            if abortExtraction {
-                audioFile.framePosition = startFrame
-                abortExtraction = false
-                return nil
-            }
-            
-            do {
-                audioFile.framePosition = startFrame
-                try audioFile.read(into: buffer, frameCount: currentFramesPerBuffer)
-            } catch {
-                reject("AUDIO_READ_ERROR", "Couldn't read into buffer: \(error.localizedDescription)")
-                return nil
-            }
-            
-            //TODO: check if we need conversion based on bitDepth here
-            guard let floatData = buffer.floatChannelData else {
-                reject("BUFFER_DATA_ERROR", "Failed to retrieve float data from buffer.")
-                return nil
-            }
-            for frame in 0..<Int(buffer.frameLength) {
-                channelData.append(floatData[0][frame])
-            }
-            
-            startFrame += AVAudioFramePosition(currentFramesPerBuffer)
-        }
-        
-        NSLog("""
-            [AudioProcessor] Audio processing completed:
-            - processedFrames: \(endFrame - startFrame)
-            - framesPerBuffer: \(framesPerBuffer)
-        """)
-        
-        return processChannelData(
-            channelData: channelData,
-            sampleRate: Float(audioFile.fileFormat.sampleRate),
-            segmentDurationMs: segmentDurationMs,
-            featureOptions: featureOptions,
-            bitDepth: bitDepth,
-            numberOfChannels: numberOfChannels
-        )
-    }
-    
-    /// Processes audio data from a buffer.
-    /// - Parameters:
-    ///   - data: The audio data buffer.
-    ///   - sampleRate: The sample rate of the audio data.
-    ///   - segmentDurationMs: The duration of each segment in milliseconds.
-    ///   - featureOptions: The features to extract.
-    ///   - bitDepth: The bit depth of the audio data.
-    ///   - numberOfChannels: The number of channels in the audio data.
-    /// - Returns: An `AudioAnalysisData` object containing the extracted features.
-    public func processAudioBuffer(
-        data: Data,
-        sampleRate: Float,
-        segmentDurationMs: Int,
-        featureOptions: [String: Bool],
-        bitDepth: Int,
-        numberOfChannels: Int
-    ) -> AudioAnalysisData? {
-        guard !data.isEmpty else {
-            Logger.debug("AudioProcessor", "Data is empty, rejecting")
-            reject("DATA_EMPTY", "The audio data is empty.")
-            return nil
-        }
-
-        // Convert Data to Float array based on bit depth
-        let floatData: [Float]
-        switch bitDepth {
-        case 16:
-            floatData = data.withUnsafeBytes { bufferPointer in
-                let int16Pointer = bufferPointer.bindMemory(to: Int16.self)
-                return int16Pointer.map { Float($0) / Float(Int16.max) }
-            }
-        case 32:
-            floatData = data.withUnsafeBytes { bufferPointer in
-                let int32Pointer = bufferPointer.bindMemory(to: Int32.self)
-                return int32Pointer.map { Float($0) / Float(Int32.max) }
-            }
-        default:
-            Logger.debug("AudioProcessor", "Unsupported bit depth. Rejecting")
-            reject("UNSUPPORTED_BIT_DEPTH", "Unsupported bit depth: \(bitDepth)")
-            return nil
-        }
-
-        return processChannelData(
-            channelData: floatData,
-            sampleRate: sampleRate,
-            segmentDurationMs: segmentDurationMs,
-            featureOptions: featureOptions,
-            bitDepth: bitDepth,
-            numberOfChannels: numberOfChannels
-        )
-    }
-
-    /// Processes the given audio channel data to extract features.
-    /// - Parameters:
-    ///   - channelData: The audio channel data to process.
-    ///   - sampleRate: The sample rate of the audio data.
-    ///   - segmentDurationMs: The duration of each segment in milliseconds.
-    ///   - featureOptions: The features to extract.
-    ///   - bitDepth: The bit depth of the audio data.
-    ///   - numberOfChannels: The number of channels in the audio data.
-    /// - Returns: An `AudioAnalysisData` object containing the extracted features.
-    private func processChannelData(
-        channelData: [Float],
-        sampleRate: Float,
-        segmentDurationMs: Int,
-        featureOptions: [String: Bool],
-        bitDepth: Int,
-        numberOfChannels: Int
-    ) -> AudioAnalysisData? {
-        Logger.debug("AudioProcessor", "Processing audio data with sample rate: \(sampleRate), segmentDurationMs: \(segmentDurationMs), bitDepth: \(bitDepth), numberOfChannels: \(numberOfChannels)")
-        
-        let startTime = CACurrentMediaTime()
-
-        let length = channelData.count
-        // Calculate points per segment based on segment duration
-        let samplesPerSegment = Int(Float(segmentDurationMs) * sampleRate / 1000.0)
-        var dataPoints = [DataPoint]()
-        var minAmplitude: Float = .greatestFiniteMagnitude
-        var maxAmplitude: Float = -.greatestFiniteMagnitude
-        
-        // Calculate bytes per sample
-        let bytesPerSample = bitDepth / 8
-        
-        // Process data in segments
-        var i = 0
-        while i < length {
-            let segmentEnd = min(i + samplesPerSegment, length)
-            let segment = Array(channelData[i..<segmentEnd])
-            
-            // Calculate byte positions and timing
-            let startPosition = i * bytesPerSample * numberOfChannels
-            let endPosition = segmentEnd * bytesPerSample * numberOfChannels
-            let startTime = Float(i) / sampleRate
-            let endTime = Float(segmentEnd) / sampleRate
-            
-            // Process segment and create data point
-            let dataPoint = processSegment(
-                segment,
-                sampleRate: sampleRate,
-                featureOptions: featureOptions,
-                startTime: startTime,
-                endTime: endTime,
-                startPosition: startPosition,
-                endPosition: endPosition
-            )
-            dataPoints.append(dataPoint)
-            
-            // Update min/max amplitudes
-            minAmplitude = min(minAmplitude, segment.min() ?? minAmplitude)
-            maxAmplitude = max(maxAmplitude, segment.max() ?? maxAmplitude)
-            
-            i += samplesPerSegment
-        }
-        
-        let endTime = CACurrentMediaTime()
-        let processingTimeMs = Float((endTime - startTime) * 1000)
-
-        Logger.debug("AudioProcessor", "Processed \(dataPoints.count) data points in \(processingTimeMs) ms")
-
-        return AudioAnalysisData(
-            segmentDurationMs: segmentDurationMs,
-            durationMs: Int(Float(length) / sampleRate * 1000),
-            bitDepth: bitDepth,
-            numberOfChannels: numberOfChannels,
-            sampleRate: Int(sampleRate),
-            samples: length,
-            dataPoints: dataPoints,
-            amplitudeRange: AudioAnalysisData.AmplitudeRange(
-                min: minAmplitude,
-                max: maxAmplitude
-            ),
-            rmsRange: AudioAnalysisData.AmplitudeRange(
-                min: 0,
-                max: 1
-            ),
-            speechAnalysis: nil,
-            extractionTimeMs: processingTimeMs
-        )
-    }
-    
-    private func processSegment(
-        _ segment: [Float],
-        sampleRate: Float,
-        featureOptions: [String: Bool],
-        startTime: Float,
-        endTime: Float,
-        startPosition: Int,
-        endPosition: Int
-    ) -> DataPoint {
-        let sumSquares: Float = segment.reduce(0) { $0 + $1 * $1 }
-        let rms = sqrt(sumSquares / Float(segment.count))
-        let silent = rms < SILENCE_THRESHOLD_RMS
-        let dB = Float(20 * log10(Double(rms)))
-        
-        let features = computeFeatures(
-            segmentData: segment,
-            sampleRate: sampleRate,
-            sumSquares: sumSquares,
-            zeroCrossings: 0,
-            segmentLength: segment.count,
-            featureOptions: featureOptions
-        )
-        
-        
-        let dataPoint = DataPoint(
-            id: Int(uniqueIdCounter),
-            amplitude: segment.max() ?? 0,
-            rms: rms,
-            dB: dB,
-            silent: silent,
-            features: features,
-            speech: SpeechFeatures(isActive: !silent),
-            startTime: startTime,
-            endTime: endTime,
-            startPosition: startPosition,
-            endPosition: endPosition,
-            samples: segment.count
-        )
-        uniqueIdCounter += 1
-        return dataPoint
-    }
-    
-    private func computeFeatures(
-        segmentData: [Float], 
-        sampleRate: Float,
-        sumSquares: Float,
-        zeroCrossings: Int,
-        segmentLength: Int,
-        featureOptions: [String: Bool]
-    ) -> Features {
-        let rms = sqrt(sumSquares / Float(segmentLength))
-        let energy = featureOptions["energy"] == true ? sumSquares : 0
-        let zcr = featureOptions["zcr"] == true ? Float(zeroCrossings) / Float(segmentLength) : 0
-        let mfcc = featureOptions["mfcc"] == true ? extractMFCC(from: segmentData, sampleRate: sampleRate) : []
-        let spectralCentroid = featureOptions["spectralCentroid"] == true ? extractSpectralCentroid(from: segmentData, sampleRate: sampleRate) : 0
-        let spectralFlatness = featureOptions["spectralFlatness"] == true ? extractSpectralFlatness(from: segmentData) : 0
-        let spectralRollOff = featureOptions["spectralRollOff"] == true ? extractSpectralRollOff(from: segmentData, sampleRate: sampleRate) : 0
-        let spectralBandwidth = featureOptions["spectralBandwidth"] == true ? extractSpectralBandwidth(from: segmentData, sampleRate: sampleRate) : 0
-        let chromagram = featureOptions["chromagram"] == true ? extractChromagram(from: segmentData, sampleRate: sampleRate) : []
-        let tempo = featureOptions["tempo"] == true ? extractTempo(from: segmentData, sampleRate: sampleRate) : 0
-        let hnr = featureOptions["hnr"] == true ? extractHNR(from: segmentData) : 0
-        let melSpectrogram = featureOptions["melSpectrogram"] == true ? computeMelSpectrogram(from: segmentData, sampleRate: sampleRate) : []
-        let spectralContrast = featureOptions["spectralContrast"] == true ? computeSpectralContrast(from: segmentData, sampleRate: sampleRate) : []
-        let tonnetz = featureOptions["tonnetz"] == true ? computeTonnetz(from: segmentData, sampleRate: sampleRate) : []
-        let pitch = featureOptions["pitch"] == true ? estimatePitch(from: segmentData, sampleRate: sampleRate) : 0
-        
-        // Calculate min and max amplitudes from the segment data
-        let minAmplitude = segmentData.map(abs).min() ?? 0
-        let maxAmplitude = segmentData.map(abs).max() ?? 0
-        
-        let crc32Value = featureOptions["crc32"] == true ? 
-            calculateCRC32(from: segmentData, count: segmentData.count) : nil
-        
-        return Features(
-            energy: energy,
-            mfcc: mfcc,
-            rms: rms,
-            minAmplitude: minAmplitude,
-            maxAmplitude: maxAmplitude,
-            zcr: zcr,
-            spectralCentroid: spectralCentroid,
-            spectralFlatness: spectralFlatness,
-            spectralRollOff: spectralRollOff,
-            spectralBandwidth: spectralBandwidth,
-            chromagram: chromagram,
-            tempo: tempo,
-            hnr: hnr,
-            melSpectrogram: melSpectrogram,
-            spectralContrast: spectralContrast,
-            tonnetz: tonnetz,
-            pitch: pitch,
-            crc32: crc32Value
-        )
-    }
-    
-    /// Processes audio data with time range support
-    public func processAudioData(
-        startTimeMs: Double? = nil,
-        endTimeMs: Double? = nil,
-        segmentDurationMs: Int = 100, // Default 100ms
-        featureOptions: [String: Bool]
-    ) -> AudioAnalysisData? {
-        guard let audioFile = audioFile else {
-            Logger.debug("AudioProcessor", "No audio file loaded")
-            return nil
-        }
-
-        let startTime = CACurrentMediaTime()
-        let sampleRate = Float(audioFile.fileFormat.sampleRate)
-        let _ = AVAudioFrameCount(audioFile.length) // Changed from totalFrameCount
-        let bitDepth = audioFile.fileFormat.settings[AVLinearPCMBitDepthKey] as? Int ?? 16
-        let numberOfChannels = Int(audioFile.fileFormat.channelCount)
-        
-        // Convert time to frames
-        let startFrame = startTimeMs.map { AVAudioFramePosition(Double($0) * Double(sampleRate) / 1000.0) } ?? 0
-        let endFrame = endTimeMs.map { AVAudioFramePosition(Double($0) * Double(sampleRate) / 1000.0) } ?? audioFile.length
-        
-        // Validate frame range
-        guard startFrame >= 0 && endFrame <= audioFile.length && startFrame < endFrame else {
-            Logger.debug("AudioProcessor", "Invalid time range")
-            return nil
-        }
-
-        // Calculate frames per buffer based on segment duration
-        let framesPerBuffer = AVAudioFrameCount(Float(sampleRate) * Float(segmentDurationMs) / 1000.0)
-        
-        guard let buffer = AVAudioPCMBuffer(pcmFormat: audioFile.processingFormat, frameCapacity: framesPerBuffer) else {
-            Logger.debug("AudioProcessor", "Failed to create buffer")
-            return nil
-        }
-
-        var dataPoints: [DataPoint] = []
-        var minAmplitude: Float = .greatestFiniteMagnitude
-        var maxAmplitude: Float = -.greatestFiniteMagnitude
-        var currentId = 0
-
-        audioFile.framePosition = startFrame
-        var currentFrame = startFrame
-
-        while currentFrame < endFrame {
-            let framesToRead = min(framesPerBuffer, AVAudioFrameCount(endFrame - currentFrame))
-            
-            do {
-                try audioFile.read(into: buffer, frameCount: framesToRead)
-                
-                guard let channelData = buffer.floatChannelData else {
-                    continue
-                }
-                
-                // Process each channel's data
-                var summedData = [Float](repeating: 0, count: Int(framesToRead))
-                for channel in 0..<numberOfChannels {
-                    let channelBuffer = UnsafeBufferPointer(start: channelData[channel], count: Int(framesToRead))
-                    for (index, sample) in channelBuffer.enumerated() {
-                        summedData[index] += sample
-                    }
-                }
-                
-                // Average across channels
-                for i in 0..<summedData.count {
-                    summedData[i] /= Float(numberOfChannels)
-                }
-                
-                // Calculate both peak amplitude and RMS
-                var localMax: Float = 0
-                var rms: Float = 0
-                vDSP_maxmgv(summedData, 1, &localMax, vDSP_Length(framesToRead))
-
-                // Calculate RMS using vDSP
-                var meanSquare: Float = 0
-                vDSP_measqv(summedData, 1, &meanSquare, vDSP_Length(framesToRead))
-                rms = sqrt(meanSquare)
-                
-                minAmplitude = min(minAmplitude, localMax)
-                maxAmplitude = max(maxAmplitude, localMax)
-                
-                // Create data point
-                let startTime = Float(currentFrame) / Float(sampleRate)
-                let endTime = Float(currentFrame + Int64(framesToRead)) / Float(sampleRate)
-                
-                let dataPoint = DataPoint(
-                    id: currentId,
-                    amplitude: localMax,      // Always use peak amplitude
-                    rms: rms,                // Use calculated RMS value
-                    dB: Float(20 * log10(Double(rms))),  // Use RMS for dB calculation
-                    silent: rms < SILENCE_THRESHOLD_RMS,      // Use RMS for silence detection
-                    features: computeFeatures(
-                        segmentData: Array(summedData[0..<Int(framesToRead)]), // Fixed dangling pointer
-                        sampleRate: sampleRate,
-                        sumSquares: rms * rms,
-                        zeroCrossings: 0,
-                        segmentLength: Int(framesToRead),
-                        featureOptions: featureOptions
-                    ),
-                    speech: SpeechFeatures(isActive: rms >= SILENCE_THRESHOLD_RMS),
-                    startTime: startTime,
-                    endTime: endTime,
-                    startPosition: Int(currentFrame),
-                    endPosition: Int(currentFrame + Int64(framesToRead)),
-                    samples: Int(framesToRead)
-                )
-                
-                dataPoints.append(dataPoint)
-                currentId += 1
-            } catch {
-                Logger.debug("AudioProcessor", "Error reading audio data: \(error)")
-                return nil
-            }
-            
-            currentFrame += Int64(framesToRead)
-        }
-        
-        let endTime = CACurrentMediaTime()
-        let extractionTime = Float(endTime - startTime) * 1000 // Convert to milliseconds
-        
-        return AudioAnalysisData(
-            segmentDurationMs: segmentDurationMs,
-            durationMs: Int(Float(endFrame - startFrame) * 1000 / sampleRate),
-            bitDepth: bitDepth,
-            numberOfChannels: numberOfChannels,
-            sampleRate: Int(sampleRate),
-            samples: Int(endFrame - startFrame),
-            dataPoints: dataPoints,
-            amplitudeRange: AudioAnalysisData.AmplitudeRange(
-                min: minAmplitude,
-                max: maxAmplitude
-            ),
-            rmsRange: AudioAnalysisData.AmplitudeRange(
-                min: 0,
-                max: 1
-            ),
-            speechAnalysis: nil,
-            extractionTimeMs: extractionTime
-        )
-    }
-
-    /// Trims audio file to specified range
-    public func trimAudio(
-        mode: String,
-        startTimeMs: Double?,
-        endTimeMs: Double?,
-        ranges: [[String: Double]]?,
-        outputFileName: String?,
-        outputFormat: [String: Any]?,
-        decodingOptions: [String: Any]?,
-        progressCallback: ((Float, Int64, Int64) -> Void)? = nil
-    ) -> TrimResult? {
-        // Log the input parameters
-        Logger.debug("AudioProcessor", "Starting audio trim operation:")
-        Logger.debug("AudioProcessor", "- Mode: \(mode)")
-        if let start = startTimeMs, let end = endTimeMs {
-            Logger.debug("AudioProcessor", "- Time range: \(start)ms to \(end)ms")
-        }
-        if let ranges = ranges {
-            Logger.debug("AudioProcessor", "- Ranges count: \(ranges.count)")
-        }
-        
-        // Log output format details
-        if let format = outputFormat {
-            let formatType = format["format"] as? String ?? "unknown"
-            let bitrate = format["bitrate"] as? Int ?? 0
-            Logger.debug("AudioProcessor", "- Output format: \(formatType), bitrate: \(bitrate)")
-        }
-        
-        guard let audioFile = audioFile else { return nil }
-
-        let inputFormat = audioFile.processingFormat
-        let inputSampleRate = inputFormat.sampleRate
-        let inputChannels = Int(inputFormat.channelCount)
-        let totalDurationMs = Double(audioFile.length) / inputSampleRate * 1000
-
-        // Compute ranges to keep
-        let keepRanges = computeKeepRanges(
-            mode: mode,
-            startTimeMs: startTimeMs,
-            endTimeMs: endTimeMs,
-            ranges: ranges,
-            totalDurationMs: totalDurationMs
-        )
-
-        guard !keepRanges.isEmpty else { return nil }
-
-        // Output format setup
-        let requestedFormat = outputFormat?["format"] as? String ?? "wav"
-        let validFormats = ["wav", "aac"]
-        let formatStr = validFormats.contains(requestedFormat.lowercased()) ? requestedFormat.lowercased() : "aac"
-
-        if formatStr != requestedFormat.lowercased() {
-            Logger.debug("AudioProcessor", "Unsupported format '\(requestedFormat)', falling back to 'aac'")
-        }
-
-        let targetSampleRate = outputFormat?["sampleRate"] as? Double ?? inputSampleRate
-        let targetChannels = outputFormat?["channels"] as? Int ?? inputChannels
-        let targetBitDepth = outputFormat?["bitDepth"] as? Int ?? 16
-        let bitrate = outputFormat?["bitrate"] as? Int ?? 128000
-
-        let fileExtension = formatStr == "wav" ? "wav" : "aac"
-        let outputURL = FileManager.default.temporaryDirectory
-            .appendingPathComponent(outputFileName ?? UUID().uuidString)
-            .appendingPathExtension(fileExtension)
-
-        let decodingConfig = DecodingConfig.fromDictionary(decodingOptions ?? [:])
-        let needFormatChange = decodingConfig.targetSampleRate != nil || decodingConfig.targetChannels != nil || decodingConfig.targetBitDepth != nil
-        let isWavInput = audioFile.fileFormat.settings[AVFormatIDKey] as? UInt32 == kAudioFormatLinearPCM
-
-        do {
-            if isWavInput && formatStr == "wav" && !needFormatChange {
-                // Fast path: WAV-to-WAV with no format changes
-                let outputFile = try AVAudioFile(forWriting: outputURL, settings: inputFormat.settings)
-                var totalFrames: Int64 = 0
-                for range in keepRanges {
-                    // Break down complex expression
-                    let startTimeInSeconds = range[0] / 1000
-                    let endTimeInSeconds = range[1] / 1000
-                    let startFramePosition = startTimeInSeconds * inputSampleRate
-                    let endFramePosition = endTimeInSeconds * inputSampleRate
-                    totalFrames += Int64(endFramePosition - startFramePosition)
-                }
-                var cumulativeFrames: Int64 = 0
-
-                for range in keepRanges {
-                    // Break down complex expressions
-                    let startTimeInSeconds = range[0] / 1000
-                    let startFrame = AVAudioFramePosition(startTimeInSeconds * inputSampleRate)
-                    
-                    let endTimeInSeconds = range[1] / 1000
-                    let endFramePosition = endTimeInSeconds * inputSampleRate
-                    let frameCount = AVAudioFrameCount(endFramePosition - Double(startFrame))
-                    
-                    let buffer = AVAudioPCMBuffer(pcmFormat: inputFormat, frameCapacity: frameCount)!
-                    audioFile.framePosition = startFrame
-                    try audioFile.read(into: buffer, frameCount: frameCount)
-                    try outputFile.write(from: buffer)
-                    cumulativeFrames += Int64(frameCount)
-                    let progress = Float(cumulativeFrames) / Float(totalFrames) * 100
-                    progressCallback?(progress, Int64(frameCount) * Int64(inputFormat.streamDescription.pointee.mBytesPerFrame), totalFrames * Int64(inputFormat.streamDescription.pointee.mBytesPerFrame))
-                }
-
-                // When creating the output file
-                Logger.debug("AudioProcessor", "Creating output file at: \(outputURL.path)")
-                
-                // After processing is complete
-                Logger.debug("AudioProcessor", "Trim operation completed")
-                Logger.debug("AudioProcessor", "- Output file: \(outputURL.path)")
-                Logger.debug("AudioProcessor", "- File exists: \(FileManager.default.fileExists(atPath: outputURL.path))")
-                Logger.debug("AudioProcessor", "- File size: \((try? FileManager.default.attributesOfItem(atPath: outputURL.path)[.size] as? Int64) ?? 0) bytes") // Fixed optional unwrapping
-                Logger.debug("AudioProcessor", "- File extension: \(outputURL.pathExtension)")
-                
-                return createTrimResult(from: outputURL, keepRanges: keepRanges, formatStr: formatStr, sampleRate: Int(inputSampleRate), channels: inputChannels, bitDepth: 16, bitrate: bitrate)
-            } else {
-                // Non-fast path: Decode and re-encode
-                let targetFormat = AVAudioFormat(
-                    commonFormat: .pcmFormatFloat32,
-                    sampleRate: targetSampleRate,
-                    channels: AVAudioChannelCount(targetChannels),
-                    interleaved: false
-                )!
-
-                var totalFrames: Int64 = 0
-                for range in keepRanges {
-                    // Break down complex expression
-                    let startTimeInSeconds = range[0] / 1000
-                    let endTimeInSeconds = range[1] / 1000
-                    let startFramePosition = startTimeInSeconds * inputSampleRate
-                    let endFramePosition = endTimeInSeconds * inputSampleRate
-                    totalFrames += Int64(endFramePosition - startFramePosition)
-                }
-                var cumulativeFrames: Int64 = 0
-
-                if formatStr == "wav" {
-                    let outputFile = try AVAudioFile(forWriting: outputURL, settings: [
-                        AVFormatIDKey: kAudioFormatLinearPCM,
-                        AVSampleRateKey: targetSampleRate,
-                        AVNumberOfChannelsKey: targetChannels,
-                        AVLinearPCMBitDepthKey: targetBitDepth,
-                        AVLinearPCMIsFloatKey: false,
-                        AVLinearPCMIsBigEndianKey: false
-                    ])
-
-                    for range in keepRanges {
-                        // Break down complex expressions
-                        let startTimeInSeconds = range[0] / 1000
-                        let startFrame = AVAudioFramePosition(startTimeInSeconds * inputSampleRate)
-                        
-                        let endTimeInSeconds = range[1] / 1000
-                        let endFramePosition = endTimeInSeconds * inputSampleRate
-                        let frameCount = AVAudioFrameCount(endFramePosition - Double(startFrame))
-                        
-                        let buffer = AVAudioPCMBuffer(pcmFormat: inputFormat, frameCapacity: frameCount)!
-                        audioFile.framePosition = startFrame
-                        try audioFile.read(into: buffer, frameCount: frameCount)
-                        let converter = AVAudioConverter(from: inputFormat, to: targetFormat)!
-                        let convertedBuffer = AVAudioPCMBuffer(pcmFormat: targetFormat, frameCapacity: frameCount)!
-                        var error: NSError?
-                        _ = converter.convert(to: convertedBuffer, error: &error) { inNumPackets, outStatus in
-                            outStatus.pointee = .haveData
-                            return buffer
-                        }
-                        if let error = error {
-                            Logger.debug("AudioProcessor", "Format conversion failed: \(error.localizedDescription)")
-                            Logger.debug("AudioProcessor", "Skipping this buffer")
-                            continue
-                        }
-                        try outputFile.write(from: convertedBuffer)
-                        cumulativeFrames += Int64(frameCount)
-                        let progress = Float(cumulativeFrames) / Float(totalFrames) * 100
-                        progressCallback?(progress, 0, totalFrames * Int64(inputFormat.streamDescription.pointee.mBytesPerFrame))
-                    }
-                    return createTrimResult(from: outputURL, keepRanges: keepRanges, formatStr: formatStr, sampleRate: Int(targetSampleRate), channels: targetChannels, bitDepth: targetBitDepth, bitrate: bitrate)
-                } else {
-                    // Use AAC instead of Opus (Opus support removed)
-                    Logger.debug("AudioProcessor", "Using AAC format instead of requested \(formatStr)")
-                    
-                    // Keep the existing AAC settings structure for consistency
-                    let outputSettings: [String: Any] = [
-                        AVFormatIDKey: kAudioFormatMPEG4AAC,
-                        AVSampleRateKey: targetSampleRate,
-                        AVNumberOfChannelsKey: targetChannels,
-                        AVEncoderBitRateKey: bitrate,
-                        AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue
-                    ]
-                    let _ = AVFileType.m4a // Changed from fileType
-                    
-                    // 4. Update container extension logic for when Opus was selected
-                    let _ = "m4a" // Changed from tempFileExtension
-                    
-                    // 5. Update the MIME type logic for AAC only
-                    let _ = "audio/mp4" // Changed from mimeType
-                    
-                    let outputFile = try AVAudioFile(forWriting: outputURL, settings: outputSettings)
-                    var totalFrames: Int64 = 0
-                    for range in keepRanges {
-                        // Break down complex expressions
-                        let startTimeInSeconds = range[0] / 1000
-                        let startFrame = AVAudioFramePosition(startTimeInSeconds * inputSampleRate)
-                        
-                        let endTimeInSeconds = range[1] / 1000
-                        let endFramePosition = endTimeInSeconds * inputSampleRate
-                        let frameCount = AVAudioFrameCount(endFramePosition - Double(startFrame))
-                        
-                        let buffer = AVAudioPCMBuffer(pcmFormat: inputFormat, frameCapacity: frameCount)!
-                        audioFile.framePosition = startFrame
-                        try audioFile.read(into: buffer, frameCount: frameCount)
-                        try outputFile.write(from: buffer)
-                        totalFrames += Int64(frameCount)
-                        let progress = Float(cumulativeFrames) / Float(totalFrames) * 100
-                        progressCallback?(progress, 0, totalFrames * Int64(inputFormat.streamDescription.pointee.mBytesPerFrame))
-                    }
-                    return createTrimResult(
-                        from: outputURL, 
-                        keepRanges: keepRanges, 
-                        formatStr: formatStr, 
-                        sampleRate: Int(targetSampleRate), 
-                        channels: targetChannels, 
-                        bitDepth: 16, 
-                        bitrate: bitrate, 
-                        compression: nil
-                    )
-                }
-            }
-        } catch {
-            reject("TRIM_ERROR", "Failed to trim audio: \(error.localizedDescription)")
-            return nil
-        }
-    }
-    
-    private func computeKeepRanges(mode: String, startTimeMs: Double?, endTimeMs: Double?, ranges: [[String: Double]]?, totalDurationMs: Double) -> [[Double]] {
-        switch mode {
-        case "single":
-            guard let start = startTimeMs, let end = endTimeMs else { return [] }
-            return [[start, end]]
-        case "keep":
-            return ranges?.map { [$0["startTimeMs"] ?? 0, $0["endTimeMs"] ?? totalDurationMs] } ?? []
-        case "remove":
-            let removeRanges = ranges?.map { [$0["startTimeMs"] ?? 0, $0["endTimeMs"] ?? totalDurationMs] }.sorted { $0[0] < $1[0] } ?? []
-            var keepRanges: [[Double]] = []
-            var lastEnd = 0.0
-            for range in removeRanges {
-                if range[0] > lastEnd {
-                    keepRanges.append([lastEnd, range[0]])
-                }
-                lastEnd = max(lastEnd, range[1])
-            }
-            if lastEnd < totalDurationMs {
-                keepRanges.append([lastEnd, totalDurationMs])
-            }
-            return keepRanges
-        default:
-            return []
-        }
-    }
-
-    private func createTrimResult(from url: URL, keepRanges: [[Double]], formatStr: String, sampleRate: Int, channels: Int, bitDepth: Int, bitrate: Int, compression: [String: Any]? = nil) -> TrimResult {
-        let durationMs = keepRanges.map { $0[1] - $0[0] }.reduce(0, +)
-        let size = (try? FileManager.default.attributesOfItem(atPath: url.path)[.size] as? Int64 ?? 0) ?? 0
-        let fileExtension = formatStr == "wav" ? "wav" : "aac"
-        return TrimResult(
-            uri: url.absoluteString,
-            filename: url.lastPathComponent,
-            durationMs: durationMs,
-            size: size,
-            sampleRate: sampleRate,
-            channels: channels,
-            bitDepth: bitDepth,
-            mimeType: "audio/\(fileExtension)",
-            requestedFormat: formatStr,
-            actualFormat: fileExtension,
-            compression: compression
-        )
-    }
-
-    private func createSampleBuffer(from buffer: AVAudioPCMBuffer) -> CMSampleBuffer? {
-        var formatDesc: CMAudioFormatDescription?
-        CMAudioFormatDescriptionCreate(
-            allocator: kCFAllocatorDefault,
-            asbd: buffer.format.streamDescription,
-            layoutSize: 0,
-            layout: nil,
-            magicCookieSize: 0,
-            magicCookie: nil,
-            extensions: nil,
-            formatDescriptionOut: &formatDesc
-        )
-        guard let format = formatDesc else { return nil }
-
-        var sampleBuffer: CMSampleBuffer?
-        var timingInfo = CMSampleTimingInfo(
-            duration: CMTime(value: 1, timescale: CMTimeScale(buffer.format.sampleRate)),
-            presentationTimeStamp: .zero,
-            decodeTimeStamp: .invalid
-        )
-
-        CMSampleBufferCreate(
-            allocator: kCFAllocatorDefault,
-            dataBuffer: nil,
-            dataReady: false,
-            makeDataReadyCallback: nil,
-            refcon: nil,
-            formatDescription: format,
-            sampleCount: CMItemCount(buffer.frameLength),
-            sampleTimingEntryCount: 1,
-            sampleTimingArray: &timingInfo,
-            sampleSizeEntryCount: 0,
-            sampleSizeArray: nil,
-            sampleBufferOut: &sampleBuffer
-        )
-        guard let sampleBuf = sampleBuffer else { return nil }
-
-        var dataBuffer: CMBlockBuffer?
-        CMBlockBufferCreateWithMemoryBlock(
-            allocator: kCFAllocatorDefault,
-            memoryBlock: UnsafeMutableRawPointer(buffer.floatChannelData![0]),
-            blockLength: Int(buffer.frameLength * buffer.format.streamDescription.pointee.mBytesPerFrame),
-            blockAllocator: kCFAllocatorNull,
-            customBlockSource: nil,
-            offsetToData: 0,
-            dataLength: Int(buffer.frameLength * buffer.format.streamDescription.pointee.mBytesPerFrame),
-            flags: 0,
-            blockBufferOut: &dataBuffer
-        )
-        guard let blockBuf = dataBuffer else { return nil }
-        
-        CMSampleBufferSetDataBuffer(sampleBuf, newValue: blockBuf)
-        
-        return sampleBuf
-    }
-
-    /// Extracts a preview of the audio data with consistent time range support
-    /// - Parameters:
-    ///   - numberOfPoints: The number of points to extract
-    ///   - startTimeMs: Optional start time in milliseconds
-    ///   - endTimeMs: Optional end time in milliseconds
-    ///   - featureOptions: The features to extract
-    /// - Returns: An `AudioAnalysisData` object containing the extracted features
-    public func extractPreview(
-        numberOfPoints: Int,
-        startTimeMs: Double? = nil,
-        endTimeMs: Double? = nil,
-        featureOptions: [String: Bool]
-    ) -> AudioAnalysisData? {
-        guard let audioFile = audioFile else {
-            reject("FILE_NOT_INITIALIZED", "Audio file is not initialized.")
-            return nil
-        }
-        
-        let sampleRate = Float(audioFile.fileFormat.sampleRate)
-        let totalDurationMs = Double(audioFile.length) / Double(sampleRate) * 1000
-        
-        // Calculate effective time range
-        let effectiveStartMs = startTimeMs ?? 0.0
-        let effectiveEndMs = min(endTimeMs ?? totalDurationMs, totalDurationMs)
-        let durationMs = effectiveEndMs - effectiveStartMs // This is the actual duration we want to use
-        
-        // Convert time to frames with proper offset
-        let startFrame = AVAudioFramePosition(effectiveStartMs * Double(sampleRate) / 1000.0)
-        let endFrame = AVAudioFramePosition(effectiveEndMs * Double(sampleRate) / 1000.0)
-        let samplesInRange = Int(endFrame - startFrame)
-        
-        guard samplesInRange > 0 else {
-            reject("INVALID_RANGE", "Invalid sample range: contains no samples")
-            return nil
-        }
-        
-        // Calculate exact samples per point to get the requested number of points
-        let samplesPerPoint = samplesInRange / numberOfPoints
-        var dataPoints = [DataPoint]()
-        dataPoints.reserveCapacity(numberOfPoints)
-        
-        var minAmplitude: Float = .greatestFiniteMagnitude
-        var maxAmplitude: Float = -.greatestFiniteMagnitude
-        
-        let bytesPerSample = audioFile.fileFormat.settings[AVLinearPCMBitDepthKey] as? Int ?? 16 / 8
-        
-        for i in 0..<numberOfPoints {
-            let pointStartFrame = startFrame + Int64(i * samplesPerPoint)
-            let pointEndFrame = startFrame + Int64((i + 1) * samplesPerPoint)
-            let framesToRead = AVAudioFrameCount(pointEndFrame - pointStartFrame)
-            
-            // Calculate byte positions
-            let startPosition = Int(pointStartFrame) * bytesPerSample * Int(audioFile.fileFormat.channelCount)
-            let endPosition = Int(pointEndFrame) * bytesPerSample * Int(audioFile.fileFormat.channelCount)
-            let segmentStartTime = Float(pointStartFrame) / sampleRate
-            let segmentEndTime = Float(pointEndFrame) / sampleRate
-            
-            do {
-                audioFile.framePosition = pointStartFrame
-                let buffer = AVAudioPCMBuffer(pcmFormat: audioFile.processingFormat, frameCapacity: framesToRead)!
-                try audioFile.read(into: buffer, frameCount: framesToRead)
-                
-                guard let floatData = buffer.floatChannelData else { continue }
-                
-                var sumSquares: Float = 0
-                var zeroCrossings = 0
-                var prevValue: Float = 0
-                var localMinAmplitude: Float = .greatestFiniteMagnitude
-                var localMaxAmplitude: Float = -.greatestFiniteMagnitude
-                
-                // Process samples for this point
-                for frame in 0..<Int(framesToRead) {
-                    let value = floatData[0][frame]
-                    sumSquares += value * value
-                    if frame > 0 && value * prevValue < 0 {
-                        zeroCrossings += 1
-                    }
-                    prevValue = value
-                    
-                    let absValue = abs(value)
-                    localMinAmplitude = min(localMinAmplitude, absValue)
-                    localMaxAmplitude = max(localMaxAmplitude, absValue)
-                }
-                
-                let features = computeFeatures(segmentData: Array(UnsafeBufferPointer(start: floatData[0], count: Int(framesToRead))), 
-                                            sampleRate: sampleRate,
-                                            sumSquares: sumSquares,
-                                            zeroCrossings: zeroCrossings,
-                                            segmentLength: Int(framesToRead),
-                                            featureOptions: featureOptions)
-                
-                let rms = features.rms
-                let silent = rms < SILENCE_THRESHOLD_RMS
-                let dB = Float(20 * log10(Double(rms)))
-                
-                let dataPoint = DataPoint(
-                    id: Int(uniqueIdCounter),
-                    amplitude: localMaxAmplitude,
-                    rms: rms,
-                    dB: dB,
-                    silent: silent,
-                    features: features,
-                    speech: SpeechFeatures(isActive: !silent),
-                    startTime: segmentStartTime,
-                    endTime: segmentEndTime,
-                    startPosition: startPosition,
-                    endPosition: endPosition,
-                    samples: Int(framesToRead)
-                )
-                dataPoints.append(dataPoint)
-                uniqueIdCounter += 1
-                
-                minAmplitude = min(minAmplitude, localMinAmplitude)
-                maxAmplitude = max(maxAmplitude, localMaxAmplitude)
-            } catch {
-                reject("AUDIO_READ_ERROR", "Error reading audio data: \(error.localizedDescription)")
-                return nil
-            }
-        }
-        
-        let startTime = CACurrentMediaTime() // Start timing
-        
-        let bitDepth = audioFile.fileFormat.settings[AVLinearPCMBitDepthKey] as? Int ?? 16
-        let numberOfChannels = Int(audioFile.processingFormat.channelCount)
-        
-        NSLog("""
-            [AudioProcessor] Starting preview extraction:
-            - numberOfPoints: \(numberOfPoints)
-            - startTimeMs: \(String(describing: startTimeMs))
-            - endTimeMs: \(String(describing: endTimeMs))
-            - durationMs: \(durationMs)
-            - sampleRate: \(sampleRate)
-            - bitDepth: \(bitDepth)
-            - channels: \(numberOfChannels)
-            - samplesInRange: \(samplesInRange)
-            - samplesPerPoint: \(samplesPerPoint)
-        """)
-        
-        let endTime = CACurrentMediaTime()
-        let extractionTimeMs = Float((endTime - startTime) * 1000)
-        
-        NSLog("""
-            [AudioProcessor] Preview extraction completed:
-            - dataPoints generated: \(dataPoints.count)
-            - extractionTimeMs: \(String(format: "%.2f", extractionTimeMs))ms
-            - amplitudeRange: (min: \(String(format: "%.6f", minAmplitude)), max: \(String(format: "%.6f", maxAmplitude)))
-        """)
-        
-        return AudioAnalysisData(
-            segmentDurationMs: 100, // Default 100ms
-            durationMs: Int(durationMs), // Use actual duration of trimmed section
-            bitDepth: bitDepth,
-            numberOfChannels: numberOfChannels,
-            sampleRate: Int(sampleRate),
-            samples: samplesInRange,
-            dataPoints: dataPoints,
-            amplitudeRange: AudioAnalysisData.AmplitudeRange(
-                min: minAmplitude,
-                max: maxAmplitude
-            ),
-            rmsRange: AudioAnalysisData.AmplitudeRange(
-                min: 0,
-                max: 1
-            ),
-            speechAnalysis: nil,
-            extractionTimeMs: extractionTimeMs
-        )
-    }
-
-    // Add this helper function to the AudioProcessor class
-    private func getDocumentsDirectory() -> URL {
-        return FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
-    }
-}