@mentra/acs-meeting 3.2.0-dev.120

package/android/src/test/java/com/mentra/acsmeeting/telemetry/ChromaProbeTest.kt

@@ -0,0 +1,61 @@
+package com.mentra.acsmeeting.telemetry
+
+import com.mentra.acsmeeting.video.I420Packer
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+import java.nio.ByteBuffer
+
+class ChromaProbeTest {
+  @Test
+  fun packedNeutralAveragesNearMidChroma() {
+    val width = 8
+    val height = 8
+    val packed = ByteBuffer.allocate(I420Packer.packedSize(width, height))
+    val ySize = width * height
+    val uvSize = I420Packer.chromaStride(width) * I420Packer.chromaStride(height)
+    repeat(ySize) { packed.put(100.toByte()) }
+    repeat(uvSize) { packed.put(128.toByte()) }
+    repeat(uvSize) { packed.put(128.toByte()) }
+    packed.flip()
+    val sample = ChromaProbe.samplePacked(packed, width, height)
+    assertThat(sample.y).isEqualTo(100)
+    assertThat(sample.u).isEqualTo(128)
+    assertThat(sample.v).isEqualTo(128)
+  }
+
+  @Test
+  fun samplePlanesAgreesWithSamplePacked() {
+    val width = 8
+    val height = 8
+    val packed = ByteBuffer.allocate(I420Packer.packedSize(width, height))
+    val ySize = width * height
+    val uvSize = I420Packer.chromaStride(width) * I420Packer.chromaStride(height)
+    repeat(ySize) { packed.put(90.toByte()) }
+    repeat(uvSize) { packed.put(130.toByte()) }
+    repeat(uvSize) { packed.put(126.toByte()) }
+    packed.flip()
+    val packedSample = ChromaProbe.samplePacked(packed, width, height)
+    val y = packed.duplicate().apply { position(0); limit(ySize) }.slice()
+    val u = packed.duplicate().apply { position(ySize); limit(ySize + uvSize) }.slice()
+    val v = packed.duplicate().apply { position(ySize + uvSize); limit(ySize + 2 * uvSize) }.slice()
+    val planeSample = ChromaProbe.samplePlanes(y, u, v)
+    assertThat(planeSample).isEqualTo(packedSample)
+  }
+
+  @Test
+  fun sampleNv12SeparatesInterleavedChroma() {
+    val y = ByteBuffer.allocate(8)
+    repeat(8) { y.put(100.toByte()) }
+    y.flip()
+    val uv = ByteBuffer.allocate(8)
+    for (i in 0 until 4) {
+      uv.put(130.toByte())
+      uv.put(126.toByte())
+    }
+    uv.flip()
+    val sample = ChromaProbe.sampleNv12(y, uv)
+    assertThat(sample.y).isEqualTo(100)
+    assertThat(sample.u).isEqualTo(130)
+    assertThat(sample.v).isEqualTo(126)
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/telemetry/PipelineStatsTest.kt

@@ -0,0 +1,256 @@
+package com.mentra.acsmeeting.telemetry
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class PipelineStatsTest {
+  @Test
+  fun conservationHoldsAcrossEveryDisposition() {
+    val stats = PipelineStats()
+    repeat(4) { stats.onSink() }
+    stats.onQueued(); stats.onSub()
+    stats.onDropSize()
+    stats.onDropBusy()
+    stats.onDropNullI420()
+    assertThat(stats.conserved()).isTrue()
+    assertThat(stats.sinkCount()).isEqualTo(4)
+    assertThat(stats.subCount()).isEqualTo(1)
+    assertThat(stats.dropCount()).isEqualTo(3)
+    assertThat(stats.inFlightCount()).isEqualTo(0)
+  }
+
+  @Test
+  fun latencyStraddleIsOneHundredPercentOverTenTicks() {
+    var clock = 0L
+    val stats = PipelineStats { clock }
+    val ticks = ArrayList<String>()
+    stats.onSink()
+    stats.onQueued()
+    clock += 1000
+    ticks.add(stats.tick())
+    stats.onSub()
+    repeat(9) {
+      clock += 1000
+      ticks.add(stats.tick())
+    }
+    assertThat(stats.subCount()).isEqualTo(stats.sinkCount())
+    assertThat(stats.conserved()).isTrue()
+    val last = ticks.last()
+    assertThat(last).contains("cum{sink=1 sub=1 drop=0 inFlight=0}")
+    assertThat(last).doesNotContain("CONSERVE_FAIL")
+  }
+
+  @Test
+  fun cumulativeCountersNeverDecrease() {
+    var clock = 0L
+    val stats = PipelineStats { clock }
+    stats.onSink(); stats.onQueued(); stats.onSub()
+    clock += 1000
+    val first = stats.tick()
+    clock += 1000
+    val idle = stats.tick()
+    assertThat(extractCum(first)).isEqualTo(extractCum(idle))
+    assertThat(stats.sinkCount()).isEqualTo(1)
+    assertThat(stats.subCount()).isEqualTo(1)
+  }
+
+  @Test
+  fun idleTickStillEmitsSinkZero() {
+    var clock = 0L
+    val stats = PipelineStats { clock }
+    clock += 1000
+    val line = stats.tick()
+    assertThat(line).startsWith("P6 ladder")
+    assertThat(line).contains("sink=0.0")
+    assertThat(line).contains("dec=na")
+    assertThat(line).contains("wire=0x0@na kbps=na codec=na")
+    assertThat(line).contains("drop{")
+    assertThat(line).contains("ms{")
+    assertThat(line).contains("chroma{")
+    assertThat(line).contains("cum{sink=0 sub=0 drop=0 inFlight=0}")
+  }
+
+  @Test
+  fun queuedFrameCountsAsInFlightUntilSettled() {
+    val stats = PipelineStats()
+    stats.onSink()
+    stats.onQueued()
+    assertThat(stats.conserved()).isTrue()
+    assertThat(stats.inFlightCount()).isEqualTo(1)
+    stats.onSub()
+    assertThat(stats.inFlightCount()).isEqualTo(0)
+    assertThat(stats.conserved()).isTrue()
+  }
+
+  /**
+   * The device logged 14 CONSERVE_FAIL lines on a pipeline with zero drops.
+   * Cause was a tracked inFlight counter read mid-settle, not lost frames.
+   */
+  @Test
+  fun concurrentSendsNeverReportConserveFail() {
+    val stats = PipelineStats { 0L }
+    val sender = Thread {
+      repeat(20_000) {
+        stats.onSink()
+        stats.onQueued()
+        stats.onSub()
+      }
+    }
+    val failures = ArrayList<String>()
+    val reader = Thread {
+      repeat(20_000) {
+        if (!stats.conserved()) failures.add("inFlight=${stats.inFlightCount()}")
+      }
+    }
+    sender.start(); reader.start()
+    sender.join(); reader.join()
+    assertThat(failures).isEmpty()
+    assertThat(stats.inFlightCount()).isEqualTo(0)
+    assertThat(stats.tick()).doesNotContain("CONSERVE_FAIL")
+  }
+
+  @Test
+  fun recvHealthReportsDeltasNotAbsolutes() {
+    val stats = PipelineStats { 0L }
+    assertThat(stats.recvLabel()).isEqualTo("recv{na}")
+    stats.setRecvHealth(
+      PipelineStats.RecvHealth(assembled = 100, dropped = 5, packetsLost = 40, nack = 7, pli = 2, freezes = 1),
+    )
+    assertThat(stats.recvLabel()).contains("drop=5", "lost=40", "nack=7", "pli=2", "freeze=1")
+    stats.setRecvHealth(
+      PipelineStats.RecvHealth(assembled = 115, dropped = 5, packetsLost = 52, nack = 9, pli = 2, freezes = 3),
+    )
+    assertThat(stats.recvLabel()).contains("drop=0", "lost=12", "nack=2", "pli=0", "freeze=2")
+  }
+
+  @Test
+  fun recvHealthAveragesPerFrameTimings() {
+    val stats = PipelineStats { 0L }
+    stats.setRecvHealth(
+      PipelineStats.RecvHealth(
+        assembled = 200,
+        decodeSec = 0.8,
+        jitterBufferSec = 12.0,
+        jitterBufferEmits = 200,
+        jitter = 0.015,
+      ),
+    )
+    val label = stats.recvLabel()
+    assertThat(label).contains("decMs=4.0")
+    assertThat(label).contains("jbMs=60.0")
+    assertThat(label).contains("jit=15.0")
+  }
+
+  @Test
+  fun recvHealthToleratesMissingMembers() {
+    val stats = PipelineStats { 0L }
+    stats.setRecvHealth(PipelineStats.RecvHealth())
+    val label = stats.recvLabel()
+    assertThat(label).contains("drop=na", "lost=na", "decMs=na", "jbMs=na", "decImpl=na")
+    assertThat(stats.tick()).contains("recv{")
+  }
+
+  @Test
+  fun recvHealthPrintsDecoderImplementation() {
+    val stats = PipelineStats { 0L }
+    stats.setRecvHealth(PipelineStats.RecvHealth(decImpl = "OMX.qcom.video.decoder.avc"))
+    assertThat(stats.recvLabel()).contains("decImpl=OMX.qcom.video.decoder.avc")
+  }
+
+  @Test
+  fun ladderIncludesArmLabel() {
+    var clock = 0L
+    val stats = PipelineStats { clock }
+    clock += 1000
+    assertThat(stats.tick()).contains("arm=whep")
+    stats.arm = "synthetic"
+    clock += 1000
+    assertThat(stats.tick()).contains("arm=synthetic")
+  }
+
+  @Test
+  fun ladderExposesCpuAttributionFields() {
+    var clock = 0L
+    val stats = PipelineStats { clock }
+    stats.toI420.record(4_000_000)
+    stats.sinkCb.record(8_000_000)
+    stats.split.record(1_000_000)
+    stats.onDestAlloc()
+    stats.onPlaneAlloc()
+    stats.onPlaneAlloc()
+    clock += 1000
+    val line = stats.tick()
+    assertThat(line).contains("i420P95=4.0")
+    assertThat(line).contains("sinkCbP95=8.0")
+    assertThat(line).contains("splitP95=1.0")
+    assertThat(line).contains("alloc{dest=1 plane=2}")
+  }
+
+  @Test
+  fun ladderCarriesPathBufStrideZcAndCopyP95Na() {
+    var clock = 0L
+    val stats = PipelineStats { clock }
+    clock += 1000
+    val idle = stats.tick()
+    assertThat(idle).contains("path{mode=texture copy=packsplit pix=i420}")
+    assertThat(idle).contains("wire=0x0@na kbps=na codec=na")
+    assertThat(idle).contains("buf{tex=0 i420=0 other=0}")
+    assertThat(idle).contains("stride{y=0 u=0 v=0 tight=0 padded=0}")
+    assertThat(idle).contains("zc{on=0 used=0 fell=0 padded=0 heldMax=0 timeout=0}")
+    assertThat(idle).contains("copyP95=na")
+
+    stats.pathMode = "bytebuf"
+    stats.pathCopy = "nv12"
+    stats.pix = "nv12"
+    stats.codecName = "h264 sw"
+    stats.onFrameBuffer("tex")
+    stats.onFrameBuffer("i420")
+    stats.onFrameBuffer("i420")
+    stats.onFrameBuffer("nv12")
+    stats.onStrides(1280, 640, 640, 1280)
+    stats.onStrides(1280, 768, 768, 1280)
+    stats.zcOn = 1
+    stats.onZcUsed(1)
+    stats.onZcUsed(2)
+    stats.onZcFell()
+    stats.onZcPadded()
+    stats.onZcTimeout()
+    stats.copy.record(3_000_000)
+    clock += 1000
+    val line = stats.tick()
+    assertThat(line).contains("path{mode=bytebuf copy=nv12 pix=nv12}")
+    assertThat(line).contains("codec=h264_sw")
+    assertThat(line).contains("buf{tex=1 i420=2 other=1}")
+    assertThat(line).contains("stride{y=1280 u=768 v=768 tight=1 padded=1}")
+    assertThat(line).contains("zc{on=1 used=2 fell=1 padded=1 heldMax=2 timeout=1}")
+    assertThat(line).contains("copyP95=3.0")
+  }
+
+  @Test
+  fun ladderPrintsAcsWireGeometryAndBitrate() {
+    var clock = 0L
+    val stats = PipelineStats { clock }
+    stats.wireWidth = 960
+    stats.wireHeight = 540
+    stats.wireFps = 29.8
+    stats.wireBitrateBps = 1_480_000
+    clock += 1000
+    stats.codecName = "H264SkypeEncoder_HW"
+    assertThat(stats.tick()).contains("wire=960x540@29.8 kbps=1480 codec=H264SkypeEncoder_HW")
+  }
+
+  @Test
+  fun ladderExposesRecvRateSeparateFromDecode() {
+    var clock = 0L
+    val stats = PipelineStats { clock }
+    stats.recvFps = 14.8
+    stats.decodedFps = 8.1
+    clock += 1000
+    val line = stats.tick()
+    assertThat(line).contains("recv=14.8")
+    assertThat(line).contains("dec=8.1")
+  }
+
+  private fun extractCum(line: String): String =
+    Regex("""cum\{[^}]+\}""").find(line)?.value ?: line
+}

package/android/src/test/java/com/mentra/acsmeeting/telemetry/ProcessCpuTest.kt

@@ -0,0 +1,18 @@
+package com.mentra.acsmeeting.telemetry
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class ProcessCpuTest {
+  @Test
+  fun percentMatchesTopStyleOverOneSecond() {
+    assertThat(ProcessCpu.percent(cpuDeltaMs = 1120, wallDeltaMs = 1000)).isEqualTo(112.0)
+    assertThat(ProcessCpu.percent(cpuDeltaMs = 200, wallDeltaMs = 1000)).isEqualTo(20.0)
+  }
+
+  @Test
+  fun labelFormatsNaUntilFirstSample() {
+    assertThat(ProcessCpu.label(null, 8)).isEqualTo("cpu{proc=na cores=8}")
+    assertThat(ProcessCpu.label(112.4, 8)).isEqualTo("cpu{proc=112.4 cores=8}")
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/telemetry/RingPercentileTest.kt

@@ -0,0 +1,49 @@
+package com.mentra.acsmeeting.telemetry
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+
+class RingPercentileTest {
+  @Test
+  fun emptyIsNa() {
+    assertThat(RingPercentile().p50()).isEqualTo("na")
+    assertThat(RingPercentile().p95()).isEqualTo("na")
+  }
+
+  @Test
+  fun knownInputs() {
+    val ring = RingPercentile(8)
+    ring.record(10_000_000)
+    ring.record(20_000_000)
+    ring.record(40_000_000)
+    assertThat(ring.p50()).isEqualTo("20.0")
+  }
+
+  @Test
+  fun wraparoundKeepsNewest() {
+    val ring = RingPercentile(3)
+    repeat(6) { index -> ring.record((index + 1) * 1_000_000L) }
+    assertThat(ring.size()).isEqualTo(3)
+    assertThat(ring.p50()).isEqualTo("5.0")
+  }
+
+  @Test
+  fun concurrentRecordDoesNotCorruptCount() {
+    val ring = RingPercentile(32)
+    val pool = Executors.newFixedThreadPool(4)
+    val latch = CountDownLatch(4)
+    repeat(4) {
+      pool.execute {
+        repeat(50) { ring.record(1_000_000) }
+        latch.countDown()
+      }
+    }
+    assertThat(latch.await(5, TimeUnit.SECONDS)).isTrue()
+    pool.shutdown()
+    assertThat(ring.size()).isEqualTo(32)
+    assertThat(ring.p50()).isNotEqualTo("na")
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/video/AcsTimestampTest.kt

@@ -0,0 +1,43 @@
+package com.mentra.acsmeeting.video
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class AcsTimestampTest {
+  @Test
+  fun streamClockWinsWhenItIsAdvancing() {
+    val ticks = AcsTimestamp.resolve(streamTicks = 5_000, captureNs = 1_000_000, lastTicks = 100)
+    assertThat(ticks).isEqualTo(5_000)
+  }
+
+  @Test
+  fun captureNsConvertsToHundredNanosecondTicks() {
+    val ticks = AcsTimestamp.resolve(streamTicks = 0, captureNs = 66_700_000, lastTicks = 0)
+    assertThat(ticks).isEqualTo(667_000)
+  }
+
+  /**
+   * A run of timestamp-0 frames is what Teams renders as a freeze: the jitter
+   * buffer holds the last picture because presentation time never moves.
+   */
+  @Test
+  fun zeroInputsStillAdvance() {
+    val first = AcsTimestamp.resolve(streamTicks = 0, captureNs = 0, lastTicks = 0)
+    val second = AcsTimestamp.resolve(streamTicks = 0, captureNs = 0, lastTicks = first)
+    assertThat(first).isEqualTo(1)
+    assertThat(second).isGreaterThan(first)
+  }
+
+  @Test
+  fun neverReusesTheLastTick() {
+    val stuckStream = 40L
+    val ticks = AcsTimestamp.resolve(streamTicks = stuckStream, captureNs = 1_000, lastTicks = 40)
+    assertThat(ticks).isEqualTo(41)
+  }
+
+  @Test
+  fun captureBehindLastTickStillAdvances() {
+    val ticks = AcsTimestamp.resolve(streamTicks = 0, captureNs = 100, lastTicks = 9_000)
+    assertThat(ticks).isEqualTo(9_001)
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/video/FrameGeometryTest.kt

@@ -0,0 +1,33 @@
+package com.mentra.acsmeeting.video
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class FrameGeometryTest {
+  @Test
+  fun rotationZeroUsesBufferSize() {
+    val size = FrameGeometry.packSize(1280, 720, 0)
+    assertThat(size.width).isEqualTo(1280)
+    assertThat(size.height).isEqualTo(720)
+    assertThat(size.rotationNonZero).isFalse()
+  }
+
+  @Test
+  fun rotation90KeepsBufferCoordinatesNotRotatedDisplaySize() {
+    val bufferW = 1280
+    val bufferH = 720
+    val rotatedWidth = bufferH
+    val rotatedHeight = bufferW
+    val size = FrameGeometry.packSize(bufferW, bufferH, 90)
+    assertThat(size.width).isEqualTo(bufferW)
+    assertThat(size.height).isEqualTo(bufferH)
+    assertThat(size.rotationNonZero).isTrue()
+    assertThat(size.width).isNotEqualTo(rotatedWidth)
+    assertThat(size.height).isNotEqualTo(rotatedHeight)
+    val overrun = I420Packer.packedSize(rotatedWidth, rotatedHeight)
+    val actual = I420Packer.packedSize(size.width, size.height)
+    assertThat(overrun).isEqualTo(actual)
+    val planeIfRotated = rotatedHeight * 1280
+    assertThat(planeIfRotated).isGreaterThan(bufferW * bufferH)
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/video/I420FormatSpecTest.kt

@@ -0,0 +1,77 @@
+package com.mentra.acsmeeting.video
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+/**
+ * Asserts the advertised format arithmetic via [I420FormatSpec]. The ACS
+ * VideoStreamFormat object itself is not constructed here: it is native-backed
+ * and throws ExceptionInInitializerError outside an Android runtime.
+ */
+class AcsFrameSenderFormatTest {
+  @Test
+  fun i420FormatOffersTight720p20() {
+    val spec = I420FormatSpec.of()
+    assertThat(spec.width).isEqualTo(1280)
+    assertThat(spec.height).isEqualTo(720)
+    assertThat(spec.fps).isEqualTo(20f)
+    assertThat(spec.strideY).isEqualTo(1280)
+    assertThat(spec.strideU).isEqualTo(640)
+    assertThat(spec.strideV).isEqualTo(640)
+  }
+
+  @Test
+  fun i420FormatRoundsOddChromaStrides() {
+    val spec = I420FormatSpec.of(width = 3, height = 3, fps = 15f)
+    assertThat(spec.strideY).isEqualTo(3)
+    assertThat(spec.strideU).isEqualTo(2)
+    assertThat(spec.strideV).isEqualTo(2)
+  }
+
+  @Test
+  fun advertisedStridesMatchPacker() {
+    assertThat(I420Packer.chromaStride(1280)).isEqualTo(640)
+    assertThat(I420Packer.packedSize(1280, 720)).isEqualTo(1_382_400)
+  }
+
+  /** A disagreement here means ACS reads chroma at the wrong offset: green frames. */
+  @Test
+  fun advertisedSizeMatchesWhatThePackerWrites() {
+    for ((w, h) in listOf(1280 to 720, 960 to 540, 640 to 360, 3 to 3, 641 to 361)) {
+      val spec = I420FormatSpec.of(width = w, height = h)
+      assertThat(spec.packedSize())
+        .describedAs("%dx%d", w, h)
+        .isEqualTo(I420Packer.packedSize(w, h))
+    }
+  }
+
+  @Test
+  fun i420FormatStaysInsideAcsBounds() {
+    assertThat(I420FormatSpec.of().withinAcsBounds()).isTrue()
+  }
+
+  @Test
+  fun parseOrNullAllowsDocumentedVirtualCameraSizesOnly() {
+    assertThat(I420FormatSpec.parseOrNull(1280, 720, 15f)).isNotNull()
+    assertThat(I420FormatSpec.parseOrNull(960, 540, 30f)).isNotNull()
+    assertThat(I420FormatSpec.parseOrNull(540, 960, 30f)).isNull()
+    assertThat(I420FormatSpec.parseOrNull(854, 480, 15f)).isNull()
+  }
+
+  @Test
+  fun namedResolutionMapsAcsEnumsAndRejectsNearMatches() {
+    assertThat(I420FormatSpec.of(1280, 720).namedResolution()).isEqualTo(AcsNamedResolution.P720)
+    assertThat(I420FormatSpec.of(960, 540).namedResolution()).isEqualTo(AcsNamedResolution.P540)
+    assertThat(I420FormatSpec.of(858, 480).namedResolution()).isEqualTo(AcsNamedResolution.P480)
+    assertThat(I420FormatSpec.of(640, 360).namedResolution()).isEqualTo(AcsNamedResolution.P360)
+    assertThat(I420FormatSpec.of(854, 480).namedResolution()).isNull()
+    assertThat(I420FormatSpec.of(540, 960).namedResolution()).isNull()
+  }
+
+  @Test
+  fun outOfRangeGeometryIsReportedNotSilentlyClamped() {
+    assertThat(I420FormatSpec.of(width = 3, height = 3).withinAcsBounds()).isFalse()
+    assertThat(I420FormatSpec.of(width = 4096, height = 2160).withinAcsBounds()).isFalse()
+    assertThat(I420FormatSpec.of(fps = 60f).withinAcsBounds()).isFalse()
+  }
+}

package/android/src/test/java/com/mentra/acsmeeting/video/I420PackerTest.kt

@@ -0,0 +1,126 @@
+package com.mentra.acsmeeting.video
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+import java.nio.ByteBuffer
+
+class I420PackerTest {
+  @Test
+  fun percentileMsHandlesEmptyAndOrder() {
+    assertThat(I420Packer.percentileMs(LongArray(0), 0.50)).isEqualTo("na")
+    assertThat(I420Packer.percentileMs(longArrayOf(10_000_000, 20_000_000, 40_000_000), 0.50)).isEqualTo("20.0")
+  }
+
+  @Test
+  fun packedSizeUsesChromaRounding() {
+    assertThat(I420Packer.packedSize(4, 4)).isEqualTo(24)
+    assertThat(I420Packer.packedSize(3, 3)).isEqualTo(3 * 3 + 2 * 2 * 2)
+    assertThat(I420Packer.packedSize(1280, 720)).isEqualTo(1280 * 720 * 3 / 2)
+  }
+
+  @Test
+  fun planeMinBytesIsLastRowPlusFullStrides() {
+    assertThat(I420Packer.planeMinBytes(8, 8, 4)).isEqualTo(32)
+    assertThat(I420Packer.planeMinBytes(16, 8, 4)).isEqualTo(16 * 3 + 8)
+    assertThat(I420Packer.planeMinBytes(4, 8, 4)).isEqualTo(0)
+  }
+
+  @Test
+  fun copyPlaneFromPaddedStrideWritesTightDest() {
+    val width = 4
+    val height = 4
+    val padded = buildPlanes(width, height, strideY = 8, strideUv = 4, seed = 7)
+    val dest = ByteBuffer.allocate(width * height)
+    I420Packer.copyPlane(padded.y, 8, width, height, dest)
+    dest.flip()
+    val out = ByteArray(dest.remaining())
+    dest.get(out)
+    assertThat(out).containsExactly(
+      7, 8, 9, 10,
+      11, 12, 13, 14,
+      15, 16, 17, 18,
+      19, 20, 21, 22,
+    )
+  }
+
+  @Test
+  fun chromaStrideMatchesAcsI420Offer() {
+    assertThat(I420Packer.chromaStride(1280)).isEqualTo(640)
+    assertThat(I420Packer.chromaStride(3)).isEqualTo(2)
+  }
+
+  @Test
+  fun paddedStridesPackIdenticallyToTightStrides() {
+    val width = 4
+    val height = 4
+    val tight = buildPlanes(width, height, strideY = 4, strideUv = 2, seed = 7)
+    val padded = buildPlanes(width, height, strideY = 8, strideUv = 4, seed = 7)
+    val tightOut = ByteBuffer.allocate(I420Packer.packedSize(width, height))
+    val paddedOut = ByteBuffer.allocate(I420Packer.packedSize(width, height))
+    I420Packer.pack(
+      tight.y, 4, tight.u, 2, tight.v, 2, width, height, tightOut,
+    )
+    I420Packer.pack(
+      padded.y, 8, padded.u, 4, padded.v, 4, width, height, paddedOut,
+    )
+    assertThat(bytes(paddedOut)).isEqualTo(bytes(tightOut))
+    assertThat(tightOut.remaining()).isEqualTo(I420Packer.packedSize(width, height))
+  }
+
+  @Test
+  fun oddDimensionsPackExactBytes() {
+    val width = 3
+    val height = 3
+    val planes = buildPlanes(width, height, strideY = 5, strideUv = 3, seed = 11)
+    val dest = ByteBuffer.allocate(I420Packer.packedSize(width, height))
+    I420Packer.pack(planes.y, 5, planes.u, 3, planes.v, 3, width, height, dest)
+    val packed = bytes(dest)
+    assertThat(packed).hasSize(3 * 3 + 2 * 2 * 2)
+    // Visible Y is seed + row*width + col; chroma is 2x2 after (3+1)/2 rounding.
+    assertThat(packed.copyOfRange(0, 9)).containsExactly(
+      11, 12, 13,
+      14, 15, 16,
+      17, 18, 19,
+    )
+    assertThat(packed.copyOfRange(9, 13)).containsExactly(31, 32, 33, 34)
+    assertThat(packed.copyOfRange(13, 17)).containsExactly(41, 42, 43, 44)
+  }
+
+  private fun buildPlanes(
+    width: Int,
+    height: Int,
+    strideY: Int,
+    strideUv: Int,
+    seed: Int,
+  ): Planes {
+    val chromaW = (width + 1) / 2
+    val chromaH = (height + 1) / 2
+    val y = ByteBuffer.allocate(strideY * height)
+    val u = ByteBuffer.allocate(strideUv * chromaH)
+    val v = ByteBuffer.allocate(strideUv * chromaH)
+    for (row in 0 until height) {
+      for (col in 0 until width) {
+        y.put(row * strideY + col, (seed + row * width + col).toByte())
+      }
+    }
+    for (row in 0 until chromaH) {
+      for (col in 0 until chromaW) {
+        u.put(row * strideUv + col, (seed + 20 + row * chromaW + col).toByte())
+        v.put(row * strideUv + col, (seed + 30 + row * chromaW + col).toByte())
+      }
+    }
+    y.rewind()
+    u.rewind()
+    v.rewind()
+    return Planes(y, u, v)
+  }
+
+  private fun bytes(buffer: ByteBuffer): ByteArray {
+    val copy = buffer.duplicate()
+    val out = ByteArray(copy.remaining())
+    copy.get(out)
+    return out
+  }
+
+  private data class Planes(val y: ByteBuffer, val u: ByteBuffer, val v: ByteBuffer)
+}