@openmoq/playback 0.0.0-stage → 0.6.0

package/dist/startup-buffer.js

@@ -0,0 +1,107 @@
+/**
+ * StartupBuffer — holds frames before first drain to warm the jitter estimator.
+ *
+ * Prevents initial stutter by collecting N frames (determined by network class)
+ * before allowing the pipeline to start draining. During the hold, the adaptive
+ * tolerance controller calibrates from real arrival timing — so it's ready
+ * when playback begins.
+ *
+ * Network classification uses the QUIC handshake RTT (available before any media)
+ * to set initial parameters:
+ * - LAN (<1ms): 2 frames / 80ms max — near-zero startup delay
+ * - Near-LAN (1-5ms): 3 frames / 120ms
+ * - Metro WAN (5-50ms): 8 frames / 300ms
+ * - Long-haul WAN (>50ms): 12 frames / 500ms
+ *
+ * @see draft-ietf-moq-loc-01 §4.2 (decode order)
+ * @module
+ */
+/**
+ * Classify network conditions from QUIC handshake RTT.
+ *
+ * @param handshakeRttMs Round-trip time from the QUIC/WebTransport handshake
+ */
+export function classifyNetwork(handshakeRttMs) {
+    if (handshakeRttMs < 1) {
+        return { minFrames: 2, maxWaitMs: 80 };
+    }
+    else if (handshakeRttMs < 5) {
+        return { minFrames: 3, maxWaitMs: 120 };
+    }
+    else if (handshakeRttMs < 50) {
+        return { minFrames: 8, maxWaitMs: 300 };
+    }
+    else {
+        return { minFrames: 12, maxWaitMs: 500 };
+    }
+}
+// ─── StartupBuffer ──────────────────────────────────────────────────
+/**
+ * Gates pipeline draining until enough frames have arrived for smooth startup.
+ *
+ * Usage:
+ * ```ts
+ * // In pipeline.pushObject():
+ * startupBuffer.recordFrame(clock.now() / 1000);
+ *
+ * // In pipeline.tick():
+ * if (!startupBuffer.shouldDrain) return; // hold frames
+ * // ... normal drain logic
+ * ```
+ */
+export class StartupBuffer {
+    minFrames;
+    maxWaitMs;
+    _frameCount = 0;
+    _firstFrameMs = 0;
+    _lastFrameMs = 0;
+    _draining = false;
+    constructor(params) {
+        this.minFrames = params.minFrames;
+        this.maxWaitMs = params.maxWaitMs;
+    }
+    /**
+     * Record a frame arrival. Call from pushObject().
+     * @param nowMs Current time in milliseconds
+     */
+    recordFrame(nowMs) {
+        this._frameCount++;
+        if (this._frameCount === 1) {
+            this._firstFrameMs = nowMs;
+        }
+        this._lastFrameMs = nowMs;
+        // Check transition
+        if (!this._draining) {
+            const elapsed = this._lastFrameMs - this._firstFrameMs;
+            if (this._frameCount >= this.minFrames || elapsed >= this.maxWaitMs) {
+                this._draining = true;
+            }
+        }
+    }
+    /** Whether the pipeline should start draining (buffer phase complete). */
+    get shouldDrain() {
+        return this._draining;
+    }
+    /** Number of frames recorded. */
+    get frameCount() {
+        return this._frameCount;
+    }
+    /** Time elapsed since first frame in milliseconds. */
+    get elapsedMs() {
+        if (this._frameCount === 0)
+            return 0;
+        return this._lastFrameMs - this._firstFrameMs;
+    }
+    /** Accelerated EMA alpha for warmup (4x standard 1/16). */
+    get warmupEmaAlpha() {
+        return 0.25;
+    }
+    /** Reset to buffering state (e.g., after seek or pause→resume). */
+    reset() {
+        this._frameCount = 0;
+        this._firstFrameMs = 0;
+        this._lastFrameMs = 0;
+        this._draining = false;
+    }
+}
+//# sourceMappingURL=startup-buffer.js.map

