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

package/android/src/main/java/com/mentra/acsmeeting/CallCapabilities.kt

@@ -0,0 +1,33 @@
+package com.mentra.acsmeeting
+
+/**
+ * One ACS participant capability, as reported to the host.
+ *
+ * [allowed] is nullable on purpose. "Denied" and "not known yet" are different facts and the UI has
+ * to treat them differently: a denied End must be hidden, while an unknown one is what every call
+ * looks like for the moment between joining and the first capabilities event.
+ */
+data class CapabilityStatus(val allowed: Boolean? = null, val reason: String? = null) {
+    fun toMap(): Map<String, Any?> = mapOf("allowed" to allowed, "reason" to reason)
+}
+
+/**
+ * Whether an End-for-everyone attempt should be made at all.
+ *
+ * Teams only lets a presenter end a meeting for everyone, and ACS surfaces that as the runtime
+ * capability `HANG_UP_FOR_EVERYONE`. Refusing a known-denied End locally is better than sending it:
+ * ACS rejects it with an opaque error, and the wearer would have watched a confirm sheet for
+ * nothing. An *unknown* capability is not a refusal — it is the ordinary state before the first
+ * capabilities event lands, and letting the service decide is more honest than guessing.
+ */
+object EndForEveryonePolicy {
+
+    const val REFUSED_PREFIX = "hang_up_for_everyone_not_allowed"
+
+    /** The refusal to report, or null when the End should be attempted. */
+    fun refusalFor(status: CapabilityStatus): String? {
+        if (status.allowed != false) return null
+        val reason = status.reason?.takeIf { it.isNotBlank() } ?: "unknown"
+        return "$REFUSED_PREFIX:$reason"
+    }
+}

package/android/src/main/java/com/mentra/acsmeeting/audio/AcsAudioPolicy.kt

@@ -82,6 +82,27 @@ object CapturePolicy {
   fun captureGlassesMic(source: AudioSourceKind): Boolean = source == AudioSourceKind.GLASSES
 }
 
