scrypted-kasa 1.0.0

package/src/camera/rtsp.ts

@@ -0,0 +1,204 @@
+import { randomBytes } from 'crypto';
+import net from 'net';
+
+const RTSP_INTERLEAVED_MAGIC = 0x24; // '$'
+
+export interface RtspChannelPair {
+    rtp: number;
+    rtcp: number;
+}
+
+export interface RtspChannels {
+    video: RtspChannelPair;
+    audio: RtspChannelPair;
+}
+
+export interface RtspSendInterleaved {
+    (channel: number, packet: Buffer): boolean;
+}
+
+export interface RtspHandlerOptions {
+    sdp: string;
+    onPlay: (send: RtspSendInterleaved, channels: RtspChannels) => void;
+    onTeardown: () => void;
+    console: Console;
+}
+
+interface RtspRequest {
+    method: string;
+    uri: string;
+    headers: Record<string, string>;
+}
+
+// Minimal RTSP server-side handler for ONE TCP client. Supports the methods Scrypted (and
+// any standard RTSP client) actually uses: OPTIONS, DESCRIBE, SETUP, PLAY, PAUSE, TEARDOWN.
+// TCP-interleaved transport only — that's what Scrypted's pipeline asks for by default and
+// it sidesteps every NAT/UDP-loss complication. We build the SDP upstream and just serve it
+// on DESCRIBE; we never parse one.
+export function handleRtspClient(client: net.Socket, opts: RtspHandlerOptions): void {
+    const sessionId = randomBytes(8).toString('hex');
+    let videoChannels: RtspChannelPair | undefined;
+    let audioChannels: RtspChannelPair | undefined;
+    let buffered: Buffer = Buffer.alloc(0);
+    let isPlaying = false;
+    let teardownNotified = false;
+
+    const notifyTeardown = () => {
+        if (teardownNotified) return;
+        teardownNotified = true;
+        opts.onTeardown();
+    };
+
+    const send: RtspSendInterleaved = (channel, packet) => {
+        if (client.destroyed) return false;
+        // Interleaved frame: '$' + 1-byte channel + 2-byte BE length + RTP packet bytes.
+        // Header + body in one Buffer to avoid splitting writes (a small write between the
+        // two would let an out-of-order chunk arrive in the middle of an interleaved frame).
+        const out = Buffer.allocUnsafe(4 + packet.length);
+        out[0] = RTSP_INTERLEAVED_MAGIC;
+        out[1] = channel;
+        out.writeUInt16BE(packet.length, 2);
+        packet.copy(out, 4);
+        // The destroyed check above is racy — the socket can be torn down between the
+        // check and write (different microtask), in which case write throws
+        // ERR_STREAM_DESTROYED. Catch it; the next packet's destroyed check will gate
+        // further sends.
+        try {
+            return client.write(out);
+        } catch {
+            return false;
+        }
+    };
+
+    const respond = (
+        cseq: string,
+        status: number,
+        statusText: string,
+        headers: Record<string, string | number> = {},
+        body?: string,
+    ) => {
+        const lines = [`RTSP/1.0 ${status} ${statusText}`, `CSeq: ${cseq}`];
+        if (body !== undefined) headers['Content-Length'] = Buffer.byteLength(body);
+        for (const [k, v] of Object.entries(headers)) lines.push(`${k}: ${v}`);
+        const message = lines.join('\r\n') + '\r\n\r\n' + (body || '');
+        client.write(message);
+    };
+
+    const handleRequest = (req: RtspRequest) => {
+        const cseq = req.headers['cseq'] || '0';
+        switch (req.method) {
+            case 'OPTIONS':
+                respond(cseq, 200, 'OK', {
+                    Public: 'OPTIONS, DESCRIBE, SETUP, PLAY, PAUSE, TEARDOWN',
+                });
+                return;
+
+            case 'DESCRIBE':
+                respond(cseq, 200, 'OK', { 'Content-Type': 'application/sdp' }, opts.sdp);
+                return;
+
+            case 'SETUP': {
+                const transport = req.headers['transport'] || '';
+                const m = /interleaved=(\d+)-(\d+)/i.exec(transport);
+                if (!m) {
+                    // We only support TCP-interleaved transport. UDP would require allocating
+                    // server-side ports, parsing client_port, and sending RTP via dgram —
+                    // pointless for a localhost-only stream.
+                    respond(cseq, 461, 'Unsupported Transport');
+                    return;
+                }
+                const rtp = parseInt(m[1], 10);
+                const rtcp = parseInt(m[2], 10);
+                const trackMatch = req.uri.match(/trackID=(\d+)/i);
+                const trackId = trackMatch ? parseInt(trackMatch[1], 10) : -1;
+                if (trackId === 0) videoChannels = { rtp, rtcp };
+                else if (trackId === 1) audioChannels = { rtp, rtcp };
+                else {
+                    respond(cseq, 404, 'Not Found');
+                    return;
+                }
+                respond(cseq, 200, 'OK', { Transport: transport, Session: sessionId });
+                return;
+            }
+
+            case 'PLAY':
+                if (!videoChannels || !audioChannels) {
+                    respond(cseq, 412, 'Precondition Failed');
+                    return;
+                }
+                respond(cseq, 200, 'OK', { Session: sessionId, Range: 'npt=0.000-' });
+                if (!isPlaying) {
+                    isPlaying = true;
+                    try {
+                        opts.onPlay(send, { video: videoChannels, audio: audioChannels });
+                    } catch (e) {
+                        opts.console.warn('rtsp onPlay handler error', e);
+                        client.destroy();
+                    }
+                }
+                return;
+
+            case 'PAUSE':
+                respond(cseq, 200, 'OK', { Session: sessionId });
+                return;
+
+            case 'TEARDOWN':
+                respond(cseq, 200, 'OK', { Session: sessionId });
+                client.end();
+                return;
+
+            default:
+                respond(cseq, 405, 'Method Not Allowed');
+        }
+    };
+
+    const HEADER_TERMINATOR = Buffer.from('\r\n\r\n');
+    client.on('data', chunk => {
+        buffered = buffered.length === 0 ? chunk : Buffer.concat([buffered, chunk]);
+        // Parse messages until we run out of complete ones in the buffer.
+        while (buffered.length > 0) {
+            // Skip any interleaved frames the client might send back at us. (Standard
+            // clients don't, but defending against the bidirectional channel costs nothing
+            // and is robust against odd consumers that probe.)
+            if (buffered[0] === RTSP_INTERLEAVED_MAGIC) {
+                if (buffered.length < 4) return;
+                const len = buffered.readUInt16BE(2);
+                if (buffered.length < 4 + len) return;
+                buffered = buffered.subarray(4 + len);
+                continue;
+            }
+            const headerEndIdx = buffered.indexOf(HEADER_TERMINATOR);
+            if (headerEndIdx < 0) return;
+            const headerStr = buffered.subarray(0, headerEndIdx).toString('utf8');
+            const headerLines = headerStr.split('\r\n');
+            const requestLine = headerLines.shift() || '';
+            const [method, uri] = requestLine.split(' ');
+            const headers: Record<string, string> = {};
+            for (const line of headerLines) {
+                const colon = line.indexOf(':');
+                if (colon < 0) continue;
+                headers[line.slice(0, colon).trim().toLowerCase()] = line.slice(colon + 1).trim();
+            }
+            const contentLength = parseInt(headers['content-length'] || '0', 10);
+            const totalLen = headerEndIdx + HEADER_TERMINATOR.length + contentLength;
+            if (buffered.length < totalLen) return;
+            // We currently ignore request bodies — none of the methods we handle need one.
+            buffered = buffered.subarray(totalLen);
+            if (!method || !uri) {
+                opts.console.warn('rtsp: malformed request line', JSON.stringify(requestLine));
+                client.destroy();
+                return;
+            }
+            try {
+                handleRequest({ method: method.toUpperCase(), uri, headers });
+            } catch (e) {
+                opts.console.warn('rtsp handleRequest threw', e);
+                client.destroy();
+                return;
+            }
+        }
+    });
+
+    client.on('close', notifyTeardown);
+    client.on('error', notifyTeardown);
+}

