OMT Protocol Deep Dive

import { WaveClient } from '@wave/api-client';

const wave = new WaveClient({ apiKey: 'wave_live_xxxxx' });

// Create OMT stream with ultra-low latency configuration
const createOMTStream = async () => {
  const stream = await wave.streams.create({
    title: 'Interactive E-Sports Stream',
    protocol: 'omt',
    omt: {
      targetLatency: 16,        // Target 16ms end-to-end
      quality: 'gaming',         // Preset: 'gaming' | 'interactive' | 'broadcast' | '4k'

      // Video encoding settings
      video: {
        codec: 'av1',            // 'av1' | 'hevc' | 'vp9'
        resolution: '720p',      // '720p' | '1080p' | '4k'
        fps: 60,
        bitrate: {
          min: 1500,             // Minimum bitrate (Kbps)
          target: 3000,          // Target bitrate (Kbps)
          max: 4500              // Maximum bitrate (Kbps)
        },
        keyframeInterval: 60,    // Frames (1 second at 60fps)
        bframes: 0,              // Disable B-frames for lowest latency
        tune: 'zerolatency'
      },

      // Audio encoding settings
      audio: {
        codec: 'opus',
        bitrate: 128,            // Kbps
        sampleRate: 48000,       // Hz
        channels: 2,             // Stereo
        frameDuration: 20        // ms (lowest latency)
      },

      // Network optimization
      network: {
        fec: {
          enabled: true,
          overhead: 0.2          // 20% FEC overhead
        },
        congestionControl: 'gcc', // Google Congestion Control
        bufferSize: 16,          // ms (jitter buffer)
        mtu: 1500                // bytes
      },

      // Interactive features
      features: {
        chatSync: true,          // Synchronize chat with video timeline
        polls: true,             // Enable real-time polls
        reactions: true,         // Enable emoji reactions
        latencyDisplay: true     // Show latency to viewers
      }
    },
    recording: { enabled: true }
  });

  console.log('OMT Stream Created:', stream.id);
  console.log('Ingest URL:', stream.ingest.omt.url);
  console.log('Stream Key:', stream.ingest.omt.streamKey);
  console.log('Playback URL:', stream.playback.url);

  return stream;
};

// Monitor OMT stream health with real-time metrics
const monitorOMTStream = async (streamId: string) => {
  const ws = wave.streams.subscribe(streamId, {
    metrics: ['latency', 'bitrate', 'fps', 'packetLoss', 'jitter', 'viewers']
  });

  ws.on('stats', (stats) => {
    console.log('OMT Stream Stats:', {
      latency: {
        encoder: stats.latency.encoder,      // Encoding latency (ms)
        network: stats.latency.network,      // Network transit (ms)
        playback: stats.latency.playback,    // Playback buffer (ms)
        total: stats.latency.total           // End-to-end latency (ms)
      },
      quality: {
        resolution: stats.video.resolution,
        fps: stats.video.fps,
        bitrate: stats.video.bitrate,        // Current bitrate (Kbps)
        codec: stats.video.codec
      },
      network: {
        packetLoss: stats.network.packetLoss,  // Percentage
        jitter: stats.network.jitter,          // ms
        rtt: stats.network.rtt                 // Round-trip time (ms)
      },
      viewers: {
        total: stats.viewers.total,
        peak: stats.viewers.peak,
        avgLatency: stats.viewers.avgLatency   // Average viewer latency
      }
    });

    // Alert on high latency
    if (stats.latency.total > 25) {
      console.warn('WARNING: Latency exceeds 25ms:', stats.latency.total);
    }

    // Alert on packet loss
    if (stats.network.packetLoss > 1) {
      console.warn('WARNING: High packet loss:', stats.network.packetLoss + '%');
    }
  });

  ws.on('warning', (warning) => {
    console.warn('Stream Warning:', warning.message);
    // Send alert to monitoring system
  });

  return ws;
};

// Synchronized chat with OMT stream
const setupSynchronizedChat = async (streamId: string) => {
  const chat = wave.chat.connect(streamId, {
    sync: true,              // Enable timestamp-based sync
    syncMode: 'video'        // Sync to video timeline
  });

  chat.on('message', (message) => {
    console.log(`[${message.timestamp}] ${message.user}: ${message.text}`);
    // Display message at exact video timestamp
  });

  // Send message
  await chat.send({
    text: 'This message is synced to video timestamp',
    metadata: {
      videoTimestamp: Date.now()  // Automatically synced by SDK
    }
  });

  return chat;
};

// Interactive poll synchronized with stream
const createSynchronizedPoll = async (streamId: string) => {
  const poll = await wave.interactions.createPoll({
    streamId,
    question: 'Which weapon should I use?',
    options: ['Sniper Rifle', 'Shotgun', 'SMG'],
    duration: 30000,         // 30 seconds
    showResults: 'realtime', // Show results as votes come in
    syncToVideo: true        // Display at specific video timestamp
  });

  // Listen for votes
  poll.on('vote', (vote) => {
    console.log(`Vote for ${vote.option}: Total ${vote.count} votes`);
  });

  // Close poll
  setTimeout(() => poll.close(), 30000);

  return poll;
};

// Complete OMT streaming workflow
(async () => {
  try {
    // Create stream
    const stream = await createOMTStream();

    // Start monitoring
    const monitor = await monitorOMTStream(stream.id);

    // Setup chat
    const chat = await setupSynchronizedChat(stream.id);

    // Create poll
    const poll = await createSynchronizedPoll(stream.id);

    console.log('OMT Stream Ready!');
    console.log('Target Latency: <16ms');
    console.log('Share URL:', stream.playback.url);

    // Keep running
    process.on('SIGINT', async () => {
      await wave.streams.end(stream.id);
      monitor.close();
      chat.disconnect();
      console.log('Stream ended');
      process.exit(0);
    });

  } catch (error) {
    console.error('OMT Stream Error:', error);
  }
})();