LocalVideoStream interface

inputDevice

Currently selected camera as a CameraDeviceInfo (combines deviceId, groupId, label). Use me.video.inputDevice.label for "Camera: X" UI; me.video.inputDevice.deviceId for storage / comparison.

setInputDevice async

Hot-swap to a different camera. The stream instance is preserved — SDK swaps the underlying track and rebinds all attached <video> elements transparently. Strongly typed — passing a MicrophoneDeviceInfo or SpeakerDeviceInfo is a compile-time error.

const cameras = await VideoSDK.getCameras();
const back = cameras.find(c => c.label.toLowerCase().includes('back'));
if (back) await me.video.setInputDevice(back);
// Attached <video> elements continue rendering — no re-attach needed

updateSettings async

Change resolution and/or frame rate mid-stream without re-publishing. Internally calls applyConstraints() on the underlying track.

await me.video.updateSettings({ resolution: 'h1080', frameRate: 60 });

setContentHint

Encoder optimization hint. "motion" for high-motion content (gameplay, sports). "detail" for sharpness-critical static content (slide presentations, document cameras).

getInputCapabilities async

Reports what the current device can do — max resolution, frame rates, facingModes, etc. Wraps the browser's MediaStreamTrack.getCapabilities().

const caps = await me.video.getInputCapabilities();
console.log(`Max ${caps.width.max}×${caps.height.max} @ ${caps.frameRate.max}fps`);
console.log('Facing modes:', caps.facingMode);

stop async PRE-CALL

Aborts a pre-call preview stream. Releases the underlying camera (MediaStreamTrack stopped) and clears the VideoSDK.videoStream singleton slot so the next createVideoStream succeeds. After stop(), all methods on this instance throw STREAM_STOPPED.

const preview = await VideoSDK.createVideoStream({ device: cameras[0] });
preview.attach(previewEl);

// User clicks "Cancel" instead of "Join"
await preview.stop();
// camera released, VideoSDK.videoStream is null again

Related open questions: Q18 — Pre-call preview lifecycle (singleton vs render-only)

captureFrame async LOCAL ONLY

One-shot snapshot of the current frame as a Base64-encoded data URL. Useful for thumbnails, profile-photo capture, AI vision input, or sending a snapshot to a server.

Not available on remote streams — to snapshot a remote video, use canvas.drawImage() on the user-attached <video> element.

Two ways to size the output — pick whichever is more natural. aspectRatio (with an optional single dimension) gives you a target shape; width / height give you exact pixel dimensions. The resolution rules:

// 256×256 from any source aspect, cropping to the center (default 'cover')
const dataUrl = await me.video.captureFrame({
  aspectRatio: '1:1',
  width:       256,
});
document.querySelector('#avatar').src = dataUrl;

// Force 1280×720 (16:9); keep the entire source visible with bars if needed
const dataUrl = await me.video.captureFrame({
  aspectRatio: '16:9',
  width:       1280,
  fit:         'contain',     // black bars instead of cropping
  quality:     0.85,
});

// No sizing options → source frame's natural dimensions
const dataUrl = await me.video.captureFrame({ quality: 0.85 });

document.querySelector('#preview').src = dataUrl;

// Upload
await fetch('/snapshot', {
  method: 'POST',
  body:   JSON.stringify({ image: dataUrl }),
});

// Download as file
const a = document.createElement('a');
a.href = dataUrl;
a.download = 'snapshot.jpg';
a.click();