@mentra/acs-meeting 3.2.0-dev.222 → 3.2.0-dev.225

package/android/src/main/java/com/mentra/acsmeeting/telemetry/RingPercentile.kt

@@ -1,48 +0,0 @@
-package com.mentra.acsmeeting.telemetry
-
-import kotlin.math.roundToInt
-
-/** Thread-safe ring of nanosecond samples. p50/p95 for the 1 Hz ladder. */
-class RingPercentile(private val capacity: Int = 32) {
-  private val samples = LongArray(capacity)
-  private var count = 0
-  private var index = 0
-
-  @Synchronized
-  fun record(ns: Long) {
-    samples[index] = ns
-    index = (index + 1) % capacity
-    if (count < capacity) count += 1
-  }
-
-  fun p50(): String = percentile(0.50)
-
-  fun p95(): String = percentile(0.95)
-
-  @Synchronized
-  fun percentile(quantile: Double): String {
-    if (count == 0) return "na"
-    val copy = samples.copyOf(count)
-    copy.sort()
-    val idx = ((copy.size - 1) * quantile).roundToInt().coerceIn(0, copy.lastIndex)
-    return ((copy[idx] / 1_000_000.0) * 10).roundToInt().div(10.0).toString()
-  }
-
-  /**
-   * p95 in milliseconds, or -1 when nothing has been recorded.
-   *
-   * Numeric rather than the formatted [p95] because the ladder ranks stages against each other to
-   * name the slowest one, and comparing the rendered strings would order "9.0" above "10.0".
-   */
-  @Synchronized
-  fun p95Ms(): Double {
-    if (count == 0) return -1.0
-    val copy = samples.copyOf(count)
-    copy.sort()
-    val idx = ((copy.size - 1) * 0.95).roundToInt().coerceIn(0, copy.lastIndex)
-    return copy[idx] / 1_000_000.0
-  }
-
-  @Synchronized
-  fun size(): Int = count
-}

package/android/src/main/java/com/mentra/acsmeeting/telemetry/VideoQuality.kt