package/src/camera/stream.ts

@@ -0,0 +1,428 @@
+import child_process from 'child_process';
+import dgram from 'dgram';
+import { once } from 'events';
+import net from 'net';
+import { Writable } from 'stream';
+import { findSpsPps, KasaClient, KasaMimeG711U, KasaMimeVideo, KasaPart } from './api';
+import { handleRtspClient } from './rtsp';
+
+// Process-level cleanup registry. Scrypted runs plugins as worker threads, and child
+// processes spawned by a worker survive the worker's termination — they're owned by the
+// host Node process. So when our plugin gets unloaded (or even when the worker crashes),
+// any in-flight ffmpeg subprocess + kasa HTTPS connection would otherwise leak. We catch
+// that here: every spawnKasaStream and intercom-ffmpeg registers its kill function and
+// removes itself on normal teardown. On worker exit, the hook nukes anything still live.
+const liveCleanups = new Set<() => void>();
+let exitHookInstalled = false;
+function installExitHook() {
+    if (exitHookInstalled) return;
+    exitHookInstalled = true;
+    process.once('exit', () => {
+        for (const cleanup of liveCleanups) {
+            try {
+                cleanup();
+            } catch {
+                /* best-effort, can't do anything from inside 'exit' */
+            }
+        }
+        liveCleanups.clear();
+    });
+}
+
+export function registerLiveCleanup(cleanup: () => void): () => void {
+    installExitHook();
+    liveCleanups.add(cleanup);
+    return () => liveCleanups.delete(cleanup);
+}
+
+// Hard ceiling on the upfront SPS/PPS scan. Real cameras emit them well under a second; if
+// we don't see them in this window the camera is misbehaving and there's no point holding
+// the call.
+const SPS_PPS_TIMEOUT_MS = 10000;
+// Belt-and-suspenders caps on the prebuffer. The timeout already bounds the wait, but a
+// camera that streams at high bitrate and never emits SPS/PPS could fill memory before the
+// timer fires. Either trip throws.
+const SPS_PPS_MAX_BUFFERED_PARTS = 1024;
+const SPS_PPS_MAX_BUFFERED_BYTES = 32 * 1024 * 1024;
+
+export interface KasaStreamOptions {
+    kasa: KasaClient;
+    ffmpegPath: string;
+    console: Console;
+}
+
+export interface KasaStreamHandle {
+    url: string;
+    kill(): void;
+    exited: Promise<void>;
+}
+
+interface BoundUdp {
+    socket: dgram.Socket;
+    port: number;
+}
+
+interface UdpPair {
+    rtp: BoundUdp;
+    rtcp: BoundUdp;
+}
+
+// 1 MB UDP receive buffer — comfortably absorbs an IDR-frame burst on the localhost hop
+// from ffmpeg, which can be 100+ RTP packets arriving back-to-back. The default Linux
+// SO_RCVBUF (~200 KB) overflows on 1080p H.264 IDRs and drops fragments, surfacing as
+// "fua packet missing" in downstream consumers.
+const UDP_RECV_BUFFER_BYTES = 1024 * 1024;
+
+async function bindUdp(port: number = 0): Promise<BoundUdp> {
+    const sock = dgram.createSocket('udp4');
+    await new Promise<void>((resolve, reject) => {
+        const onError = (e: Error) => {
+            sock.removeListener('listening', onListen);
+            reject(e);
+        };
+        const onListen = () => {
+            sock.removeListener('error', onError);
+            resolve();
+        };
+        sock.once('error', onError);
+        sock.once('listening', onListen);
+        sock.bind(port, '127.0.0.1');
+    });
+    // setRecvBufferSize tries to bump SO_RCVBUF; the kernel caps it at net.core.rmem_max
+    // (often 200 KB on stock Linux, 2+ MB on most server distros). We don't fail if the
+    // bump is rejected — small buffer just means we may drop on big bursts.
+    try {
+        sock.setRecvBufferSize(UDP_RECV_BUFFER_BYTES);
+    } catch {
+        /* best-effort */
+    }
+    return { socket: sock, port: (sock.address() as { port: number }).port };
+}
+
+// Bind a (RTP, RTP+1) UDP pair so RTCP gets the conventional next port. ffmpeg's `-f rtp`
+// output assumes RTP+1 for RTCP unless rtcpport= overrides; binding the pair ourselves
+// keeps the wiring straightforward. Retry up to 10 times in case RTP+1 is already taken.
+async function bindUdpPair(): Promise<UdpPair> {
+    for (let attempt = 0; attempt < 10; attempt++) {
+        const rtp = await bindUdp();
+        try {
+            const rtcp = await bindUdp(rtp.port + 1);
+            return { rtp, rtcp };
+        } catch {
+            rtp.socket.close();
+        }
+    }
+    throw new Error('failed to bind sequential RTP/RTCP udp pair after 10 tries');
+}
+
+// Reserve a TCP port on localhost for the RTSP server. Brief TOCTOU window between close
+// and re-bind is accepted — nothing else snatches loopback ports in those few ms.
+async function reserveTcpPort(): Promise<number> {
+    return new Promise<number>((resolve, reject) => {
+        const probe = net.createServer();
+        probe.once('error', reject);
+        probe.listen(0, '127.0.0.1', () => {
+            const port = (probe.address() as net.AddressInfo).port;
+            probe.close(() => resolve(port));
+        });
+    });
+}
+
+// Build the SDP we serve on DESCRIBE. We embed sprop-parameter-sets so consumers can decode
+// without waiting for the next IDR — important for HomeKit's strict first-frame timeouts.
+function buildSdp(sps: Buffer, pps: Buffer): string {
+    // RFC 6184: profile-level-id is the 3 SPS bytes (profile_idc, profile-iop, level_idc)
+    // immediately following the NAL header byte, encoded as 6 hex chars.
+    const profileLevelId = sps.subarray(1, 4).toString('hex').toUpperCase();
+    const spropParameterSets = sps.toString('base64') + ',' + pps.toString('base64');
+    return (
+        [
+            'v=0',
+            'o=- 0 0 IN IP4 127.0.0.1',
+            's=Kasa',
+            'c=IN IP4 127.0.0.1',
+            't=0 0',
+            'm=video 0 RTP/AVP 96',
+            'a=rtpmap:96 H264/90000',
+            `a=fmtp:96 packetization-mode=1; profile-level-id=${profileLevelId}; sprop-parameter-sets=${spropParameterSets}`,
+            'a=control:trackID=0',
+            'm=audio 0 RTP/AVP 0',
+            'a=rtpmap:0 PCMU/8000',
+            'a=control:trackID=1',
+        ].join('\r\n') + '\r\n'
+    );
+}
+
+async function preScanSpsPps(kasa: KasaClient): Promise<{ sps: Buffer; pps: Buffer; buffered: KasaPart[] }> {
+    const buffered: KasaPart[] = [];
+    let bufferedBytes = 0;
+    const found: { sps?: Buffer; pps?: Buffer } = {};
+    const deadline = Date.now() + SPS_PPS_TIMEOUT_MS;
+    while (!found.sps || !found.pps) {
+        if (Date.now() > deadline) throw new Error('timed out waiting for H.264 SPS/PPS');
+        if (buffered.length >= SPS_PPS_MAX_BUFFERED_PARTS)
+            throw new Error(`H.264 SPS/PPS not found within ${SPS_PPS_MAX_BUFFERED_PARTS} parts`);
+        if (bufferedBytes >= SPS_PPS_MAX_BUFFERED_BYTES)
+            throw new Error(`H.264 SPS/PPS not found within ${SPS_PPS_MAX_BUFFERED_BYTES} prebuffered bytes`);
+        const part = await kasa.readPart();
+        buffered.push(part);
+        bufferedBytes += part.body.length;
+        if (part.contentType === KasaMimeVideo) findSpsPps(part.body, found);
+    }
+    return { sps: found.sps!, pps: found.pps!, buffered };
+}
+
+// Replays the buffered parts captured during the SPS/PPS scan (so ffmpeg sees the
+// SPS+PPS+IDR sequence required to start decoding) then continues pumping live parts. We
+// honor backpressure: if ffmpeg falls behind (CPU spike, paused consumer, etc.), ignoring
+// drain would let Node's write buffer grow without bound. Awaiting drain throttles the
+// camera read loop instead — the camera's TCP receive window will fill up and the kernel
+// will pause it for us.
+async function pumpKasa(
+    kasa: KasaClient,
+    videoPipe: Writable,
+    audioPipe: Writable,
+    prebuffered: KasaPart[],
+): Promise<void> {
+    const writePart = async (part: KasaPart) => {
+        const pipe =
+            part.contentType === KasaMimeVideo ? videoPipe : part.contentType === KasaMimeG711U ? audioPipe : undefined;
+        if (!pipe || pipe.writableEnded || pipe.destroyed) return;
+        if (!pipe.write(part.body)) {
+            // Race 'drain' against teardown. If the pipe closes/errors before draining,
+            // 'drain' never fires and the pump would hang forever. AbortController removes
+            // the losing listeners after the race so frequent backpressure cycles don't
+            // accumulate listeners on the pipe.
+            const ac = new AbortController();
+            try {
+                await Promise.race([
+                    once(pipe, 'drain', { signal: ac.signal }).catch(() => {}),
+                    once(pipe, 'close', { signal: ac.signal }).catch(() => {}),
+                    once(pipe, 'error', { signal: ac.signal }).catch(() => {}),
+                ]);
+            } finally {
+                ac.abort();
+            }
+        }
+    };
+
+    try {
+        for (const part of prebuffered) await writePart(part);
+        // Release prebuffered parts (up to a few hundred KB each) — they were captured
+        // during the SPS/PPS scan and are only needed for this single replay.
+        prebuffered.length = 0;
+        while (true) {
+            const part = await kasa.readPart();
+            await writePart(part);
+        }
+    } finally {
+        try {
+            videoPipe.end();
+        } catch {}
+        try {
+            audioPipe.end();
+        } catch {}
+    }
+}
+
+// Orchestrates the kasa→consumer streaming pipeline:
+//   kasa multipart → ffmpeg pipe inputs (codec copy) → RTP UDP outputs
+//                  → minimal RTSP server forwards UDP RTP as TCP-interleaved frames
+//                  → consumer reads via rtsp:// URL
+//
+// Returns a handle whose `kill()` tears down everything (kasa, ffmpeg, UDP sockets, TCP
+// server, active client) and whose `exited` promise resolves once that teardown is done.
+export async function spawnKasaStream(opts: KasaStreamOptions): Promise<KasaStreamHandle> {
+    const { kasa, ffmpegPath, console } = opts;
+
+    const { sps, pps, buffered } = await preScanSpsPps(kasa);
+    const sdp = buildSdp(sps, pps);
+
+    const videoUdp = await bindUdpPair();
+    const audioUdp = await bindUdpPair();
+
+    // Two RTP outputs, one per track. `-vn`/`-an` per output filter the unwanted side
+    // rather than using `-map`. Explicit -payload_type lines pin the PTs to the values our
+    // SDP advertises (96 for H.264, 0 for PCMU) so a future ffmpeg default change can't
+    // silently break the SDP/stream contract.
+    // prettier-ignore
+    const args = [
+        '-hide_banner',
+        '-loglevel', 'error',
+        '-thread_queue_size', '1024',
+        '-f', 'h264',
+        '-i', 'pipe:3',
+        '-thread_queue_size', '1024',
+        '-f', 'mulaw',
+        '-ar', '8000',
+        '-ac', '1',
+        '-i', 'pipe:4',
+        '-vcodec', 'copy', '-an', '-dn', '-sn',
+        '-f', 'rtp',
+        '-payload_type', '96',
+        `rtp://127.0.0.1:${videoUdp.rtp.port}?rtcpport=${videoUdp.rtcp.port}`,
+        '-acodec', 'copy', '-vn', '-dn', '-sn',
+        '-f', 'rtp',
+        '-payload_type', '0',
+        `rtp://127.0.0.1:${audioUdp.rtp.port}?rtcpport=${audioUdp.rtcp.port}`,
+    ];
+
+    const cp = child_process.spawn(ffmpegPath, args, {
+        stdio: ['ignore', 'pipe', 'pipe', 'pipe', 'pipe'],
+    });
+    cp.stderr?.on('data', d => {
+        const text = d.toString().trim();
+        if (text) console.log('[kasa-ffmpeg]', text);
+    });
+
+    const videoPipe = cp.stdio[3] as Writable;
+    const audioPipe = cp.stdio[4] as Writable;
+
+    let resolveExited!: () => void;
+    const exited = new Promise<void>(r => {
+        resolveExited = r;
+    });
+
+    // Forward-declare anything cleanupAll touches that's initialized later in the function.
+    // ffmpeg's `exit`/`error` events or a pump throw can fire cleanupAll while we're still
+    // awaiting `reserveTcpPort()` below — referencing TDZ const bindings here would throw
+    // an uncaught ReferenceError and skip the rest of teardown. Explicit `= undefined` so
+    // eslint's prefer-const sees the later reassignment.
+    let tcpServer: net.Server | undefined = undefined;
+    let activeClient: net.Socket | undefined = undefined;
+    let unregisterCleanup: (() => void) | undefined = undefined;
+
+    let killed = false;
+    const cleanupAll = () => {
+        if (killed) return;
+        killed = true;
+        try {
+            unregisterCleanup?.();
+        } catch {}
+        try {
+            tcpServer?.close();
+        } catch {}
+        try {
+            activeClient?.destroy();
+        } catch {}
+        try {
+            kasa.destroy();
+        } catch {}
+        try {
+            cp.kill('SIGKILL');
+        } catch {}
+        try {
+            videoUdp.rtp.socket.close();
+        } catch {}
+        try {
+            videoUdp.rtcp.socket.close();
+        } catch {}
+        try {
+            audioUdp.rtp.socket.close();
+        } catch {}
+        try {
+            audioUdp.rtcp.socket.close();
+        } catch {}
+        resolveExited();
+    };
+    // Register with the process-level cleanup registry so worker termination kills the
+    // ffmpeg subprocess + closes the kasa connection even if our normal teardown path
+    // (release(), kill switch, ffmpeg exit) didn't run.
+    unregisterCleanup = registerLiveCleanup(cleanupAll);
+
+    // ffmpeg exit (or spawn error) is itself a teardown trigger.
+    cp.once('exit', cleanupAll);
+    cp.once('error', cleanupAll);
+
+    // Pump kasa → ffmpeg pipes. If the pump throws (kasa stream ended/errored), tear down.
+    // We suppress the warn when `killed` is already set, because that means our own
+    // cleanupAll destroyed the kasa connection and the resulting "stream ended" throw is
+    // expected close-sequence noise, not a real error.
+    pumpKasa(kasa, videoPipe, audioPipe, buffered)
+        .catch(e => {
+            if (!killed) console.warn('[kasa-stream] pump error', (e as Error).message);
+        })
+        .finally(cleanupAll);
+
+    // Forwarding state — populated atomically when the RTSP client PLAYs, used by the
+    // always-attached UDP message handlers below. One reference instead of two so the
+    // handlers can't observe a half-set state under any scheduling.
+    interface ActiveForwarder {
+        send: (channel: number, packet: Buffer) => boolean;
+        videoRtp: number;
+        videoRtcp: number;
+        audioRtp: number;
+        audioRtcp: number;
+    }
+    let active: ActiveForwarder | null = null;
+
+    // Attach UDP listeners IMMEDIATELY (not on PLAY) so the kernel buffer gets drained as
+    // soon as ffmpeg starts producing packets. Without this, packets sent before the RTSP
+    // client connects pile up in SO_RCVBUF and either get dropped on overflow, or block
+    // libuv from polling the socket cleanly. Until `active` is set, we just discard.
+    videoUdp.rtp.socket.on('message', msg => {
+        if (active) active.send(active.videoRtp, msg);
+    });
+    videoUdp.rtcp.socket.on('message', msg => {
+        if (active) active.send(active.videoRtcp, msg);
+    });
+    audioUdp.rtp.socket.on('message', msg => {
+        if (active) active.send(active.audioRtp, msg);
+    });
+    audioUdp.rtcp.socket.on('message', msg => {
+        if (active) active.send(active.audioRtcp, msg);
+    });
+
+    // Bind the RTSP listener last, after all the supporting pieces are in place.
+    const rtspPort = await reserveTcpPort();
+    const url = `rtsp://127.0.0.1:${rtspPort}/kasa`;
+
+    tcpServer = net.createServer();
+
+    tcpServer.on('connection', client => {
+        // tcpServer.close() in cleanupAll only stops accepting NEW connections; an inflight
+        // accept can still fire 'connection' after we've started teardown. Reject those so
+        // the late client doesn't become activeClient and leak.
+        if (killed) {
+            client.destroy();
+            return;
+        }
+        if (activeClient) {
+            // We only serve one consumer per stream session. Reject anything else.
+            client.destroy();
+            return;
+        }
+        // RTSP-over-TCP-interleaved frames are small (~4 B header + RTP packet). Disable
+        // Nagle so frame headers don't get held up to 200 ms hoping to coalesce.
+        client.setNoDelay(true);
+        activeClient = client;
+        handleRtspClient(client, {
+            sdp,
+            console,
+            onPlay(send, channels) {
+                active = {
+                    send,
+                    videoRtp: channels.video.rtp,
+                    videoRtcp: channels.video.rtcp,
+                    audioRtp: channels.audio.rtp,
+                    audioRtcp: channels.audio.rtcp,
+                };
+            },
+            onTeardown: cleanupAll,
+        });
+    });
+
+    await new Promise<void>((resolve, reject) => {
+        tcpServer.once('error', reject);
+        tcpServer.listen(rtspPort, '127.0.0.1', () => {
+            tcpServer.removeListener('error', reject);
+            resolve();
+        });
+    });
+
+    return {
+        url,
+        kill: cleanupAll,
+        exited,
+    };
+}