@siteed/audio-studio 3.2.0-beta.1 → 3.2.0

package/ios/AudioStreamDecoder.swift

@@ -38,6 +38,7 @@ public final class AudioStreamDecoder {
         public let chunkDurationMs: Int
         public let maxChunkBytes: Int?
         public let maxBufferedChunks: Int
+        public let backpressureTimeoutMs: Double?
 
         public init(
             requestId: String,
@@ -49,7 +50,8 @@ public final class AudioStreamDecoder {
             normalizeAudio: Bool,
             chunkDurationMs: Int,
             maxChunkBytes: Int?,
-            maxBufferedChunks: Int
+            maxBufferedChunks: Int,
+            backpressureTimeoutMs: Double? = nil
         ) {
             self.requestId = requestId
             self.fileUri = fileUri
@@ -58,9 +60,10 @@ public final class AudioStreamDecoder {
             self.targetSampleRate = targetSampleRate
             self.channels = channels
             self.normalizeAudio = normalizeAudio
-            self.chunkDurationMs = max(10, min(60000, chunkDurationMs))
+            self.chunkDurationMs = chunkDurationMs
             self.maxChunkBytes = maxChunkBytes
             self.maxBufferedChunks = max(1, maxBufferedChunks)
+            self.backpressureTimeoutMs = backpressureTimeoutMs
         }
     }
 
@@ -70,10 +73,8 @@ public final class AudioStreamDecoder {
     private let queue: DispatchQueue
     private let cancelLock = NSLock()
     private var cancelled = false
-    private let ackLock = NSLock()
     private let ackCondition = NSCondition()
     private var lastAckedIndex = -1
-    private var lastEmittedIndex = -1
 
     public init(options: Options) {
         self.options = options
@@ -139,10 +140,22 @@ public final class AudioStreamDecoder {
             return
         }
 
-        let trackDuration = CMTimeGetSeconds(asset.duration) * 1000.0
-        let totalDurationMs = trackDuration.isFinite && trackDuration > 0
-            ? trackDuration
-            : 0.0
+        let assetDurationMs: Double = {
+            let raw = CMTimeGetSeconds(asset.duration) * 1000.0
+            return raw.isFinite && raw > 0 ? raw : 0.0
+        }()
+        // Duration of the *decoded range*, not the whole asset, so progress
+        // and completion payloads match what the caller actually receives.
+        let totalDurationMs: Double = {
+            if let s = options.startTimeMs, let e = options.endTimeMs {
+                return max(0, e - s)
+            }
+            if let e = options.endTimeMs {
+                return max(0, e)
+            }
+            let start = options.startTimeMs ?? 0
+            return max(0, assetDurationMs - start)
+        }()
 
         // Read source sample rate from track.
         let sourceSampleRate: Double = {
@@ -170,7 +183,13 @@ public final class AudioStreamDecoder {
 
         let outputSampleRate = options.targetSampleRate
             ?? (sourceSampleRate > 0 ? sourceSampleRate : 16000)
-        let outputChannels = options.channels ?? min(2, max(1, sourceChannelCount))
+        // Accept the caller's value only when it's positive; explicit `0` or
+        // negative input falls back to the source channel count (mirrors the
+        // Android guard) so we never produce empty chunks forever.
+        let outputChannels: Int = {
+            if let c = options.channels, c > 0 { return c }
+            return min(2, max(1, sourceChannelCount))
+        }()
 
         let outputSettings: [String: Any] = [
             AVFormatIDKey: kAudioFormatLinearPCM,
@@ -213,6 +232,12 @@ public final class AudioStreamDecoder {
                 start: start,
                 duration: CMTime.positiveInfinity
             )
+        } else if let endMs = options.endTimeMs {
+            // endMs-only ranges are documented; treat missing startMs as 0 so
+            // iOS matches Android/Web behavior instead of silently decoding the
+            // full file.
+            let duration = CMTime(seconds: endMs / 1000.0, preferredTimescale: 600)
+            reader.timeRange = CMTimeRange(start: .zero, duration: duration)
         }
 
         let trackOutput = AVAssetReaderTrackOutput(
@@ -240,101 +265,142 @@ public final class AudioStreamDecoder {
         }
 
         let samplesPerChunk = max(
-            1,
-            Int((Double(options.chunkDurationMs) / 1000.0) * outputSampleRate)
-        ) * outputChannels
+            outputChannels,
+            Int((Double(options.chunkDurationMs) / 1000.0) * outputSampleRate) *
+                outputChannels
+        )
         let cappedSamplesPerChunk: Int = {
             guard let maxBytes = options.maxChunkBytes else { return samplesPerChunk }
-            let maxFloats = max(1, maxBytes / 4)
-            return min(samplesPerChunk, maxFloats)
+            // Round to a multiple of `outputChannels` so a single interleaved
+            // frame is never split across chunks (which would yield a
+            // fractional `startSample` for the next chunk).
+            let rawMax = max(outputChannels, maxBytes / 4)
+            let maxFloats = max(
+                outputChannels,
+                (rawMax / outputChannels) * outputChannels
+            )
+            return max(outputChannels, min(samplesPerChunk, maxFloats))
         }()
 
         var pending = [Float]()
         pending.reserveCapacity(cappedSamplesPerChunk * 2)
+        // Head-index cursor over `pending`. Avoids `removeFirst(n)` (which is
+        // O(remaining)) on every emitted chunk; we periodically compact when
+        // the head drifts far enough that the unused prefix becomes wasteful.
+        var pendingHead = 0
+        let compactThreshold = max(cappedSamplesPerChunk * 4, 4096)
         var chunkIndex = 0
         var totalSamples = 0
         var processedMs: Double = 0
         var cancelledByUser = false
+        var backpressureTimedOut = false
         let rangeStartMs = options.startTimeMs ?? 0
 
         while reader.status == .reading {
-            if isCancelled() {
-                cancelledByUser = true
-                break
-            }
-            guard let sampleBuffer = trackOutput.copyNextSampleBuffer() else {
-                break
-            }
-            guard let block = CMSampleBufferGetDataBuffer(sampleBuffer) else {
-                continue
-            }
-            let frameCount = CMSampleBufferGetNumSamples(sampleBuffer)
-            if frameCount <= 0 { continue }
-
-            var lengthAtOffset = 0
-            var totalLength = 0
-            var dataPointer: UnsafeMutablePointer<Int8>?
-            let status = CMBlockBufferGetDataPointer(
-                block,
-                atOffset: 0,
-                lengthAtOffsetOut: &lengthAtOffset,
-                totalLengthOut: &totalLength,
-                dataPointerOut: &dataPointer
-            )
-            guard status == kCMBlockBufferNoErr, let raw = dataPointer else {
-                continue
-            }
-
-            let sampleCount = totalLength / MemoryLayout<Float>.size
-            let floatPtr = UnsafeRawPointer(raw)
-                .assumingMemoryBound(to: Float.self)
-            var idx = pending.count
-            pending.append(contentsOf: repeatElement(0, count: sampleCount))
-            for i in 0..<sampleCount {
-                let v = floatPtr[i]
-                if v.isNaN || v.isInfinite {
-                    pending[idx] = 0
-                } else if options.normalizeAudio {
-                    pending[idx] = max(-1.0, min(1.0, v))
-                } else {
-                    pending[idx] = v
+            let shouldContinue = autoreleasepool { () -> Bool in
+                if isCancelled() {
+                    cancelledByUser = true
+                    return false
                 }
-                idx += 1
-            }
-
-            while pending.count >= cappedSamplesPerChunk {
-                let payload = Array(pending.prefix(cappedSamplesPerChunk))
-                pending.removeFirst(cappedSamplesPerChunk)
-                let durationOfChunk = Double(cappedSamplesPerChunk)
-                    / (outputSampleRate * Double(outputChannels))
-                let startMs = rangeStartMs
-                    + (Double(totalSamples) / (outputSampleRate * Double(outputChannels))) * 1000.0
-                emitChunk(
-                    index: chunkIndex,
-                    startTimeMs: startMs,
-                    endTimeMs: startMs + durationOfChunk * 1000.0,
-                    startSample: totalSamples / outputChannels,
-                    sampleRate: outputSampleRate,
-                    channels: outputChannels,
-                    samples: payload,
-                    isFinal: false
-                )
-                lastEmittedIndex = chunkIndex
-                chunkIndex += 1
-                totalSamples += cappedSamplesPerChunk
-                processedMs = startMs + durationOfChunk * 1000.0
-                emitProgress(
-                    processedMs: processedMs,
-                    durationMs: totalDurationMs,
-                    emittedChunks: chunkIndex
+                guard let sampleBuffer = trackOutput.copyNextSampleBuffer() else {
+                    return false
+                }
+                guard let block = CMSampleBufferGetDataBuffer(sampleBuffer) else {
+                    return true
+                }
+                let frameCount = CMSampleBufferGetNumSamples(sampleBuffer)
+                if frameCount <= 0 { return true }
+
+                var lengthAtOffset = 0
+                var totalLength = 0
+                var dataPointer: UnsafeMutablePointer<Int8>?
+                let status = CMBlockBufferGetDataPointer(
+                    block,
+                    atOffset: 0,
+                    lengthAtOffsetOut: &lengthAtOffset,
+                    totalLengthOut: &totalLength,
+                    dataPointerOut: &dataPointer
                 )
+                guard status == kCMBlockBufferNoErr, let raw = dataPointer else {
+                    return true
+                }
 
-                if waitForAckOrCancel(upTo: chunkIndex - 1) {
-                    cancelledByUser = true
-                    break
+                let sampleCount = totalLength / MemoryLayout<Float>.size
+                let floatPtr = UnsafeRawPointer(raw)
+                    .assumingMemoryBound(to: Float.self)
+                var idx = pending.count
+                pending.append(contentsOf: repeatElement(0, count: sampleCount))
+                for i in 0..<sampleCount {
+                    let v = floatPtr[i]
+                    if v.isNaN || v.isInfinite {
+                        pending[idx] = 0
+                    } else if options.normalizeAudio {
+                        pending[idx] = max(-1.0, min(1.0, v))
+                    } else {
+                        pending[idx] = v
+                    }
+                    idx += 1
+                }
+
+                while (pending.count - pendingHead) >= cappedSamplesPerChunk {
+                    let payload = Array(
+                        pending[pendingHead..<(pendingHead + cappedSamplesPerChunk)]
+                    )
+                    pendingHead += cappedSamplesPerChunk
+                    if pendingHead >= compactThreshold {
+                        pending.removeFirst(pendingHead)
+                        pendingHead = 0
+                    }
+                    let durationOfChunk = Double(cappedSamplesPerChunk)
+                        / (outputSampleRate * Double(outputChannels))
+                    let startMs = rangeStartMs
+                        + (Double(totalSamples) / (outputSampleRate * Double(outputChannels))) * 1000.0
+                    emitChunk(
+                        index: chunkIndex,
+                        startTimeMs: startMs,
+                        endTimeMs: startMs + durationOfChunk * 1000.0,
+                        startSample: totalSamples / outputChannels,
+                        sampleRate: outputSampleRate,
+                        channels: outputChannels,
+                        samples: payload,
+                        isFinal: false
+                    )
+                    chunkIndex += 1
+                    totalSamples += cappedSamplesPerChunk
+                    // Progress is *elapsed decoded time within the requested
+                    // range* so `processedMs / durationMs` stays in [0, 1]
+                    // regardless of `startTimeMs`. Chunk timestamps stay
+                    // absolute (rangeStart + offset).
+                    processedMs = (Double(totalSamples) /
+                        (outputSampleRate * Double(outputChannels))) * 1000.0
+                    emitProgress(
+                        processedMs: processedMs,
+                        durationMs: totalDurationMs,
+                        emittedChunks: chunkIndex
+                    )
+
+                    switch waitForAckOrCancel(upTo: chunkIndex - 1) {
+                    case .ok:
+                        ()
+                    case .cancelled:
+                        cancelledByUser = true
+                    case .timedOut:
+                        backpressureTimedOut = true
+                    }
+                    if cancelledByUser || backpressureTimedOut { return false }
                 }
+                return true
             }
-            if cancelledByUser { break }
+            if !shouldContinue { break }
+        }
+
+        if backpressureTimedOut {
+            reader.cancelReading()
+            emitError(
+                code: "ERR_AUDIO_STREAM_BACKPRESSURE_TIMEOUT",
+                message: "Timed out waiting for JS acknowledgement after \(Int(options.backpressureTimeoutMs ?? 0))ms"
+            )
+            return
         }
 
         if cancelledByUser {
@@ -343,8 +409,10 @@ public final class AudioStreamDecoder {
                 code: "ERR_AUDIO_STREAM_CANCELLED",
                 message: "Stream cancelled"
             )
+            // `durationMs` reports the requested range (matches Android),
+            // `samples` reports what was actually decoded before cancel.
             emitComplete(
-                durationMs: processedMs,
+                durationMs: totalDurationMs,
                 sampleRate: outputSampleRate,
                 channels: outputChannels,
                 chunks: chunkIndex,
@@ -364,8 +432,10 @@ public final class AudioStreamDecoder {
         }
 
         // Flush remaining samples as final chunk.
-        if !pending.isEmpty {
-            let durationOfChunk = Double(pending.count)
+        let tailCount = pending.count - pendingHead
+        if tailCount > 0 {
+            let tail = Array(pending[pendingHead..<pending.count])
+            let durationOfChunk = Double(tailCount)
                 / (outputSampleRate * Double(outputChannels))
             let startMs = rangeStartMs
                 + (Double(totalSamples) / (outputSampleRate * Double(outputChannels))) * 1000.0
@@ -376,16 +446,26 @@ public final class AudioStreamDecoder {
                 startSample: totalSamples / outputChannels,
                 sampleRate: outputSampleRate,
                 channels: outputChannels,
-                samples: pending,
+                samples: tail,
                 isFinal: true
             )
-            totalSamples += pending.count
+            totalSamples += tailCount
             chunkIndex += 1
-            processedMs = startMs + durationOfChunk * 1000.0
+            processedMs = (Double(totalSamples) /
+                (outputSampleRate * Double(outputChannels))) * 1000.0
+            // Mirror the per-chunk progress emission so consumers always see
+            // a final `processedMs / durationMs ≈ 1.0` from `onProgress`.
+            emitProgress(
+                processedMs: processedMs,
+                durationMs: totalDurationMs,
+                emittedChunks: chunkIndex
+            )
             pending.removeAll(keepingCapacity: false)
-        } else if chunkIndex > 0 {
-            // Last emitted chunk wasn't marked final. Emit a zero-sample final
-            // tail so consumers that key off isFinal see termination.
+            pendingHead = 0
+        } else {
+            // Last emitted chunk wasn't marked final (or no data was decoded).
+            // Emit a zero-sample final tail so consumers that key off isFinal
+            // see termination even for empty-but-valid ranges.
             let startMs = rangeStartMs
                 + (Double(totalSamples) / (outputSampleRate * Double(outputChannels))) * 1000.0
             emitChunk(
@@ -411,20 +491,31 @@ public final class AudioStreamDecoder {
         )
     }
 
+    private enum AckWaitResult {
+        case ok
+        case cancelled
+        case timedOut
+    }
+
     /// Blocks the decoder thread while too many unacked chunks are in flight.
-    /// Returns true if cancellation arrived while waiting.
-    private func waitForAckOrCancel(upTo index: Int) -> Bool {
+    private func waitForAckOrCancel(upTo index: Int) -> AckWaitResult {
+        let deadline = options.backpressureTimeoutMs
+            .flatMap { $0 > 0 ? Date().addingTimeInterval($0 / 1000.0) : nil }
         ackCondition.lock()
         defer { ackCondition.unlock() }
         while true {
             if isCancelled() {
-                return true
+                return .cancelled
             }
             let inFlight = index - lastAckedIndex
             if inFlight < options.maxBufferedChunks {
-                return false
+                return .ok
+            }
+            if let deadline, Date() >= deadline {
+                return .timedOut
             }
-            ackCondition.wait(until: Date().addingTimeInterval(0.05))
+            let nextWake = min(0.05, max(0.001, deadline?.timeIntervalSinceNow ?? 0.05))
+            ackCondition.wait(until: Date().addingTimeInterval(nextWake))
         }
     }
 

package/ios/AudioStudioModule.swift

@@ -82,6 +82,20 @@ public class AudioStudioModule: Module, AudioStreamManagerDelegate, AudioDeviceM
         OnDestroy {
             Logger.debug("AudioStudioModule", "Module destroyed, stopping device monitoring.")
             _ = streamManager.stopRecording()
+            // Cancel any in-flight streamAudioData decoders before the module
+            // is torn down. Without this, decoder threads can outlive the
+            // module and try to emit events through a destroyed instance.
+            // Detach each decoder's delegate *before* cancelling so the
+            // terminal "cancelled" events the worker emits after observing
+            // `cancel()` are dropped instead of being forwarded.
+            self.streamDecodersLock.lock()
+            let inflight = self.streamDecoders
+            self.streamDecoders.removeAll()
+            self.streamDecodersLock.unlock()
+            for (_, decoder) in inflight {
+                decoder.delegate = nil
+                decoder.cancel()
+            }
             // Clear device manager delegate
             deviceManager.delegate = nil
         }
@@ -932,18 +946,27 @@ public class AudioStudioModule: Module, AudioStreamManagerDelegate, AudioDeviceM
                 return
             }
 
+            let chunkDurationMs = options["chunkDurationMs"] as? Int ?? 1000
+            guard (10...60000).contains(chunkDurationMs) else {
+                promise.reject(
+                    "ERR_AUDIO_STREAM_INVALID_RANGE",
+                    "chunkDurationMs must be in [10, 60000]"
+                )
+                return
+            }
+
             let opts = AudioStreamDecoder.Options(
                 requestId: requestId,
                 fileUri: fileUri,
                 startTimeMs: options["startTimeMs"] as? Double,
                 endTimeMs: options["endTimeMs"] as? Double,
-                targetSampleRate: options["targetSampleRate"] as? Double
-                    ?? (options["sampleRate"] as? Double),
+                targetSampleRate: options["targetSampleRate"] as? Double,
                 channels: options["channels"] as? Int,
                 normalizeAudio: options["normalizeAudio"] as? Bool ?? true,
-                chunkDurationMs: options["chunkDurationMs"] as? Int ?? 1000,
+                chunkDurationMs: chunkDurationMs,
                 maxChunkBytes: options["maxChunkBytes"] as? Int,
-                maxBufferedChunks: options["maxBufferedChunks"] as? Int ?? 4
+                maxBufferedChunks: options["maxBufferedChunks"] as? Int ?? 4,
+                backpressureTimeoutMs: options["backpressureTimeoutMs"] as? Double
             )
 
             let decoder = AudioStreamDecoder(options: opts)
@@ -1009,12 +1032,25 @@ public class AudioStudioModule: Module, AudioStreamManagerDelegate, AudioDeviceM
         streamDecodersLock.unlock()
     }
 
+    /// Returns true when `requestId` is still tracked by the module. Used as
+    /// the lifecycle gate for delegate sends: callbacks that race with
+    /// `OnDestroy` (which clears the map *before* cancelling) see `false`
+    /// and skip `sendEvent`, so we never push events through a destroyed
+    /// React context.
+    private func isActiveStreamDecoder(_ requestId: String) -> Bool {
+        streamDecodersLock.lock()
+        defer { streamDecodersLock.unlock() }
+        return streamDecoders[requestId] != nil
+    }
+
     // MARK: - AudioStreamDecoderDelegate
 
     public func streamDecoder(
         _ decoder: AudioStreamDecoder,
         didEmitChunk payload: [String: Any]
     ) {
+        guard let requestId = payload["requestId"] as? String,
+              isActiveStreamDecoder(requestId) else { return }
         sendEvent(audioStreamChunkEvent, payload)
     }
 
@@ -1022,6 +1058,8 @@ public class AudioStudioModule: Module, AudioStreamManagerDelegate, AudioDeviceM
         _ decoder: AudioStreamDecoder,
         didReportProgress payload: [String: Any]
     ) {
+        guard let requestId = payload["requestId"] as? String,
+              isActiveStreamDecoder(requestId) else { return }
         sendEvent(audioStreamProgressEvent, payload)
     }
 
@@ -1029,9 +1067,9 @@ public class AudioStudioModule: Module, AudioStreamManagerDelegate, AudioDeviceM
         _ decoder: AudioStreamDecoder,
         didCompleteWith payload: [String: Any]
     ) {
-        if let requestId = payload["requestId"] as? String {
-            releaseStreamDecoder(requestId)
-        }
+        guard let requestId = payload["requestId"] as? String,
+              isActiveStreamDecoder(requestId) else { return }
+        releaseStreamDecoder(requestId)
         sendEvent(audioStreamCompleteEvent, payload)
     }
 
@@ -1039,8 +1077,9 @@ public class AudioStudioModule: Module, AudioStreamManagerDelegate, AudioDeviceM
         _ decoder: AudioStreamDecoder,
         didFailWith payload: [String: Any]
     ) {
-        if let requestId = payload["requestId"] as? String,
-           let code = payload["code"] as? String,
+        guard let requestId = payload["requestId"] as? String,
+              isActiveStreamDecoder(requestId) else { return }
+        if let code = payload["code"] as? String,
            code != "ERR_AUDIO_STREAM_CANCELLED" {
             releaseStreamDecoder(requestId)
         }