@mentra/acs-meeting 3.2.0-dev.120

package/android/src/main/java/com/mentra/acsmeeting/source/GlassesMediaSource.kt

@@ -0,0 +1,101 @@
+package com.mentra.acsmeeting.source
+
+enum class SourceKind { WHEP, DIRECT }
+
+enum class SourceState { IDLE, CONNECTING, LIVE, FAILED }
+
+data class SourceConfig(
+  val url: String,
+  val kind: SourceKind = SourceKind.WHEP,
+)
+
+/** ACS-negotiated output size. One object so a frame cannot observe a torn width/height. */
+data class TargetSize(val width: Int, val height: Int)
+
+/**
+ * Whether a subscriber already on [currentUrl] can serve [next] as-is instead of
+ * being rebuilt.
+ *
+ * Reuse is the whole point: a rebuild mints a new peer and restarts the wait for
+ * the first frame, which is the outage we are trying to shorten. `CONNECTING`
+ * counts as reusable, and since `LIVE` means "a frame reached the sink" that now
+ * spans the answer → first frame window too. It cannot strand a caller, because
+ * every `CONNECTING` is bounded: the offer post fails, or the answer's
+ * first-frame deadline expires into `FAILED` and this returns false.
+ */
+fun canReuseSource(currentUrl: String?, state: SourceState, next: SourceConfig): Boolean =
+  currentUrl == next.url && next.kind == SourceKind.WHEP && state != SourceState.FAILED
+
+/**
+ * Observes source health transitions. `FAILED` is the one that matters: ICE
+ * dropped, the WHEP endpoint went away, or an answered subscription never
+ * delivered a frame — and nothing downstream will notice on its own, because
+ * ACS keeps the call up with a frozen last frame.
+ */
+fun interface SourceStateListener {
+  fun onSourceState(state: SourceState, reason: String?)
+}
+
+/**
+ * Transports whatever the glasses already captured. Capture policy lives
+ * outside this interface so a Cloudflare hop can be replaced without touching ACS.
+ */
+interface GlassesMediaSource {
+  fun start(config: SourceConfig)
+  fun restart(config: SourceConfig)
+  /** Rebuild the transport for the current config even if it looks healthy. */
+  fun forceRestart() {}
+  fun stop()
+  val state: SourceState
+  fun setPcmDeliveryEnabled(enabled: Boolean)
+  fun setTargetSize(size: TargetSize?) {}
+  fun setStateListener(listener: SourceStateListener?) {}
+}
+
+fun interface GlassesMediaSourceFactory {
+  fun create(video: VideoFrameListener, pcm: PcmListener): GlassesMediaSource
+}
+
+class GlassesMediaController(
+  private val factory: GlassesMediaSourceFactory,
+) {
+  private var source: GlassesMediaSource? = null
+  private var stateListener: SourceStateListener? = null
+
+  val state: SourceState
+    get() = source?.state ?: SourceState.IDLE
+
+  fun attach(video: VideoFrameListener, pcm: PcmListener, config: SourceConfig) {
+    source?.stop()
+    source = factory.create(video, pcm).also {
+      it.setStateListener(stateListener)
+      it.start(config)
+    }
+  }
+
+  fun restart(config: SourceConfig) {
+    source?.restart(config)
+  }
+
+  fun forceRestart() {
+    source?.forceRestart()
+  }
+
+  fun setStateListener(listener: SourceStateListener?) {
+    stateListener = listener
+    source?.setStateListener(listener)
+  }
+
+  fun stop() {
+    source?.stop()
+    source = null
+  }
+
+  fun setPcmDeliveryEnabled(enabled: Boolean) {
+    source?.setPcmDeliveryEnabled(enabled)
+  }
+
+  fun setTargetSize(size: TargetSize?) {
+    source?.setTargetSize(size)
+  }
+}

package/android/src/main/java/com/mentra/acsmeeting/source/MediaListeners.kt

