@mentra/acs-meeting 3.2.0-dev.120

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

@@ -0,0 +1,22 @@
+package com.mentra.acsmeeting.source
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+import java.nio.ByteBuffer
+
+class BitmapFontTest {
+  @Test
+  fun drawsOnPixelsForDigitEight() {
+    val width = 80
+    val height = 40
+    val dest = ByteBuffer.allocate(width * height)
+    BitmapFont.draw(dest, width, height, "8", 0, 0, 2, 0xEB.toByte())
+    var on = 0
+    for (i in 0 until dest.capacity()) {
+      if (dest.get(i) == 0xEB.toByte()) on += 1
+    }
+    assertThat(on).isGreaterThan(0)
+    assertThat(BitmapFont.textWidth(1, 2)).isEqualTo(5 * 2)
+    assertThat(BitmapFont.textHeight(2)).isEqualTo(7 * 2)
+  }
+}

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

@@ -0,0 +1,60 @@
+package com.mentra.acsmeeting.source
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class FirstFrameGateTest {
+  @Test
+  fun answerAloneDoesNotPromote() {
+    val gate = FirstFrameGate()
+    gate.arm(1)
+    // The answer is armed, not live: nothing has reached the sink yet.
+    assertThat(gate.expired(1)).isTrue()
+  }
+
+  @Test
+  fun firstFrameForTheArmedGenerationPromotesExactlyOnce() {
+    val gate = FirstFrameGate()
+    gate.arm(7)
+    assertThat(gate.onFrame(7)).isTrue()
+    assertThat(gate.onFrame(7)).isFalse()
+    assertThat(gate.expired(7)).isFalse()
+  }
+
+  @Test
+  fun framesFromAPeerBeingTornDownNeverPromote() {
+    val gate = FirstFrameGate()
+    gate.arm(2)
+    assertThat(gate.onFrame(1)).isFalse()
+    assertThat(gate.expired(2)).isTrue()
+  }
+
+  @Test
+  fun deadlineForASupersededGenerationDoesNotFailTheNewPeer() {
+    val gate = FirstFrameGate()
+    gate.arm(3)
+    gate.arm(4)
+    assertThat(gate.expired(3)).isFalse()
+    assertThat(gate.expired(4)).isTrue()
+  }
+
+  @Test
+  fun iceRecoveryRearmsSoTheNextFramePromotesAgain() {
+    val gate = FirstFrameGate()
+    gate.arm(5)
+    assertThat(gate.onFrame(5)).isTrue()
+    // ICE bounced and came back on the same peer: LIVE has to be re-earned.
+    gate.arm(5)
+    assertThat(gate.expired(5)).isTrue()
+    assertThat(gate.onFrame(5)).isTrue()
+  }
+
+  @Test
+  fun resetClearsTheArmSoAStoppedSourceCannotBeFailedLater() {
+    val gate = FirstFrameGate()
+    gate.arm(6)
+    gate.reset()
+    assertThat(gate.expired(6)).isFalse()
+    assertThat(gate.onFrame(6)).isFalse()
+  }
+}

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

