Your Cameras.
Anywhere.
Instantly.

import { useEffect, useRef } from "react";

type Props = { url: string };

export function SimpleWHEPPlayer({ url }: Props) {
  const videoRef = useRef<HTMLVideoElement>(null);

  useEffect(() => {
    const pc = new RTCPeerConnection();
    pc.addTransceiver("video", { direction: "recvonly" });
    pc.ontrack = (e) => { if (videoRef.current) videoRef.current.srcObject = e.streams[0]; };

    (async () => {
      const offer = await pc.createOffer();
      await pc.setLocalDescription(offer);
      const res = await fetch(url, { method: "POST", headers: { "content-type": "application/sdp" }, body: offer.sdp });
      const answer = await res.text();
      await pc.setRemoteDescription({ type: "answer", sdp: answer });
    })();

    return () => pc.close();
  }, [url]);

  return <video ref={videoRef} autoPlay playsInline muted style={{ width: "100%", background: "#000" }} />;
}

// Usage:
// e.g., app/page.tsx
import { SimpleWHEPPlayer } from "./SimpleWHEPPlayer";

export default function Page() {
  const token = process.env.RELAY_TOKEN!;
  const org = process.env.RELAY_ORG_ID!;
  const cam = "exit-cam-06";

  const url = `https://webrtc.therelay.net/${token}%2F${org}%2F${cam}/whep`;

  return <SimpleWHEPPlayer url={url} />;
}

package main
import (
	"fmt"
	"os"
	"gocv.io/x/gocv"
)

func main() {
	token := os.Getenv("RELAY_TOKEN")
	org := os.Getenv("RELAY_ORG_ID")
	cam := "warehouse-01"

	url := fmt.Sprintf("rtsp://stream.therelay.net/%s/%s/%s", token, org, cam)
	fmt.Println("Opening:", url)

	webcam, err := gocv.OpenVideoCapture(url)
	if err != nil { panic(err) }
	defer webcam.Close()

	window := gocv.NewWindow("TheRelay Stream")
	defer window.Close()

	img := gocv.NewMat()
	defer img.Close()

	for {
		if ok := webcam.Read(&img); !ok || img.Empty() {
			break
		}
		// Your CV/AI processing here

		window.IMShow(img)
		if window.WaitKey(1) == 'q' {
			break
		}
	}
}

// src/main.rs
use opencv::{highgui, prelude::*, videoio, Result};
use std::env;

fn main() -> Result<()> {
    let token = env::var("RELAY_TOKEN")?;
    let org   = env::var("RELAY_ORG_ID")?;
    let cam = "exit-cam-02";

    let url = format("rtsp://stream.therelay.net/{}/{}/{}", token, org, cam);
    println!("Opening: {}", url);

    let mut cap = videoio::VideoCapture::from_file(&url, videoio::CAP_FFMPEG)?;
    if !videoio::VideoCapture::is_opened(&cap)? {
        panic!("Failed to open stream");
    }

    highgui::named_window("TheRelay Stream", highgui::WINDOW_AUTOSIZE)?;
    loop {
        let mut frame = Mat::default();
        if !cap.read(&mut frame)? || frame.empty() {
            break;
        }
        // Your CV/AI processing here

        highgui::imshow("TheRelay Stream", &frame)?;
        if highgui::wait_key(1)? == 'q' as i32 {
            break;
        }
    }
    Ok(())
}