@@ -0,0 +1,57 @@
+package com.mentra.acsmeeting.source
+
+import com.mentra.acsmeeting.video.I420Packer
+import java.nio.ByteBuffer
+
+/** Replaceable later by LocalGlassesVideoSource (SoftAP / local WebRTC). */
+interface VideoSource {
+  fun start(whepUrl: String)
+  fun updateUrl(whepUrl: String)
+  fun stop()
+}
+
+/**
+ * Planes are valid only for the duration of the callback unless [retain] is
+ * non-null and invoked before the callback returns. [release] must then be
+ * called exactly once after ACS is done with the buffers.
+ */
+class I420Planes(
+  val y: ByteBuffer,
+  val strideY: Int,
+  val u: ByteBuffer,
+  val strideU: Int,
+  val v: ByteBuffer,
+  val strideV: Int,
+  val width: Int,
+  val height: Int,
+  val timestampNs: Long,
+  val retain: (() -> Unit)? = null,
+  val release: (() -> Unit)? = null,
+) {
+  fun isTight(): Boolean {
+    val chroma = I420Packer.chromaStride(width)
+    return strideY == width && strideU == chroma && strideV == chroma
+  }
+
+  fun isDirect(): Boolean = y.isDirect && u.isDirect && v.isDirect
+
+  fun planesReadable(): Boolean {
+    val chromaW = I420Packer.chromaStride(width)
+    val chromaH = I420Packer.chromaStride(height)
+    return remaining(y) >= I420Packer.planeMinBytes(strideY, width, height) &&
+      remaining(u) >= I420Packer.planeMinBytes(strideU, chromaW, chromaH) &&
+      remaining(v) >= I420Packer.planeMinBytes(strideV, chromaW, chromaH)
+  }
+
+  companion object {
+    fun remaining(buffer: ByteBuffer): Int = buffer.duplicate().remaining()
+  }
+}
+
+fun interface VideoFrameListener {
+  fun onVideoFrame(planes: I420Planes)
+}
+
+fun interface PcmListener {
+  fun onPcm(pcm16Le: ByteArray, sampleRate: Int, channels: Int)
+}

package/android/src/main/java/com/mentra/acsmeeting/source/SyntheticFrameFactory.kt