+/**
+ * Which of the two possible sources of the wearer's voice this call listens to.
+ *
+ * SoftAP takes BLE LC3 from the host ([AcsMeetingSession.pushOutgoingPcm]) and ignores the WHIP
+ * track, which the glasses publish video-only (`captureAudio=false`). WHEP has no such flag: the
+ * wearer's voice is already mixed into the subscribed track, so that call takes the relay.
+ * Exactly one source is ever on.
+ *
+ * A previous revision routed SoftAP to the relay too, on a soak that read LC3 `meanAbs` ~15 as
+ * "analog-silent". Bench measurement of the same path puts the quiet-room floor at ~30–60, and
+ * that soak had already published with `captureAudio=false`, so neither the BES capture nor the
+ * SoC microphone was at fault. The JS gate `SOFTAP_BLE_LC3_UPLINK` and this routing move together.
+ */
+data class GlassesPcmRouting(val relayPcm: Boolean, val externalPcm: Boolean) {
+  companion object {
+    fun decide(softap: Boolean, enabled: Boolean): GlassesPcmRouting =
+      if (softap) GlassesPcmRouting(relayPcm = false, externalPcm = enabled)
+      else GlassesPcmRouting(relayPcm = enabled, externalPcm = false)
+  }
+}
+
 /** Null ACS call handles must fail, never report success via `call?.mute(); Unit`. */
 object CallGuard {
   fun <T : Any> require(value: T?): Result<T> =

package/android/src/main/java/com/mentra/acsmeeting/audio/AudioUplinkChain.kt

@@ -0,0 +1,126 @@
+package com.mentra.acsmeeting.audio
+
+/**
+ * Everything between "a microphone buffer arrived" and "the pacer has it", behind one lock.
+ *
+ * The lock is the point. Muting an audio path is not one flag: the wearer's voice is spread across
+ * a delay ring, a resampler's filter history, a partial 20 ms frame, and the pacer's ring, and
+ * clearing them one at a time leaves whichever stage the producer thread happened to be writing to.
+ * Serializing ingest against mute is what makes "mute" mean the same thing at every stage.
+ *
+ * It cannot make mute instantaneous at the far end. Buffers already handed to ACS cannot be
+ * recalled, so the residual tail is bounded by [UplinkSender.MAX_IN_FLIGHT] frames and measured
+ * rather than assumed — see the sender's `muteTailMs`.
+ *
+ * @param bridge downmix/resample to the 48 kHz mono 20 ms frames ACS wants
+ * @param pacer the clock-domain adapter the sender drains
+ * @param delayMs how long to hold input before the bridge, for A/V alignment (0 = passthrough)
+ * @param onIngest raw input plus arrival time, before the delay line, for A/V clap measurement
+ */
+class AudioUplinkChain(
+  private val bridge: PcmBridge,
+  private val pacer: UplinkPacer,
+  private val delayMs: Int = 0,
+  private val clock: () -> Long = System::nanoTime,
+  private val onIngest: ((pcm: ByteArray, nowNs: Long) -> Unit)? = null,
+) {
+  private val lock = Any()
+  private val delay = DelayLine(delayMs.coerceIn(0, MAX_DELAY_MS))
+  @Volatile private var muted = false
+
+  /**
+   * Accept one microphone buffer. A no-op while muted, so muted audio never enters any stage and
+   * an unmute cannot resurrect words the wearer said while muted.
+   */
+  fun ingest(pcm: ByteArray, sampleRate: Int, channels: Int) {
+    synchronized(lock) {
+      if (muted) return
+      val now = clock()
+      onIngest?.invoke(pcm, now)
+      for (chunk in delay.push(pcm, now)) {
+        for (frame in bridge.ingest(chunk, sampleRate, channels)) pacer.push(frame)
+      }
+    }
+  }
+
+  /** Stop accepting audio and drop everything already buffered, atomically against [ingest]. */
+  fun mute() {
+    synchronized(lock) {
+      muted = true
+      resetLocked()
+    }
+  }
+
+  /** Accept audio again. The pacer re-prerolls, so Teams hears voice one preroll later. */
+  fun unmute() {
+    synchronized(lock) { muted = false }
+  }
+
+  fun isMuted(): Boolean = muted
+
+  /** Drop buffered audio without changing the mute state. For leave and source rebuilds. */
+  fun reset() {
+    synchronized(lock) { resetLocked() }
+  }
+
+  /** Buffered input held for A/V alignment, in bytes. Diagnostics and tests. */
+  fun delayedBytes(): Int = synchronized(lock) { delay.heldBytes() }
+
+  private fun resetLocked() {
+    delay.reset()
+    bridge.reset()
+    pacer.reset()
+  }
+
+  /**
+   * Holds input until it is [delayMs] old.
+   *
+   * In front of the resampler rather than behind it so the delay is expressed in the input's own
+   * arrival times, which is what a receiver-side A/V measurement calibrates against.
+   */
+  private class DelayLine(private val delayMs: Int) {
+    private class Chunk(val bytes: ByteArray, val atNanos: Long)
+
+    private val queue = ArrayDeque<Chunk>()
+    private var bytesHeld = 0
+
+    fun push(pcm: ByteArray, nowNanos: Long): List<ByteArray> {
+      if (delayMs <= 0) return listOf(pcm)
+      queue.addLast(Chunk(pcm, nowNanos))
+      bytesHeld += pcm.size
+      val threshold = delayMs * 1_000_000L
+      val released = mutableListOf<ByteArray>()
+      while (queue.isNotEmpty()) {
+        val head = queue.first()
+        if (nowNanos - head.atNanos < threshold) break
+        queue.removeFirst()
+        bytesHeld -= head.bytes.size
+        released.add(head.bytes)
+      }
+      // Age alone bounds this in normal operation. The cap is for the case it cannot see: a clock
+      // that does not advance would otherwise turn a held buffer into an unbounded one.
+      val cap = delayMs * MAX_BYTES_PER_MS
+      while (bytesHeld > cap && queue.isNotEmpty()) {
+        val dropped = queue.removeFirst()
+        bytesHeld -= dropped.bytes.size
+        released.add(dropped.bytes)
+      }
+      return released
+    }
+
+    fun reset() {
+      queue.clear()
+      bytesHeld = 0
+    }
+
+    fun heldBytes(): Int = bytesHeld
+  }
+
+  companion object {
+    /** Half a second is already unusable as conversation; past that it is a bug, not a setting. */
+    const val MAX_DELAY_MS = 500
+
+    /** 48 kHz stereo PCM16, the widest input the bridge accepts. Sizes the safety cap only. */
+    internal const val MAX_BYTES_PER_MS = 48_000 * 2 * 2 / 1000
+  }
+}

package/android/src/main/java/com/mentra/acsmeeting/audio/PcmBridge.kt

@@ -20,6 +20,8 @@ class PcmBridge(
   private val outgoing = ByteArrayOutputStream()
   private val resampler = PcmResampler(TARGET_RATE)
   private var lastRmsLogMs = 0L
+  @Volatile var lastMeanAbs: Int = -1
+    private set
 
   fun ingest(pcm16Le: ByteArray, sampleRate: Int, channels: Int): List<ByteArray> {
     if (dump != null && !dumped) {
@@ -47,6 +49,19 @@ class PcmBridge(
     return frames
   }
 
+  /**
+   * Drop the state that spans calls to [ingest]: the resampler's filter history and fractional
+   * phase, and the partial 20 ms frame not yet emitted.
+   *
+   * What makes this necessary is that both are, by design, audio the wearer already spoke. A mute
+   * that left them behind would emit them on the next unmute — a fraction of a word, from before
+   * the wearer asked not to be heard. Serialization is the caller's job; see [AudioUplinkChain].
+   */
+  fun reset() {
+    resampler.reset()
+    outgoing.reset()
+  }
+
   @Synchronized
   fun finishDump() {
     if (dumped) return
@@ -60,9 +75,6 @@ class PcmBridge(
   }
 
   private fun logLevel(pcm: ByteArray, sampleRate: Int, channels: Int) {
-    val now = System.currentTimeMillis()
-    if (now - lastRmsLogMs < 1000) return
-    lastRmsLogMs = now
     var acc = 0L
     var n = 0
     var i = 0
@@ -74,7 +86,12 @@ class PcmBridge(
       i += 2
     }
     val mean = if (n == 0) 0 else acc / n
-    Log.i(TAG, "P4 pcm rate=$sampleRate ch=$channels meanAbs=$mean bytes=${pcm.size}")
+    lastMeanAbs = mean.toInt()
+    val now = System.currentTimeMillis()
+    if (now - lastRmsLogMs < 1000) return
+    lastRmsLogMs = now
+    val verdict = if (mean < SILENCE_MEAN_ABS) "SILENCE" else "voice"
+    Log.i(TAG, "P4 pcm rate=$sampleRate ch=$channels meanAbs=$mean bytes=${pcm.size} $verdict")
   }
 
   companion object {
@@ -104,5 +121,11 @@ class PcmBridge(
     }
 
     fun encodeBase64(pcm: ByteArray): String = Base64.encodeToString(pcm, Base64.NO_WRAP)
+
+    /**
+     * 16-bit speech sits in the hundreds to thousands. Below this is the LC3/ADC noise floor
+     * Teams hears as mute even when ACS is unmuted and the pacer is RUNNING.
+     */
+    const val SILENCE_MEAN_ABS = 50
   }
 }

package/android/src/main/java/com/mentra/acsmeeting/audio/UplinkPacer.kt

@@ -13,7 +13,8 @@ import kotlin.math.min
  *
  * - sustained depth above [HIGH_MS] (producer fast) discards a [CORRECTION_MS] slice
  * - sustained depth below [LOW_MS] (producer slow) inserts a [CORRECTION_MS] slice of silence
- * - depth above [EMERGENCY_CAP_MS] drops oldest down to target immediately
+ * - depth above [EMERGENCY_CAP_MS] shears only the peak above the cap — not back to target.
+ *   Shearing to target was a 150 ms hole every time the SoftAP delay line released a burst.
  *
  * Corrections read an EMA over roughly two seconds and are rate limited to one
  * per [CORRECTION_INTERVAL_MS], so ordinary jitter never triggers one; only
@@ -28,7 +29,10 @@ import kotlin.math.min
  * [push] runs on the WebRTC audio thread and [tick] on the pacing thread, so
  * every entry point is synchronized on this instance.
  */
-class UplinkPacer(private val targetMs: Int = TARGET_MS) {
+class UplinkPacer(
+  private var targetMs: Int = TARGET_MS,
+  private val log: ((String) -> Unit)? = null,
+) {
   enum class State { PREROLLING, RUNNING, STARVED }
 
   /** One [FRAME_MS] frame. [silence] marks a frame the pacer manufactured. */
@@ -72,6 +76,15 @@ class UplinkPacer(private val targetMs: Int = TARGET_MS) {
   private var driftCorrections = 0L
   private var driftDroppedBytes = 0L
   private var driftInsertedBytes = 0L
+  private var lastUnderrunLogNanos = 0L
+
+  /** Select headroom for the producer before starting a call; discard the previous call's PCM. */
+  @Synchronized
+  fun configureTarget(ms: Int) {
+    require(ms in FRAME_MS..EMERGENCY_CAP_MS)
+    targetMs = ms
+    reset()
+  }
 
   /** Appends 48 kHz mono PCM16 from the producer thread. */
   @Synchronized
@@ -83,12 +96,12 @@ class UplinkPacer(private val targetMs: Int = TARGET_MS) {
       // A single burst larger than the whole ring: keep only the newest audio.
       offset = len - CAPACITY_BYTES
       len = CAPACITY_BYTES
-      overflowDroppedBytes += offset
+      noteDrop("overflow-push", offset)
     }
     val overflow = used + len - CAPACITY_BYTES
     if (overflow > 0) {
       dropOldest(overflow)
-      overflowDroppedBytes += overflow
+      noteDrop("overflow-push", overflow)
     }
     write(pcm16Le, offset, len)
   }
@@ -164,6 +177,7 @@ class UplinkPacer(private val targetMs: Int = TARGET_MS) {
     driftCorrections = 0
     driftDroppedBytes = 0
     driftInsertedBytes = 0
+    lastUnderrunLogNanos = 0
   }
 
   @Synchronized
@@ -201,9 +215,14 @@ class UplinkPacer(private val targetMs: Int = TARGET_MS) {
     val since = starvingSinceNanos
     if (since == null) {
       starvingSinceNanos = nowNanos
-    } else if (nowNanos - since >= STARVE_MS * 1_000_000L) {
+      if (lastUnderrunLogNanos == 0L || nowNanos - lastUnderrunLogNanos >= 1_000_000_000L) {
+        lastUnderrunLogNanos = nowNanos
+        log?.invoke("P8 audio-up drop reason=underrun depthMs=0 state=$state")
+      }
+    } else if (nowNanos - since >= STARVE_MS * 1_000_000L && state != State.STARVED) {
       state = State.STARVED
       depthEmaBytes = -1.0
+      log?.invoke("P8 audio-up drop reason=starved depthMs=0 silentMs=$STARVE_MS")
     }
     return silence()
   }
@@ -211,9 +230,9 @@ class UplinkPacer(private val targetMs: Int = TARGET_MS) {
   private fun enforceCap() {
     val cap = EMERGENCY_CAP_MS * BYTES_PER_MS
     if (used <= cap) return
-    val excess = used - targetMs * BYTES_PER_MS
+    val excess = used - cap
     dropOldest(excess)
-    overflowDroppedBytes += excess
+    noteDrop("overflow-cap", excess)
     depthEmaBytes = used.toDouble()
   }
 
@@ -224,11 +243,11 @@ class UplinkPacer(private val targetMs: Int = TARGET_MS) {
     val emaMs = depthEmaBytes / BYTES_PER_MS
     val slice = CORRECTION_MS * BYTES_PER_MS
     when {
-      emaMs > HIGH_MS -> {
+      emaMs > targetMs + (HIGH_MS - TARGET_MS) -> {
         dropOldest(slice)
         driftDroppedBytes += slice
       }
-      emaMs < LOW_MS -> {
+      emaMs < targetMs - (TARGET_MS - LOW_MS) -> {
         if (used + slice > CAPACITY_BYTES) return
         write(SILENCE_SLICE, 0, slice)
         driftInsertedBytes += slice
@@ -240,6 +259,15 @@ class UplinkPacer(private val targetMs: Int = TARGET_MS) {
     depthEmaBytes = used.toDouble()
   }
 
+  private fun noteDrop(reason: String, bytes: Int) {
+    if (bytes <= 0) return
+    overflowDroppedBytes += bytes
+    log?.invoke(
+      "P8 audio-up drop reason=$reason droppedMs=${bytes / BYTES_PER_MS} " +
+        "depthMs=${used / BYTES_PER_MS} state=$state",
+    )
+  }
+
   private fun dropOldest(bytes: Int) {
     val n = min(bytes, used)
     head = (head + n) % CAPACITY_BYTES
@@ -285,9 +313,16 @@ class UplinkPacer(private val targetMs: Int = TARGET_MS) {
     const val FRAME_BYTES = FRAME_MS * BYTES_PER_MS
 
     const val TARGET_MS = 60
+    // Device traces contain 90–130 ms BLE delivery gaps. Preserve enough real PCM for those gaps.
+    const val LC3_TARGET_MS = 160
     const val LOW_MS = 40
     const val HIGH_MS = 100
-    const val EMERGENCY_CAP_MS = 200
+    /**
+     * Peak the ring may hold. SoftAP+LC3 parks ~170 ms in the delay line and then
+     * releases it as a burst; 200 ms used to shear that dump back to [TARGET_MS]
+     * and punch a hole the wearer hears as a dropout.
+     */
+    const val EMERGENCY_CAP_MS = 400
 
     const val CORRECTION_MS = 10
     const val CORRECTION_INTERVAL_MS = 500L

package/android/src/main/java/com/mentra/acsmeeting/audio/UplinkSender.kt

@@ -3,7 +3,9 @@ package com.mentra.acsmeeting.audio
 import android.util.Log
 import com.azure.android.communication.calling.RawAudioBuffer
 import com.azure.android.communication.calling.RawOutgoingAudioStream
+import com.mentra.acsmeeting.source.AcsInvestigation
 import com.mentra.acsmeeting.telemetry.RingPercentile
+import com.mentra.acsmeeting.video.AcsTimestamp
 import java.nio.ByteBuffer
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicInteger
@@ -22,8 +24,28 @@ fun interface UplinkTransport {
   fun send(frame: ByteArray, onComplete: (Throwable?) -> Unit)
 }
 
-/** [UplinkTransport] over ACS's raw outgoing audio stream. */
-class AcsUplinkTransport(private val stream: RawOutgoingAudioStream) : UplinkTransport {
+/**
+ * [UplinkTransport] over ACS's raw outgoing audio stream.
+ *
+ * Every buffer is stamped on the same 100-nanosecond tick base the outgoing video uses
+ * ([AcsTimestamp]), because `System.nanoTime()` is the only reference the two streams share — the
+ * audio arrives over BLE and the video over the SoftAP peer, so submission order says nothing about
+ * capture order. Unlike `VirtualOutgoingVideoStream`, `RawOutgoingAudioStream` in 2.16.0 offers no
+ * stream clock to prefer, so the capture time is always the source.
+ *
+ * Whether ACS actually *uses* these ticks to lip-sync raw audio at the receiver is an open question
+ * that only a receiver-side recording answers. Stamping them is the precondition for asking it, not
+ * the answer, and it is separately worth doing: a run of zero timestamps is what makes the Teams
+ * jitter buffer hold. [AcsInvestigation.acsAudioTimestamps] turns it off so the question can be
+ * asked both ways on the same device.
+ */
+class AcsUplinkTransport(
+  private val stream: RawOutgoingAudioStream,
+  private val clock: () -> Long = System::nanoTime,
+  private val stamp: Boolean = AcsInvestigation.acsAudioTimestamps,
+) : UplinkTransport {
+  private var lastTicks = 0L
+
   override fun send(frame: ByteArray, onComplete: (Throwable?) -> Unit) {
     // Fresh direct storage per submission. Pooling is a valid follow-up, but
     // only if buffers return to the pool on completion rather than on return.
@@ -32,6 +54,11 @@ class AcsUplinkTransport(private val stream: RawOutgoingAudioStream) : UplinkTra
     direct.flip()
     val buffer = RawAudioBuffer()
     buffer.buffer = direct
+    if (stamp) {
+      val ticks = AcsTimestamp.resolve(streamTicks = 0L, captureNs = clock(), lastTicks = lastTicks)
+      lastTicks = ticks
+      buffer.timestampInTicks = ticks
+    }
     stream.sendRawAudioBuffer(buffer).whenComplete { _, error ->
       try {
         buffer.close()
@@ -60,6 +87,19 @@ class UplinkSender(
   private val pacer: UplinkPacer,
   private val transport: UplinkTransport,
   private val clock: () -> Long = System::nanoTime,
+  /**
+   * Read immediately before every submission, not once per period.
+   *
+   * The last gate on the path. The pacer pops a frame and the transport accepts it on the same
+   * thread but not at the same instant, and a mute that lands in between would otherwise put the
+   * wearer's last word on the call after they asked not to be heard.
+   */
+  private val muted: () -> Boolean = { false },
+  /**
+   * Latest 16-bit mean-abs from [PcmBridge]. Mute flags and a RUNNING pacer both look healthy on
+   * analog-silent LC3; this is what tells a soak that Teams is hearing the noise floor.
+   */
+  private val pcmMeanAbs: () -> Int = { -1 },
   private val log: (String) -> Unit = { Log.i(TAG, it) },
   private val logError: (String, Throwable?) -> Unit = { message, error -> Log.e(TAG, message, error) },
 ) {
@@ -70,6 +110,14 @@ class UplinkSender(
     val inFlight: Int,
     val sendFailures: Long,
     val backpressureDrops: Long,
+    /** Frames replaced by silence by the mute gate, i.e. voice that never reached Teams. */
+    val mutedFrames: Long,
+    /**
+     * How long after a mute the buffers ACS had already accepted took to drain, or null while no
+     * mute has completed. This is the honest measure of "when did Teams stop hearing the wearer";
+     * the gate itself is instantaneous, `sendRawAudioBuffer` is not.
+     */
+    val muteTailMs: Long?,
   )
 
   private val running = AtomicBoolean(false)
@@ -86,6 +134,11 @@ class UplinkSender(
   @Volatile private var backpressureDrops = 0L
   @Volatile private var lastLogNanos: Long? = null
   @Volatile private var lastFailureLogNanos: Long? = null
+  @Volatile private var mutedFrames = 0L
+  @Volatile private var mutedSinceNanos: Long? = null
+  @Volatile private var muteTailNanos: Long? = null
+  private var lastLoggedOverflowMs = 0L
+  private var lastLoggedSilence = 0L
 
   /** Idempotent: a second call is a no-op so a session can only ever pace once. */
   @Synchronized
@@ -96,6 +149,8 @@ class UplinkSender(
     }
     nextDeadlineNanos = null
     lastLogNanos = null
+    lastLoggedOverflowMs = 0
+    lastLoggedSilence = 0
     running.set(true)
     // Audio cadence: a late frame is an artifact, so outrank the RN and
     // decoder threads this competes with.
@@ -131,6 +186,8 @@ class UplinkSender(
     inFlight = inFlight.get(),
     sendFailures = sendFailures.get(),
     backpressureDrops = backpressureDrops,
+    mutedFrames = mutedFrames,
+    muteTailMs = muteTailNanos?.let { it / 1_000_000L },
   )
 
   private fun loop() {
@@ -166,6 +223,9 @@ class UplinkSender(
       deadline + PERIOD_NANOS
     }
     nextDeadlineNanos = next
+    // Before the submission, because this period's own frame is silence once muted and counting it
+    // as in flight would make the tail look like it never finished draining.
+    trackMuteTail(nowNanos)
     submit(pacer.tick(nowNanos))
     maybeLog(nowNanos)
     return next
@@ -177,11 +237,19 @@ class UplinkSender(
       backpressureDrops += 1
       return
     }
+    // Silence rather than nothing: the cadence ACS reads as a healthy stream has to continue, and
+    // a gap is a glitch on the far end rather than a mute.
+    val bytes = if (!frame.silence && muted()) {
+      mutedFrames += 1
+      SILENCE_FRAME
+    } else {
+      frame.bytes
+    }
     inFlight.incrementAndGet()
     framesSubmitted.incrementAndGet()
     val startedNanos = clock()
     try {
-      transport.send(frame.bytes) { error ->
+      transport.send(bytes) { error ->
         inFlight.decrementAndGet()
         completion.record(clock() - startedNanos)
         if (error != null) recordFailure(error)
@@ -192,6 +260,30 @@ class UplinkSender(
     }
   }
 
+  /**
+   * Time the drain of the buffers ACS accepted before the mute.
+   *
+   * Measured from the first period that observed the mute to the first period with nothing left in
+   * flight, which is the last moment any pre-mute voice can still be played out at the receiver.
+   */
+  private fun trackMuteTail(nowNanos: Long) {
+    if (!muted()) {
+      mutedSinceNanos = null
+      return
+    }
+    val since = mutedSinceNanos
+    if (since == null) {
+      mutedSinceNanos = nowNanos
+      muteTailNanos = null
+      return
+    }
+    if (muteTailNanos == null && inFlight.get() == 0) {
+      val tail = nowNanos - since
+      muteTailNanos = tail
+      log("P8 audio-up muteTailMs=${tail / 1_000_000L} mutedFrames=$mutedFrames")
+    }
+  }
+
   private fun recordFailure(error: Throwable) {
     sendFailures.incrementAndGet()
     val now = clock()
@@ -207,15 +299,22 @@ class UplinkSender(
     lastLogNanos = nowNanos
     if (last == null) return
     val pace = pacer.snapshot(nowNanos)
+    val overflowDelta = pace.overflowDroppedMs - lastLoggedOverflowMs
+    val silenceDelta = pace.silenceFrames - lastLoggedSilence
+    lastLoggedOverflowMs = pace.overflowDroppedMs
+    lastLoggedSilence = pace.silenceFrames
     log(
       "P8 audio-up state=${pace.state} depthMs=${pace.depthMs} targetMs=${pace.targetMs} " +
         "sentFps=${"%.1f".format(pace.sentFps)} silenceFrames=${pace.silenceFrames} " +
-        "overflowDroppedMs=${pace.overflowDroppedMs} driftCorrections=${pace.driftCorrections} " +
+        "overflowDroppedMs=${pace.overflowDroppedMs} dropMs=$overflowDelta silenceDelta=$silenceDelta " +
+        "driftCorrections=${pace.driftCorrections} " +
         "driftDroppedMs=${pace.driftDroppedMs} driftInsertedMs=${pace.driftInsertedMs} " +
         "tickLateP95Ms=${lateness.p95()} tickLateMaxMs=${maxLateNanos / 1_000_000L} " +
         "skippedTicks=$skippedTicks inFlight=${inFlight.get()} " +
         "sendFailures=${sendFailures.get()} sendCompletionP95Ms=${completion.p95()} " +
-        "backpressureDrops=$backpressureDrops",
+        "backpressureDrops=$backpressureDrops mutedFrames=$mutedFrames " +
+        "muteTailMs=${muteTailNanos?.let { it / 1_000_000L } ?: -1} " +
+        "pcmMeanAbs=${pcmMeanAbs()}",
     )
   }
 
@@ -226,5 +325,11 @@ class UplinkSender(
     const val MAX_IN_FLIGHT = 10
     private const val JOIN_TIMEOUT_MS = 500L
     private const val LOG_INTERVAL_NANOS = 1_000_000_000L
+
+    /**
+     * Shared, and safe to share: [UplinkTransport] contracts to copy into its own storage before
+     * returning, so nothing downstream retains this array.
+     */
+    private val SILENCE_FRAME = ByteArray(UplinkPacer.FRAME_BYTES)
   }
 }