@@ -0,0 +1,133 @@
+package com.mentra.acsmeeting.source
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class FakeGlassesMediaSource : GlassesMediaSource {
+  val started = mutableListOf<SourceConfig>()
+  val restarted = mutableListOf<SourceConfig>()
+  var stopped = 0
+  var pcmEnabled = true
+  var pcmListener: PcmListener? = null
+  val targetSizes = mutableListOf<TargetSize?>()
+  override var state: SourceState = SourceState.IDLE
+    private set
+
+  override fun start(config: SourceConfig) {
+    started.add(config)
+    state = SourceState.CONNECTING
+    state = SourceState.LIVE
+  }
+
+  override fun restart(config: SourceConfig) {
+    restarted.add(config)
+    start(config)
+  }
+
+  override fun stop() {
+    stopped += 1
+    state = SourceState.IDLE
+  }
+
+  override fun setPcmDeliveryEnabled(enabled: Boolean) {
+    pcmEnabled = enabled
+  }
+
+  override fun setTargetSize(size: TargetSize?) {
+    targetSizes.add(size)
+  }
+
+  fun emitPcm(pcm: ByteArray, sampleRate: Int = 16_000, channels: Int = 1) {
+    if (pcmEnabled && state == SourceState.LIVE) {
+      pcmListener?.onPcm(pcm, sampleRate, channels)
+    }
+  }
+}
+
+class GlassesMediaSourceContractTest {
+  private fun contract(source: FakeGlassesMediaSource) {
+    val pcm = mutableListOf<ByteArray>()
+    source.pcmListener = PcmListener { bytes, _, _ -> pcm.add(bytes) }
+    val controller = GlassesMediaController { _, listener ->
+      source.pcmListener = listener
+      source
+    }
+
+    assertThat(controller.state).isEqualTo(SourceState.IDLE)
+    controller.attach(
+      video = VideoFrameListener { _ -> },
+      pcm = { bytes, _, _ -> pcm.add(bytes) },
+      config = SourceConfig("https://example.com/whep"),
+    )
+    assertThat(source.started).containsExactly(SourceConfig("https://example.com/whep"))
+    assertThat(controller.state).isEqualTo(SourceState.LIVE)
+
+    source.emitPcm(byteArrayOf(1, 2, 3, 4))
+    assertThat(pcm).hasSize(1)
+
+    controller.setPcmDeliveryEnabled(false)
+    source.emitPcm(byteArrayOf(9, 9))
+    assertThat(pcm).hasSize(1)
+
+    controller.restart(SourceConfig("https://example.com/whep-2"))
+    assertThat(source.restarted.map { it.url }).contains("https://example.com/whep-2")
+    assertThat(controller.state).isEqualTo(SourceState.LIVE)
+
+    controller.setTargetSize(TargetSize(1280, 720))
+    assertThat(source.targetSizes).contains(TargetSize(1280, 720))
+
+    controller.stop()
+    assertThat(source.stopped).isGreaterThanOrEqualTo(1)
+    assertThat(controller.state).isEqualTo(SourceState.IDLE)
+  }
+
+  @Test
+  fun fakeSourceHonorsStartRestartStopPcmAndState() {
+    contract(FakeGlassesMediaSource())
+  }
+
+  @Test
+  fun sameUrlIsReusedUntilTheSubscriberFails() {
+    val url = "https://example.com/whep"
+    val config = SourceConfig(url)
+    // A resumed glasses uplink re-sends the same URL. ACS never lost its
+    // subscription, so rebuilding would only restart the wait for a first frame.
+    assertThat(canReuseSource(url, SourceState.LIVE, config)).isTrue()
+    // Includes the answer → first frame window, which LIVE no longer covers.
+    assertThat(canReuseSource(url, SourceState.CONNECTING, config)).isTrue()
+    // ICE dropped, or the answer never produced a frame: rebuild.
+    assertThat(canReuseSource(url, SourceState.FAILED, config)).isFalse()
+    // A new stream means a new WHEP URL, and a stopped source has none.
+    assertThat(canReuseSource(url, SourceState.LIVE, SourceConfig("https://example.com/whep-2"))).isFalse()
+    assertThat(canReuseSource(null, SourceState.IDLE, config)).isFalse()
+    assertThat(canReuseSource(url, SourceState.LIVE, SourceConfig(url, SourceKind.DIRECT))).isFalse()
+  }
+
+  @Test
+  fun syntheticSourceHonorsStartRestartStopAndState() {
+    val source = SyntheticI420Source(
+      video = { _ -> },
+      stats = com.mentra.acsmeeting.telemetry.PipelineStats(),
+      isReady = { false },
+    )
+    val controller = GlassesMediaController { _, _ -> source }
+
+    assertThat(controller.state).isEqualTo(SourceState.IDLE)
+    controller.attach(
+      video = { _ -> },
+      pcm = { _, _, _ -> },
+      config = SourceConfig("https://example.com/whep", SourceKind.DIRECT),
+    )
+    assertThat(controller.state).isEqualTo(SourceState.LIVE)
+
+    controller.setPcmDeliveryEnabled(false)
+    assertThat(source.pcmDeliveryEnabled()).isFalse()
+
+    controller.restart(SourceConfig("https://example.com/whep-2", SourceKind.DIRECT))
+    assertThat(controller.state).isEqualTo(SourceState.LIVE)
+
+    controller.setTargetSize(TargetSize(1280, 720))
+    controller.stop()
+    assertThat(controller.state).isEqualTo(SourceState.IDLE)
+  }
+}

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

