@stinkycomputing/web-live-player 0.1.3 → 0.1.4

package/README.md

@@ -23,7 +23,7 @@ npm install @stinkycomputing/web-live-player
 ### Using with MoQ (Standalone)
 
 ```typescript
-import { createPlayer, createStandaloneMoQSource } from '@stinkycomputing/web-live-player';
+import { createPlayer, createMoQSource } from '@stinkycomputing/web-live-player';
 
 // Create player
 const player = createPlayer({
@@ -32,7 +32,7 @@ const player = createPlayer({
 });
 
 // Create MoQ source
-const moqSource = createStandaloneMoQSource({
+const moqSource = createMoQSource({
   relayUrl: 'https://moq-relay.example.com',
   namespace: 'live/stream',
   subscriptions: [
@@ -372,16 +372,42 @@ const player = createPlayer({
 });
 ```
 
-## Demo
+## Demos
 
-Run the demo application:
+The library includes three demo applications showcasing different use cases:
+
+### [Player Demo](demo/player/)
+Live stream and file playback with multiple decoder options.
+- Connect to MoQ or WebSocket streams
+- Play MP4 files with seeking
+- Real-time statistics and frame timing visualization
+
+### [Capture Demo](demo/capture/)
+Media capture and encoding with transport publishing.
+- Camera/microphone capture with device selection
+- Configurable video/audio codecs and bitrates
+- Publish to MoQ relay or WebSocket server
+
+### [Chat Demo](demo/chat/)
+Multi-user video chat combining capture and playback.
+- Full duplex video/audio communication
+- Room-based user discovery
+- Text chat over data tracks
+
+### Running the Demos
 
 ```bash
 npm install
 npm run dev
 ```
 
-Open http://localhost:3001 to see the demo.
+Open http://localhost:3001 to see all demos.
+
+| Demo | URL | Description |
+|------|-----|-------------|
+| Player | http://localhost:3001/player/ | Stream playback & file player |
+| Capture | http://localhost:3001/capture/ | Camera capture & streaming |
+| Chat | http://localhost:3001/chat/ | Multi-user video chat |
 
 ## Building
 

package/dist/assets/audio-encoder.worker-c5c829bb.js

@@ -0,0 +1,114 @@
+let t, o = !1, u = !1, g = 50, p = 0;
+self.onmessage = async (a) => {
+  const { type: s, data: e } = a.data;
+  switch (s) {
+    case "init":
+      h(e.config), e.audioLevels && (u = !0, g = e.audioLevels.interval || 50);
+      break;
+    case "stream":
+      e.readable && await b(e.readable);
+      break;
+    case "encode":
+      y(e.frame);
+      break;
+    case "close":
+      v();
+      break;
+    default:
+      console.error("Unknown message type:", s);
+  }
+};
+function h(a) {
+  t = new AudioEncoder({
+    output: (s, e) => {
+      self.postMessage({
+        type: "chunk",
+        data: s,
+        metadata: e
+      });
+    },
+    error: (s) => {
+      self.postMessage({ type: "error", data: s.message });
+    }
+  }), t.configure(a), self.postMessage({ type: "ready" });
+}
+function y(a) {
+  if (!a) {
+    self.postMessage({ type: "error", data: "Received null or undefined frame" });
+    return;
+  }
+  if (!t) {
+    self.postMessage({ type: "error", data: "Encoder not initialized" });
+    return;
+  }
+  if (t.state !== "configured") {
+    self.postMessage({ type: "error", data: `Encoder not in configured state: ${t.state}` });
+    return;
+  }
+  try {
+    t.encode(a), a.close();
+  } catch (s) {
+    self.postMessage({ type: "error", data: s instanceof Error ? s.message : String(s) });
+  }
+}
+function v() {
+  if (t) {
+    try {
+      t.close();
+    } catch {
+    }
+    t = void 0;
+  }
+  o = !1, self.postMessage({ type: "closed" });
+}
+function M(a) {
+  const s = performance.now();
+  if (!(s - p < g)) {
+    p = s;
+    try {
+      const e = a.numberOfChannels || 2, r = new Float32Array(a.allocationSize({ planeIndex: 0 }) / 4);
+      a.copyTo(r, { planeIndex: 0 });
+      const c = [], i = r.length / e;
+      for (let n = 0; n < e; n++) {
+        let d = 0;
+        for (let l = 0; l < i; l++) {
+          const f = r[l * e + n];
+          d += f * f;
+        }
+        const m = Math.sqrt(d / i);
+        c[n] = m;
+      }
+      self.postMessage({
+        type: "audio-levels",
+        data: {
+          levels: c,
+          timestamp: s
+        }
+      });
+    } catch {
+    }
+  }
+}
+async function b(a) {
+  if (o) {
+    self.postMessage({ type: "error", data: "Already processing a stream" });
+    return;
+  }
+  o = !0;
+  const s = a.getReader();
+  try {
+    for (; ; ) {
+      const { done: e, value: r } = await s.read();
+      if (e)
+        break;
+      r && (u && M(r), y(r));
+    }
+  } catch (e) {
+    self.postMessage({
+      type: "error",
+      data: e instanceof Error ? e.message : String(e)
+    });
+  } finally {
+    s.releaseLock(), o = !1, self.postMessage({ type: "stream-complete" });
+  }
+}