@@ -1,178 +0,0 @@
-package com.mentra.acsmeeting.telemetry
-
-import kotlin.math.roundToInt
-
-/**
- * How good the picture is, as opposed to how many frames of it there are.
- *
- * Every rate number we log can be healthy while Teams shows mush, because
- * "pixelated" is bits per pixel and nothing in the ladder computed that.
- * `wire=960x540@14.4 kbps=1276` reads fine and is 0.17 bits per pixel, which is
- * under what a head-mounted camera needs. ACS 2.16.0's
- * `OutgoingVideoStatistics` exposes no QP and no quality-limitation reason —
- * only codec, bitrate, packet count, rate, and size — so bits per pixel is the
- * only quality signal available and it has to be derived here.
- *
- * Bands come from the Kush gauge, the standard H.264 estimate
- * `bitrate ≈ width · height · fps · 0.07 · motion`, which rearranges to
- * `bpp ≈ 0.07 · motion`. Motion is 1 for a near-static scene, 2 for moderate,
- * and 4 for high. Glasses are strapped to someone's head, so the honest target
- * is the high-motion one — which is why a number sitting mid-band can still
- * look bad and the log says so rather than printing a bare "OK".
- */
-object VideoQuality {
-  enum class Band {
-    /** Below what even a static scene needs. Visible blocking. */
-    BLOCKY,
-
-    /** Enough for a near-static scene only. Soft, smeared on movement. */
-    SOFT,
-
-    /** Enough for moderate motion. Still short for a head-mounted camera. */
-    OK,
-
-    /** Enough for high motion, which is what glasses actually produce. */
-    GOOD,
-
-    UNKNOWN,
-  }
-
-  /** bpp ≈ 0.07 · motion, for motion = 1, 2, and 4. */
-  const val STATIC_BPP = 0.07
-  const val MODERATE_BPP = 0.14
-  const val HIGH_MOTION_BPP = 0.28
-
-  fun bitsPerPixel(bitrateBps: Long?, width: Int?, height: Int?, fps: Double?): Double? {
-    if (bitrateBps == null || width == null || height == null || fps == null) return null
-    if (bitrateBps <= 0 || width <= 0 || height <= 0 || fps <= 0.0) return null
-    return bitrateBps / (width.toDouble() * height * fps)
-  }
-
-  fun band(bpp: Double?): Band = when {
-    bpp == null -> Band.UNKNOWN
-    bpp < STATIC_BPP -> Band.BLOCKY
-    bpp < MODERATE_BPP -> Band.SOFT
-    bpp < HIGH_MOTION_BPP -> Band.OK
-    else -> Band.GOOD
-  }
-
-  /** Bitrate this geometry needs to reach [bpp], so the log can name the shortfall. */
-  fun neededBps(width: Int, height: Int, fps: Double, bpp: Double): Long {
-    if (width <= 0 || height <= 0 || fps <= 0.0) return 0L
-    return (width.toDouble() * height * fps * bpp).toLong()
-  }
-
-  /**
-   * Whether the granted ceiling can even reach high motion at this geometry.
-   *
-   * This is the check that turns "the picture is bad" into a decision. 540p15
-   * against a 1.5 Mbps budget tops out at 0.19 bpp even if ACS spends every bit,
-   * so no encoder change and no rate fix can make that combination look sharp on
-   * a moving camera — the budget is the ceiling, and it has to move.
-   */
-  fun budgetCapsQuality(width: Int, height: Int, fps: Double, budgetBps: Int): Boolean {
-    if (budgetBps <= 0) return false
-    return budgetBps < neededBps(width, height, fps, HIGH_MOTION_BPP)
-  }
-
-  /**
-   * Whether ACS is actually spending what it was granted.
-   *
-   * The grant is a target, not a wall — a device run recorded `used=108%`, the wire
-   * at 1623 kbps against a 1.5 Mbps grant — so falling short of it is a choice the
-   * rate controller made rather than a limit it hit. That makes the shortfall
-   * diagnostic: something upstream of the ceiling is holding the bitrate down, and
-   * [hint] uses CPU to say which thing.
-   */
-  const val SPENDING_FRACTION = 0.85
-
-  /**
-   * Process CPU at which a software encoder is a plausible cap.
-   *
-   * The figure is a percentage of a *single* core, not of the device, so on an
-   * 8-core phone 88% means one core nearly full while seven sit idle. That still
-   * binds a single-threaded encoder, which is why the threshold sits near one core
-   * rather than near the machine.
-   */
-  const val ENCODER_BUSY_PERCENT = 90.0
-
-  fun spendingBudget(wireBitrateBps: Long?, budgetBps: Int): Boolean {
-    if (wireBitrateBps == null || budgetBps <= 0) return false
-    return wireBitrateBps >= budgetBps * SPENDING_FRACTION
-  }
-
-  fun hint(
-    band: Band,
-    budgetCapped: Boolean,
-    spendingBudget: Boolean,
-    encoderBusy: Boolean,
-  ): String = when {
-    band == Band.UNKNOWN -> "no wire report yet"
-    band == Band.GOOD -> "enough for high motion"
-    !spendingBudget && encoderBusy ->
-      "bits unspent with a core nearly full; encoder is the cap -- cut pixels, not the ceiling"
-    !spendingBudget ->
-      "bits unspent while CPU is idle; congestion control is holding the rate down, " +
-        "so neither a bigger ceiling nor fewer pixels addresses it -- check the network"
-    budgetCapped ->
-      "budget cannot reach high motion at this geometry; raise maxBitrateBps or drop resolution"
-    band == Band.BLOCKY -> "far below any usable bitrate; check for a rate-controller collapse"
-    band == Band.SOFT -> "only enough for a static scene; a head camera will smear"
-    else -> "fine for moderate motion, still short for a head-mounted camera"
-  }
-
-  /**
-   * One line per tick. Prints the derived figures and the bitrate that would be
-   * needed, because "0.17 bpp" alone does not tell anyone what to change.
-   */
-  fun line(
-    wireWidth: Int?,
-    wireHeight: Int?,
-    wireFps: Double?,
-    wireBitrateBps: Long?,
-    budgetBps: Int,
-    packetsPerSecond: Double?,
-    cpuPercent: Double?,
-    sendQuality: String,
-  ): String {
-    val bpp = bitsPerPixel(wireBitrateBps, wireWidth, wireHeight, wireFps)
-    val band = band(bpp)
-    val capped = if (wireWidth != null && wireHeight != null && wireFps != null) {
-      budgetCapsQuality(wireWidth, wireHeight, wireFps, budgetBps)
-    } else {
-      false
-    }
-    val bitsPerFrame = if (wireBitrateBps != null && wireFps != null && wireFps > 0) {
-      (wireBitrateBps / wireFps).roundToInt().toString()
-    } else {
-      "na"
-    }
-    val goodKbps = if (wireWidth != null && wireHeight != null && wireFps != null) {
-      (neededBps(wireWidth, wireHeight, wireFps, HIGH_MOTION_BPP) / 1000).toString()
-    } else {
-      "na"
-    }
-    val usedKbps = wireBitrateBps?.let { (it / 1000).toString() } ?: "na"
-    val usedPercent = if (wireBitrateBps != null && budgetBps > 0) {
-      ((wireBitrateBps * 100.0 / budgetBps).roundToInt()).toString()
-    } else {
-      "na"
-    }
-    return "P9 quality band=$band bpp=${bpp?.let { decimal(it) } ?: "na"} " +
-      "size=${wireWidth ?: 0}x${wireHeight ?: 0}@${wireFps?.let { PipelineStats.formatRate(it) } ?: "na"} " +
-      "bitsPerFrame=$bitsPerFrame kbps=$usedKbps budgetKbps=${budgetBps / 1000} used=$usedPercent% " +
-      "goodNeedsKbps=$goodKbps budgetCapped=$capped " +
-      "pps=${packetsPerSecond?.let { PipelineStats.formatRate(it) } ?: "na"} " +
-      "cpu=${cpuPercent?.let { PipelineStats.formatRate(it) } ?: "na"} " +
-      "sendQuality=${sendQuality.ifBlank { "na" }} -- " +
-      hint(
-        band = band,
-        budgetCapped = capped,
-        spendingBudget = spendingBudget(wireBitrateBps, budgetBps),
-        encoderBusy = cpuPercent != null && cpuPercent >= ENCODER_BUSY_PERCENT,
-      )
-  }
-
-  /** Three places, because bpp differences that matter show up in the third. */
-  private fun decimal(value: Double): String = ((value * 1000).roundToInt() / 1000.0).toString()
-}