@@ -0,0 +1,67 @@
+package com.mentra.acsmeeting.source
+
+import com.mentra.acsmeeting.video.I420Packer
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+import java.nio.ByteBuffer
+
+class I420PlanesTest {
+  @Test
+  fun tightWhenStridesMatchWidth() {
+    val planes = planes(width = 8, height = 4, strideY = 8, strideUv = 4, direct = false)
+    assertThat(planes.isTight()).isTrue()
+    assertThat(planes.planesReadable()).isTrue()
+  }
+
+  @Test
+  fun paddedWhenStrideExceedsWidth() {
+    val planes = planes(width = 8, height = 4, strideY = 16, strideUv = 8, direct = false)
+    assertThat(planes.isTight()).isFalse()
+    assertThat(planes.planesReadable()).isTrue()
+  }
+
+  @Test
+  fun heapBuffersAreNotDirect() {
+    val planes = planes(width = 4, height = 4, strideY = 4, strideUv = 2, direct = false)
+    assertThat(planes.isDirect()).isFalse()
+  }
+
+  @Test
+  fun directBuffersReportDirect() {
+    val planes = planes(width = 4, height = 4, strideY = 4, strideUv = 2, direct = true)
+    assertThat(planes.isDirect()).isTrue()
+  }
+
+  @Test
+  fun shortPlaneIsNotReadable() {
+    val y = ByteBuffer.allocate(4)
+    val u = ByteBuffer.allocate(2)
+    val v = ByteBuffer.allocate(2)
+    val planes = I420Planes(y, 8, u, 4, v, 4, 8, 4, 0L)
+    assertThat(planes.planesReadable()).isFalse()
+    assertThat(I420Packer.planeMinBytes(8, 8, 4)).isEqualTo(32)
+  }
+
+  private fun planes(
+    width: Int,
+    height: Int,
+    strideY: Int,
+    strideUv: Int,
+    direct: Boolean,
+  ): I420Planes {
+    val chromaH = I420Packer.chromaStride(height)
+    fun alloc(bytes: Int): ByteBuffer =
+      if (direct) ByteBuffer.allocateDirect(bytes) else ByteBuffer.allocate(bytes)
+    return I420Planes(
+      y = alloc(strideY * height),
+      strideY = strideY,
+      u = alloc(strideUv * chromaH),
+      strideU = strideUv,
+      v = alloc(strideUv * chromaH),
+      strideV = strideUv,
+      width = width,
+      height = height,
+      timestampNs = 0L,
+    )
+  }
+}

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

