@livepeer-frameworks/player-core 0.0.3

package/src/core/MistSignaling.ts

@@ -0,0 +1,346 @@
+/**
+ * MistSignaling - WebSocket signaling for MistServer's native WebRTC protocol
+ *
+ * Protocol messages (from MistServer):
+ * - on_connected: WebSocket opened successfully
+ * - on_disconnected: WebSocket closed
+ * - on_answer_sdp: SDP answer received, { result: boolean, answer_sdp: string }
+ * - on_time: Time update { current: ms, end: ms, begin: ms, tracks: string[] }
+ * - on_stop: Stream ended
+ * - on_error: Error occurred { message: string }
+ *
+ * Protocol messages (to MistServer):
+ * - offer_sdp: SDP offer { offer_sdp: string }
+ * - seek: Seek to position { seek_time: number | "live" }
+ * - hold: Pause playback
+ * - stop: Stop playback
+ * - tracks: Select tracks { video: string, audio: string }
+ * - set_speed: Set playback rate { play_rate: number | "auto" }
+ */
+
+import { TypedEventEmitter } from './EventEmitter';
+
+export interface MistSignalingConfig {
+  /** WebSocket URL (will convert http to ws) */
+  url: string;
+  /** Connection timeout in ms (default: 5000) */
+  timeout?: number;
+  /** Callback for debug logging */
+  onLog?: (message: string) => void;
+}
+
+export interface MistTimeUpdate {
+  /** Current playback position in ms */
+  current: number;
+  /** End position in ms (0 for live) */
+  end: number;
+  /** Begin position in ms (buffer start) */
+  begin: number;
+  /** Currently active track IDs */
+  tracks?: string[];
+  /** Whether playback is paused */
+  paused?: boolean;
+  /** Whether at live point */
+  live_point?: boolean;
+}
+
+export interface MistSignalingEvents {
+  /** Connection established */
+  'connected': void;
+  /** Connection closed */
+  'disconnected': { code: number };
+  /** SDP answer received */
+  'answer_sdp': { result: boolean; answer_sdp: string };
+  /** Time/track update */
+  'time_update': MistTimeUpdate;
+  /** Seek completed */
+  'seeked': { live_point?: boolean };
+  /** Playback speed changed */
+  'speed_changed': { play_rate: number; play_rate_curr: number };
+  /** Stream ended */
+  'stopped': void;
+  /** Error occurred */
+  'error': { message: string };
+}
+
+export type MistSignalingState = 'connecting' | 'connected' | 'disconnected' | 'closed';
+
+/**
+ * MistSignaling handles WebSocket communication with MistServer for WebRTC
+ */
+export class MistSignaling extends TypedEventEmitter<MistSignalingEvents> {
+  private ws: WebSocket | null = null;
+  private url: string;
+  private timeout: number;
+  private timeoutId: ReturnType<typeof setTimeout> | null = null;
+  private onLog: (message: string) => void;
+  private _state: MistSignalingState = 'disconnected';
+
+  // Promise for seek operation
+  public seekPromise: {
+    resolve: (msg: string) => void;
+    reject: (msg: string) => void;
+  } | null = null;
+
+  constructor(config: MistSignalingConfig) {
+    super();
+    // Convert http(s) to ws(s)
+    this.url = config.url.replace(/^http/, 'ws');
+    this.timeout = config.timeout ?? 5000;
+    this.onLog = config.onLog ?? (() => {});
+  }
+
+  /**
+   * Get current connection state
+   */
+  get state(): MistSignalingState {
+    return this._state;
+  }
+
+  /**
+   * Check if connected
+   */
+  get isConnected(): boolean {
+    return this._state === 'connected';
+  }
+
+  /**
+   * Connect to MistServer WebSocket
+   */
+  connect(): void {
+    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
+      this.onLog('Already connected or connecting');
+      return;
+    }
+
+    this._state = 'connecting';
+    this.onLog(`Connecting to ${this.url}`);
+
+    try {
+      this.ws = new WebSocket(this.url);
+    } catch (e) {
+      this.onLog(`Failed to create WebSocket: ${e}`);
+      this._state = 'disconnected';
+      return;
+    }
+
+    // Connection timeout
+    this.timeoutId = setTimeout(() => {
+      if (this.ws && this.ws.readyState === WebSocket.CONNECTING) {
+        this.onLog('WebSocket connection timeout');
+        this.ws.close();
+        this._state = 'disconnected';
+        this.emit('error', { message: 'Connection timeout' });
+      }
+    }, this.timeout);
+
+    this.ws.onopen = () => {
+      if (this.timeoutId) {
+        clearTimeout(this.timeoutId);
+        this.timeoutId = null;
+      }
+      this._state = 'connected';
+      this.onLog('WebSocket connected');
+      this.emit('connected', undefined);
+    };
+
+    this.ws.onmessage = (event) => {
+      try {
+        const cmd = JSON.parse(event.data);
+        this.handleMessage(cmd);
+      } catch (err) {
+        this.onLog(`Failed to parse message: ${err}`);
+      }
+    };
+
+    this.ws.onclose = (event) => {
+      if (this.timeoutId) {
+        clearTimeout(this.timeoutId);
+        this.timeoutId = null;
+      }
+      this._state = 'closed';
+      this.onLog(`WebSocket closed (code: ${event.code})`);
+      this.emit('disconnected', { code: event.code });
+    };
+
+    this.ws.onerror = (event) => {
+      this.onLog(`WebSocket error: ${event}`);
+    };
+  }
+
+  /**
+   * Handle incoming message from MistServer
+   */
+  private handleMessage(cmd: Record<string, unknown>): void {
+    const type = cmd.type as string;
+
+    switch (type) {
+      case 'on_connected':
+        // Already handled by onopen
+        break;
+
+      case 'on_disconnected':
+        this._state = 'disconnected';
+        this.emit('disconnected', { code: (cmd.code as number) || 0 });
+        break;
+
+      case 'on_answer_sdp':
+        this.emit('answer_sdp', {
+          result: cmd.result as boolean,
+          answer_sdp: cmd.answer_sdp as string,
+        });
+        break;
+
+      case 'on_time':
+        this.emit('time_update', {
+          current: cmd.current as number,
+          end: cmd.end as number,
+          begin: cmd.begin as number,
+          tracks: cmd.tracks as string[] | undefined,
+          paused: cmd.paused as boolean | undefined,
+          live_point: cmd.live_point as boolean | undefined,
+        });
+        break;
+
+      case 'seek':
+        this.emit('seeked', {
+          live_point: (cmd as Record<string, unknown>).live_point as boolean | undefined,
+        });
+        // Resolve seek promise if pending
+        if (this.seekPromise) {
+          this.seekPromise.resolve('Seeked');
+          this.seekPromise = null;
+        }
+        break;
+
+      case 'set_speed':
+        this.emit('speed_changed', {
+          play_rate: (cmd as Record<string, unknown>).play_rate as number,
+          play_rate_curr: (cmd as Record<string, unknown>).play_rate_curr as number,
+        });
+        break;
+
+      case 'on_stop':
+        this.emit('stopped', undefined);
+        break;
+
+      case 'on_error':
+        this.emit('error', { message: cmd.message as string });
+        break;
+
+      default:
+        this.onLog(`Unhandled message type: ${type}`);
+    }
+  }
+
+  /**
+   * Send a message to MistServer
+   */
+  send(cmd: Record<string, unknown>): boolean {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.onLog('Cannot send: WebSocket not connected');
+      return false;
+    }
+
+    try {
+      this.ws.send(JSON.stringify(cmd));
+      return true;
+    } catch (e) {
+      this.onLog(`Failed to send message: ${e}`);
+      return false;
+    }
+  }
+
+  /**
+   * Send SDP offer to MistServer
+   */
+  sendOfferSDP(sdp: string): boolean {
+    return this.send({ type: 'offer_sdp', offer_sdp: sdp });
+  }
+
+  /**
+   * Seek to position (in seconds or "live")
+   */
+  seek(time: number | 'live'): Promise<string> {
+    return new Promise((resolve, reject) => {
+      if (!this.isConnected) {
+        reject('Not connected');
+        return;
+      }
+
+      // Cancel previous seek if pending
+      if (this.seekPromise) {
+        this.seekPromise.reject('New seek requested');
+      }
+
+      // Send seek command (time in ms for MistServer)
+      const seekTime = time === 'live' ? 'live' : time * 1000;
+      this.send({ type: 'seek', seek_time: seekTime });
+
+      // Store promise handlers
+      this.seekPromise = { resolve, reject };
+    });
+  }
+
+  /**
+   * Pause playback (hold)
+   */
+  pause(): boolean {
+    return this.send({ type: 'hold' });
+  }
+
+  /**
+   * Stop playback
+   */
+  stop(): boolean {
+    return this.send({ type: 'stop' });
+  }
+
+  /**
+   * Set track selection
+   * @param video - Video track selection (e.g., "~1080x720", "|500000", "none")
+   * @param audio - Audio track selection (e.g., "eng", "none")
+   */
+  setTracks(options: { video?: string; audio?: string }): boolean {
+    return this.send({ type: 'tracks', ...options });
+  }
+
+  /**
+   * Set playback speed
+   * @param rate - Playback rate (1.0 normal, "auto" for live catch-up)
+   */
+  setSpeed(rate: number | 'auto'): boolean {
+    return this.send({ type: 'set_speed', play_rate: rate });
+  }
+
+  /**
+   * Close the connection
+   */
+  close(): void {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+
+    if (this.seekPromise) {
+      this.seekPromise.reject('Connection closed');
+      this.seekPromise = null;
+    }
+
+    if (this.ws) {
+      this._state = 'closed';
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+
+  /**
+   * Destroy and cleanup
+   */
+  destroy(): void {
+    this.close();
+    this.removeAllListeners();
+  }
+}
+
+export default MistSignaling;