package/dist/startup-buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startup-buffer.js","sourceRoot":"","sources":["../src/startup-buffer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAWH;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,cAAsB;IACpD,IAAI,cAAc,GAAG,CAAC,EAAE,CAAC;QACvB,OAAO,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC;IACzC,CAAC;SAAM,IAAI,cAAc,GAAG,CAAC,EAAE,CAAC;QAC9B,OAAO,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;IAC1C,CAAC;SAAM,IAAI,cAAc,GAAG,EAAE,EAAE,CAAC;QAC/B,OAAO,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;IAC1C,CAAC;SAAM,CAAC;QACN,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;IAC3C,CAAC;AACH,CAAC;AAED,uEAAuE;AAEvE;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,aAAa;IACP,SAAS,CAAS;IAClB,SAAS,CAAS;IAE3B,WAAW,GAAG,CAAC,CAAC;IAChB,aAAa,GAAG,CAAC,CAAC;IAClB,YAAY,GAAG,CAAC,CAAC;IACjB,SAAS,GAAG,KAAK,CAAC;IAE1B,YAAY,MAAqB;QAC/B,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QAClC,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;IACpC,CAAC;IAED;;;OAGG;IACH,WAAW,CAAC,KAAa;QACvB,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,IAAI,CAAC,WAAW,KAAK,CAAC,EAAE,CAAC;YAC3B,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;QAC7B,CAAC;QACD,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAE1B,mBAAmB;QACnB,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACpB,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,aAAa,CAAC;YACvD,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,SAAS,IAAI,OAAO,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;gBACpE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACxB,CAAC;QACH,CAAC;IACH,CAAC;IAED,0EAA0E;IAC1E,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,iCAAiC;IACjC,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,sDAAsD;IACtD,IAAI,SAAS;QACX,IAAI,IAAI,CAAC,WAAW,KAAK,CAAC;YAAE,OAAO,CAAC,CAAC;QACrC,OAAO,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,aAAa,CAAC;IAChD,CAAC;IAED,2DAA2D;IAC3D,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,mEAAmE;IACnE,KAAK;QACH,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;QACrB,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;QACvB,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;QACtB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACzB,CAAC;CACF"}

package/dist/sync.d.ts