@@ -0,0 +1,205 @@
+package com.mentra.acsmeeting.source
+
+import com.mentra.acsmeeting.video.I420Packer
+import java.nio.ByteBuffer
+import kotlin.math.max
+
+/**
+ * Packed I420 generator. No Android / ACS / WebRTC types so JVM tests stay cheap.
+ *
+ * CHEAP paints a flat field, a moving bar, and a Recall-style stamp (6-digit
+ * frame id + 1s FPS). Low motion: enough change that ACS cannot skip, still
+ * trivially compressible.
+ *
+ * MOTION pans a tiled scene across the frame. That is the glasses-turn proxy:
+ * temporal prediction dies (almost every pixel changes) but spatial structure
+ * stays, so an I-frame still compresses. Use this to ask whether ACS holds
+ * 15 fps under high motion.
+ *
+ * NOISE rewrites the whole Y plane from an LCG. That is not camera motion.
+ * Neighbors are uncorrelated, so even I-frames stay huge. Measured on ACS at
+ * 720p it pinned ~1.9 Mbps and collapsed the wire rate to 1.4 fps while we
+ * submitted 15. Use it to stress the encoder, never to model glasses movement.
+ *
+ * Chroma stays at 128 in every mode.
+ */
+class SyntheticFrameFactory(
+  private val entropy: SyntheticEntropy = SyntheticEntropy.CHEAP,
+) {
+  private var lastDest: ByteBuffer? = null
+  private var lastWidth = 0
+  private var lastHeight = 0
+  private var background: ByteArray? = null
+  private var scene: ByteArray? = null
+  private var sceneWidth = 0
+  private var sceneHeight = 0
+
+  fun write(dest: ByteBuffer, width: Int, height: Int, frameIndex: Int, emitFps: Double? = null) {
+    require(width > 0 && height > 0) { "size must be positive" }
+    val needed = I420Packer.packedSize(width, height)
+    require(dest.capacity() >= needed) { "dest capacity ${dest.capacity()} < $needed" }
+    when (entropy) {
+      SyntheticEntropy.NOISE -> writeNoise(dest, width, height, frameIndex)
+      SyntheticEntropy.MOTION -> writeMotion(dest, width, height, frameIndex)
+      SyntheticEntropy.CHEAP -> writeCheap(dest, width, height, frameIndex)
+    }
+    writeStamp(dest, width, height, frameIndex, emitFps)
+    dest.position(0)
+    dest.limit(needed)
+  }
+
+  private fun writeCheap(dest: ByteBuffer, width: Int, height: Int, frameIndex: Int) {
+    // Bulk-restore the field instead of a per-pixel loop: this runs on the emit
+    // thread every frame, and 921600 single-byte puts is exactly the Kotlin
+    // per-pixel cost the rest of this module exists to avoid.
+    val ySize = width * height
+    val template = background.takeIf { it != null && it.size == ySize }
+      ?: ByteArray(ySize) { BG_Y }.also { background = it }
+    dest.clear()
+    dest.put(template, 0, ySize)
+    if (dest !== lastDest || width != lastWidth || height != lastHeight) {
+      fillChroma(dest, width, height)
+      lastDest = dest
+      lastWidth = width
+      lastHeight = height
+    }
+    val barWidth = max(8, width / 80)
+    val travel = max(1, width - barWidth)
+    val barX = ((frameIndex.toLong() * barWidth) % travel).toInt()
+    fillYRect(dest, width, height, barX, 0, barWidth, height, BAR_Y)
+  }
+
+  /**
+   * Copy a pre-painted tiled scene with a wrap-safe offset. One bulk put per
+   * row, not one put per pixel — the scene is the glasses-turn stand-in, and
+   * generating it in Kotlin every frame would be the cost we are trying to
+   * isolate out of this measurement.
+   */
+  private fun writeMotion(dest: ByteBuffer, width: Int, height: Int, frameIndex: Int) {
+    val field = ensureScene(width, height)
+    val ox = ((frameIndex.toLong() * PAN_X) % TILE).toInt()
+    val oy = ((frameIndex.toLong() * PAN_Y) % TILE).toInt()
+    for (row in 0 until height) {
+      dest.position(row * width)
+      dest.put(field, (row + oy) * sceneWidth + ox, width)
+    }
+    if (dest !== lastDest || width != lastWidth || height != lastHeight) {
+      fillChroma(dest, width, height)
+      lastDest = dest
+      lastWidth = width
+      lastHeight = height
+    }
+  }
+
+  private fun ensureScene(width: Int, height: Int): ByteArray {
+    val sw = width + TILE
+    val sh = height + TILE
+    val existing = scene
+    if (existing != null && sceneWidth == sw && sceneHeight == sh) return existing
+    val field = ByteArray(sw * sh)
+    for (y in 0 until sh) {
+      val rowOff = y * sw
+      val tileY = y / TILE
+      val gy = y % TILE
+      for (x in 0 until sw) {
+        val tile = (x / TILE + tileY) and 1
+        val gx = x % TILE
+        val base = if (tile == 0) DARK_TILE else LIGHT_TILE
+        field[rowOff + x] = (base + gx - TILE / 2 + gy / 4).toByte()
+      }
+    }
+    scene = field
+    sceneWidth = sw
+    sceneHeight = sh
+    return field
+  }
+
+  private fun writeNoise(dest: ByteBuffer, width: Int, height: Int, frameIndex: Int) {
+    writeNoiseY(dest, width, height, frameIndex)
+    fillChroma(dest, width, height)
+    lastDest = dest
+    lastWidth = width
+    lastHeight = height
+  }
+
+  private fun writeNoiseY(dest: ByteBuffer, width: Int, height: Int, frameIndex: Int) {
+    val ySize = width * height
+    var seed = (frameIndex + 1) * LCG_SEED
+    for (i in 0 until ySize) {
+      seed = seed * LCG_MUL + LCG_ADD
+      dest.put(i, ((seed ushr 24) and 0xFF).toByte())
+    }
+  }
+
+  /**
+   * Recall burns `F 000123` plus live rates into the captured page. Same idea here:
+   * a 6-digit unique-frame id and the last 1s emit rate, readable on the Teams tile.
+   */
+  private fun writeStamp(
+    dest: ByteBuffer,
+    width: Int,
+    height: Int,
+    frameIndex: Int,
+    emitFps: Double?,
+  ) {
+    val scale = (height / 60).coerceIn(8, 16)
+    val line1 = "F ${frameIndex.coerceAtLeast(0).toString().padStart(6, '0')}"
+    val fpsLabel = emitFps?.let { ((it * 10).toInt() / 10.0).toString() } ?: "--"
+    val line2 = "FPS $fpsLabel"
+    val pad = scale * 2
+    val lineH = BitmapFont.textHeight(scale)
+    val gap = scale
+    val boxW = max(BitmapFont.textWidth(line1.length, scale), BitmapFont.textWidth(line2.length, scale)) + pad * 2
+    val boxH = lineH * 2 + gap + pad * 2
+    val boxX = (width / 16).coerceAtLeast(16)
+    val boxY = (height / 2 - boxH / 2).coerceAtLeast(0)
+    fillYRect(dest, width, height, boxX, boxY, boxW, boxH, OFF_Y)
+    BitmapFont.draw(dest, width, height, line1, boxX + pad, boxY + pad, scale, BAR_Y)
+    BitmapFont.draw(dest, width, height, line2, boxX + pad, boxY + pad + lineH + gap, scale, BAR_Y)
+  }
+
+  private fun fillChroma(dest: ByteBuffer, width: Int, height: Int) {
+    val ySize = width * height
+    val uvSize = I420Packer.chromaStride(width) * I420Packer.chromaStride(height)
+    val end = ySize + 2 * uvSize
+    for (i in ySize until end) dest.put(i, CHROMA)
+  }
+
+  private fun fillYRect(
+    dest: ByteBuffer,
+    width: Int,
+    height: Int,
+    x0: Int,
+    y0: Int,
+    rectW: Int,
+    rectH: Int,
+    value: Byte,
+  ) {
+    val xStart = x0.coerceIn(0, width)
+    val yStart = y0.coerceIn(0, height)
+    val xEnd = (x0 + rectW).coerceIn(0, width)
+    val yEnd = (y0 + rectH).coerceIn(0, height)
+    if (xStart >= xEnd || yStart >= yEnd) return
+    for (row in yStart until yEnd) {
+      val rowOff = row * width
+      for (col in xStart until xEnd) {
+        dest.put(rowOff + col, value)
+      }
+    }
+  }
+
+  companion object {
+    const val BG_Y: Byte = 40
+    const val OFF_Y: Byte = 16
+    const val BAR_Y: Byte = 235.toByte()
+    const val CHROMA: Byte = 128.toByte()
+    const val TILE = 32
+    const val PAN_X = 8
+    const val PAN_Y = 4
+    private const val DARK_TILE = 70
+    private const val LIGHT_TILE = 170
+    private const val LCG_SEED = -1640531527
+    private const val LCG_MUL = 1664525
+    private const val LCG_ADD = 1013904223
+  }
+}

