@stinkycomputing/web-live-player 0.1.2 → 0.1.4

package/dist/capture/moq-sink.d.ts

@@ -0,0 +1,55 @@
+import { BaseCaptureSink, CaptureSinkConfig, SerializedPacket } from './capture-sink';
+
+/**
+ * Track configuration for MoQ publishing
+ */
+export interface MoQTrackConfig {
+    trackName: string;
+    priority?: number;
+}
+/**
+ * MoQ-specific sink configuration
+ */
+export interface MoQSinkConfig extends CaptureSinkConfig {
+    /** MoQ relay URL */
+    relayUrl: string;
+    /** Namespace for the streams */
+    namespace: string;
+    /** Video track configuration */
+    videoTrack?: MoQTrackConfig;
+    /** Audio track configuration */
+    audioTrack?: MoQTrackConfig;
+    /** Additional data tracks (e.g., for chat messages) */
+    dataTracks?: MoQTrackConfig[];
+    /** Reconnection delay in ms */
+    reconnectionDelay?: number;
+}
+/**
+ * Capture sink that sends data over MoQ
+ */
+export declare class MoQCaptureSink extends BaseCaptureSink {
+    private moqConfig;
+    private session;
+    private connecting;
+    private disposed;
+    private currentVideoGroup;
+    private audioFrameCount;
+    private static readonly AUDIO_FRAMES_PER_GROUP;
+    constructor(config: MoQSinkConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    send(packet: SerializedPacket): void;
+    private setupEventListeners;
+    dispose(): void;
+    /**
+     * Send custom data on a data track (e.g., chat messages)
+     * Each data message starts a new group.
+     * @param trackName The data track name to send on
+     * @param data The data to send
+     */
+    sendData(trackName: string, data: Uint8Array): void;
+}
+/**
+ * Factory function to create a MoQ capture sink
+ */
+export declare function createMoQSink(config: MoQSinkConfig): MoQCaptureSink;

package/dist/capture/video-encoder.worker.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Video Encoder Worker
+ *
+ * Handles video encoding in a separate thread using WebCodecs VideoEncoder.
+ * Supports keyframe requests and configurable GOP (Group of Pictures).
+ */
+export {};

package/dist/capture/websocket-sink.d.ts

@@ -0,0 +1,35 @@
+import { BaseCaptureSink, CaptureSinkConfig, SerializedPacket } from './capture-sink';
+
+/**
+ * WebSocket-specific sink configuration
+ */
+export interface WebSocketSinkConfig extends CaptureSinkConfig {
+    /** WebSocket URL to connect to */
+    url: string;
+    /** Connection timeout in ms */
+    connectionTimeout?: number;
+    /** Whether to automatically reconnect on disconnect */
+    autoReconnect?: boolean;
+    /** Delay between reconnection attempts in ms */
+    reconnectDelay?: number;
+}
+/**
+ * Capture sink that sends data over WebSocket
+ */
+export declare class WebSocketCaptureSink extends BaseCaptureSink {
+    private websocket?;
+    private wsConfig;
+    private reconnectTimer?;
+    private disposed;
+    constructor(config: WebSocketSinkConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    send(packet: SerializedPacket): void;
+    private scheduleReconnect;
+    private clearReconnectTimer;
+    dispose(): void;
+}
+/**
+ * Factory function to create a WebSocket capture sink
+ */
+export declare function createWebSocketSink(config: WebSocketSinkConfig): WebSocketCaptureSink;

package/dist/index.d.ts

@@ -12,10 +12,10 @@ export * from './sources/stream-source';
 export { BasePlayer } from './player/base-player';
 export type { BasePlayerConfig } from './player/base-player';
 export { LiveVideoPlayer, createPlayer } from './player/live-player';
-export type { PlayerConfig, PlayerStats, PlayerState } from './player/live-player';
+export type { PlayerConfig, PlayerStats, PlayerState, BandwidthStats } from './player/live-player';
 export { FileVideoPlayer, createFilePlayer } from './player/file-player';
 export type { FilePlayerConfig, FilePlayerState, FilePlayerStats, FilePlayMode } from './player/file-player';
-export { createStandaloneMoQSource, StandaloneMoQSource } from './sources/standalone-moq-source';
+export { createMoQSource, MoQSource } from './sources/moq-source';
 export { WebSocketSource, createWebSocketSource } from './sources/websocket-source';
 export type { WebSocketSourceConfig, VideoMetadata } from './sources/websocket-source';
 export { MP4FileSource } from './sources/mp4-file-source';
@@ -30,6 +30,7 @@ export { FileAudioPlayer } from './audio/file-audio-player';
 export { LiveAudioPlayer } from './audio/live-audio-player';
 export type { LiveAudioConfig } from './audio/live-audio-player';
 export { FrameScheduler } from './scheduling/frame-scheduler';
-export type { FrameTiming, LatencyStats, SchedulerStatus, SchedulerConfig } from './scheduling/frame-scheduler';
-export { SesameBinaryProtocol } from './protocol/sesame-binary-protocol';
+export type { FrameTiming, LatencyStats, SchedulerStatus, SchedulerConfig, PacketTimingEntry } from './scheduling/frame-scheduler';
+export { SesameBinaryProtocol, FLAG_IS_KEYFRAME, FLAG_HAS_CODEC_DATA, PacketType } from './protocol/sesame-binary-protocol';
 export type { ParsedData, HeaderData, HeaderCodecData } from './protocol/sesame-binary-protocol';
+export * from './capture';

package/dist/player/live-player.d.ts

@@ -21,6 +21,14 @@ export interface PlayerConfig {
  * Player state
  */
 export type PlayerState = 'idle' | 'playing' | 'paused' | 'error';
+/**
+ * Bandwidth statistics
+ */
+export interface BandwidthStats {
+    videoBytesPerSecond: number;
+    audioBytesPerSecond: number;
+    totalBytesPerSecond: number;
+}
 /**
  * Player statistics
  */
@@ -36,6 +44,7 @@ export interface PlayerStats {
     streamHeight: number;
     frameRate: number;
     latency: LatencyStats | null;
+    bandwidth: BandwidthStats | null;
 }
 /**
  * Player event types
@@ -79,11 +88,21 @@ export declare class LiveVideoPlayer extends BasePlayer<PlayerState> {
     private streamWidth;
     private streamHeight;
     private estimatedFrameRate;
+    private lastVideoTimestampUs;
+    private fpsEstimateSamples;
+    private static readonly FPS_SAMPLE_COUNT;
     private audioContext;
     private audioPlayer;
     private ownsAudioContext;
     private audioCodecData;
     private arrivalTimes;
+    private keyframeStatus;
+    private videoBytesReceived;
+    private audioBytesReceived;
+    private lastBandwidthUpdateTime;
+    private lastVideoBytesReceived;
+    private lastAudioBytesReceived;
+    private currentBandwidth;
     constructor(config?: PlayerConfig);
     /**
      * Enable or disable debug logging at runtime
@@ -109,7 +128,7 @@ export declare class LiveVideoPlayer extends BasePlayer<PlayerState> {
      * Convenience method to connect to a MoQ-like session
      *
      * Note: For audio support, the MoQ session must also be subscribed to the audio track.
-     * When using StandaloneMoQSource, include both 'video' and 'audio' in subscriptions.
+     * When using MoQSource, include both 'video' and 'audio' in subscriptions.
      * When using Elmo's MoQSessionNode, add an audio track to the session config.
      *
      * @param session - MoQ session implementing IStreamSource (e.g., Elmo's MoQSessionNode)
@@ -164,6 +183,14 @@ export declare class LiveVideoPlayer extends BasePlayer<PlayerState> {
      * Get player statistics
      */
     getStats(): PlayerStats;
+    /**
+     * Update bandwidth statistics
+     */
+    private updateBandwidthStats;
+    /**
+     * Get packet timing history for visualization/debugging
+     */
+    getPacketTimingHistory(): import('..').PacketTimingEntry[];
     /**
      * Subscribe to player events (typed overload)
      */

package/dist/scheduling/frame-scheduler.d.ts

@@ -42,6 +42,23 @@ export interface SchedulerStatus {
     driftCorrections: number;
     latency: LatencyStats | null;
 }
+/**
+ * Packet timing entry for visualization
+ */
+export interface PacketTimingEntry {
+    /** Time packet arrived (performance.now()) */
+    arrivalTime: number;
+    /** Time since previous packet (ms) */
+    intervalMs: number;
+    /** Stream timestamp (us) */
+    streamTimestampUs: number;
+    /** Whether this was a keyframe */
+    isKeyframe: boolean;
+    /** Decode latency (ms) */
+    decodeLatencyMs: number;
+    /** Whether frame was dropped */
+    wasDropped: boolean;
+}
 export interface SchedulerConfig<T> {
     /** Target buffer delay in milliseconds (0 = bypass mode, always return latest) */
     bufferDelayMs?: number;
@@ -81,6 +98,9 @@ export declare class FrameScheduler<T> {
     private dequeueCount;
     private latencyHistory;
     private latencyHistorySize;
+    private packetTimingHistory;
+    private packetTimingHistorySize;
+    private lastPacketArrivalTime;
     private stats;
     private logger;
     private onFrameDropped?;
@@ -90,7 +110,7 @@ export declare class FrameScheduler<T> {
     /** Effective drift threshold - scales with buffer target for low-latency mode */
     private get effectiveDriftThresholdMs();
     /** Enqueue a decoded frame with timing information */
-    enqueue(frame: T, timestampUs: number, timing: FrameTiming): void;
+    enqueue(frame: T, timestampUs: number, timing: FrameTiming, isKeyframe?: boolean): void;
     /** Dequeue frame for rendering at given real time (milliseconds) */
     dequeue(realTimeMs: number): T | null;
     /** Bypass mode: return latest frame, drop rest */
@@ -119,4 +139,6 @@ export declare class FrameScheduler<T> {
     logStatus(): void;
     /** Reset statistics */
     resetStats(): void;
+    /** Get packet timing history for visualization */
+    getPacketTimingHistory(): PacketTimingEntry[];
 }

package/dist/sources/moq-source.d.ts

@@ -0,0 +1,44 @@
+import { BaseStreamSource } from './stream-source';
+
+/**
+ * Track configuration for MoQ source
+ */
+export interface MoQTrack {
+    trackName: string;
+    priority?: number;
+    streamType: 'video' | 'audio' | 'data';
+}
+/**
+ * Configuration for MoQ source
+ */
+export interface MoQSourceConfig {
+    relayUrl: string;
+    namespace: string;
+    subscriptions: MoQTrack[];
+    reconnectionDelay?: number;
+}
+/**
+ * Factory function to create a MoQ source
+ */
+export declare function createMoQSource(config: MoQSourceConfig): MoQSource;
+/**
+ * MoQ stream source implementation
+ */
+export declare class MoQSource extends BaseStreamSource {
+    private config;
+    private session;
+    private trackTypeMap;
+    private connecting;
+    constructor(config: MoQSourceConfig);
+    /**
+     * Connect to the MoQ relay
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the MoQ relay
+     */
+    disconnect(): Promise<void>;
+    private setupEventListeners;
+    private handleIncomingData;
+    dispose(): void;
+}

package/dist/sources/mp4-file-source.d.ts

@@ -18,6 +18,7 @@ export interface MP4FileInfo {
     bitrate?: number;
     audioChannels?: number;
     audioSampleRate?: number;
+    isMoovAtStart?: boolean;
 }
 /**
  * Sample ready for decoding

package/dist/sources/standalone-moq-source.d.ts

@@ -1,35 +1,35 @@
 import { BaseStreamSource } from './stream-source';
 
 /**
- * Track configuration for standalone MoQ source
+ * Track configuration for MoQ source
  */
-export interface StandaloneMoQTrack {
+export interface MoQTrack {
     trackName: string;
     priority?: number;
     streamType: 'video' | 'audio' | 'data';
 }
 /**
- * Configuration for standalone MoQ source
+ * Configuration for MoQ source
  */
-export interface StandaloneMoQConfig {
+export interface MoQSourceConfig {
     relayUrl: string;
     namespace: string;
-    subscriptions: StandaloneMoQTrack[];
+    subscriptions: MoQTrack[];
     reconnectionDelay?: number;
 }
 /**
- * Factory function to create a standalone MoQ source
+ * Factory function to create a MoQ source
  */
-export declare function createStandaloneMoQSource(config: StandaloneMoQConfig): StandaloneMoQSource;
+export declare function createMoQSource(config: MoQSourceConfig): MoQSource;
 /**
- * Standalone MoQ stream source implementation
+ * MoQ stream source implementation
  */
-export declare class StandaloneMoQSource extends BaseStreamSource {
+export declare class MoQSource extends BaseStreamSource {
     private config;
     private session;
     private trackTypeMap;
     private connecting;
-    constructor(config: StandaloneMoQConfig);
+    constructor(config: MoQSourceConfig);
     /**
      * Connect to the MoQ relay
      */