@@ -0,0 +1,234 @@
+/**
+ * A/V sync controller with injectable clock.
+ *
+ * Audio-master model: the first audio sample establishes a sync reference
+ * mapping CaptureTimestamp (wall-clock microseconds) to local clock time.
+ * Video render times are computed relative to this reference.
+ *
+ * Drift detection: reportPresentationTiming measures VIDEO PRESENTATION SCHEDULE
+ * drift — actual presentation time minus the exact scheduled time carried with
+ * the frame. If it exceeds the adaptive threshold, presentationDriftExceeded
+ * signals and a sync_drift event is emitted — but no automatic re-anchor occurs.
+ * Actual audio/video skew is a separate metric (sync_skew).
+ * The reference is set once to avoid audio glitching from re-anchor jumps.
+ * In practice, gap recovery (skip_forward) and seek/pause naturally re-anchor.
+ *
+ * Live catch-up: measures end-to-end latency by comparing CaptureTimestamp
+ * (publisher wall-clock) to subscriber wall-clock. When latency exceeds
+ * targetLatency + threshold, activates catch-up (playback rate > 1.0).
+ * Hysteresis prevents oscillation near the threshold boundary.
+ *
+ * @see draft-ietf-moq-loc-01 §2.3.1.1 (CaptureTimestamp)
+ * @see draft-ietf-moq-msf-00 §5.1.16 (targetLatency)
+ * @module
+ */
+import type { ClockSource, CatchUpState } from './types.js';
+/**
+ * Render time calculation result.
+ */
+export interface RenderTiming {
+    /** When to render this frame, in local clock microseconds. */
+    readonly renderTimeUs: number;
+    /** How far ahead (+) or behind (-) this frame is relative to now. */
+    readonly offsetUs: number;
+    /** Whether this frame should be dropped (too late to render). */
+    readonly shouldDrop: boolean;
+}
+/**
+ * Injectable wall-clock source for latency measurement.
+ * Returns Unix epoch microseconds (same domain as CaptureTimestamp).
+ * Default: `Date.now() * 1000`.
+ *
+ * @see draft-ietf-moq-loc-01 §2.3.1.1 (CaptureTimestamp = wall-clock µs)
+ */
+export interface WallClockSource {
+    /** Current wall-clock time in microseconds since Unix epoch. */
+    now(): number;
+}
+export interface SyncControllerConfig {
+    readonly driftThresholdUs: number;
+    readonly dropThresholdUs?: number;
+    readonly clock: ClockSource;
+    /** Target end-to-end latency in ms. @see draft-ietf-moq-msf-00 §5.1.16 */
+    readonly targetLatencyMs?: number;
+    /** Max playback rate for catch-up (e.g., 1.1). Default: 1.0 (disabled). */
+    readonly maxCatchUpRate?: number;
+    /** Latency above target before catch-up activates (ms). Default: 500. */
+    readonly catchUpThresholdMs?: number;
+    /** Latency above target before catch-up deactivates (ms, hysteresis). Default: 50. */
+    readonly catchUpRecoveryMs?: number;
+    /** Injectable wall-clock for testability. Default: Date.now() * 1000. */
+    readonly wallClock?: WallClockSource;
+}
+/**
+ * A/V sync controller with live catch-up.
+ *
+ * @see draft-ietf-moq-loc-01 §2.3.1.1
+ * @see draft-ietf-moq-msf-00 §5.1.16
+ */
+export declare class SyncController {
+    private _driftThresholdUs;
+    private readonly dropThresholdUs;
+    private readonly clock;
+    /** Local clock time when audio reference was set. */
+    private localBaselineUs;
+    /** CaptureTimestamp of the audio reference sample. */
+    private captureBaselineUs;
+    /** Accumulated drift measurement. */
+    private _currentDriftUs;
+    /**
+     * Video join offset — shifts video render times forward during live join.
+     *
+     * When joining a live stream, video starts from the GOP boundary
+     * (which has an older CaptureTimestamp than the current audio).
+     * This offset shifts video render times forward so the first frames
+     * render in the future instead of the past, preventing startup stutter.
+     *
+     * Snaps to zero when the video timeline catches up to the audio live edge.
+     * Audio render times are unaffected.
+     */
+    private _videoJoinOffsetUs;
+    private readonly wallClock;
+    private readonly targetLatencyMs;
+    private readonly maxCatchUpRate;
+    private readonly catchUpThresholdMs;
+    private readonly catchUpRecoveryMs;
+    private _catchUpActive;
+    private _currentRate;
+    private _lastLatencyUs;
+    constructor(config: SyncControllerConfig);
+    /** Whether a sync reference has been established. */
+    get hasReference(): boolean;
+    /** Current drift magnitude in microseconds. */
+    get currentDriftUs(): number;
+    /** Current drift threshold in microseconds. Mutable for adaptive tolerance. */
+    get driftThresholdUs(): number;
+    set driftThresholdUs(value: number);
+    /**
+     * Whether PRESENTATION SCHEDULE drift exceeds the threshold.
+     *
+     * Deliberately has NO live-join suppression. The exact queued schedule
+     * already contains the join offset, so missing that schedule during a join
+     * is a real miss. (The legacy PTS-era metric needed the suppression because
+     * the offset itself showed up as drift; see {@link needsResync}.)
+     */
+    get presentationDriftExceeded(): boolean;
+    /**
+     * @deprecated Threshold check for the legacy {@link reportActualRenderTime}
+     * metric, retaining its live-join suppression. Use
+     * {@link presentationDriftExceeded} with schedule-based measurement.
+     */
+    get needsResync(): boolean;
+    /** Whether catch-up is currently active. */
+    get catchUpActive(): boolean;
+    /** Current playback rate (1.0 when catch-up inactive). */
+    get currentRate(): number;
+    /**
+     * Last measured latency in microseconds.
+     * 0 before first measurement.
+     * @see draft-ietf-moq-loc-01 §2.3.1.1
+     */
+    get latencyUs(): number;
+    /**
+     * Establish sync reference from an audio sample.
+     * Maps captureTimestamp to the current local clock time.
+     * Resets drift measurement.
+     *
+     * @param captureTimestampUs CaptureTimestamp in microseconds
+     */
+    setAudioReference(captureTimestampUs: bigint): void;
+    /**
+     * Establish sync reference from a video frame (video-only mode).
+     * No-op if a reference already exists — audio has priority.
+     *
+     * @param captureTimestampUs CaptureTimestamp of the first video frame
+     */
+    setVideoReference(captureTimestampUs: bigint): void;
+    /** Current video join offset in microseconds. 0 = no offset active. */
+    get videoJoinOffsetUs(): number;
+    /**
+     * Apply video join re-anchor for live stream join.
+     *
+     * Called when the first video keyframe is decoded after a live join.
+     * Computes an offset that shifts video render times forward so the
+     * first frame renders at `now + cushion` instead of in the past.
+     *
+     * The offset is a constant added to all video render times. It preserves
+     * inter-frame timing (33ms spacing) while shifting the whole timeline.
+     * Snaps to zero when video catches up to the live edge.
+     *
+     * @param firstKeyframeCaptureUs CaptureTimestamp of the first keyframe
+     * @param cushionUs Extra future cushion (default: 16ms ≈ 1 rAF tick)
+     */
+    onVideoJoin(firstKeyframeCaptureUs: bigint, cushionUs?: number): void;
+    /**
+     * Compute render timing for a video frame.
+     *
+     * @param captureTimestampUs CaptureTimestamp in microseconds
+     */
+    computeVideoRenderTime(captureTimestampUs: bigint): RenderTiming | null;
+    /**
+     * Compute render timing for an audio sample.
+     *
+     * @param captureTimestampUs CaptureTimestamp in microseconds
+     */
+    computeAudioRenderTime(captureTimestampUs: bigint): RenderTiming | null;
+    /**
+     * Record PRESENTATION SCHEDULE drift: did the renderer present the frame
+     * when it was told to?
+     *
+     * `scheduledUs` must be the EXACT timestamp stored with the rendered frame.
+     * It already accounts for the playout cushion actually applied to that
+     * frame, the live-join offset, decode-output recomputation and late-frame
+     * handling — none of which may be recomputed or subtracted later, because an
+     * adaptive cushion can move between enqueue and presentation.
+     *
+     * The schedule is REQUIRED here. Optionality lives at
+     * `FrameRenderedFeedback`, where the pipeline suppresses the whole
+     * measurement/event transaction cleanly: missing evidence is not drift.
+     *
+     * Actual audio/video skew is measured separately as `sync_skew`.
+     */
+    reportPresentationTiming(scheduledUs: number, actualUs: number): void;
+    /**
+     * @deprecated Compares against the UNCUSHIONED PTS-anchored time, so a
+     * stream presenting exactly on its intended schedule reports the whole
+     * playout cushion as drift. Retained as a compatibility path only; use
+     * {@link reportPresentationTiming}.
+     */
+    reportActualRenderTime(captureTimestampUs: bigint, actualLocalUs: number): void;
+    /**
+     * Measure end-to-end latency from a wall-clock timestamp.
+     *
+     * Compares the publisher's wall-clock timestamp to the subscriber's
+     * wall clock, both in Unix epoch microseconds. A media-time timestamp
+     * (LOC-04 with Timescale) has no wall-clock meaning, so latency is
+     * unmeasurable and this returns null.
+     *
+     * @param captureTimestampUs Timestamp in microseconds
+     * @param isWallClock False when the timestamp is media time. Undefined means wall clock.
+     * @returns Latency in microseconds, or null if unmeasurable
+     * @see draft-ietf-moq-loc-01 §2.3.1.1
+     * @see draft-ietf-moq-loc-04 §2.3.1.2
+     */
+    measureLatency(captureTimestampUs: bigint, isWallClock?: boolean): number | null;
+    /**
+     * Evaluate catch-up state based on current latency.
+     *
+     * Hysteresis: activates when latency > target + threshold,
+     * deactivates when latency <= target + recovery.
+     *
+     * Rate is proportional to overshoot, quantized to 0.05x increments.
+     *
+     * @param captureTimestampUs CaptureTimestamp in microseconds (Unix epoch)
+     * @returns CatchUpState if evaluated, null if catch-up is disabled or no timestamp
+     * @see draft-ietf-moq-msf-00 §5.1.16 (targetLatency)
+     */
+    evaluateCatchUp(captureTimestampUs: bigint, isWallClock?: boolean): CatchUpState | null;
+    /**
+     * Reset the sync reference (e.g., after a skip-forward).
+     */
+    reset(): void;
+    private computeRenderTime;
+}
+//# sourceMappingURL=sync.d.ts.map

package/dist/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../src/sync.ts"],"names":[],"mappings":"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"}