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

package/android/src/main/java/net/siteed/audiostudio/AudioStreamDecoder.kt

@@ -11,6 +11,7 @@ import android.content.Context
 import android.media.MediaCodec
 import android.media.MediaExtractor
 import android.media.MediaFormat
+import android.media.MediaMetadataRetriever
 import android.net.Uri
 import android.os.Bundle
 import androidx.core.os.bundleOf
@@ -20,6 +21,7 @@ import java.nio.ByteOrder
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicInteger
 import kotlin.concurrent.thread
+import kotlin.math.ceil
 
 interface AudioStreamDecoderDelegate {
     fun streamDecoderEmit(eventName: String, payload: Bundle)
@@ -41,6 +43,7 @@ class AudioStreamDecoder(
         val chunkDurationMs: Int,
         val maxChunkBytes: Int?,
         val maxBufferedChunks: Int,
+        val backpressureTimeoutMs: Long?,
     )
 
     companion object {
@@ -77,12 +80,15 @@ class AudioStreamDecoder(
     }
 
     private fun run() {
-        val path = resolveFilePath(options.fileUri)
-        if (path == null) {
+        val resolved = resolveFilePath(options.fileUri)
+        if (resolved == null) {
             emitError("ERR_AUDIO_STREAM_FILE_NOT_FOUND", "Cannot resolve file: ${options.fileUri}")
             return
         }
+        val path = resolved.path
+        val tempFile = resolved.tempFile
         if (!File(path).exists()) {
+            tempFile?.let { runCatching { it.delete() } }
             emitError("ERR_AUDIO_STREAM_FILE_NOT_FOUND", "File not found: $path")
             return
         }
@@ -91,7 +97,7 @@ class AudioStreamDecoder(
         var codec: MediaCodec? = null
         var emittedChunks = 0
         var emittedSamples = 0L
-        var totalDurationUs: Long = -1
+        var backpressureTimedOut = false
         var outputSampleRate = options.targetSampleRate ?: 0
         var outputChannels = options.channels ?: 0
 
@@ -119,16 +125,48 @@ class AudioStreamDecoder(
             }
             extractor.selectTrack(trackIndex)
             val format = extractor.getTrackFormat(trackIndex)
-            totalDurationUs = if (format.containsKey(MediaFormat.KEY_DURATION)) {
+            val extractorDurationUs = if (format.containsKey(MediaFormat.KEY_DURATION)) {
                 format.getLong(MediaFormat.KEY_DURATION)
             } else {
-                -1
+                -1L
+            }
+            val metadataDurationMs = if (extractorDurationUs <= 0) {
+                readMetadataDurationMs(path)
+            } else {
+                -1L
+            }
+            val assetDurationUs = if (extractorDurationUs > 0) {
+                extractorDurationUs
+            } else if (metadataDurationMs > 0) {
+                metadataDurationMs * 1000L
+            } else {
+                -1L
+            }
+            val assetDurationMs = if (assetDurationUs > 0) {
+                assetDurationUs / 1000.0
+            } else {
+                0.0
+            }
+            // Duration of the *decoded range*, not the whole file, so progress
+            // and completion payloads match what the caller actually receives.
+            val rangeDurationMs = when {
+                options.startTimeMs != null && options.endTimeMs != null ->
+                    (options.endTimeMs - options.startTimeMs).toDouble().coerceAtLeast(0.0)
+                options.endTimeMs != null -> options.endTimeMs.toDouble().coerceAtLeast(0.0)
+                options.startTimeMs != null ->
+                    (assetDurationMs - options.startTimeMs).coerceAtLeast(0.0)
+                else -> assetDurationMs
             }
 
-            val sourceSampleRate = format.getInteger(MediaFormat.KEY_SAMPLE_RATE)
-            val sourceChannels = format.getInteger(MediaFormat.KEY_CHANNEL_COUNT)
+            var sourceSampleRate = format.getInteger(MediaFormat.KEY_SAMPLE_RATE)
+            var sourceChannels = format.getInteger(MediaFormat.KEY_CHANNEL_COUNT)
             if (outputSampleRate <= 0) outputSampleRate = sourceSampleRate
             if (outputChannels <= 0) outputChannels = minOf(2, maxOf(1, sourceChannels))
+            val maxOutputSamples = options.endTimeMs?.let {
+                ((rangeDurationMs / 1000.0) * outputSampleRate.toDouble() * outputChannels.toDouble())
+                    .toLong()
+                    .coerceAtLeast(0L)
+            } ?: Long.MAX_VALUE
 
             options.startTimeMs?.let {
                 extractor.seekTo(it * 1000L, MediaExtractor.SEEK_TO_CLOSEST_SYNC)
@@ -156,14 +194,49 @@ class AudioStreamDecoder(
 
             val endTimeUs = options.endTimeMs?.let { it * 1000L } ?: Long.MAX_VALUE
             val rangeStartMs = options.startTimeMs ?: 0L
+            val targetStartUs = rangeStartMs * 1000L
             val samplesPerChunk = run {
                 val byTime = (options.chunkDurationMs.toLong() *
                     outputSampleRate.toLong() / 1000L).toInt() * outputChannels
-                val byBytes = options.maxChunkBytes?.let { it / 4 } ?: Int.MAX_VALUE
-                maxOf(1, minOf(byTime, byBytes))
+                // Round byte-cap down to a multiple of `outputChannels` so a
+                // single interleaved frame is never split across chunks.
+                val byBytes = options.maxChunkBytes?.let {
+                    (it / 4 / outputChannels) * outputChannels
+                } ?: Int.MAX_VALUE
+                val raw = minOf(byTime, byBytes)
+                maxOf(outputChannels, (raw / outputChannels) * outputChannels)
             }
-            val pending = FloatArray(samplesPerChunk * 2)
+            var pending = FloatArray(samplesPerChunk * 2)
             var pendingLen = 0
+            var pendingHead = 0
+            fun pendingAvailable(): Int = pendingLen - pendingHead
+            fun compactPending() {
+                val available = pendingAvailable()
+                if (pendingHead == 0) return
+                if (available > 0) {
+                    System.arraycopy(pending, pendingHead, pending, 0, available)
+                }
+                pendingHead = 0
+                pendingLen = available
+            }
+            fun appendPending(samples: FloatArray) {
+                if (samples.isEmpty()) return
+                val available = pendingAvailable()
+                val requiredLen = available + samples.size
+                if (requiredLen > pending.size) {
+                    val grown = FloatArray(requiredLen.coerceAtLeast(pending.size * 2))
+                    if (available > 0) {
+                        System.arraycopy(pending, pendingHead, grown, 0, available)
+                    }
+                    pending = grown
+                    pendingHead = 0
+                    pendingLen = available
+                } else if (pending.size - pendingLen < samples.size && pendingHead > 0) {
+                    compactPending()
+                }
+                System.arraycopy(samples, 0, pending, pendingLen, samples.size)
+                pendingLen += samples.size
+            }
             val info = MediaCodec.BufferInfo()
             var sawInputEOS = false
             var sawOutputEOS = false
@@ -220,52 +293,72 @@ class AudioStreamDecoder(
                             outputChannels,
                             options.normalizeAudio
                         )
+                        // SEEK_TO_CLOSEST_SYNC can land before the requested
+                        // start (encoder priming on AAC/MP3, sync-frame
+                        // granularity on lossy containers). Trim source-rate
+                        // frames whose presentation time is before
+                        // `targetStartUs` so the first emitted sample lines
+                        // up with `startTimeMs`.
+                        val bufferStartUs = info.presentationTimeUs
+                        val trimmed: FloatArray = if (
+                            targetStartUs > 0 &&
+                            bufferStartUs in 0L until targetStartUs &&
+                            converted.isNotEmpty()
+                        ) {
+                            val deltaUs = targetStartUs - bufferStartUs
+                            val skipFrames = (
+                                deltaUs.toDouble() * sourceSampleRate.toDouble() /
+                                    1_000_000.0
+                            ).toInt()
+                            val totalFrames = converted.size / outputChannels
+                            val actualSkip = minOf(skipFrames, totalFrames)
+                            if (actualSkip >= totalFrames) {
+                                FloatArray(0)
+                            } else if (actualSkip > 0) {
+                                val skipFloats = actualSkip * outputChannels
+                                val out = FloatArray(converted.size - skipFloats)
+                                System.arraycopy(
+                                    converted,
+                                    skipFloats,
+                                    out,
+                                    0,
+                                    out.size
+                                )
+                                out
+                            } else {
+                                converted
+                            }
+                        } else {
+                            converted
+                        }
                         val resampled = resampler.process(
-                            converted,
+                            trimmed,
                             sourceSampleRate,
                             outputSampleRate
                         )
-
-                        // Append into pending, grow if needed
-                        val newLen = pendingLen + resampled.size
-                        val target = if (newLen > pending.size) {
-                            val grown = FloatArray(newLen.coerceAtLeast(pending.size * 2))
-                            System.arraycopy(pending, 0, grown, 0, pendingLen)
-                            grown.also {
-                                System.arraycopy(it, 0, pending, 0, pendingLen)
+                        val remainingOutputSamples =
+                            maxOutputSamples - emittedSamples - pendingAvailable().toLong()
+                        val boundedResampled = when {
+                            remainingOutputSamples <= 0L -> FloatArray(0)
+                            resampled.size.toLong() > remainingOutputSamples -> {
+                                val boundedSize = (
+                                    remainingOutputSamples.toInt() / outputChannels
+                                    ) * outputChannels
+                                resampled.copyOf(boundedSize)
                             }
-                        } else {
-                            pending
-                        }
-                        // Note: when grown, we use a transient buffer that we
-                        // process and never write back into the original.
-                        val workBuffer: FloatArray
-                        if (target !== pending) {
-                            System.arraycopy(resampled, 0, target, pendingLen, resampled.size)
-                            pendingLen += resampled.size
-                            workBuffer = target
-                        } else {
-                            System.arraycopy(resampled, 0, pending, pendingLen, resampled.size)
-                            pendingLen += resampled.size
-                            workBuffer = pending
+                            else -> resampled
                         }
 
-                        while (pendingLen >= samplesPerChunk) {
+                        appendPending(boundedResampled)
+
+                        chunkLoop@ while (pendingAvailable() >= samplesPerChunk) {
                             if (cancelled.get()) break
                             val chunk = FloatArray(samplesPerChunk)
-                            System.arraycopy(workBuffer, 0, chunk, 0, samplesPerChunk)
-                            // Shift remainder forward.
-                            val remainder = pendingLen - samplesPerChunk
-                            if (remainder > 0) {
-                                System.arraycopy(
-                                    workBuffer,
-                                    samplesPerChunk,
-                                    workBuffer,
-                                    0,
-                                    remainder
-                                )
+                            System.arraycopy(pending, pendingHead, chunk, 0, samplesPerChunk)
+                            pendingHead += samplesPerChunk
+                            if (pendingHead > pending.size / 2) {
+                                compactPending()
                             }
-                            pendingLen = remainder
 
                             val chunkDurationMs =
                                 (chunk.size.toDouble() /
@@ -279,7 +372,7 @@ class AudioStreamDecoder(
                                 index = emittedChunks,
                                 startTimeMs = startMs,
                                 endTimeMs = startMs + chunkDurationMs,
-                                startSample = (emittedSamples / outputChannels).toInt(),
+                                startSample = emittedSamples / outputChannels,
                                 sampleRate = outputSampleRate,
                                 channels = outputChannels,
                                 samples = chunk,
@@ -287,14 +380,29 @@ class AudioStreamDecoder(
                             )
                             emittedChunks += 1
                             emittedSamples += chunk.size
+                            // 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).
+                            val elapsedMs = (emittedSamples.toDouble() /
+                                (outputSampleRate.toDouble() *
+                                    outputChannels.toDouble())) * 1000.0
                             emitProgress(
-                                processedMs = startMs + chunkDurationMs,
-                                durationMs = if (totalDurationUs > 0) totalDurationUs / 1000.0 else 0.0,
+                                processedMs = elapsedMs,
+                                durationMs = rangeDurationMs,
                                 emittedChunks = emittedChunks
                             )
-                            if (waitForAckOrCancel(emittedChunks - 1)) {
-                                cancelled.set(true)
-                                break
+                            when (waitForAckOrCancel(emittedChunks - 1)) {
+                                AckWaitResult.OK -> Unit
+                                AckWaitResult.CANCELLED -> {
+                                    cancelled.set(true)
+                                    break@chunkLoop
+                                }
+                                AckWaitResult.TIMED_OUT -> {
+                                    backpressureTimedOut = true
+                                    break@chunkLoop
+                                }
                             }
                         }
                     }
@@ -302,34 +410,55 @@ class AudioStreamDecoder(
                     if (info.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM != 0) {
                         sawOutputEOS = true
                     }
+                    if (backpressureTimedOut) {
+                        break
+                    }
                 } else if (outputIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                     val newFormat = codec.outputFormat
+                    // Codec output format is authoritative once decoding starts;
+                    // the resampler is told the new source rate on its next call
+                    // so the output rate (and chunk timestamps) stay correct.
                     if (newFormat.containsKey(MediaFormat.KEY_SAMPLE_RATE)) {
-                        // Source rate from codec output overrides extractor's
-                        // format when the codec exposes a different value.
-                        @Suppress("UNUSED_VARIABLE")
-                        val updatedRate = newFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE)
+                        sourceSampleRate = newFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE)
                     }
+                    if (newFormat.containsKey(MediaFormat.KEY_CHANNEL_COUNT)) {
+                        sourceChannels = newFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT)
+                    }
+                }
+            }
+
+            if (!cancelled.get() && !backpressureTimedOut) {
+                val resamplerTail = resampler.flush()
+                if (resamplerTail.isNotEmpty()) {
+                    appendPending(resamplerTail)
                 }
             }
 
+            if (backpressureTimedOut) {
+                emitError(
+                    "ERR_AUDIO_STREAM_BACKPRESSURE_TIMEOUT",
+                    "Timed out waiting for JS acknowledgement after ${options.backpressureTimeoutMs}ms"
+                )
+                return
+            }
+
             if (cancelled.get()) {
                 emitError("ERR_AUDIO_STREAM_CANCELLED", "Stream cancelled")
                 emitComplete(
-                    durationMs = if (totalDurationUs > 0) totalDurationUs / 1000.0 else 0.0,
+                    durationMs = rangeDurationMs,
                     sampleRate = outputSampleRate,
                     channels = outputChannels,
                     chunks = emittedChunks,
-                    samples = emittedSamples.toInt(),
+                    samples = emittedSamples,
                     cancelled = true
                 )
                 return
             }
 
             // Flush remainder as final chunk
-            if (pendingLen > 0) {
-                val tail = FloatArray(pendingLen)
-                System.arraycopy(pending, 0, tail, 0, pendingLen)
+            if (pendingAvailable() > 0) {
+                val tail = FloatArray(pendingAvailable())
+                System.arraycopy(pending, pendingHead, tail, 0, tail.size)
                 val tailDurationMs =
                     (tail.size.toDouble() /
                         (outputSampleRate.toDouble() * outputChannels.toDouble())) *
@@ -342,7 +471,7 @@ class AudioStreamDecoder(
                     index = emittedChunks,
                     startTimeMs = startMs,
                     endTimeMs = startMs + tailDurationMs,
-                    startSample = (emittedSamples / outputChannels).toInt(),
+                    startSample = emittedSamples / outputChannels,
                     sampleRate = outputSampleRate,
                     channels = outputChannels,
                     samples = tail,
@@ -350,7 +479,18 @@ class AudioStreamDecoder(
                 )
                 emittedChunks += 1
                 emittedSamples += tail.size
-            } else if (emittedChunks > 0) {
+                // Mirror the per-chunk progress emission so consumers always
+                // see a final `processedMs / durationMs ≈ 1.0` from
+                // `onProgress`.
+                val elapsedMs = (emittedSamples.toDouble() /
+                    (outputSampleRate.toDouble() *
+                        outputChannels.toDouble())) * 1000.0
+                emitProgress(
+                    processedMs = elapsedMs,
+                    durationMs = rangeDurationMs,
+                    emittedChunks = emittedChunks
+                )
+            } else {
                 emitChunk(
                     index = emittedChunks,
                     startTimeMs = rangeStartMs +
@@ -361,7 +501,7 @@ class AudioStreamDecoder(
                         (emittedSamples.toDouble() /
                             (outputSampleRate.toDouble() * outputChannels.toDouble())) *
                             1000.0,
-                    startSample = (emittedSamples / outputChannels).toInt(),
+                    startSample = emittedSamples / outputChannels,
                     sampleRate = outputSampleRate,
                     channels = outputChannels,
                     samples = FloatArray(0),
@@ -371,11 +511,11 @@ class AudioStreamDecoder(
             }
 
             emitComplete(
-                durationMs = if (totalDurationUs > 0) totalDurationUs / 1000.0 else 0.0,
+                durationMs = rangeDurationMs,
                 sampleRate = outputSampleRate,
                 channels = outputChannels,
                 chunks = emittedChunks,
-                samples = emittedSamples.toInt(),
+                samples = emittedSamples,
                 cancelled = false
             )
         } catch (e: Exception) {
@@ -394,17 +534,40 @@ class AudioStreamDecoder(
             try {
                 extractor.release()
             } catch (_: Exception) { /* noop */ }
+            tempFile?.let { runCatching { it.delete() } }
         }
     }
 
-    private fun resolveFilePath(uri: String): String? {
-        if (uri.startsWith("/")) return uri
+    private data class ResolvedFile(val path: String, val tempFile: File?)
+
+    private fun readMetadataDurationMs(path: String): Long {
+        return try {
+            val retriever = MediaMetadataRetriever()
+            try {
+                retriever.setDataSource(path)
+                retriever
+                    .extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)
+                    ?.toLongOrNull()
+                    ?: -1L
+            } finally {
+                retriever.release()
+            }
+        } catch (_: Exception) {
+            -1L
+        }
+    }
+
+    private fun resolveFilePath(uri: String): ResolvedFile? {
+        if (uri.startsWith("/")) return ResolvedFile(uri, null)
         return try {
             val parsed = Uri.parse(uri)
             when (parsed.scheme) {
-                "file" -> parsed.path
+                "file" -> parsed.path?.let { ResolvedFile(it, null) }
                 "content" -> {
-                    // Copy to cache so MediaExtractor can read by path.
+                    // MediaExtractor needs a real file path; copy the content
+                    // URI into the cache dir and remember the temp file so we
+                    // can delete it in `finally` (otherwise every call leaks a
+                    // copy of the source audio onto disk).
                     val temp = File.createTempFile(
                         "audiostream_${options.requestId}_",
                         null,
@@ -413,9 +576,9 @@ class AudioStreamDecoder(
                     context.contentResolver.openInputStream(parsed)?.use { input ->
                         temp.outputStream().use { out -> input.copyTo(out) }
                     }
-                    temp.absolutePath
+                    ResolvedFile(temp.absolutePath, temp)
                 }
-                null -> uri
+                null -> ResolvedFile(uri, null)
                 else -> null
             }
         } catch (e: Exception) {
@@ -480,16 +643,23 @@ class AudioStreamDecoder(
         return out
     }
 
-    private fun waitForAckOrCancel(emittedIndex: Int): Boolean {
+    private enum class AckWaitResult { OK, CANCELLED, TIMED_OUT }
+
+    private fun waitForAckOrCancel(emittedIndex: Int): AckWaitResult {
+        val deadlineMs = options.backpressureTimeoutMs
+            ?.takeIf { it > 0 }
+            ?.let { System.currentTimeMillis() + it }
         synchronized(ackLock) {
             while (true) {
-                if (cancelled.get()) return true
+                if (cancelled.get()) return AckWaitResult.CANCELLED
                 val inFlight = emittedIndex - lastAckedIndex.get()
-                if (inFlight < options.maxBufferedChunks) return false
-                ackLock.wait(50L)
+                if (inFlight < options.maxBufferedChunks) return AckWaitResult.OK
+                val remainingMs = deadlineMs?.let { it - System.currentTimeMillis() }
+                if (remainingMs != null && remainingMs <= 0L) {
+                    return AckWaitResult.TIMED_OUT
+                }
+                ackLock.wait(minOf(50L, remainingMs ?: 50L))
             }
-            @Suppress("UNREACHABLE_CODE")
-            return false
         }
     }
 
@@ -497,7 +667,7 @@ class AudioStreamDecoder(
         index: Int,
         startTimeMs: Double,
         endTimeMs: Double,
-        startSample: Int,
+        startSample: Long,
         sampleRate: Int,
         channels: Int,
         samples: FloatArray,
@@ -544,7 +714,7 @@ class AudioStreamDecoder(
         sampleRate: Int,
         channels: Int,
         chunks: Int,
-        samples: Int,
+        samples: Long,
         cancelled: Boolean,
     ) {
         val payload = bundleOf(
@@ -576,28 +746,49 @@ class AudioStreamDecoder(
 private class LinearResampler(private val channels: Int) {
     private var lastSrcFrame: FloatArray? = null
     private var fractional: Double = 0.0
+    private var lastSourceRate: Int? = null
+    private var lastTargetRate: Int? = null
+    private var canFlushLastFrame = false
 
     fun process(input: FloatArray, sourceRate: Int, targetRate: Int): FloatArray {
         if (input.isEmpty() || channels <= 0) return FloatArray(0)
-        if (sourceRate == targetRate) return input
+        val srcFrames = input.size / channels
+        if (srcFrames <= 0) return FloatArray(0)
+
+        if (lastSourceRate != null &&
+            (lastSourceRate != sourceRate || lastTargetRate != targetRate)
+        ) {
+            reset()
+        }
+        lastSourceRate = sourceRate
+        lastTargetRate = targetRate
+
+        if (sourceRate == targetRate) {
+            stashLastFrame(input, srcFrames)
+            fractional = 0.0
+            canFlushLastFrame = false
+            return input
+        }
 
         val ratio = sourceRate.toDouble() / targetRate.toDouble()
-        val srcFrames = input.size / channels
         val previousFrame = lastSrcFrame
         val totalSrcFrames = srcFrames + if (previousFrame != null) 1 else 0
         if (totalSrcFrames < 2) {
             // Not enough to interpolate yet; stash and return empty.
-            lastSrcFrame = FloatArray(channels).also { dst ->
-                if (srcFrames >= 1) {
-                    System.arraycopy(input, (srcFrames - 1) * channels, dst, 0, channels)
-                }
-            }
+            stashLastFrame(input, srcFrames)
+            canFlushLastFrame = true
             return FloatArray(0)
         }
 
         // Build virtual stream: [previousFrame?, input...].
         val virtualLen = totalSrcFrames
-        val out = ArrayList<Float>(((virtualLen * targetRate) / sourceRate + 1) * channels)
+        val outFrames = ceil(((virtualLen - 1) - fractional) / ratio)
+            .toInt()
+            .coerceAtLeast(0)
+        // Add one frame of slack for floating-point boundary rounding; trim
+        // below if the conservative capacity was not used.
+        val out = FloatArray((outFrames + 1) * channels)
+        var outIdx = 0
         var srcPos = fractional
         while (srcPos < virtualLen - 1) {
             val i = srcPos.toInt()
@@ -605,20 +796,41 @@ private class LinearResampler(private val channels: Int) {
             for (c in 0 until channels) {
                 val a = sampleAt(i, c, previousFrame, input)
                 val b = sampleAt(i + 1, c, previousFrame, input)
-                out.add(a + (b - a) * frac)
+                out[outIdx++] = a + (b - a) * frac
             }
             srcPos += ratio
         }
         fractional = srcPos - (virtualLen - 1)
 
-        // Stash last source frame for the next call.
+        // Stash last source frame for the next call. The interpolation loop
+        // intentionally stops before the final frame so that it can interpolate
+        // across the next decoder buffer; flush() emits this tail at EOS.
+        stashLastFrame(input, srcFrames)
+        canFlushLastFrame = true
+
+        return if (outIdx == out.size) out else out.copyOf(outIdx)
+    }
+
+    fun flush(): FloatArray {
+        val tail = if (canFlushLastFrame) {
+            lastSrcFrame?.copyOf() ?: FloatArray(0)
+        } else {
+            FloatArray(0)
+        }
+        reset()
+        return tail
+    }
+
+    private fun reset() {
+        lastSrcFrame = null
+        fractional = 0.0
+        canFlushLastFrame = false
+    }
+
+    private fun stashLastFrame(input: FloatArray, srcFrames: Int) {
         lastSrcFrame = FloatArray(channels).also { dst ->
             System.arraycopy(input, (srcFrames - 1) * channels, dst, 0, channels)
         }
-
-        val arr = FloatArray(out.size)
-        for (i in out.indices) arr[i] = out[i]
-        return arr
     }
 
     private fun sampleAt(