package/android/src/main/java/com/mentra/acsmeeting/telemetry/VideoRateVerdict.kt

@@ -1,145 +0,0 @@
-package com.mentra.acsmeeting.telemetry
-
-/**
- * Names what is holding the outgoing frame rate down.
- *
- * The fps question kept being answered by inference: a soak put ~8.8 fps on the
- * wire, so the ACS software encoder "holds 8.8 fps". That does not follow. At
- * least four different things produce a low wire rate, they are trivial to tell
- * apart from numbers we already collect, and two of them want opposite fixes —
- * cutting resolution rescues an encoder that is genuinely CPU-bound and makes a
- * bitrate-starved stream strictly worse.
- *
- * So this prints the answer instead of leaving it to be guessed:
- *
- * - [Bound.SOURCE_SHORT] the glasses are not sending enough frames. Nothing
- *   downstream of the decoder can raise the rate.
- * - [Bound.PACER_SHORT] our own gate is the limit — it admitted fewer frames
- *   than we advertised while the source had plenty. This is what a greedy
- *   `FramePacer` did: 14.6 fps in, 7.3 out, against an advertised 8.
- * - [Bound.ENCODER_SHORT] ACS took the frames and put fewer on the wire while
- *   the CPU was busy. The real encoder ceiling. Cut pixels.
- * - [Bound.BITRATE_STARVED] ACS took the frames and put fewer on the wire with
- *   CPU to spare and the bitrate far under the budget we granted. The rate
- *   controller is throttling an encoder that could keep up. Cutting fps or
- *   pixels here makes it worse; fix delivery consistency.
- * - [Bound.CAP_BOUND] every frame is on the wire and the bitrate is pressed
- *   against the ceiling we granted. Nothing is broken; the grant is simply the
- *   limit, so the picture cannot get sharper until the number does.
- */
-object VideoRateVerdict {
-  enum class Bound {
-    OK,
-    SOURCE_SHORT,
-    PACER_SHORT,
-    ENCODER_SHORT,
-    BITRATE_STARVED,
-    CAP_BOUND,
-    UNKNOWN,
-  }
-
-  /** Below this fraction of the target a rate counts as short rather than noise. */
-  const val SHORT_FRACTION = 0.85
-
-  /**
-   * The pacer is held to a tighter tolerance than anything else, because it is
-   * deterministic code we own rather than a jittery encoder or radio. The bug
-   * this class was written for delivered 7.3 against an advertised 8 — a 9%
-   * chronic shortfall, comfortably inside [SHORT_FRACTION] and still enough to
-   * bias the ACS rate controller down on every hiccup.
-   */
-  const val PACER_SHORT_FRACTION = 0.95
-
-  /** Process CPU at or above this is treated as the encoder being the cost. */
-  const val CPU_BUSY_PERCENT = 80.0
-
-  /** Wire bitrate below this fraction of the granted budget is a throttled stream. */
-  const val STARVED_FRACTION = 0.6
-
-  /**
-   * Wire bitrate at or above this fraction of the grant counts as riding the ceiling.
-   *
-   * The grant is a target rather than a wall — a device run recorded the wire at 1623 kbps
-   * against a 1.5 Mbps grant, 108% — so "pressed against it" has to mean near, not exactly at.
-   * 0.95 is below the noise on a controller that routinely overshoots and well above the 0.85
-   * that [VideoQuality.SPENDING_FRACTION] treats as merely spending the budget.
-   */
-  const val CAP_BOUND_FRACTION = 0.95
-
-  fun of(
-    advertisedFps: Double,
-    sinkFps: Double,
-    admittedFps: Double,
-    wireFps: Double?,
-    wireBitrateBps: Long?,
-    budgetBps: Int,
-    cpuPercent: Double?,
-  ): Bound {
-    if (advertisedFps <= 0.0) return Bound.UNKNOWN
-    // Source first: when the glasses are short, every rate below them is short
-    // too, and blaming the encoder for that sends the next fix to the wrong leg.
-    if (sinkFps < advertisedFps * SHORT_FRACTION) return Bound.SOURCE_SHORT
-    // Against what the source actually supplied, not against the advertise. The
-    // pacer cannot admit frames that never arrived, and scoring it on the
-    // advertise alone would read a merely slow source as our own bug.
-    val deliverable = minOf(advertisedFps, sinkFps)
-    if (admittedFps < deliverable * PACER_SHORT_FRACTION) return Bound.PACER_SHORT
-    if (wireFps == null) return Bound.UNKNOWN
-    if (wireFps >= admittedFps * SHORT_FRACTION) {
-      // A full frame rate is not the same as a good picture, and this is the one case where the
-      // fix is the ceiling itself. Reporting it as a plain OK is how "the quality is low" turns
-      // into an argument about the encoder: every rate number looks healthy, so the grant — the
-      // one thing actually holding the bits down — never comes up.
-      val capBound =
-        wireBitrateBps != null && budgetBps > 0 && wireBitrateBps >= budgetBps * CAP_BOUND_FRACTION
-      return if (capBound) Bound.CAP_BOUND else Bound.OK
-    }
-    if (cpuPercent != null && cpuPercent >= CPU_BUSY_PERCENT) return Bound.ENCODER_SHORT
-    val starved =
-      wireBitrateBps != null && budgetBps > 0 && wireBitrateBps < budgetBps * STARVED_FRACTION
-    return if (starved) Bound.BITRATE_STARVED else Bound.ENCODER_SHORT
-  }
-
-  /** What to do about it, so the log line does not need a reader who has this file open. */
-  fun hint(bound: Bound): String = when (bound) {
-    Bound.OK -> "wire is holding the advertised rate"
-    Bound.SOURCE_SHORT -> "glasses/WHIP leg is short; raising ACS fps cannot help"
-    Bound.PACER_SHORT -> "our gate drops frames the source supplied; check FramePacer interval"
-    Bound.ENCODER_SHORT -> "ACS encoder is the ceiling; cut pixels (VideoProfile.SD) not fps"
-    Bound.BITRATE_STARVED -> "rate controller is throttling, not CPU; do not cut fps or pixels"
-    Bound.CAP_BOUND -> "wire is riding the granted ceiling; raising maxBitrateBps is the only lever"
-    Bound.UNKNOWN -> "not enough evidence yet"
-  }
-
-  /**
-   * One line per tick. Prints every input beside the verdict: a verdict whose
-   * inputs are not visible is the same guess this class exists to replace.
-   */
-  fun line(
-    advertisedFps: Double,
-    sinkFps: Double,
-    admittedFps: Double,
-    wireFps: Double?,
-    wireBitrateBps: Long?,
-    budgetBps: Int,
-    cpuPercent: Double?,
-    codecName: String,
-  ): String {
-    val bound = of(
-      advertisedFps = advertisedFps,
-      sinkFps = sinkFps,
-      admittedFps = admittedFps,
-      wireFps = wireFps,
-      wireBitrateBps = wireBitrateBps,
-      budgetBps = budgetBps,
-      cpuPercent = cpuPercent,
-    )
-    val wireLabel = wireFps?.let { PipelineStats.formatRate(it) } ?: "na"
-    val wireKbps = wireBitrateBps?.let { (it / 1000).toString() } ?: "na"
-    return "P7 rate bound=$bound advertised=${PipelineStats.formatRate(advertisedFps)} " +
-      "sink=${PipelineStats.formatRate(sinkFps)} admitted=${PipelineStats.formatRate(admittedFps)} " +
-      "wire=$wireLabel kbps=$wireKbps budgetKbps=${budgetBps / 1000} " +
-      "cpu=${cpuPercent?.let { PipelineStats.formatRate(it) } ?: "na"} " +
-      "codec=${codecName.ifBlank { "na" }.replace(' ', '_')} -- ${hint(bound)}"
-  }
-}