package/dist/assets/video-encoder.worker-a613b1f0.js

@@ -0,0 +1,91 @@
+let s, t = !1, n = !1, o = 0, i = 60;
+self.onmessage = async (r) => {
+  const { type: e, data: a } = r.data;
+  switch (e) {
+    case "init":
+      i = a.config.gopSize || 60, l(a.config);
+      break;
+    case "stream":
+      a.readable && await p(a.readable);
+      break;
+    case "encode":
+      f(a.frame);
+      break;
+    case "close":
+      d();
+      break;
+    case "request-keyframe":
+      n = !0;
+      break;
+    default:
+      console.error("Unknown message type:", e);
+  }
+};
+function l(r) {
+  s = new VideoEncoder({
+    output: (e, a) => {
+      self.postMessage({
+        type: "chunk",
+        data: e,
+        metadata: a
+      });
+    },
+    error: (e) => {
+      self.postMessage({ type: "error", data: e.message });
+    }
+  }), s.configure(r), self.postMessage({ type: "ready" });
+}
+function f(r) {
+  if (!r) {
+    self.postMessage({ type: "error", data: "Received null or undefined frame" });
+    return;
+  }
+  if (!s) {
+    self.postMessage({ type: "error", data: "Encoder not initialized" });
+    return;
+  }
+  if (s.state !== "configured") {
+    self.postMessage({ type: "error", data: `Encoder not in configured state: ${s.state}` });
+    return;
+  }
+  try {
+    o++;
+    let e = o % i === 0;
+    n && (n = !1, e = !0, o = 0), s.encode(r, { keyFrame: e }), r.close();
+  } catch (e) {
+    self.postMessage({ type: "error", data: e instanceof Error ? e.message : String(e) });
+  }
+}
+function d() {
+  if (s) {
+    try {
+      s.close();
+    } catch {
+    }
+    s = void 0;
+  }
+  t = !1, o = 0, self.postMessage({ type: "closed" });
+}
+async function p(r) {
+  if (t) {
+    self.postMessage({ type: "error", data: "Already processing a stream" });
+    return;
+  }
+  t = !0;
+  const e = r.getReader();
+  try {
+    for (; ; ) {
+      const { done: a, value: c } = await e.read();
+      if (a)
+        break;
+      c && f(c);
+    }
+  } catch (a) {
+    self.postMessage({
+      type: "error",
+      data: a instanceof Error ? a.message : String(a)
+    });
+  } finally {
+    e.releaseLock(), t = !1, self.postMessage({ type: "stream-complete" });
+  }
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Audio Encoder Worker
+ *
+ * Handles audio encoding in a separate thread using WebCodecs AudioEncoder.
+ * Supports audio level monitoring for VU meters.
+ */
+export {};

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

@@ -0,0 +1,105 @@
+import { CodecType } from './capture-types';
+
+/**
+ * Serialized packet ready for transmission
+ */
+export interface SerializedPacket {
+    data: ArrayBuffer;
+    isKeyframe: boolean;
+    timestamp: number;
+    type: 'video' | 'audio';
+}
+/**
+ * Interface for capture sinks that handle outgoing media data
+ */
+export interface ICaptureSink {
+    /**
+     * Whether the sink is currently connected
+     */
+    readonly connected: boolean;
+    /**
+     * Connect to the transport
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the transport
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Reconnect to the transport
+     */
+    reconnect(): Promise<void>;
+    /**
+     * Send encoded media data
+     * @param packet The serialized packet to send
+     */
+    send(packet: SerializedPacket): void;
+    /**
+     * Set callback for keyframe requests from receiver
+     */
+    onKeyframeRequest(callback: () => void): void;
+    /**
+     * Dispose of all resources
+     */
+    dispose(): void;
+}
+/**
+ * Configuration for video stream in a capture sink
+ */
+export interface VideoStreamConfig {
+    /** Video codec type */
+    codec: CodecType;
+    /** Video width */
+    width: number;
+    /** Video height */
+    height: number;
+    /** Timebase numerator */
+    timebaseNum?: number;
+    /** Timebase denominator */
+    timebaseDen?: number;
+}
+/**
+ * Configuration for audio stream in a capture sink
+ */
+export interface AudioStreamConfig {
+    /** Audio codec type */
+    codec: CodecType;
+    /** Sample rate in Hz */
+    sampleRate: number;
+    /** Number of channels */
+    channels: number;
+    /** Timebase numerator */
+    timebaseNum?: number;
+    /** Timebase denominator */
+    timebaseDen?: number;
+}
+/**
+ * Base configuration for capture sinks
+ */
+export interface CaptureSinkConfig {
+    /** Video stream configuration (optional if not sending video) */
+    video?: VideoStreamConfig;
+    /** Audio stream configuration (optional if not sending audio) */
+    audio?: AudioStreamConfig;
+    /** Topic/channel identifier for routing */
+    topic?: string;
+    /** Audio timestamp offset to align audio and video (in microseconds) */
+    audioTimestampOffset?: number;
+}
+/**
+ * Base class for capture sink implementations
+ */
+export declare abstract class BaseCaptureSink implements ICaptureSink {
+    protected config: CaptureSinkConfig;
+    protected keyframeCallback?: () => void;
+    protected _connected: boolean;
+    constructor(config: CaptureSinkConfig);
+    get connected(): boolean;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract send(packet: SerializedPacket): void;
+    reconnect(): Promise<void>;
+    onKeyframeRequest(callback: () => void): void;
+    protected requestKeyframe(): void;
+    dispose(): void;
+}

package/dist/capture/capture-types.d.ts

@@ -0,0 +1,120 @@
+import { CodecType, PacketType } from '../protocol/sesame-binary-protocol';
+
+export { CodecType, PacketType };
+/**
+ * Video codec configuration options
+ */
+export interface VideoEncoderOptions {
+    codec: CodecType;
+    width?: number;
+    height?: number;
+    bitrate?: number;
+    frameRate?: number;
+    keyFrameInterval?: number;
+    latencyMode?: 'quality' | 'realtime';
+}
+/**
+ * Audio codec configuration options
+ */
+export interface AudioEncoderOptions {
+    codec: CodecType;
+    sampleRate?: number;
+    channels?: number;
+    bitrate?: number;
+    latencyMode?: 'quality' | 'realtime';
+}
+/**
+ * Media capture configuration
+ */
+export interface CaptureConfig {
+    /** Enable video capture */
+    video?: boolean | MediaTrackConstraints;
+    /** Enable audio capture */
+    audio?: boolean | MediaTrackConstraints;
+    /** Video encoder options */
+    videoEncoder?: VideoEncoderOptions;
+    /** Audio encoder options */
+    audioEncoder?: AudioEncoderOptions;
+    /** Enable audio level monitoring */
+    audioLevelMonitoring?: boolean;
+    /** Audio level reporting interval in ms */
+    audioLevelInterval?: number;
+}
+/**
+ * Default capture configuration
+ */
+export declare const DEFAULT_CAPTURE_CONFIG: Required<CaptureConfig>;
+/**
+ * Encoded chunk event from encoder
+ */
+export interface EncodedChunkEvent {
+    type: 'audio' | 'video';
+    chunk: EncodedAudioChunk | EncodedVideoChunk;
+    keyframe: boolean;
+    timestamp: number;
+    metadata?: EncodedChunkMetadata;
+}
+/**
+ * Metadata associated with an encoded chunk
+ */
+export interface EncodedChunkMetadata {
+    width?: number;
+    height?: number;
+    channels?: number;
+    sampleRate?: number;
+    decoderConfig?: VideoDecoderConfig | AudioDecoderConfig;
+}
+/**
+ * Audio level data event
+ */
+export interface AudioLevelEvent {
+    timestamp: number;
+    levels: number[];
+}
+/**
+ * Capture statistics
+ */
+export interface CaptureStats {
+    /** Number of video frames encoded */
+    videoFramesEncoded: number;
+    /** Number of audio frames encoded */
+    audioFramesEncoded: number;
+    /** Total bytes sent */
+    bytesSent: number;
+    /** Packets sent */
+    packetsSent: number;
+    /** Current video bitrate */
+    videoBitrate: number;
+    /** Current audio bitrate */
+    audioBitrate: number;
+    /** Capture start time */
+    startTime: number;
+    /** Duration in ms */
+    duration: number;
+}
+/**
+ * Capture state
+ */
+export type CaptureState = 'idle' | 'initializing' | 'capturing' | 'paused' | 'stopped' | 'error';
+/**
+ * Events emitted by the capture system
+ */
+export interface CaptureEvents {
+    'state-change': (state: CaptureState) => void;
+    'encoded-chunk': (event: EncodedChunkEvent) => void;
+    'audio-levels': (event: AudioLevelEvent) => void;
+    'stats': (stats: CaptureStats) => void;
+    'error': (error: Error) => void;
+}
+/**
+ * Convert CodecType to WebCodecs codec string
+ */
+export declare function codecTypeToString(codec: CodecType): string;
+/**
+ * Check if a codec is a video codec
+ */
+export declare function isVideoCodec(codec: CodecType): boolean;
+/**
+ * Check if a codec is an audio codec
+ */
+export declare function isAudioCodec(codec: CodecType): boolean;

package/dist/capture/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Capture Module
+ *
+ * Provides media capture capabilities for video and audio streaming.
+ * Supports encoding with WebCodecs and transport over MoQ or WebSocket.
+ */
+export * from './capture-types';
+export { MediaStreamEncoder } from './media-encoder';
+export type { EncoderEventHandler } from './media-encoder';
+export { BaseCaptureSink } from './capture-sink';
+export type { ICaptureSink, CaptureSinkConfig, SerializedPacket, VideoStreamConfig, AudioStreamConfig, } from './capture-sink';
+export { WebSocketCaptureSink, createWebSocketSink } from './websocket-sink';
+export type { WebSocketSinkConfig } from './websocket-sink';
+export { MoQCaptureSink, createMoQSink } from './moq-sink';
+export type { MoQSinkConfig, MoQTrackConfig } from './moq-sink';
+export { MediaCapture, createMediaCapture } from './media-capture';
+export type { MediaCaptureConfig, CaptureEventHandler } from './media-capture';

package/dist/capture/media-capture.d.ts

@@ -0,0 +1,89 @@
+import { CaptureConfig, CaptureState, CaptureStats, AudioLevelEvent } from './capture-types';
+import { ICaptureSink } from './capture-sink';
+
+/**
+ * Full media capture configuration
+ */
+export interface MediaCaptureConfig extends CaptureConfig {
+    /** Capture sink for sending encoded data */
+    sink: ICaptureSink;
+    /** Topic/channel identifier for routing packets */
+    topic?: string;
+    /** Audio timestamp offset to align with video (microseconds) */
+    audioTimestampOffset?: number;
+}
+/**
+ * Event handler types
+ */
+export type CaptureEventHandler<T> = (event: T) => void;
+/**
+ * Media Capture - captures and encodes media from browser devices
+ */
+export declare class MediaCapture {
+    private config;
+    private sink;
+    private encoder?;
+    private mediaStream?;
+    private state;
+    private disposed;
+    private stats;
+    private videoMetadata?;
+    private audioMetadata?;
+    private handlers;
+    constructor(config: MediaCaptureConfig);
+    /**
+     * Register event handler
+     */
+    on(event: 'state-change', handler: CaptureEventHandler<CaptureState>): this;
+    on(event: 'audio-levels', handler: CaptureEventHandler<AudioLevelEvent>): this;
+    on(event: 'stats', handler: CaptureEventHandler<CaptureStats>): this;
+    on(event: 'error', handler: CaptureEventHandler<Error>): this;
+    /**
+     * Unregister event handler
+     */
+    off(event: string, handler: CaptureEventHandler<any>): this;
+    private emit;
+    private setState;
+    /**
+     * Get current capture state
+     */
+    getState(): CaptureState;
+    /**
+     * Get current capture statistics
+     */
+    getStats(): CaptureStats;
+    /**
+     * Check if media devices are available
+     */
+    static hasMediaDevices(): boolean;
+    /**
+     * Get list of available media devices
+     */
+    static getDevices(): Promise<MediaDeviceInfo[]>;
+    /**
+     * Start capturing and encoding media
+     */
+    start(): Promise<void>;
+    /**
+     * Stop capturing
+     */
+    stop(): Promise<void>;
+    /**
+     * Request immediate keyframe
+     */
+    requestKeyframe(): void;
+    /**
+     * Get the underlying MediaStream (for preview purposes)
+     */
+    getMediaStream(): MediaStream | undefined;
+    private handleEncodedChunk;
+    private createPacket;
+    /**
+     * Dispose of all resources
+     */
+    dispose(): void;
+}
+/**
+ * Factory function to create a media capture instance
+ */
+export declare function createMediaCapture(config: MediaCaptureConfig): MediaCapture;

package/dist/capture/media-encoder.d.ts

@@ -0,0 +1,65 @@
+import { AudioEncoderOptions, VideoEncoderOptions, EncodedChunkEvent, AudioLevelEvent } from './capture-types';
+
+/**
+ * Event handler types
+ */
+export type EncoderEventHandler<T> = (event: T) => void;
+/**
+ * Media stream encoder that handles both audio and video encoding
+ */
+export declare class MediaStreamEncoder {
+    private audioWorker;
+    private videoWorker;
+    private audioProcessor;
+    private videoProcessor;
+    private disposed;
+    private handlers;
+    private audioReady;
+    private videoReady;
+    private hasAudio;
+    private hasVideo;
+    private audioMetadata?;
+    private videoMetadata?;
+    constructor(stream: MediaStream, videoOptions?: VideoEncoderOptions, audioOptions?: AudioEncoderOptions, audioLevelConfig?: {
+        enabled: boolean;
+        interval?: number;
+    });
+    /**
+     * Register event handler
+     */
+    on(event: 'chunk', handler: EncoderEventHandler<EncodedChunkEvent>): this;
+    on(event: 'audio-levels', handler: EncoderEventHandler<AudioLevelEvent>): this;
+    on(event: 'error', handler: EncoderEventHandler<Error>): this;
+    on(event: 'ready', handler: EncoderEventHandler<void>): this;
+    /**
+     * Unregister event handler
+     */
+    off(event: 'chunk', handler: EncoderEventHandler<EncodedChunkEvent>): this;
+    off(event: 'audio-levels', handler: EncoderEventHandler<AudioLevelEvent>): this;
+    off(event: 'error', handler: EncoderEventHandler<Error>): this;
+    off(event: 'ready', handler: EncoderEventHandler<void>): this;
+    private emit;
+    private checkReady;
+    private createAudioEncoder;
+    private createVideoEncoder;
+    private startProcessingAudio;
+    private startProcessingVideo;
+    /**
+     * Request an immediate keyframe from the video encoder
+     */
+    requestKeyframe(): void;
+    /**
+     * Dispose of all resources
+     */
+    dispose(): void;
+}
+declare global {
+    interface MediaStreamTrackProcessor<T> {
+        readable: ReadableStream<T>;
+    }
+    const MediaStreamTrackProcessor: {
+        new <T>(options: {
+            track: MediaStreamTrack;
+        }): MediaStreamTrackProcessor<T>;
+    };
+}