@mentra/acs-meeting 3.2.0-dev.120

package/android/src/test/java/com/mentra/acsmeeting/audio/IncomingAudioPumpTest.kt

@@ -0,0 +1,97 @@
+package com.mentra.acsmeeting.audio
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class IncomingAudioPumpTest {
+  private fun silence(ms: Int, rate: Int, channels: Int = 1) = ByteArray(rate * channels * 2 * ms / 1000)
+
+  @Test
+  fun bytesForMatches16kMono() {
+    assertThat(IncomingAudioPump.bytesFor(20)).isEqualTo(640)
+    assertThat(IncomingAudioPump.bytesFor(60)).isEqualTo(1920)
+    assertThat(IncomingAudioPump.bytesFor(120)).isEqualTo(3840)
+  }
+
+  @Test
+  fun defaultPrerollIsOneOfTheLadderSteps() {
+    // The downlink A/B walks this ladder on real hardware; whatever ships must
+    // be a step on it, not an arbitrary number.
+    assertThat(IncomingAudioPump.PREROLL_LADDER_MS).containsExactly(120, 160, 200)
+    assertThat(IncomingAudioPump.PREROLL_LADDER_MS).contains(IncomingAudioPump.DEFAULT_PREROLL_MS)
+  }
+
+  @Test
+  fun holdsDefaultPrerollBeforeFirstEmit() {
+    val emitted = mutableListOf<ByteArray>()
+    val pump = IncomingAudioPump { emitted.add(it) }
+    val callbacks = IncomingAudioPump.DEFAULT_PREROLL_MS / 20
+
+    repeat(callbacks - 1) { pump.push(silence(20, 16_000), 16_000, 1) }
+    assertThat(emitted).isEmpty()
+
+    pump.push(silence(20, 16_000), 16_000, 1)
+    assertThat(emitted).isNotEmpty()
+    assertThat(emitted).allSatisfy { assertThat(it).hasSize(IncomingAudioPump.bytesFor(IncomingAudioPump.DEFAULT_BATCH_MS)) }
+    // Whole batches only; the sub-batch remainder stays as headroom.
+    val total = emitted.sumOf { it.size }
+    assertThat(total)
+      .isGreaterThan(IncomingAudioPump.bytesFor(IncomingAudioPump.DEFAULT_PREROLL_MS - IncomingAudioPump.DEFAULT_BATCH_MS))
+      .isLessThanOrEqualTo(IncomingAudioPump.bytesFor(IncomingAudioPump.DEFAULT_PREROLL_MS))
+  }
+
+  @Test
+  fun holdsPrerollThenEmitsBatches() {
+    val emitted = mutableListOf<ByteArray>()
+    val pump = IncomingAudioPump(prerollMs = 120, batchMs = 60) { emitted.add(it) }
+
+    // Five 20 ms ACS callbacks = 100 ms: below the 120 ms preroll.
+    repeat(5) { pump.push(silence(20, 16_000), 16_000, 1) }
+    assertThat(emitted).isEmpty()
+
+    pump.push(silence(20, 16_000), 16_000, 1)
+    assertThat(emitted).hasSize(2)
+    assertThat(emitted.all { it.size == IncomingAudioPump.bytesFor(60) }).isTrue()
+
+    // Steady state: one 60 ms batch per three callbacks.
+    repeat(2) { pump.push(silence(20, 16_000), 16_000, 1) }
+    assertThat(emitted).hasSize(2)
+    pump.push(silence(20, 16_000), 16_000, 1)
+    assertThat(emitted).hasSize(3)
+  }
+
+  @Test
+  fun normalizes48kStereoTo16kMono() {
+    val emitted = mutableListOf<ByteArray>()
+    val pump = IncomingAudioPump(prerollMs = 0, batchMs = 20) { emitted.add(it) }
+    // 200 ms of 48 kHz stereo (as ACS would deliver if it ignored our 16 kHz request).
+    repeat(10) { pump.push(silence(20, 48_000, channels = 2), 48_000, 2) }
+    val total = emitted.sumOf { it.size }
+    // 200 ms at 16 kHz mono = 6400 bytes, minus FIR warm-up and one held batch.
+    assertThat(total).isBetween(IncomingAudioPump.bytesFor(140), IncomingAudioPump.bytesFor(200))
+    assertThat(pump.format).isEqualTo(IncomingAudioPump.Format(48_000, 2))
+    assertThat(pump.formatChanges).isEqualTo(0)
+  }
+
+  @Test
+  fun flushEmitsTailAndRearmsPreroll() {
+    val emitted = mutableListOf<ByteArray>()
+    val pump = IncomingAudioPump(prerollMs = 120, batchMs = 60) { emitted.add(it) }
+    pump.push(silence(20, 16_000), 16_000, 1)
+    pump.flush()
+    assertThat(emitted).hasSize(1)
+    assertThat(emitted[0].size).isEqualTo(IncomingAudioPump.bytesFor(20))
+
+    repeat(5) { pump.push(silence(20, 16_000), 16_000, 1) }
+    assertThat(emitted).hasSize(1)
+  }
+
+  @Test
+  fun countsFormatChanges() {
+    val pump = IncomingAudioPump(prerollMs = 0, batchMs = 20) {}
+    pump.push(silence(20, 16_000), 16_000, 1)
+    pump.push(silence(20, 48_000), 48_000, 1)
+    assertThat(pump.formatChanges).isEqualTo(1)
+    assertThat(pump.eventsIn).isEqualTo(2)
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/audio/IncomingRateProbeTest.kt

@@ -0,0 +1,78 @@
+package com.mentra.acsmeeting.audio
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class IncomingRateProbeTest {
+  @Test
+  fun measuresTrueRateFromElapsedTimeNotAssumedCadence() {
+    val probe = IncomingRateProbe()
+    var now = 0L
+    var reading: IncomingRateProbe.Reading? = null
+
+    // 16 kHz mono, 320 samples every 20 ms, for slightly over a second.
+    repeat(52) {
+      reading = probe.record(now, bytes = 640, sampleRate = 16_000, channels = 1) ?: reading
+      now += 20_000_000L
+    }
+
+    val result = requireNotNull(reading)
+    assertThat(result.declaredRate).isEqualTo(16_000)
+    assertThat(result.samplesPerCallback).isEqualTo(320)
+    assertThat(result.callbackHz).isBetween(49.5, 50.5)
+    assertThat(result.measuredRate).isBetween(15_900.0, 16_100.0)
+    assertThat(result.events).isEqualTo(50L)
+  }
+
+  @Test
+  fun mislabeledRateShowsAsMeasuredDisagreeingWithDeclared() {
+    val probe = IncomingRateProbe()
+    var now = 0L
+    var reading: IncomingRateProbe.Reading? = null
+
+    // ACS declares 16 kHz but hands over 48 kHz worth of samples per 20 ms.
+    repeat(52) {
+      reading = probe.record(now, bytes = 1920, sampleRate = 16_000, channels = 1) ?: reading
+      now += 20_000_000L
+    }
+
+    val result = requireNotNull(reading)
+    assertThat(result.declaredRate).isEqualTo(16_000)
+    assertThat(result.measuredRate).isBetween(47_500.0, 48_500.0)
+  }
+
+  @Test
+  fun halfRateCadenceShowsInCallbackHz() {
+    val probe = IncomingRateProbe()
+    var now = 0L
+    var reading: IncomingRateProbe.Reading? = null
+
+    // One 40 ms callback instead of two 20 ms ones: same rate, half the Hz.
+    repeat(27) {
+      reading = probe.record(now, bytes = 1280, sampleRate = 16_000, channels = 1) ?: reading
+      now += 40_000_000L
+    }
+
+    val result = requireNotNull(reading)
+    assertThat(result.samplesPerCallback).isEqualTo(640)
+    assertThat(result.callbackHz).isBetween(24.5, 25.5)
+    assertThat(result.measuredRate).isBetween(15_900.0, 16_100.0)
+  }
+
+  @Test
+  fun stereoCountsSamplesPerChannel() {
+    val probe = IncomingRateProbe()
+    probe.record(0, bytes = 1920, sampleRate = 48_000, channels = 2)
+    val reading = probe.record(1_000_000_000L, bytes = 1920, sampleRate = 48_000, channels = 2)
+
+    assertThat(requireNotNull(reading).samplesPerCallback).isEqualTo(480)
+  }
+
+  @Test
+  fun resetReopensTheWindow() {
+    val probe = IncomingRateProbe()
+    probe.record(0, bytes = 640, sampleRate = 16_000, channels = 1)
+    probe.reset()
+    assertThat(probe.record(2_000_000_000L, bytes = 640, sampleRate = 16_000, channels = 1)).isNull()
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/audio/PcmResamplerTest.kt

@@ -0,0 +1,125 @@
+package com.mentra.acsmeeting.audio
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.math.PI
+import kotlin.math.sin
+import kotlin.math.sqrt
+
+class PcmResamplerTest {
+  private fun tone(rate: Int, hz: Double, seconds: Double, amplitude: Double = 8000.0, channels: Int = 1): ByteArray {
+    val frames = (rate * seconds).toInt()
+    val out = ByteArray(frames * channels * 2)
+    val bb = ByteBuffer.wrap(out).order(ByteOrder.LITTLE_ENDIAN)
+    for (i in 0 until frames) {
+      val s = (amplitude * sin(2 * PI * hz * i / rate)).toInt().toShort()
+      for (c in 0 until channels) bb.putShort(s)
+    }
+    return out
+  }
+
+  private fun shorts(pcm: ByteArray): ShortArray {
+    val s = ShortArray(pcm.size / 2)
+    ByteBuffer.wrap(pcm).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer().get(s)
+    return s
+  }
+
+  private fun rms(s: ShortArray, from: Int = 0): Double {
+    var acc = 0.0
+    for (i in from until s.size) acc += s[i].toDouble() * s[i]
+    return sqrt(acc / (s.size - from))
+  }
+
+  private fun zeroCrossings(s: ShortArray, from: Int = 0): Int {
+    var n = 0
+    for (i in from + 1 until s.size) if ((s[i - 1] < 0) != (s[i] < 0)) n++
+    return n
+  }
+
+  @Test
+  fun passthroughAt16kMonoIsByteExact() {
+    val input = tone(16_000, 440.0, 0.1)
+    val out = PcmResampler(16_000).process(input, 16_000, 1)
+    assertThat(out).isEqualTo(input)
+  }
+
+  @Test
+  fun stereoDownmixAveragesChannels() {
+    val frames = 100
+    val input = ByteArray(frames * 4)
+    val bb = ByteBuffer.wrap(input).order(ByteOrder.LITTLE_ENDIAN)
+    for (i in 0 until frames) {
+      bb.putShort(1000)
+      bb.putShort(-1000)
+    }
+    val out = shorts(PcmResampler(16_000).process(input, 16_000, 2))
+    assertThat(out).hasSize(frames)
+    assertThat(out.all { it == 0.toShort() }).isTrue()
+  }
+
+  @Test
+  fun downsamples48kTo16kPreservingSpeechBandTone() {
+    val input = tone(48_000, 1000.0, 1.0)
+    val out = shorts(PcmResampler(16_000).process(input, 48_000, 1))
+    // 1 s at 16 kHz minus FIR warm-up (62 input samples ≈ 20 output samples).
+    assertThat(out.size).isBetween(16_000 - 30, 16_000)
+    val settle = 200
+    assertThat(rms(out, settle)).isBetween(8000 / sqrt(2.0) * 0.97, 8000 / sqrt(2.0) * 1.03)
+    // 1 kHz tone: 2000 zero crossings per second.
+    val seconds = (out.size - settle) / 16_000.0
+    assertThat(zeroCrossings(out, settle) / seconds).isBetween(1990.0, 2010.0)
+  }
+
+  @Test
+  fun downsamplingRejectsContentAboveOutputNyquist() {
+    // 20 kHz at 48 kHz would alias to 4 kHz at full amplitude with plain decimation.
+    val input = tone(48_000, 20_000.0, 1.0)
+    val out = shorts(PcmResampler(16_000).process(input, 48_000, 1))
+    assertThat(rms(out, 200)).isLessThan(8000 / sqrt(2.0) * 0.02)
+  }
+
+  @Test
+  fun chunkedInputMatchesContiguousInput() {
+    val input = tone(48_000, 700.0, 0.5)
+    val whole = shorts(PcmResampler(16_000).process(input, 48_000, 1))
+
+    val chunked = PcmResampler(16_000)
+    val pieces = ArrayList<Short>()
+    var offset = 0
+    val chunk = 960 // 10 ms at 48 kHz, WebRTC's callback size
+    while (offset < input.size) {
+      val end = minOf(input.size, offset + chunk)
+      pieces.addAll(shorts(chunked.process(input.copyOfRange(offset, end), 48_000, 1)).toList())
+      offset = end
+    }
+    assertThat(pieces.size).isEqualTo(whole.size)
+    for (i in whole.indices) {
+      assertThat(pieces[i].toInt()).isCloseTo(whole[i].toInt(), org.assertj.core.data.Offset.offset(1))
+    }
+  }
+
+  @Test
+  fun upsamplesWithoutFilterAndKeepsLength() {
+    val input = tone(8_000, 400.0, 0.5)
+    val out = shorts(PcmResampler(16_000).process(input, 8_000, 1))
+    assertThat(out.size).isBetween(8_000 - 4, 8_000)
+    assertThat(rms(out, 50)).isBetween(8000 / sqrt(2.0) * 0.95, 8000 / sqrt(2.0) * 1.03)
+  }
+
+  @Test
+  fun formatChangeResetsStateAndKeepsGoing() {
+    val r = PcmResampler(16_000)
+    r.process(tone(48_000, 1000.0, 0.1), 48_000, 1)
+    val out = shorts(r.process(tone(16_000, 1000.0, 0.1), 16_000, 1))
+    assertThat(out.size).isEqualTo(1600)
+  }
+
+  @Test
+  fun lowPassTapsAreUnityGainAtDc() {
+    val taps = PcmResampler.designLowPass(48_000, 16_000)
+    assertThat(taps.sum().toDouble()).isCloseTo(1.0, org.assertj.core.data.Offset.offset(1e-4))
+    assertThat(taps.size % 2).isEqualTo(1)
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/audio/UplinkPacerTest.kt

@@ -0,0 +1,201 @@
+package com.mentra.acsmeeting.audio
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class UplinkPacerTest {
+  private val frameBytes = UplinkPacer.FRAME_BYTES
+  private val tickNanos = UplinkPacer.FRAME_MS * 1_000_000L
+
+  /** Non-zero PCM so a manufactured silence frame is distinguishable. */
+  private fun tone(ms: Int): ByteArray = ByteArray(ms * UplinkPacer.BYTES_PER_MS) { 0x20 }
+
+  @Test
+  fun prerollGateHoldsUntilTargetDepth() {
+    val pacer = UplinkPacer()
+    var now = 0L
+    pacer.push(tone(40))
+    repeat(3) {
+      assertThat(pacer.tick(now).silence).isTrue()
+      now += tickNanos
+    }
+    assertThat(pacer.state()).isEqualTo(UplinkPacer.State.PREROLLING)
+    assertThat(pacer.depthMs()).isEqualTo(40)
+
+    pacer.push(tone(20))
+    assertThat(pacer.tick(now).silence).isFalse()
+    assertThat(pacer.state()).isEqualTo(UplinkPacer.State.RUNNING)
+  }
+
+  @Test
+  fun steadyStateSendsFiftyFramesPerSecondAtTargetDepth() {
+    val pacer = UplinkPacer()
+    var now = 0L
+    pacer.push(tone(UplinkPacer.TARGET_MS))
+    var audio = 0
+    repeat(500) {
+      if (!pacer.tick(now).silence) audio += 1
+      pacer.push(tone(UplinkPacer.FRAME_MS))
+      now += tickNanos
+    }
+
+    assertThat(audio).isEqualTo(500)
+    val stats = pacer.snapshot(now)
+    assertThat(stats.sentFps).isBetween(49.5, 50.5)
+    assertThat(stats.depthMs).isEqualTo(UplinkPacer.TARGET_MS)
+    assertThat(stats.silenceFrames).isEqualTo(0L)
+    assertThat(stats.driftCorrections).isEqualTo(0L)
+  }
+
+  @Test
+  fun burstIsSmoothedToOneFramePerTick() {
+    val pacer = UplinkPacer()
+    // One 100 ms delivery, as the WebRTC audio thread bursts it.
+    pacer.push(tone(100))
+    val frames = (0 until 5).map { pacer.tick(it * tickNanos) }
+
+    assertThat(frames.map { it.bytes.size }).containsOnly(frameBytes)
+    assertThat(frames.none { it.silence }).isTrue()
+    assertThat(pacer.depthMs()).isEqualTo(0)
+  }
+
+  @Test
+  fun underrunEmitsSilenceWithoutLeavingRunning() {
+    val pacer = UplinkPacer()
+    var now = 0L
+    pacer.push(tone(UplinkPacer.TARGET_MS))
+    repeat(3) {
+      pacer.tick(now)
+      now += tickNanos
+    }
+    assertThat(pacer.depthMs()).isEqualTo(0)
+
+    val frame = pacer.tick(now)
+    assertThat(frame.silence).isTrue()
+    assertThat(frame.bytes.size).isEqualTo(frameBytes)
+    assertThat(pacer.state()).isEqualTo(UplinkPacer.State.RUNNING)
+  }
+
+  @Test
+  fun prolongedOutageStarvesAndRebuildsHeadroomBeforeResuming() {
+    val pacer = UplinkPacer()
+    var now = 0L
+    pacer.push(tone(UplinkPacer.TARGET_MS))
+    repeat(3) {
+      pacer.tick(now)
+      now += tickNanos
+    }
+
+    // 1.5 s with no producer audio at all.
+    repeat(75) {
+      assertThat(pacer.tick(now).silence).isTrue()
+      now += tickNanos
+    }
+    assertThat(pacer.state()).isEqualTo(UplinkPacer.State.STARVED)
+
+    // Audio is back but below target: still silence, and no source audio is
+    // consumed, so the rebuild is not spent immediately.
+    pacer.push(tone(40))
+    assertThat(pacer.tick(now).silence).isTrue()
+    now += tickNanos
+    assertThat(pacer.state()).isEqualTo(UplinkPacer.State.STARVED)
+    assertThat(pacer.depthMs()).isEqualTo(40)
+
+    pacer.push(tone(20))
+    assertThat(pacer.tick(now).silence).isFalse()
+    assertThat(pacer.state()).isEqualTo(UplinkPacer.State.RUNNING)
+  }
+
+  @Test
+  fun depthAboveEmergencyCapDropsOldestDownToTarget() {
+    val pacer = UplinkPacer()
+    var now = 0L
+    pacer.push(tone(UplinkPacer.TARGET_MS))
+    pacer.tick(now)
+    now += tickNanos
+
+    pacer.push(tone(500))
+    assertThat(pacer.tick(now).silence).isFalse()
+    assertThat(pacer.controlDepthMs()).isEqualTo(UplinkPacer.TARGET_MS)
+    val stats = pacer.snapshot(now)
+    assertThat(stats.overflowDroppedMs).isEqualTo(480L)
+    assertThat(stats.driftCorrections).isEqualTo(0L)
+  }
+
+  @Test
+  fun fastProducerClockStaysInsideEnvelopeForAnHour() {
+    val run = simulateDrift(ppm = 300.0, minutes = 60)
+
+    assertThat(run.minControlMs).isGreaterThanOrEqualTo(UplinkPacer.LOW_MS)
+    assertThat(run.maxControlMs).isLessThanOrEqualTo(UplinkPacer.HIGH_MS + UplinkPacer.CORRECTION_MS)
+    assertThat(run.stats.silenceFrames).isEqualTo(0L)
+    assertThat(run.stats.overflowDroppedMs).isEqualTo(0L)
+    assertThat(run.stats.driftInsertedMs).isEqualTo(0L)
+    // 300 ppm over an hour is ~1080 ms of excess audio to shed.
+    assertThat(run.stats.driftDroppedMs).isBetween(900L, 1300L)
+    assertThat(run.stats.driftCorrections).isLessThan(200L)
+  }
+
+  @Test
+  fun slowProducerClockStaysInsideEnvelopeForAnHour() {
+    val run = simulateDrift(ppm = -300.0, minutes = 60)
+
+    assertThat(run.minControlMs).isGreaterThanOrEqualTo(UplinkPacer.LOW_MS - UplinkPacer.CORRECTION_MS)
+    assertThat(run.maxControlMs).isLessThanOrEqualTo(UplinkPacer.HIGH_MS)
+    assertThat(run.stats.silenceFrames).isEqualTo(0L)
+    assertThat(run.stats.overflowDroppedMs).isEqualTo(0L)
+    assertThat(run.stats.driftDroppedMs).isEqualTo(0L)
+    assertThat(run.stats.driftInsertedMs).isBetween(900L, 1300L)
+    assertThat(run.stats.driftCorrections).isLessThan(200L)
+  }
+
+  @Test
+  fun resetRearmsPreroll() {
+    val pacer = UplinkPacer()
+    pacer.push(tone(UplinkPacer.TARGET_MS))
+    pacer.tick(0)
+    assertThat(pacer.state()).isEqualTo(UplinkPacer.State.RUNNING)
+
+    pacer.reset()
+    assertThat(pacer.state()).isEqualTo(UplinkPacer.State.PREROLLING)
+    assertThat(pacer.depthMs()).isEqualTo(0)
+    assertThat(pacer.snapshot(0).framesEmitted).isEqualTo(0L)
+  }
+
+  private class DriftRun(
+    val minControlMs: Int,
+    val maxControlMs: Int,
+    val stats: UplinkPacer.Stats,
+  )
+
+  /**
+   * Runs [minutes] of call time with a producer clock offset by [ppm], one
+   * simulated 20 ms period per iteration. The pacer's injected clock is what
+   * makes an hour cost milliseconds.
+   */
+  private fun simulateDrift(ppm: Double, minutes: Int): DriftRun {
+    val pacer = UplinkPacer()
+    var now = 0L
+    var minMs = Int.MAX_VALUE
+    var maxMs = Int.MIN_VALUE
+    var owed = 0.0
+    val bytesPerTick = frameBytes * (1.0 + ppm / 1_000_000.0)
+    val ticks = minutes * 60 * 1000 / UplinkPacer.FRAME_MS
+
+    pacer.push(tone(UplinkPacer.TARGET_MS))
+    repeat(ticks) {
+      pacer.tick(now)
+      minMs = minOf(minMs, pacer.controlDepthMs())
+      maxMs = maxOf(maxMs, pacer.controlDepthMs())
+      owed += bytesPerTick
+      // Sample-aligned: PCM16 frames never split a sample.
+      val whole = (owed.toInt() / 2) * 2
+      if (whole > 0) {
+        pacer.push(ByteArray(whole) { 0x20 })
+        owed -= whole
+      }
+      now += tickNanos
+    }
+    return DriftRun(minMs, maxMs, pacer.snapshot(now))
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/audio/UplinkSenderTest.kt

@@ -0,0 +1,166 @@
+package com.mentra.acsmeeting.audio
+
+import java.util.Collections
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class UplinkSenderTest {
+  private fun tone(ms: Int): ByteArray = ByteArray(ms * UplinkPacer.BYTES_PER_MS) { 0x20 }
+
+  private class FakeTransport : UplinkTransport {
+    val sent = mutableListOf<ByteArray>()
+    private val pending = mutableListOf<(Throwable?) -> Unit>()
+    var autoComplete = true
+    var failWith: Throwable? = null
+
+    override fun send(frame: ByteArray, onComplete: (Throwable?) -> Unit) {
+      sent.add(frame)
+      if (autoComplete) onComplete(failWith) else pending.add(onComplete)
+    }
+
+    fun completeAll(error: Throwable? = null) {
+      val drained = pending.toList()
+      pending.clear()
+      drained.forEach { it(error) }
+    }
+  }
+
+  /** Preroll, then one 20 ms production per period: steady 60 ms of headroom. */
+  private fun pump(sender: UplinkSender, pacer: UplinkPacer, periods: Int, from: Int = 0) {
+    repeat(periods) {
+      sender.pumpOnce((from + it) * UplinkSender.PERIOD_NANOS)
+      pacer.push(tone(UplinkPacer.FRAME_MS))
+    }
+  }
+
+  @Test
+  fun aStallSendsOneFrameAndCountsSkippedTicks() {
+    val pacer = UplinkPacer()
+    val transport = FakeTransport()
+    val sender = UplinkSender(pacer, transport, clock = { 0L }, log = {})
+    pacer.push(tone(UplinkPacer.TARGET_MS))
+
+    sender.pumpOnce(0)
+    pacer.push(tone(UplinkPacer.FRAME_MS))
+    sender.pumpOnce(20_000_000L)
+    pacer.push(tone(UplinkPacer.FRAME_MS))
+    // 80 ms stall: this wake is 60 ms past its 40 ms deadline.
+    sender.pumpOnce(100_000_000L)
+
+    assertThat(transport.sent).hasSize(3)
+    val stats = sender.stats()
+    assertThat(stats.framesSubmitted).isEqualTo(3L)
+    assertThat(stats.skippedTicks).isEqualTo(3L)
+    assertThat(stats.tickLateMaxMs).isEqualTo(60L)
+
+    // The deadline is re-based on now, so the very next period is 20 ms out
+    // rather than three frames being replayed back to back.
+    pacer.push(tone(UplinkPacer.FRAME_MS))
+    sender.pumpOnce(120_000_000L)
+    assertThat(transport.sent).hasSize(4)
+    assertThat(sender.stats().skippedTicks).isEqualTo(3L)
+  }
+
+  @Test
+  fun everySubmissionGetsItsOwnStorageUntilCompletion() {
+    val pacer = UplinkPacer()
+    val transport = FakeTransport().apply { autoComplete = false }
+    val sender = UplinkSender(pacer, transport, clock = { 0L }, log = {})
+    pacer.push(tone(UplinkPacer.TARGET_MS))
+
+    pump(sender, pacer, 5)
+
+    assertThat(transport.sent).hasSize(5)
+    // ACS still holds all five, so no two may share an array.
+    val identities = transport.sent.mapTo(mutableSetOf()) { System.identityHashCode(it) }
+    assertThat(identities).hasSize(5)
+    assertThat(transport.sent).allSatisfy { frame ->
+      assertThat(frame).hasSize(UplinkPacer.FRAME_BYTES)
+      assertThat(frame.all { it == 0x20.toByte() }).isTrue()
+    }
+    assertThat(sender.stats().inFlight).isEqualTo(5)
+
+    transport.completeAll()
+    assertThat(sender.stats().inFlight).isEqualTo(0)
+    assertThat(sender.stats().sendFailures).isEqualTo(0L)
+  }
+
+  @Test
+  fun failedSendIsSurfacedNotSwallowed() {
+    val pacer = UplinkPacer()
+    val transport = FakeTransport().apply {
+      failWith = IllegalStateException("FAILED_TO_SEND_RAW_AUDIO_BUFFER")
+    }
+    val errors = mutableListOf<String>()
+    val sender = UplinkSender(
+      pacer,
+      transport,
+      clock = { 0L },
+      log = {},
+      logError = { message, _ -> errors.add(message) },
+    )
+    pacer.push(tone(UplinkPacer.TARGET_MS))
+
+    sender.pumpOnce(0)
+
+    assertThat(sender.stats().sendFailures).isEqualTo(1L)
+    assertThat(errors).hasSize(1)
+    assertThat(errors[0]).contains("sendRawAudioBuffer failed").contains("total=1")
+  }
+
+  @Test
+  fun backpressureStopsFeedingWhileAcsIsBehind() {
+    val pacer = UplinkPacer()
+    val transport = FakeTransport().apply { autoComplete = false }
+    val sender = UplinkSender(pacer, transport, clock = { 0L }, log = {})
+    pacer.push(tone(UplinkPacer.TARGET_MS))
+
+    pump(sender, pacer, UplinkSender.MAX_IN_FLIGHT + 5)
+
+    assertThat(transport.sent).hasSize(UplinkSender.MAX_IN_FLIGHT)
+    assertThat(sender.stats().backpressureDrops).isEqualTo(5L)
+
+    transport.completeAll()
+    pump(sender, pacer, 1, from = UplinkSender.MAX_IN_FLIGHT + 5)
+    assertThat(transport.sent).hasSize(UplinkSender.MAX_IN_FLIGHT + 1)
+  }
+
+  @Test
+  fun logsOneP8LinePerSecond() {
+    val pacer = UplinkPacer()
+    val logs = mutableListOf<String>()
+    val sender = UplinkSender(pacer, FakeTransport(), clock = { 0L }, log = { logs.add(it) })
+    pacer.push(tone(UplinkPacer.TARGET_MS))
+
+    // 0 .. 1980 ms: one 1 Hz boundary crossed.
+    pump(sender, pacer, 100)
+
+    val lines = logs.filter { it.startsWith("P8 audio-up state=") }
+    assertThat(lines).hasSize(1)
+    assertThat(lines[0])
+      .contains("state=RUNNING")
+      .contains("depthMs=60")
+      .contains("targetMs=60")
+      .contains("silenceFrames=0")
+      .contains("skippedTicks=0")
+      .contains("sendFailures=0")
+      .contains("backpressureDrops=0")
+  }
+
+  @Test
+  fun secondStartIsANoOp() {
+    val logs = Collections.synchronizedList(mutableListOf<String>())
+    val sender = UplinkSender(UplinkPacer(), FakeTransport(), clock = { 0L }, log = { logs.add(it) })
+
+    sender.start()
+    sender.start()
+    assertThat(sender.isRunning()).isTrue()
+    sender.stop()
+    sender.stop()
+
+    assertThat(sender.isRunning()).isFalse()
+    assertThat(logs.count { it.contains("sender started") }).isEqualTo(1)
+    assertThat(logs.count { it.contains("already started") }).isEqualTo(1)
+    assertThat(logs.count { it.contains("sender stopped") }).isEqualTo(1)
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/source/AcsInvestigationTest.kt

@@ -0,0 +1,26 @@
+package com.mentra.acsmeeting.source
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class AcsInvestigationTest {
+  @Test
+  fun videoArmDefaultsToWhep() {
+    assertThat(AcsInvestigation.videoArm).isEqualTo(VideoSourceArm.WHEP)
+  }
+
+  @Test
+  fun decoderModeDefaultsToTexture() {
+    assertThat(AcsInvestigation.decoderMode).isEqualTo(DecoderMode.TEXTURE)
+  }
+
+  @Test
+  fun zeroCopyDefaultsToOff() {
+    assertThat(AcsInvestigation.zeroCopy).isFalse()
+  }
+
+  @Test
+  fun pixelFormatDefaultsToI420() {
+    assertThat(AcsInvestigation.pixelFormat).isEqualTo(PixelFormatArm.I420)
+  }
+}