package/android/src/main/java/com/mentra/acsmeeting/trace/SoftApTrace.kt

@@ -1,143 +0,0 @@
-package com.mentra.acsmeeting.trace
-
-import android.os.SystemClock
-import android.util.Log
-
-/**
- * Correlated stage logging for the SoftAP calling pipeline (phone side).
- *
- * TEMPORARY DIAGNOSTIC. Every line carries the literal `SOFTAP_TRACE` marker so a single
- * `rg -n 'SOFTAP_TRACE'` finds all of them at cleanup time. Flip [ENABLED] to false to mute the
- * layer for a release without deleting call sites.
- *
- * The logcat tag is deliberately distinct from the module's `ACS-SPIKE` tag so that
- * `adb logcat -s SOFTAP-TRACE` isolates the whole SoftAP pipeline in one stream.
- *
- * The phone mints [traceId] when it starts the hotspot and passes it to the glasses in
- * `start_stream`. Both devices stamp the same id on every line, which is the only way to correlate
- * two logs whose clocks were never synchronised.
- */
-object SoftApTrace {
-
-    /** Master switch. Flip to false to mute the trace without removing call sites. */
-    const val ENABLED = true
-
-    /** Grep marker. Never build this by concatenation — a single grep must be exhaustive. */
-    const val MARKER = "SOFTAP_TRACE"
-
-    const val TAG = "SOFTAP-TRACE"
-
-    private const val REDACTED = "<redacted>"
-
-    /** Keys whose values must never reach logcat. Matched case-insensitively as substrings. */
-    private val SENSITIVE_KEYS = listOf(
-        "password", "passwd", "passphrase", "psk", "token", "secret",
-        "credential", "authorization", "bearer", "meetingurl",
-    )
-
-    @Volatile
-    private var traceId: String = ""
-
-    @Volatile
-    private var originMs: Long = 0L
-
-    @Volatile
-    private var lastStage: String = ""
-
-    /** Mint a new trace id and reset the elapsed-time origin. Called when the hotspot request starts. */
-    fun begin(id: String = newTraceId()): String {
-        traceId = id
-        originMs = SystemClock.elapsedRealtime()
-        lastStage = ""
-        return id
-    }
-
-    fun reset() {
-        traceId = ""
-        originMs = 0L
-        lastStage = ""
-    }
-
-    fun traceId(): String = traceId
-
-    /** Last stage successfully logged; use as failure context when reporting an error. */
-    fun lastStage(): String = lastStage
-
-    /** Short, collision-resistant enough for correlating one call's logs. */
-    fun newTraceId(): String = java.lang.Long.toHexString(System.nanoTime() and 0xFFFFFFFFL)
-
-    /**
-     * Log one pipeline stage transition.
-     *
-     * @param stage stable snake_case stage name, e.g. `scoped_network_available`
-     */
-    fun stage(stage: String, vararg fields: Pair<String, Any?>) {
-        if (!ENABLED) return
-        lastStage = stage
-        val elapsedMs = if (originMs == 0L) 0L else SystemClock.elapsedRealtime() - originMs
-        Log.i(TAG, format(traceId, stage, elapsedMs, *fields))
-    }
-
-    /** Error-level variant so genuine failures survive a logcat level filter. */
-    fun failure(stage: String, vararg fields: Pair<String, Any?>) {
-        if (!ENABLED) return
-        val elapsedMs = if (originMs == 0L) 0L else SystemClock.elapsedRealtime() - originMs
-        Log.e(TAG, format(traceId, stage, elapsedMs, *fields, "afterStage" to lastStage))
-    }
-
-    /**
-     * Pure formatter. Split out from [stage] so it can be unit tested without the Android logging
-     * framework, which is not available to plain JVM tests in this module.
-     */
-    fun format(
-        traceId: String,
-        stage: String,
-        elapsedMs: Long,
-        vararg fields: Pair<String, Any?>,
-    ): String = buildString {
-        append('[').append(MARKER).append(']')
-        if (traceId.isNotEmpty()) append(" traceId=").append(traceId)
-        append(" stage=").append(stage)
-        append(" elapsedMs=").append(elapsedMs)
-        for ((key, value) in fields) {
-            append(' ').append(key).append('=').append(sanitize(key, value))
-        }
-    }
-
-    /**
-     * Redact secrets outright and strip query strings from URLs. The local WHIP URL is genuinely
-     * useful in a trace, but a URL carrying a watch token is not, so query and userinfo go.
-     */
-    fun sanitize(key: String, value: Any?): String {
-        if (isSensitive(key)) return REDACTED
-        if (value == null) return "null"
-
-        val text = value.toString()
-        if (text.isEmpty()) return "\"\""
-        val cleaned = stripUrlSecrets(text)
-        return if (cleaned.contains(' ')) "\"$cleaned\"" else cleaned
-    }
-
-    private fun isSensitive(key: String): Boolean {
-        val lower = key.lowercase()
-        return SENSITIVE_KEYS.any { lower.contains(it) }
-    }
-
-    /** Drop `?query`, `#fragment`, and `user:pass@` from anything URL-shaped. */
-    private fun stripUrlSecrets(text: String): String {
-        val schemeIndex = text.indexOf("://")
-        if (schemeIndex < 0) return text
-
-        var result = text
-        val query = result.indexOf('?')
-        if (query >= 0) result = result.substring(0, query) + "?" + REDACTED
-        val fragment = result.indexOf('#')
-        if (fragment >= 0) result = result.substring(0, fragment)
-
-        val at = result.indexOf('@', schemeIndex + 3)
-        if (at >= 0) {
-            result = result.substring(0, schemeIndex + 3) + REDACTED + "@" + result.substring(at + 1)
-        }
-        return result
-    }
-}