@@ -0,0 +1,193 @@
+package com.mentra.acsmeeting.source
+
+import com.mentra.acsmeeting.telemetry.ChromaProbe
+import com.mentra.acsmeeting.video.I420Packer
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+import java.nio.ByteBuffer
+
+class SyntheticFrameFactoryTest {
+  @Test
+  fun packedLengthMatchesI420() {
+    val dest = buffer(WIDTH, HEIGHT)
+    SyntheticFrameFactory().write(dest, WIDTH, HEIGHT, 0)
+    assertThat(dest.remaining()).isEqualTo(I420Packer.packedSize(WIDTH, HEIGHT))
+  }
+
+  /**
+   * Regression for the 1.4 fps wire collapse: a noisy CHEAP background is
+   * incompressible and starves the ACS encoder. CHEAP must stay flat.
+   */
+  @Test
+  fun cheapBackgroundStaysCompressible() {
+    val dest = buffer(WIDTH, HEIGHT)
+    SyntheticFrameFactory(SyntheticEntropy.CHEAP).write(dest, WIDTH, HEIGHT, 0)
+    val y = yBytes(dest)
+    var background = 0
+    for (row in HEIGHT - 40 until HEIGHT) {
+      val rowOff = row * WIDTH
+      for (col in 0 until WIDTH) {
+        if (y[rowOff + col] == SyntheticFrameFactory.BG_Y) background += 1
+      }
+    }
+    assertThat(background).isGreaterThan(30 * WIDTH)
+  }
+
+  @Test
+  fun consecutiveCheapFramesDifferInY() {
+    val a = buffer(WIDTH, HEIGHT)
+    val b = buffer(WIDTH, HEIGHT)
+    val factory = SyntheticFrameFactory(SyntheticEntropy.CHEAP)
+    factory.write(a, WIDTH, HEIGHT, 0)
+    factory.write(b, WIDTH, HEIGHT, 1)
+    assertThat(yBytes(a)).isNotEqualTo(yBytes(b))
+  }
+
+  @Test
+  fun cheapIsDeterministicForAGivenIndex() {
+    val a = buffer(WIDTH, HEIGHT)
+    val b = buffer(WIDTH, HEIGHT)
+    SyntheticFrameFactory(SyntheticEntropy.CHEAP).write(a, WIDTH, HEIGHT, 7)
+    SyntheticFrameFactory(SyntheticEntropy.CHEAP).write(b, WIDTH, HEIGHT, 7)
+    assertThat(copy(a)).isEqualTo(copy(b))
+  }
+
+  @Test
+  fun incrementalCheapMatchesFreshWrite() {
+    val stepped = buffer(WIDTH, HEIGHT)
+    val fresh = buffer(WIDTH, HEIGHT)
+    val factory = SyntheticFrameFactory(SyntheticEntropy.CHEAP)
+    factory.write(stepped, WIDTH, HEIGHT, 0)
+    factory.write(stepped, WIDTH, HEIGHT, 1)
+    SyntheticFrameFactory(SyntheticEntropy.CHEAP).write(fresh, WIDTH, HEIGHT, 1)
+    assertThat(copy(stepped)).isEqualTo(copy(fresh))
+  }
+
+  @Test
+  fun chromaAveragesLandAt128() {
+    for (entropy in SyntheticEntropy.entries) {
+      val dest = buffer(WIDTH, HEIGHT)
+      SyntheticFrameFactory(entropy).write(dest, WIDTH, HEIGHT, 3)
+      val sample = ChromaProbe.samplePacked(dest, WIDTH, HEIGHT)
+      assertThat(sample.u).isEqualTo(128)
+      assertThat(sample.v).isEqualTo(128)
+    }
+  }
+
+  @Test
+  fun motionPansAlmostEveryPixel() {
+    val a = buffer(WIDTH, HEIGHT)
+    val b = buffer(WIDTH, HEIGHT)
+    val factory = SyntheticFrameFactory(SyntheticEntropy.MOTION)
+    factory.write(a, WIDTH, HEIGHT, 0)
+    factory.write(b, WIDTH, HEIGHT, 1)
+    val ya = yBytes(a)
+    val yb = yBytes(b)
+    var differ = 0
+    for (i in ya.indices) if (ya[i] != yb[i]) differ += 1
+    assertThat(differ).isGreaterThan(ya.size / 2)
+  }
+
+  /**
+   * Glasses motion still has neighbors that look alike. A 32×32 patch in the
+   * corner must stay a gradient, not snow — that is what lets an I-frame fit
+   * the bitrate budget.
+   */
+  @Test
+  fun motionKeepsSpatialStructure() {
+    val dest = buffer(WIDTH, HEIGHT)
+    SyntheticFrameFactory(SyntheticEntropy.MOTION).write(dest, WIDTH, HEIGHT, 0)
+    val y = yBytes(dest)
+    val unique = mutableSetOf<Byte>()
+    for (row in HEIGHT - 80 until HEIGHT - 48) {
+      val rowOff = row * WIDTH
+      for (col in 0 until 32) unique.add(y[rowOff + col])
+    }
+    assertThat(unique.size).isLessThan(40)
+  }
+
+  @Test
+  fun motionIsDeterministicForAGivenIndex() {
+    val a = buffer(WIDTH, HEIGHT)
+    val b = buffer(WIDTH, HEIGHT)
+    SyntheticFrameFactory(SyntheticEntropy.MOTION).write(a, WIDTH, HEIGHT, 11)
+    SyntheticFrameFactory(SyntheticEntropy.MOTION).write(b, WIDTH, HEIGHT, 11)
+    assertThat(copy(a)).isEqualTo(copy(b))
+  }
+
+  @Test
+  fun noiseRewritesTheFullYPlane() {
+    val a = buffer(WIDTH, HEIGHT)
+    val b = buffer(WIDTH, HEIGHT)
+    val factory = SyntheticFrameFactory(SyntheticEntropy.NOISE)
+    factory.write(a, WIDTH, HEIGHT, 0)
+    factory.write(b, WIDTH, HEIGHT, 1)
+    val ya = yBytes(a)
+    val yb = yBytes(b)
+    var differ = 0
+    for (i in ya.indices) if (ya[i] != yb[i]) differ += 1
+    assertThat(differ).isGreaterThan(ya.size / 2)
+  }
+
+  @Test
+  fun stampPaintsFrameIdAndFpsOnADarkBox() {
+    val dest = buffer(WIDTH, HEIGHT)
+    SyntheticFrameFactory(SyntheticEntropy.CHEAP).write(dest, WIDTH, HEIGHT, 42, 15.0)
+    val y = yBytes(dest)
+    val boxX = WIDTH / 16
+    val boxY = HEIGHT / 2 - 80
+    var dark = 0
+    var bright = 0
+    for (row in boxY until boxY + 160) {
+      val rowOff = row * WIDTH
+      for (col in boxX until boxX + 400) {
+        val value = y[rowOff + col].toInt() and 0xFF
+        if (value <= 20) dark += 1
+        if (value >= 220) bright += 1
+      }
+    }
+    assertThat(dark).isGreaterThan(1_000)
+    assertThat(bright).isGreaterThan(200)
+  }
+
+  @Test
+  fun stampFrameIndexChangesTheOverlay() {
+    val a = buffer(WIDTH, HEIGHT)
+    val b = buffer(WIDTH, HEIGHT)
+    SyntheticFrameFactory(SyntheticEntropy.CHEAP).write(a, WIDTH, HEIGHT, 1, 15.0)
+    SyntheticFrameFactory(SyntheticEntropy.CHEAP).write(b, WIDTH, HEIGHT, 2, 15.0)
+    assertThat(copy(a)).isNotEqualTo(copy(b))
+  }
+
+  @Test
+  fun noiseIsDeterministicForAGivenIndex() {
+    val a = buffer(WIDTH, HEIGHT)
+    val b = buffer(WIDTH, HEIGHT)
+    SyntheticFrameFactory(SyntheticEntropy.NOISE).write(a, WIDTH, HEIGHT, 11)
+    SyntheticFrameFactory(SyntheticEntropy.NOISE).write(b, WIDTH, HEIGHT, 11)
+    assertThat(copy(a)).isEqualTo(copy(b))
+  }
+
+  private fun buffer(width: Int, height: Int): ByteBuffer =
+    ByteBuffer.allocate(I420Packer.packedSize(width, height))
+
+  private fun yBytes(src: ByteBuffer): ByteArray {
+    val view = src.duplicate()
+    view.position(0)
+    val y = ByteArray(WIDTH * HEIGHT)
+    view.get(y)
+    return y
+  }
+
+  private fun copy(src: ByteBuffer): ByteArray {
+    val view = src.duplicate()
+    val out = ByteArray(view.remaining())
+    view.get(out)
+    return out
+  }
+
+  companion object {
+    private const val WIDTH = 1280
+    private const val HEIGHT = 720
+  }
+}

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

