@stinkycomputing/web-live-player 0.1.3 → 0.1.5

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

@@ -0,0 +1,65 @@
+import { BaseCaptureSink, CaptureSinkConfig, SerializedPacket } from './capture-sink';
+import { MoqSessionBroadcaster } from 'stinky-moq-js';
+
+/**
+ * Track configuration for MoQ publishing
+ */
+export interface MoQTrackConfig {
+    trackName: string;
+    priority?: number;
+}
+/**
+ * MoQ-specific sink configuration
+ */
+export interface MoQSinkConfig extends CaptureSinkConfig {
+    /** MoQ relay URL (required if session is not provided) */
+    relayUrl?: string;
+    /** Namespace for the streams (required if session is not provided) */
+    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;
+    /** External MoQ session to use (if provided, relayUrl and namespace are ignored) */
+    session?: MoqSessionBroadcaster;
+}
+/**
+ * Capture sink that sends data over MoQ
+ */
+export declare class MoQCaptureSink extends BaseCaptureSink {
+    private moqConfig;
+    private session;
+    private connecting;
+    private disposed;
+    private sessionOwned;
+    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;
+    /**
+     * Set an external MoQ session (dependency injection)
+     * Similar to LiveVideoPlayer.setStreamSource()
+     * @param session - MoqSessionBroadcaster instance to use for broadcasting
+     */
+    setMoQSession(session: MoqSessionBroadcaster): 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/decoders/decoder-interface.d.ts

@@ -1,4 +1,4 @@
-import { ParsedData, HeaderCodecData } from '../protocol/sesame-binary-protocol';
+import { IMediaCodecData, ParsedFrame } from '@stinkycomputing/sesame-api-client';
 import { YUVFrame } from '../types';
 
 /**
@@ -34,12 +34,12 @@ export interface IVideoDecoder {
      * Configure the decoder for a specific codec
      * @param codecData - Codec configuration from stream header
      */
-    configure(codecData: HeaderCodecData): Promise<void>;
+    configure(codecData: IMediaCodecData): Promise<void>;
     /**
      * Decode a binary packet from the stream
      * @param data - Parsed stream data containing header and payload
      */
-    decodeBinary(data: ParsedData): void;
+    decodeBinary(data: ParsedFrame): void;
     /**
      * Flush pending frames (synchronous reset)
      */

package/dist/decoders/wasm-decoder.d.ts

@@ -1,6 +1,6 @@
-import { ParsedData } from '../protocol/sesame-binary-protocol';
 import { YUVFrame } from '../types';
 import { IVideoDecoder } from './decoder-interface';
+import { ParsedFrame } from '@stinkycomputing/sesame-api-client';
 
 export type { YUVFrame } from '../types';
 export interface WasmDecoderConfig {
@@ -27,15 +27,11 @@ export declare class WasmDecoder implements IVideoDecoder {
     /**
      * Configure the decoder (initializes the worker)
      */
-    configure(_codecData: {
-        codec_type: number;
-        width: number;
-        height: number;
-    }): Promise<void>;
+    configure(_codecData: any): Promise<void>;
     /**
      * Decode a binary packet (same interface as WebCodecsDecoder)
      */
-    decodeBinary(data: ParsedData): void;
+    decodeBinary(data: ParsedFrame): void;
     /**
      * Process next frame from queue
      */

package/dist/decoders/webcodecs-decoder.d.ts

@@ -1,4 +1,4 @@
-import { ParsedData, HeaderCodecData } from '../protocol/sesame-binary-protocol';
+import { ParsedFrame, IMediaCodecData } from '@stinkycomputing/sesame-api-client';
 import { Logger } from '../types';
 import { IVideoDecoder } from './decoder-interface';
 
@@ -40,9 +40,9 @@ export declare class WebCodecsDecoder implements IVideoDecoder {
     get state(): string;
     private createDecoder;
     /**
-     * Configure the decoder for a specific codec (from HeaderCodecData)
+     * Configure the decoder for a specific codec (from IMediaCodecData)
      */
-    configure(codecData: HeaderCodecData, preferHardware?: boolean): Promise<void>;
+    configure(codecData: IMediaCodecData, preferHardware?: boolean): Promise<void>;
     /**
      * Configure the decoder with VideoDecoderConfig directly
      */
@@ -52,13 +52,13 @@ export declare class WebCodecsDecoder implements IVideoDecoder {
      */
     private configureWithConfig;
     /**
-     * Configure with HeaderCodecData (from binary protocol)
+     * Configure with IMediaCodecData (from binary protocol)
      */
     private configureWithCodecData;
     /**
      * Decode a binary packet
      */
-    decodeBinary(data: ParsedData): void;
+    decodeBinary(data: ParsedFrame): void;
     /**
      * Decode a sample (from file demuxer)
      */

package/dist/index.d.ts

@@ -15,9 +15,9 @@ export { LiveVideoPlayer, createPlayer } 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 type { WebSocketSourceConfig } from './sources/websocket-source';
 export { MP4FileSource } from './sources/mp4-file-source';
 export type { MP4FileInfo, DecodableSample, MP4FileSourceEvents } from './sources/mp4-file-source';
 export { WebCodecsDecoder } from './decoders/webcodecs-decoder';
@@ -31,5 +31,4 @@ 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, PacketTimingEntry } from './scheduling/frame-scheduler';
-export { SesameBinaryProtocol } 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

@@ -88,6 +88,9 @@ 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;
@@ -125,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)

package/dist/protocol/codec-utils.d.ts

@@ -1,4 +1,4 @@
-import { HeaderCodecData } from './sesame-binary-protocol';
+import { IMediaCodecData } from '@stinkycomputing/sesame-api-client';
 
 /**
  * Timebase structure for timestamp conversion
@@ -10,11 +10,13 @@ export interface Timebase {
 /**
  * Rescale a timestamp from one timebase to another
  */
-export declare function rescaleTime(pts: bigint, source: Timebase, target: Timebase): number;
+export declare function rescaleTime(pts: number | bigint | null | undefined | {
+    toString(): string;
+}, source: Timebase, target: Timebase): number;
 /**
  * Check if codec data has changed
  */
-export declare function codecDataChanged(current: HeaderCodecData | undefined, newData: HeaderCodecData | undefined): boolean;
+export declare function codecDataChanged(current: IMediaCodecData | undefined, newData: IMediaCodecData | undefined): boolean;
 /**
  * Get human-readable codec name
  */
@@ -22,4 +24,4 @@ export declare function getCodecName(codecType: number): string;
 /**
  * Get WebCodecs codec string for a given codec data
  */
-export declare function getCodecString(codecData: HeaderCodecData): string | null;
+export declare function getCodecString(codecData: IMediaCodecData): string | null;

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/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
      */

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

@@ -1,4 +1,4 @@
-import { ParsedData } from '../protocol/sesame-binary-protocol';
+import { ParsedFrame } from '@stinkycomputing/sesame-api-client';
 
 /**
  * Event data emitted when stream data is received
@@ -6,7 +6,7 @@ import { ParsedData } from '../protocol/sesame-binary-protocol';
 export interface StreamDataEvent {
     trackName: string;
     streamType: 'video' | 'audio' | 'data';
-    data: ParsedData;
+    data: ParsedFrame;
 }
 /**
  * Handler type for stream data events

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

@@ -20,17 +20,7 @@ export interface WebSocketSourceConfig {
     reconnectDelay?: number;
 }
 /**
- * Video metadata returned from the server
- */
-export interface VideoMetadata {
-    width: number;
-    height: number;
-    frameRate?: number;
-    duration?: number;
-    codec?: string;
-}
-/**
- * WebSocket-based stream source for live and file-based video playback.
+ * WebSocket-based stream source for live video playback.
  *
  * @example
  * ```typescript
@@ -50,8 +40,6 @@ export declare class WebSocketSource extends BaseStreamSource {
     private messageWaiters;
     private requestId;
     private timeoutCheckInterval;
-    private ignoreCmdsBelow;
-    private isLiveStream;
     private config;
     private lastKeyframeRequest;
     private currentTrackName;
@@ -72,32 +60,13 @@ export declare class WebSocketSource extends BaseStreamSource {
     disconnect(): void;
     /**
      * Load a live stream by ID
+     * Note: Metadata is received via video stream codec data, not from this call
      */
-    loadLive(streamId: string): Promise<VideoMetadata>;
-    /**
-     * Load a video file
-     */
-    loadFile(project: string, filename: string): Promise<VideoMetadata>;
-    /**
-     * Seek to a position in the video (file playback only)
-     */
-    seek(positionMs: number): Promise<void>;
+    loadLive(streamId: string): Promise<void>;
     /**
-     * Request more packets from the server (file playback)
-     */
-    read(packetCount: number): Promise<void>;
-    /**
-     * Unload the current stream
-     */
-    unload(): Promise<void>;
-    /**
-     * Request a keyframe (live streams only)
+     * Request a keyframe
      */
     requestKeyframe(): void;
-    /**
-     * Flush pending requests (useful when seeking)
-     */
-    flush(): void;
     /**
      * Dispose the stream source
      */