590 lines
19 KiB
JavaScript
590 lines
19 KiB
JavaScript
/**
|
|
* group-playout-processor — adaptive PCM playout for group voice (per remote speaker).
|
|
*
|
|
* PCM-only bufferedMs; fractional read with clamp + EMA-smoothed rate.
|
|
* Under-target: tiered slowdown (delta-based) + optional panic (buffer hysteresis + dwell cap).
|
|
* Startup: silence until bufferedMs >= max(INITIAL_GATE_MS, target - START_GATE_TARGET_MARGIN_MS).
|
|
* Latency cap: shed when buffered PCM exceeds PCM_LATENCY_HARD_MS.
|
|
* maxPlayoutTargetMs in processorOptions must stay aligned with GCALL_GLOBAL_PLAYOUT_CAP_MS on main.
|
|
*/
|
|
const RING_CAPACITY = 48000;
|
|
const INITIAL_GATE_MS = 100;
|
|
const START_GATE_TARGET_MARGIN_MS = 20;
|
|
const DEFAULT_TARGET_MS = 100;
|
|
const ERROR_CLAMP_MS = 80;
|
|
const DEADZONE_MS = 6;
|
|
/** Minimum playback rate (over-target catch-up); under-target/panic may go lower. */
|
|
const RATE_MIN = 0.98;
|
|
const RATE_MAX = 1.01;
|
|
const EMA_ALPHA_SLOW = 0.06;
|
|
const EMA_ALPHA_FAST = 0.28;
|
|
const OUTSIDE_BAND_MS = 35;
|
|
const EMERGENCY_BAND_EXTRA_MS = 10;
|
|
const METRICS_QUANTA = 47;
|
|
const PCM_LATENCY_HARD_MS = 320;
|
|
const PCM_LATENCY_RELEASE_MS = 240;
|
|
const TARGET_RELEASE_MARGIN_MS = 40;
|
|
const OVER_TARGET_TIER_STRONG_MS = 170;
|
|
const OVER_TARGET_TIER_MID_MS = 90;
|
|
const OVER_TARGET_RATE_MID = 1.0065;
|
|
const OVER_TARGET_RATE_LIGHT = 1.0045;
|
|
const OVER_TARGET_FAST_ALPHA_MS = 125;
|
|
const CONCEALMENT_TAIL_SAMPLES = 240;
|
|
const CONCEALMENT_FADE_SAMPLES = 240;
|
|
const STATE_READ_HEAD = 0;
|
|
const STATE_WRITE_HEAD = 1;
|
|
const STATE_FILLED_SAMPLES = 2;
|
|
const STATE_UNDERRUNS = 3;
|
|
const SHARED_INGRESS_TIMESTAMP_MOD = 0x7fffffff;
|
|
|
|
/** Align with main-thread gcallPlayoutPolicy global cap (max severe across profiles). */
|
|
const DEFAULT_MAX_PLAYOUT_TARGET_MS = 280;
|
|
|
|
/** Under-target tiers (deltaMs = bufferedMs - target). */
|
|
const UNDER_TIER_DEEP_MS = -120;
|
|
const UNDER_TIER_MID_MS = -80;
|
|
const UNDER_TIER_SHALLOW_MS = -45;
|
|
const UNDER_TIER_RECOVERING_MS = -35;
|
|
const UNDER_RATE_DEEP = 0.94;
|
|
const UNDER_RATE_MID = 0.96;
|
|
const UNDER_RATE_SHALLOW = 0.98;
|
|
const UNDER_RATE_RECOVERING = 0.965;
|
|
const UNDER_RATE_DEEP_USABLE = 0.97;
|
|
const UNDER_RATE_MID_USABLE = 0.985;
|
|
const UNDER_RATE_SHALLOW_USABLE = 0.992;
|
|
const UNDER_USABLE_BUFFER_MIN_MS = 85;
|
|
const UNDER_USABLE_TARGET_RATIO = 0.62;
|
|
const UNDER_USABLE_DELTA_MIN_MS = -70;
|
|
const RATE_K_UNDER = 0.000125;
|
|
const RATE_K_OVER = 0.0001;
|
|
|
|
/** Panic: absolute PCM depth (hysteresis + dwell). */
|
|
const PANIC_ENTER_MS = 60;
|
|
const PANIC_EXIT_MS = 78;
|
|
const PANIC_RATE = 0.915;
|
|
const PANIC_DWELL_MS = 400;
|
|
const PANIC_RELAX_BLEND_MS = 500;
|
|
|
|
class GroupPlayoutProcessor extends AudioWorkletProcessor {
|
|
constructor(options) {
|
|
super();
|
|
this._sourceAddr = options.processorOptions?.sourceAddr ?? '';
|
|
this._maxPlayoutTargetMs =
|
|
typeof options.processorOptions?.maxPlayoutTargetMs === 'number' &&
|
|
Number.isFinite(options.processorOptions.maxPlayoutTargetMs)
|
|
? Math.max(
|
|
80,
|
|
Math.min(
|
|
DEFAULT_MAX_PLAYOUT_TARGET_MS,
|
|
options.processorOptions.maxPlayoutTargetMs
|
|
)
|
|
)
|
|
: DEFAULT_MAX_PLAYOUT_TARGET_MS;
|
|
|
|
this._ring = new Float32Array(RING_CAPACITY);
|
|
this._writePos = 0;
|
|
this._readPos = 0;
|
|
this._available = 0;
|
|
this._sharedRing = null;
|
|
this._sharedState = null;
|
|
this._sharedIngressTimestamps = null;
|
|
this._sharedFrameSamples = 0;
|
|
this._sharedIngressCapacityFrames = 0;
|
|
this._sharedSampleCapacity = 0;
|
|
|
|
this._readFrac = 0;
|
|
this._smoothedRate = 1;
|
|
this._targetPlayoutMs = DEFAULT_TARGET_MS;
|
|
this._playoutStarted = false;
|
|
|
|
this._inPanic = false;
|
|
this._panicSamplesInPanic = 0;
|
|
this._panicZoneEnteredPending = false;
|
|
this._panicEntryBufferedMs = null;
|
|
|
|
this._lastTail = new Float32Array(CONCEALMENT_TAIL_SAMPLES);
|
|
this._lastTailLen = 0;
|
|
this._lastTailWritePos = 0;
|
|
this._concealCursor = 0;
|
|
|
|
this._metricsQuantumCount = 0;
|
|
this._concealedThisBlock = false;
|
|
|
|
const sharedRing = options.processorOptions?.sharedRing;
|
|
const hasSharedArrayBuffer = typeof SharedArrayBuffer !== 'undefined';
|
|
if (
|
|
hasSharedArrayBuffer &&
|
|
sharedRing?.sampleBuffer instanceof SharedArrayBuffer &&
|
|
sharedRing?.stateBuffer instanceof SharedArrayBuffer
|
|
) {
|
|
this._sharedRing = new Float32Array(sharedRing.sampleBuffer);
|
|
this._sharedState = new Int32Array(sharedRing.stateBuffer);
|
|
this._sharedIngressTimestamps =
|
|
hasSharedArrayBuffer &&
|
|
sharedRing.ingressTimestampBuffer instanceof SharedArrayBuffer
|
|
? new Int32Array(sharedRing.ingressTimestampBuffer)
|
|
: null;
|
|
this._sharedFrameSamples =
|
|
typeof sharedRing.frameSamples === 'number' && sharedRing.frameSamples > 0
|
|
? sharedRing.frameSamples
|
|
: 0;
|
|
this._sharedIngressCapacityFrames =
|
|
typeof sharedRing.ingressCapacityFrames === 'number' &&
|
|
sharedRing.ingressCapacityFrames > 0
|
|
? sharedRing.ingressCapacityFrames
|
|
: 0;
|
|
this._sharedSampleCapacity =
|
|
typeof sharedRing.capacitySamples === 'number' && sharedRing.capacitySamples > 0
|
|
? sharedRing.capacitySamples
|
|
: this._sharedRing.length;
|
|
}
|
|
|
|
this.port.onmessage = (e) => {
|
|
const d = e.data;
|
|
if (d?.pcm instanceof Float32Array && d.pcm.length > 0) {
|
|
this._pushPcm(d.pcm);
|
|
return;
|
|
}
|
|
if (
|
|
d?.type === 'pcm-batch' &&
|
|
d.pcmBatch instanceof Float32Array &&
|
|
d.pcmBatch.length > 0
|
|
) {
|
|
this._pushPcm(d.pcmBatch);
|
|
return;
|
|
}
|
|
if (d?.type === 'target' && typeof d.targetPlayoutMs === 'number') {
|
|
this._targetPlayoutMs = Math.max(
|
|
40,
|
|
Math.min(this._maxPlayoutTargetMs, d.targetPlayoutMs)
|
|
);
|
|
return;
|
|
}
|
|
if (d?.type === 'reset') {
|
|
this._resetPlayoutState();
|
|
}
|
|
};
|
|
}
|
|
|
|
_resetPlayoutState() {
|
|
this._writePos = 0;
|
|
this._readPos = 0;
|
|
this._available = 0;
|
|
this._readFrac = 0;
|
|
this._smoothedRate = 1;
|
|
this._playoutStarted = false;
|
|
this._inPanic = false;
|
|
this._panicSamplesInPanic = 0;
|
|
this._panicZoneEnteredPending = false;
|
|
this._panicEntryBufferedMs = null;
|
|
this._lastTail.fill(0);
|
|
this._lastTailLen = 0;
|
|
this._lastTailWritePos = 0;
|
|
this._concealCursor = 0;
|
|
this._concealedThisBlock = false;
|
|
if (this._sharedState && this._sharedSampleCapacity > 0) {
|
|
Atomics.store(this._sharedState, STATE_READ_HEAD, 0);
|
|
Atomics.store(this._sharedState, STATE_WRITE_HEAD, 0);
|
|
Atomics.store(this._sharedState, STATE_FILLED_SAMPLES, 0);
|
|
this._sharedRing?.fill(0);
|
|
} else {
|
|
this._ring.fill(0);
|
|
}
|
|
}
|
|
|
|
_pushPcm(pcm) {
|
|
if (pcm.length > RING_CAPACITY) return;
|
|
if (this._available + pcm.length > RING_CAPACITY) {
|
|
const discard = this._available + pcm.length - RING_CAPACITY;
|
|
this._advanceReadInt(discard);
|
|
}
|
|
let toWrite = pcm.length;
|
|
let src = 0;
|
|
while (toWrite > 0) {
|
|
const chunk = Math.min(toWrite, RING_CAPACITY - this._writePos);
|
|
this._ring.set(pcm.subarray(src, src + chunk), this._writePos);
|
|
this._writePos = (this._writePos + chunk) % RING_CAPACITY;
|
|
src += chunk;
|
|
toWrite -= chunk;
|
|
}
|
|
this._available += pcm.length;
|
|
}
|
|
|
|
_advanceReadInt(n) {
|
|
if (n <= 0) return;
|
|
const take = Math.min(n, this._getAvailableSamples());
|
|
if (take <= 0) return;
|
|
if (this._sharedState && this._sharedSampleCapacity > 0) {
|
|
const readPos = Atomics.load(this._sharedState, STATE_READ_HEAD);
|
|
Atomics.store(
|
|
this._sharedState,
|
|
STATE_READ_HEAD,
|
|
(readPos + take) % this._sharedSampleCapacity
|
|
);
|
|
Atomics.sub(this._sharedState, STATE_FILLED_SAMPLES, take);
|
|
this._readPos = Atomics.load(this._sharedState, STATE_READ_HEAD);
|
|
this._available = Atomics.load(this._sharedState, STATE_FILLED_SAMPLES);
|
|
return;
|
|
}
|
|
this._readPos = (this._readPos + take) % RING_CAPACITY;
|
|
this._available -= take;
|
|
}
|
|
|
|
_sampleAtRead() {
|
|
if (this._getAvailableSamples() < 2) return 0;
|
|
const capacity = this._sharedRing ? this._sharedSampleCapacity : RING_CAPACITY;
|
|
const ring = this._sharedRing ?? this._ring;
|
|
const readPos = this._sharedState
|
|
? Atomics.load(this._sharedState, STATE_READ_HEAD)
|
|
: this._readPos;
|
|
const i0 = readPos % capacity;
|
|
const i1 = (readPos + 1) % capacity;
|
|
const s0 = ring[i0];
|
|
const s1 = ring[i1];
|
|
return s0 * (1 - this._readFrac) + s1 * this._readFrac;
|
|
}
|
|
|
|
_rememberTailSample(sample) {
|
|
this._lastTail[this._lastTailWritePos] = sample;
|
|
this._lastTailWritePos = (this._lastTailWritePos + 1) % this._lastTail.length;
|
|
if (this._lastTailLen < this._lastTail.length) {
|
|
this._lastTailLen++;
|
|
}
|
|
}
|
|
|
|
_tailSampleAt(offset) {
|
|
if (offset < 0 || offset >= this._lastTailLen) return 0;
|
|
const firstValid =
|
|
this._lastTailLen === this._lastTail.length ? this._lastTailWritePos : 0;
|
|
const idx = (firstValid + offset) % this._lastTail.length;
|
|
return this._lastTail[idx];
|
|
}
|
|
|
|
_stepReadOne(rate) {
|
|
this._readFrac += rate;
|
|
while (this._readFrac >= 1 && this._getAvailableSamples() > 0) {
|
|
this._readFrac -= 1;
|
|
if (this._sharedState && this._sharedSampleCapacity > 0) {
|
|
const readPos = Atomics.load(this._sharedState, STATE_READ_HEAD);
|
|
Atomics.store(
|
|
this._sharedState,
|
|
STATE_READ_HEAD,
|
|
(readPos + 1) % this._sharedSampleCapacity
|
|
);
|
|
Atomics.sub(this._sharedState, STATE_FILLED_SAMPLES, 1);
|
|
this._readPos = Atomics.load(this._sharedState, STATE_READ_HEAD);
|
|
this._available = Atomics.load(this._sharedState, STATE_FILLED_SAMPLES);
|
|
} else {
|
|
this._readPos = (this._readPos + 1) % RING_CAPACITY;
|
|
this._available -= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
_shedExcessPcmLatency(sampleRateHz) {
|
|
const availableSamples = this._getAvailableSamples();
|
|
const bufferedMs = (availableSamples / sampleRateHz) * 1000;
|
|
if (bufferedMs <= PCM_LATENCY_HARD_MS) return;
|
|
const releaseMs = Math.max(
|
|
PCM_LATENCY_RELEASE_MS,
|
|
this._targetPlayoutMs + TARGET_RELEASE_MARGIN_MS
|
|
);
|
|
const maxSamples = (releaseMs / 1000) * sampleRateHz;
|
|
const toDrop = Math.floor(availableSamples - maxSamples);
|
|
if (toDrop > 0) {
|
|
this._advanceReadInt(toDrop);
|
|
this._readFrac = 0;
|
|
}
|
|
}
|
|
|
|
_getAvailableSamples() {
|
|
if (this._sharedState) {
|
|
this._available = Atomics.load(this._sharedState, STATE_FILLED_SAMPLES);
|
|
return this._available;
|
|
}
|
|
return this._available;
|
|
}
|
|
|
|
_computeOldestFrameAgeMs() {
|
|
if (
|
|
!this._sharedState ||
|
|
!this._sharedIngressTimestamps ||
|
|
this._sharedFrameSamples <= 0 ||
|
|
this._sharedIngressCapacityFrames <= 0 ||
|
|
this._getAvailableSamples() < this._sharedFrameSamples
|
|
) {
|
|
return 0;
|
|
}
|
|
const readPos = Atomics.load(this._sharedState, STATE_READ_HEAD);
|
|
const frameSlot =
|
|
Math.floor((readPos % this._sharedSampleCapacity) / this._sharedFrameSamples) %
|
|
this._sharedIngressCapacityFrames;
|
|
const ingressAtMs = Atomics.load(this._sharedIngressTimestamps, frameSlot);
|
|
if (ingressAtMs <= 0) return 0;
|
|
const nowMs = Date.now();
|
|
if (!Number.isFinite(nowMs) || nowMs <= 0) return 0;
|
|
let deltaMs =
|
|
Math.round(nowMs % SHARED_INGRESS_TIMESTAMP_MOD) - ingressAtMs;
|
|
if (deltaMs < 0) {
|
|
deltaMs += SHARED_INGRESS_TIMESTAMP_MOD;
|
|
}
|
|
return Math.max(0, deltaMs);
|
|
}
|
|
|
|
/** Tier rate from delta only (under-target path). */
|
|
_underTierRate(deltaMs, bufferedMs) {
|
|
const usableBufferRelaxed =
|
|
this._playoutStarted &&
|
|
deltaMs >= UNDER_USABLE_DELTA_MIN_MS &&
|
|
bufferedMs >=
|
|
Math.max(UNDER_USABLE_BUFFER_MIN_MS, this._targetPlayoutMs * UNDER_USABLE_TARGET_RATIO);
|
|
if (deltaMs < UNDER_TIER_DEEP_MS) {
|
|
return usableBufferRelaxed ? UNDER_RATE_DEEP_USABLE : UNDER_RATE_DEEP;
|
|
}
|
|
if (deltaMs < UNDER_TIER_MID_MS) {
|
|
return usableBufferRelaxed ? UNDER_RATE_MID_USABLE : UNDER_RATE_MID;
|
|
}
|
|
if (deltaMs < UNDER_TIER_SHALLOW_MS) {
|
|
return usableBufferRelaxed ? UNDER_RATE_SHALLOW_USABLE : UNDER_RATE_SHALLOW;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
_computeRawTargetRate(bufferedMs, deltaMs, quantum, sampleRateHz) {
|
|
const emergencyThresh = OUTSIDE_BAND_MS + EMERGENCY_BAND_EXTRA_MS;
|
|
|
|
if (this._playoutStarted) {
|
|
if (!this._inPanic && bufferedMs < PANIC_ENTER_MS) {
|
|
this._inPanic = true;
|
|
this._panicSamplesInPanic = 0;
|
|
this._panicZoneEnteredPending = true;
|
|
this._panicEntryBufferedMs = bufferedMs;
|
|
} else if (this._inPanic && bufferedMs > PANIC_EXIT_MS) {
|
|
this._inPanic = false;
|
|
this._panicSamplesInPanic = 0;
|
|
}
|
|
if (this._inPanic) {
|
|
this._panicSamplesInPanic += quantum;
|
|
}
|
|
}
|
|
|
|
const panicMs =
|
|
sampleRateHz > 0
|
|
? (this._panicSamplesInPanic / sampleRateHz) * 1000
|
|
: 0;
|
|
const tierUnder = this._underTierRate(deltaMs, bufferedMs);
|
|
|
|
if (this._inPanic && this._playoutStarted) {
|
|
if (panicMs < PANIC_DWELL_MS) {
|
|
return { targetRate: PANIC_RATE, inPanic: true, panicZoneEntered: false };
|
|
}
|
|
const t = Math.min(
|
|
1,
|
|
Math.max(0, (panicMs - PANIC_DWELL_MS) / PANIC_RELAX_BLEND_MS)
|
|
);
|
|
const blended = PANIC_RATE * (1 - t) + tierUnder * t;
|
|
return { targetRate: blended, inPanic: true, panicZoneEntered: false };
|
|
}
|
|
|
|
if (deltaMs < UNDER_TIER_DEEP_MS) {
|
|
return { targetRate: UNDER_RATE_DEEP, inPanic: false, panicZoneEntered: false };
|
|
}
|
|
if (deltaMs < UNDER_TIER_MID_MS) {
|
|
return { targetRate: UNDER_RATE_MID, inPanic: false, panicZoneEntered: false };
|
|
}
|
|
if (deltaMs < UNDER_TIER_SHALLOW_MS) {
|
|
return { targetRate: UNDER_RATE_SHALLOW, inPanic: false, panicZoneEntered: false };
|
|
}
|
|
if (deltaMs < UNDER_TIER_RECOVERING_MS) {
|
|
return {
|
|
targetRate: UNDER_RATE_RECOVERING,
|
|
inPanic: false,
|
|
panicZoneEntered: false,
|
|
};
|
|
}
|
|
if (deltaMs > OVER_TARGET_TIER_STRONG_MS) {
|
|
return { targetRate: RATE_MAX, inPanic: false, panicZoneEntered: false };
|
|
}
|
|
if (deltaMs > OVER_TARGET_TIER_MID_MS) {
|
|
return {
|
|
targetRate: OVER_TARGET_RATE_MID,
|
|
inPanic: false,
|
|
panicZoneEntered: false,
|
|
};
|
|
}
|
|
if (deltaMs > emergencyThresh) {
|
|
return {
|
|
targetRate: OVER_TARGET_RATE_LIGHT,
|
|
inPanic: false,
|
|
panicZoneEntered: false,
|
|
};
|
|
}
|
|
let errorMs = Math.max(
|
|
-ERROR_CLAMP_MS,
|
|
Math.min(ERROR_CLAMP_MS, deltaMs)
|
|
);
|
|
if (Math.abs(errorMs) < DEADZONE_MS) errorMs = 0;
|
|
const k = errorMs > 0 ? RATE_K_OVER : RATE_K_UNDER;
|
|
const tr = 1 + Math.max(-0.01, Math.min(0.01, errorMs * k));
|
|
return { targetRate: tr, inPanic: false, panicZoneEntered: false };
|
|
}
|
|
|
|
process(_inputs, outputs) {
|
|
const output = outputs[0]?.[0];
|
|
if (!output) return true;
|
|
|
|
const sampleRateHz = globalThis.sampleRate;
|
|
const quantum = output.length;
|
|
|
|
this._shedExcessPcmLatency(sampleRateHz);
|
|
let bufferedMs = (this._getAvailableSamples() / sampleRateHz) * 1000;
|
|
const preProcessBufferedMs = bufferedMs;
|
|
const preProcessOldestFrameAgeMs = this._computeOldestFrameAgeMs();
|
|
|
|
this._concealedThisBlock = false;
|
|
|
|
if (!this._playoutStarted) {
|
|
const startGateMs = Math.max(
|
|
INITIAL_GATE_MS,
|
|
this._targetPlayoutMs - START_GATE_TARGET_MARGIN_MS
|
|
);
|
|
if (bufferedMs < startGateMs) {
|
|
output.fill(0);
|
|
this._concealCursor = 0;
|
|
this._maybePostMetrics(
|
|
bufferedMs,
|
|
quantum,
|
|
false,
|
|
1,
|
|
false,
|
|
preProcessBufferedMs,
|
|
preProcessOldestFrameAgeMs
|
|
);
|
|
return true;
|
|
}
|
|
this._playoutStarted = true;
|
|
}
|
|
|
|
const deltaMs = bufferedMs - this._targetPlayoutMs;
|
|
const raw = this._computeRawTargetRate(
|
|
bufferedMs,
|
|
deltaMs,
|
|
quantum,
|
|
sampleRateHz
|
|
);
|
|
let targetRate = raw.targetRate;
|
|
targetRate = Math.min(RATE_MAX, targetRate);
|
|
const floorR = raw.inPanic ? 0.9 : RATE_MIN;
|
|
targetRate = Math.max(floorR, targetRate);
|
|
|
|
const underStress =
|
|
raw.inPanic ||
|
|
deltaMs < UNDER_TIER_RECOVERING_MS ||
|
|
deltaMs > OVER_TARGET_FAST_ALPHA_MS;
|
|
const alpha = underStress ? EMA_ALPHA_FAST : EMA_ALPHA_SLOW;
|
|
this._smoothedRate += alpha * (targetRate - this._smoothedRate);
|
|
this._smoothedRate = Math.max(
|
|
raw.inPanic ? 0.9 : RATE_MIN,
|
|
Math.min(RATE_MAX, this._smoothedRate)
|
|
);
|
|
|
|
const rate = this._smoothedRate;
|
|
|
|
for (let i = 0; i < quantum; i++) {
|
|
if (this._getAvailableSamples() < 2) {
|
|
this._concealedThisBlock = true;
|
|
const conceal = this._concealSample();
|
|
output[i] = conceal;
|
|
continue;
|
|
}
|
|
const s = this._sampleAtRead();
|
|
output[i] = s;
|
|
this._rememberTailSample(s);
|
|
this._concealCursor = 0;
|
|
this._stepReadOne(rate);
|
|
}
|
|
|
|
this._maybePostMetrics(
|
|
(this._getAvailableSamples() / sampleRateHz) * 1000,
|
|
quantum,
|
|
this._concealedThisBlock,
|
|
rate,
|
|
raw.inPanic,
|
|
preProcessBufferedMs,
|
|
preProcessOldestFrameAgeMs
|
|
);
|
|
return true;
|
|
}
|
|
|
|
_concealSample() {
|
|
if (this._lastTailLen < 2) return 0;
|
|
const fadeLen = Math.min(this._lastTailLen, CONCEALMENT_FADE_SAMPLES);
|
|
if (this._concealCursor >= fadeLen) return 0;
|
|
const tailStart = this._lastTailLen - fadeLen;
|
|
const sample = this._tailSampleAt(tailStart + this._concealCursor);
|
|
const t = fadeLen <= 1 ? 1 : this._concealCursor / (fadeLen - 1);
|
|
const g = 1 - t;
|
|
this._concealCursor++;
|
|
return sample * g * g;
|
|
}
|
|
|
|
_maybePostMetrics(
|
|
bufferedMs,
|
|
quantum,
|
|
concealmentUsed,
|
|
smoothedRate,
|
|
panicActive,
|
|
preProcessBufferedMs,
|
|
preProcessOldestFrameAgeMs = 0
|
|
) {
|
|
this._metricsQuantumCount++;
|
|
if (this._metricsQuantumCount < METRICS_QUANTA) return;
|
|
this._metricsQuantumCount = 0;
|
|
const deltaMs = bufferedMs - this._targetPlayoutMs;
|
|
const outsideBandUnder =
|
|
this._playoutStarted && deltaMs < -OUTSIDE_BAND_MS;
|
|
const outsideBandOver =
|
|
this._playoutStarted && deltaMs > OUTSIDE_BAND_MS;
|
|
const outside = outsideBandUnder || outsideBandOver;
|
|
const panicZoneEntered = this._panicZoneEnteredPending;
|
|
const panicEntryBufferedMs = panicZoneEntered ? this._panicEntryBufferedMs : null;
|
|
const oldestFrameAgeMs =
|
|
typeof preProcessOldestFrameAgeMs === 'number' &&
|
|
Number.isFinite(preProcessOldestFrameAgeMs) &&
|
|
preProcessOldestFrameAgeMs > 0
|
|
? preProcessOldestFrameAgeMs
|
|
: this._computeOldestFrameAgeMs();
|
|
const playoutBand = outsideBandUnder
|
|
? 'under-target'
|
|
: outsideBandOver
|
|
? 'over-target'
|
|
: 'in-band';
|
|
this._panicZoneEnteredPending = false;
|
|
this._panicEntryBufferedMs = null;
|
|
this.port.postMessage({
|
|
type: 'gcallPlayoutMetrics',
|
|
sourceAddr: this._sourceAddr,
|
|
bufferedMs,
|
|
preProcessBufferedMs,
|
|
targetPlayoutMs: this._targetPlayoutMs,
|
|
rate: smoothedRate,
|
|
panicActive: !!panicActive,
|
|
panicZoneEntered: !!panicZoneEntered,
|
|
panicReason: panicZoneEntered ? 'absolute-low-buffer-entry' : undefined,
|
|
panicEntryBufferedMs,
|
|
panicEnterMs: PANIC_ENTER_MS,
|
|
panicExitMs: PANIC_EXIT_MS,
|
|
playoutBand,
|
|
outsideBand: outside,
|
|
outsideBandUnder,
|
|
outsideBandOver,
|
|
deltaMs,
|
|
oldestFrameAgeMs,
|
|
playoutStarted: this._playoutStarted,
|
|
concealmentUsed: !!concealmentUsed,
|
|
});
|
|
}
|
|
}
|
|
|
|
registerProcessor('group-playout-processor', GroupPlayoutProcessor);
|