package/android/src/main/java/com/mentra/acsmeeting/source/SyntheticI420Source.kt

@@ -0,0 +1,214 @@
+package com.mentra.acsmeeting.source
+
+import android.util.Log
+import com.mentra.acsmeeting.telemetry.PipelineStats
+import com.mentra.acsmeeting.video.I420Packer
+import java.nio.ByteBuffer
+import java.util.concurrent.Executors
+import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicLong
+import java.util.concurrent.atomic.AtomicReference
+
+/**
+ * Fixed-rate packed-I420 source. Bypasses glasses, Cloudflare, WHEP and decode.
+ * Ticks that fail [isReady] or lack a target size are withheld and uncounted.
+ */
+class SyntheticI420Source(
+  private val video: VideoFrameListener,
+  private val stats: PipelineStats,
+  private val isReady: () -> Boolean,
+  private val config: SyntheticConfig = SyntheticConfig(),
+) : GlassesMediaSource {
+  private val factory = SyntheticFrameFactory(config.entropy)
+  private val targetSize = AtomicReference<TargetSize?>(null)
+  private val pcmEnabled = AtomicBoolean(false)
+  private val frameIndex = AtomicInteger(0)
+  private val withheld = AtomicInteger(0)
+  private val withheldThisGap = AtomicInteger(0)
+  private val emitted = AtomicInteger(0)
+  private val emitting = AtomicBoolean(false)
+  private val firstLogged = AtomicBoolean(false)
+  private val fpsWindowStartNs = AtomicLong(0)
+  private val fpsWindowCount = AtomicInteger(0)
+  @Volatile private var stampFps: Double? = null
+  @Volatile override var state: SourceState = SourceState.IDLE
+    private set
+  @Volatile private var dest: ByteBuffer? = null
+  @Volatile private var destWidth = 0
+  @Volatile private var destHeight = 0
+  @Volatile private var destY: ByteBuffer? = null
+  @Volatile private var destU: ByteBuffer? = null
+  @Volatile private var destV: ByteBuffer? = null
+  private var scheduler: ScheduledExecutorService? = null
+
+  /** Test-visible gate transitions. Production also writes them to ACS-SPIKE. */
+  internal val events = mutableListOf<String>()
+
+  /** Puts the source in LIVE without starting the scheduler. For emitOnce tests. */
+  internal fun becomeLive() {
+    state = SourceState.LIVE
+  }
+
+  override fun start(config: SourceConfig) {
+    stop()
+    becomeLive()
+    val fps = this.config.fps.coerceAtLeast(1)
+    val periodUs = 1_000_000L / fps
+    val exec = Executors.newSingleThreadScheduledExecutor { runnable ->
+      Thread(runnable, "acs-synthetic-i420").apply { isDaemon = true }
+    }
+    scheduler = exec
+    exec.scheduleAtFixedRate({ emitOnce() }, 0, periodUs, TimeUnit.MICROSECONDS)
+  }
+
+  override fun restart(config: SourceConfig) {
+    stop()
+    start(config)
+  }
+
+  override fun stop() {
+    scheduler?.shutdownNow()
+    scheduler = null
+    frameIndex.set(0)
+    withheld.set(0)
+    withheldThisGap.set(0)
+    emitted.set(0)
+    emitting.set(false)
+    firstLogged.set(false)
+    fpsWindowStartNs.set(0)
+    fpsWindowCount.set(0)
+    stampFps = null
+    dest = null
+    destWidth = 0
+    destHeight = 0
+    destY = null
+    destU = null
+    destV = null
+    state = SourceState.IDLE
+  }
+
+  override fun setPcmDeliveryEnabled(enabled: Boolean) {
+    pcmEnabled.set(enabled)
+  }
+
+  override fun setTargetSize(size: TargetSize?) {
+    targetSize.set(size)
+  }
+
+  internal fun pcmDeliveryEnabled(): Boolean = pcmEnabled.get()
+
+  /**
+   * Generate-and-emit one frame if the sender is ready and a target size exists.
+   * Returns true only when a frame was handed to [video].
+   */
+  internal fun emitOnce(): Boolean {
+    if (state != SourceState.LIVE) return false
+    val size = targetSize.get()
+    val ready = isReady() && size != null
+    if (!ready) {
+      withheld.incrementAndGet()
+      withheldThisGap.incrementAndGet()
+      if (emitting.compareAndSet(true, false)) {
+        logEvent("P6 synthetic paused reason=not-ready afterFrames=${emitted.get()}")
+      }
+      return false
+    }
+    val gap = withheldThisGap.getAndSet(0)
+    if (!emitting.get() && emitted.get() > 0) {
+      logEvent("P6 synthetic resumed withheld=$gap")
+    }
+    emitting.set(true)
+
+    val w = size!!.width
+    val h = size.height
+    val buffer = ensureDest(w, h)
+    val index = frameIndex.getAndIncrement()
+    stampFps = sampleStampFps()
+    factory.write(buffer, w, h, index, stampFps)
+    stats.onSink()
+    stats.recordGap()
+    stats.setSize(w, h)
+    val chroma = I420Packer.chromaStride(w)
+    video.onVideoFrame(
+      I420Planes(
+        y = destY!!,
+        strideY = w,
+        u = destU!!,
+        strideU = chroma,
+        v = destV!!,
+        strideV = chroma,
+        width = w,
+        height = h,
+        timestampNs = System.nanoTime(),
+      ),
+    )
+    val count = emitted.incrementAndGet()
+    if (firstLogged.compareAndSet(false, true)) {
+      logEvent(
+        "P6 synthetic first-frame withheld=${withheld.get()} size=${w}x${h} " +
+          "fps=${config.fps} entropy=${config.entropy}",
+      )
+    }
+    return count > 0
+  }
+
+  /** 1-second emit rate, same window Recall uses for the P column on the stamp. */
+  private fun sampleStampFps(): Double? {
+    val now = System.nanoTime()
+    val started = fpsWindowStartNs.get()
+    if (started == 0L) {
+      fpsWindowStartNs.set(now)
+      fpsWindowCount.set(1)
+      return stampFps
+    }
+    fpsWindowCount.incrementAndGet()
+    val elapsedNs = now - started
+    if (elapsedNs >= 1_000_000_000L) {
+      val rate = fpsWindowCount.get() * 1_000_000_000.0 / elapsedNs
+      fpsWindowCount.set(0)
+      fpsWindowStartNs.set(now)
+      return rate
+    }
+    return stampFps
+  }
+
+  private fun ensureDest(width: Int, height: Int): ByteBuffer {
+    val needed = I420Packer.packedSize(width, height)
+    val existing = dest
+    if (existing != null && destWidth == width && destHeight == height && existing.capacity() >= needed) {
+      existing.clear()
+      return existing
+    }
+    val next = ByteBuffer.allocateDirect(needed)
+    dest = next
+    destWidth = width
+    destHeight = height
+    slicePlanes(next, width, height)
+    return next
+  }
+
+  private fun slicePlanes(packed: ByteBuffer, width: Int, height: Int) {
+    val ySize = width * height
+    val uvSize = I420Packer.chromaStride(width) * I420Packer.chromaStride(height)
+    val view = packed.duplicate()
+    view.clear()
+    destY = view.duplicate().apply { position(0); limit(ySize) }.slice()
+    destU = view.duplicate().apply { position(ySize); limit(ySize + uvSize) }.slice()
+    destV = view.duplicate().apply { position(ySize + uvSize); limit(ySize + 2 * uvSize) }.slice()
+  }
+
+  private fun logEvent(line: String) {
+    synchronized(events) { events.add(line) }
+    try {
+      Log.i(TAG, line)
+    } catch (_: Throwable) {
+    }
+  }
+
+  companion object {
+    private const val TAG = "ACS-SPIKE"
+  }
+}