@@ -0,0 +1,176 @@
+package com.mentra.acsmeeting.source
+
+import com.mentra.acsmeeting.telemetry.PipelineStats
+import com.mentra.acsmeeting.video.I420Packer
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+import java.util.concurrent.atomic.AtomicBoolean
+
+class SyntheticI420SourceTest {
+  @Test
+  fun withheldWhileNotReadyThenEmitsOnceReady() {
+    val ready = AtomicBoolean(false)
+    val frames = ArrayList<Triple<Int, Int, Int>>()
+    val stats = PipelineStats()
+    val source = source(stats, ready) { planes ->
+      frames.add(Triple(I420Planes.remaining(planes.y) + I420Planes.remaining(planes.u) + I420Planes.remaining(planes.v), planes.width, planes.height))
+    }
+    source.becomeLive()
+    source.setTargetSize(TargetSize(1280, 720))
+
+    assertThat(source.emitOnce()).isFalse()
+    assertThat(frames).isEmpty()
+    assertThat(stats.sinkCount()).isEqualTo(0)
+
+    ready.set(true)
+    assertThat(source.emitOnce()).isTrue()
+    assertThat(frames).hasSize(1)
+    assertThat(frames[0].second).isEqualTo(1280)
+    assertThat(frames[0].third).isEqualTo(720)
+    assertThat(frames[0].first).isEqualTo(I420Packer.packedSize(1280, 720))
+    assertThat(stats.sinkCount()).isEqualTo(1)
+    assertThat(source.events.any { it.startsWith("P6 synthetic first-frame") }).isTrue()
+  }
+
+  @Test
+  fun withheldWhileTargetSizeIsNull() {
+    val frames = ArrayList<Int>()
+    val stats = PipelineStats()
+    val source = source(stats, AtomicBoolean(true)) { _ -> frames.add(1) }
+    source.becomeLive()
+
+    assertThat(source.emitOnce()).isFalse()
+    assertThat(frames).isEmpty()
+    assertThat(stats.sinkCount()).isEqualTo(0)
+
+    source.setTargetSize(TargetSize(640, 360))
+    assertThat(source.emitOnce()).isTrue()
+    assertThat(frames).hasSize(1)
+  }
+
+  @Test
+  fun nReadyCallsDeliverNFramesAndHonorResize() {
+    val frames = ArrayList<Pair<Int, Int>>()
+    val stats = PipelineStats()
+    val source = source(stats, AtomicBoolean(true)) { planes -> frames.add(planes.width to planes.height) }
+    source.becomeLive()
+    source.setTargetSize(TargetSize(1280, 720))
+    repeat(4) { source.emitOnce() }
+    source.setTargetSize(TargetSize(640, 360))
+    source.emitOnce()
+
+    assertThat(frames).containsExactly(
+      1280 to 720,
+      1280 to 720,
+      1280 to 720,
+      1280 to 720,
+      640 to 360,
+    )
+    assertThat(stats.sinkCount()).isEqualTo(5)
+  }
+
+  @Test
+  fun withheldTicksTouchNoCounters() {
+    val stats = PipelineStats()
+    val source = source(stats, AtomicBoolean(false)) { _ -> }
+    source.becomeLive()
+    source.setTargetSize(TargetSize(1280, 720))
+    repeat(5) { source.emitOnce() }
+    assertThat(stats.sinkCount()).isEqualTo(0)
+    assertThat(stats.dropCount()).isEqualTo(0)
+    assertThat(stats.subCount()).isEqualTo(0)
+    assertThat(stats.pack.p95()).isEqualTo("na")
+  }
+
+  @Test
+  fun readinessFlapProducesOnePauseAndOneResume() {
+    val ready = AtomicBoolean(true)
+    val source = source(PipelineStats(), ready) { _ -> }
+    source.becomeLive()
+    source.setTargetSize(TargetSize(1280, 720))
+    source.emitOnce()
+    ready.set(false)
+    source.emitOnce()
+    ready.set(true)
+    source.emitOnce()
+
+    val pauses = source.events.filter { it.contains("paused") }
+    val resumes = source.events.filter { it.contains("resumed") }
+    assertThat(pauses).hasSize(1)
+    assertThat(resumes).hasSize(1)
+  }
+
+  @Test
+  fun stopEmitsNothingAndRestartResetsIndex() {
+    val indexes = ArrayList<Int>()
+    val ready = AtomicBoolean(true)
+    val source = source(PipelineStats(), ready) { planes ->
+      indexes.add(yCorner(planes))
+    }
+    source.becomeLive()
+    source.setTargetSize(TargetSize(64, 64))
+    source.emitOnce()
+    source.emitOnce()
+    source.stop()
+    assertThat(source.state).isEqualTo(SourceState.IDLE)
+    assertThat(source.emitOnce()).isFalse()
+
+    source.becomeLive()
+    source.setTargetSize(TargetSize(64, 64))
+    source.emitOnce()
+    assertThat(indexes).hasSize(3)
+    assertThat(indexes[0]).isEqualTo(indexes[2])
+  }
+
+  @Test
+  fun restartLeavesSourceLive() {
+    val source = source(PipelineStats(), AtomicBoolean(false)) { _ -> }
+    source.start(SourceConfig("ignored", SourceKind.DIRECT))
+    source.restart(SourceConfig("ignored-2", SourceKind.DIRECT))
+    assertThat(source.state).isEqualTo(SourceState.LIVE)
+    source.stop()
+    assertThat(source.state).isEqualTo(SourceState.IDLE)
+  }
+
+  @Test
+  fun pcmListenerIsNeverInvoked() {
+    val source = SyntheticI420Source(
+      video = { _ -> },
+      stats = PipelineStats(),
+      isReady = { true },
+    )
+    source.setPcmDeliveryEnabled(true)
+    assertThat(source.pcmDeliveryEnabled()).isTrue()
+    source.setPcmDeliveryEnabled(false)
+    assertThat(source.pcmDeliveryEnabled()).isFalse()
+  }
+
+  private fun source(
+    stats: PipelineStats,
+    ready: AtomicBoolean,
+    video: VideoFrameListener,
+  ): SyntheticI420Source = SyntheticI420Source(
+    video = video,
+    stats = stats,
+    isReady = { ready.get() },
+  )
+
+  @Test
+  fun emitsTightStridePlanesAliasingThePackedBuffer() {
+    val seen = ArrayList<I420Planes>()
+    val source = source(PipelineStats(), AtomicBoolean(true)) { seen.add(it) }
+    source.becomeLive()
+    source.setTargetSize(TargetSize(64, 64))
+    assertThat(source.emitOnce()).isTrue()
+    val planes = seen.single()
+    assertThat(planes.isTight()).isTrue()
+    assertThat(planes.retain == null).isTrue()
+    assertThat(planes.release == null).isTrue()
+    assertThat(I420Planes.remaining(planes.y)).isEqualTo(64 * 64)
+    assertThat(I420Planes.remaining(planes.u)).isEqualTo(32 * 32)
+  }
+
+  private fun yCorner(planes: I420Planes): Int {
+    return planes.y.duplicate().get(0).toInt() and 0xFF
+  }
+}

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