package/android/src/main/java/com/mentra/acsmeeting/video/FrameGeometry.kt

@@ -1,22 +0,0 @@
-package com.mentra.acsmeeting.video
-
-/**
- * Pack I420 in the buffer's coordinate system, never [VideoFrame.rotatedWidth].
- * cropAndScale and toI420 planes are un-rotated; mixing them with display size
- * overruns the plane at rotation 90/270.
- */
-object FrameGeometry {
-  data class PackSize(
-    val width: Int,
-    val height: Int,
-    val rotationNonZero: Boolean,
-  )
-
-  fun packSize(bufferWidth: Int, bufferHeight: Int, rotationDegrees: Int): PackSize {
-    return PackSize(
-      width = bufferWidth,
-      height = bufferHeight,
-      rotationNonZero = rotationDegrees % 360 != 0,
-    )
-  }
-}

package/android/src/main/java/com/mentra/acsmeeting/video/I420Packer.kt

@@ -1,72 +0,0 @@
-package com.mentra.acsmeeting.video
-
-import java.nio.ByteBuffer
-import kotlin.math.roundToInt
-
-/** Tight I420 pack + stride math. No Android / ACS / WebRTC types so JVM tests stay cheap. */
-object I420Packer {
-  fun packedSize(width: Int, height: Int): Int {
-    val chromaW = (width + 1) / 2
-    val chromaH = (height + 1) / 2
-    return width * height + 2 * chromaW * chromaH
-  }
-
-  fun chromaStride(width: Int): Int = (width + 1) / 2
-
-  /**
-   * Bytes a reader must be able to see for a plane with [stride], starting at
-   * the buffer's current position. Last row is only [width] bytes, not a full
-   * stride, so this is `stride*(height-1)+width`.
-   */
-  fun planeMinBytes(stride: Int, width: Int, height: Int): Int {
-    if (width <= 0 || height <= 0 || stride < width) return 0
-    return stride * (height - 1) + width
-  }
-
-  /**
-   * Packs padded WebRTC planes into tight I420 (strideY=width, strideU=strideV=(width+1)/2).
-   */
-  fun pack(
-    dataY: ByteBuffer,
-    strideY: Int,
-    dataU: ByteBuffer,
-    strideU: Int,
-    dataV: ByteBuffer,
-    strideV: Int,
-    width: Int,
-    height: Int,
-    dest: ByteBuffer,
-  ) {
-    dest.clear()
-    val chromaW = chromaStride(width)
-    val chromaH = chromaStride(height)
-    copyPlane(dataY, strideY, width, height, dest)
-    copyPlane(dataU, strideU, chromaW, chromaH, dest)
-    copyPlane(dataV, strideV, chromaW, chromaH, dest)
-    dest.flip()
-  }
-
-  fun copyPlane(src: ByteBuffer, stride: Int, width: Int, height: Int, dest: ByteBuffer) {
-    val plane = src.duplicate()
-    val origin = plane.position()
-    if (stride == width && plane.remaining() >= width * height) {
-      plane.limit(origin + width * height)
-      dest.put(plane)
-      return
-    }
-    for (row in 0 until height) {
-      val start = origin + row * stride
-      plane.limit(start + width)
-      plane.position(start)
-      dest.put(plane)
-    }
-  }
-
-  fun percentileMs(samplesNs: LongArray, quantile: Double): String {
-    if (samplesNs.isEmpty()) return "na"
-    val sorted = samplesNs.copyOf()
-    sorted.sort()
-    val index = ((sorted.size - 1) * quantile).roundToInt().coerceIn(0, sorted.lastIndex)
-    return ((sorted[index] / 1_000_000.0) * 10).roundToInt().div(10.0).toString()
-  }
-}