package/android/src/main/java/com/mentra/acsmeeting/source/TrackRegistry.kt

@@ -0,0 +1,31 @@
+package com.mentra.acsmeeting.source
+
+/**
+ * Dedupe WebRTC track attachments by native track id.
+ * Three observer callbacks can deliver distinct Java wrappers of one track;
+ * object identity cannot be used. [reset] is load-bearing: [CloudflareWhepSource.start]
+ * calls stop first, and a stale claim set makes reconnect never attach a sink.
+ */
+class TrackRegistry {
+  private val ids = mutableSetOf<String>()
+  private var skipped = 0
+
+  @Synchronized
+  fun claim(id: String): Boolean {
+    if (ids.add(id)) return true
+    skipped += 1
+    return false
+  }
+
+  @Synchronized
+  fun reset() {
+    ids.clear()
+    skipped = 0
+  }
+
+  @Synchronized
+  fun size(): Int = ids.size
+
+  @Synchronized
+  fun skipped(): Int = skipped
+}

package/android/src/main/java/com/mentra/acsmeeting/source/VideoSourceArm.kt

@@ -0,0 +1,41 @@
+package com.mentra.acsmeeting.source
+
+enum class VideoSourceArm { WHEP, SYNTHETIC }
+
+enum class SyntheticEntropy { CHEAP, MOTION, NOISE }
+
+enum class DecoderMode { TEXTURE, BYTE_BUFFER }
+
+enum class PixelFormatArm { I420, NV12 }
+
+/**
+ * Investigation arm. SYNTHETIC bypasses glasses, Cloudflare, WHEP and decode.
+ * Ships as WHEP. Flip locally to run the experiment; do not commit SYNTHETIC.
+ *
+ * [decoderMode] TEXTURE is the production default (shared EGL, MediaCodec to
+ * Surface). BYTE_BUFFER is the A/B: no shared context, CPU planes, no
+ * glReadPixels. 720p BYTE_BUFFER on SM_S948U decoded on hardware with
+ * i420P95=0, but wire/codec never attached and busy drops climbed. Do not
+ * commit BYTE_BUFFER until a same-phone 540p A/B clears the campaign gates.
+ *
+ * [zeroCopy] hands WebRTC I420 planes straight to ACS when they are tight and
+ * retainable. Ships off. Do not commit true.
+ *
+ * [pixelFormat] I420 is the production default. NV12 is the encoder-flip A/B:
+ * advertise and send biplanar NV12 in case ACS picks a hardware H.264
+ * encoder. Revert unless `codecName` leaves `h264 sw`. Do not commit NV12
+ * on a failed flip.
+ */
+object AcsInvestigation {
+  val videoArm = VideoSourceArm.WHEP
+  val syntheticFps = 15
+  val syntheticEntropy = SyntheticEntropy.MOTION
+  val decoderMode = DecoderMode.TEXTURE
+  val zeroCopy = false
+  val pixelFormat = PixelFormatArm.I420
+}
+
+data class SyntheticConfig(
+  val fps: Int = AcsInvestigation.syntheticFps,
+  val entropy: SyntheticEntropy = AcsInvestigation.syntheticEntropy,
+)