@@ -0,0 +1,36 @@
+package com.mentra.acsmeeting.source
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class TrackRegistryTest {
+  @Test
+  fun threeClaimsOfOneIdYieldTrueFalseFalse() {
+    val registry = TrackRegistry()
+    assertThat(registry.claim("track-a")).isTrue()
+    assertThat(registry.claim("track-a")).isFalse()
+    assertThat(registry.claim("track-a")).isFalse()
+    assertThat(registry.size()).isEqualTo(1)
+    assertThat(registry.skipped()).isEqualTo(2)
+  }
+
+  @Test
+  fun distinctIdsEachClaimOnce() {
+    val registry = TrackRegistry()
+    assertThat(registry.claim("video")).isTrue()
+    assertThat(registry.claim("audio")).isTrue()
+    assertThat(registry.size()).isEqualTo(2)
+    assertThat(registry.skipped()).isEqualTo(0)
+  }
+
+  @Test
+  fun resetMakesTheSameIdClaimableAgain() {
+    val registry = TrackRegistry()
+    assertThat(registry.claim("track-a")).isTrue()
+    registry.reset()
+    assertThat(registry.size()).isEqualTo(0)
+    assertThat(registry.skipped()).isEqualTo(0)
+    assertThat(registry.claim("track-a")).isTrue()
+    assertThat(registry.size()).isEqualTo(1)
+  }
+}