From da74b85223f0bfd07889f268fd64164b1176cdf4 Mon Sep 17 00:00:00 2001
From: henryruhs <info@henryruhs.com>
Date: Mon, 23 Mar 2026 14:20:37 +0100
Subject: [PATCH] mass test approaches

---
 facefusion/apis/core.py             |   5 +-
 facefusion/apis/endpoints/stream.py |  27 +-
 facefusion/rtc.py                   |  13 +-
 facefusion/whip_relay.py            |  10 +-
 test_stream.html                    |  29 +-
 tools/whip_relay                    | Bin 0 -> 31328 bytes
 tools/whip_relay.c                  | 664 ++++++++++++++++++++++++++++
 7 files changed, 729 insertions(+), 19 deletions(-)
 create mode 100755 tools/whip_relay
 create mode 100644 tools/whip_relay.c

diff --git a/facefusion/apis/core.py b/facefusion/apis/core.py
index ad5a501b..e99fd624 100644
--- a/facefusion/apis/core.py
+++ b/facefusion/apis/core.py
@@ -14,7 +14,7 @@ from facefusion.apis.endpoints.ping import websocket_ping
 from facefusion.apis.endpoints.session import create_session, destroy_session, get_session, refresh_session
 from facefusion.apis.endpoints.state import get_state, set_state
 from facefusion import logger
-from facefusion.apis.endpoints.stream import websocket_stream, websocket_stream_audio, websocket_stream_live, websocket_stream_mjpeg, websocket_stream_rtc, websocket_stream_whip, websocket_stream_whip_aio, websocket_stream_whip_dc, websocket_stream_whip_py
+from facefusion.apis.endpoints.stream import websocket_stream, websocket_stream_audio, websocket_stream_live, websocket_stream_mjpeg, websocket_stream_rtc, websocket_stream_whip, websocket_stream_whip_dc, websocket_stream_whip_py
 from facefusion.apis.middlewares.session import create_session_guard
 
 
@@ -87,8 +87,7 @@ def create_api() -> Starlette:
 			WebSocketRoute('/stream/whip-py', websocket_stream_whip_py, middleware = [ session_guard ]),
 			WebSocketRoute('/stream/whip-dc', websocket_stream_whip_dc, middleware = [ session_guard ]),
 			WebSocketRoute('/stream/live', websocket_stream_live, middleware = [ session_guard ]),
-			WebSocketRoute('/stream/whip-aio', websocket_stream_whip_aio, middleware = [ session_guard ]),
-			WebSocketRoute('/stream/rtc', websocket_stream_rtc, middleware = [ session_guard ]),
+WebSocketRoute('/stream/rtc', websocket_stream_rtc, middleware = [ session_guard ]),
 			WebSocketRoute('/stream/mjpeg', websocket_stream_mjpeg, middleware = [ session_guard ]),
 			WebSocketRoute('/stream/audio', websocket_stream_audio, middleware = [ session_guard ])
 		]
diff --git a/facefusion/apis/endpoints/stream.py b/facefusion/apis/endpoints/stream.py
index 24cca8a6..8c6b4b40 100644
--- a/facefusion/apis/endpoints/stream.py
+++ b/facefusion/apis/endpoints/stream.py
@@ -7,6 +7,7 @@ from collections import deque
 from concurrent.futures import ThreadPoolExecutor
 from typing import Deque, List
 
+import av
 import cv2
 import numpy
 from starlette.websockets import WebSocket
@@ -590,14 +591,18 @@ async def websocket_stream_whip_dc(websocket : WebSocket) -> None:
 
 	if source_paths:
 		from facefusion import whip_relay
+		from facefusion import rtc as rtc_audio
+		import socket as sock
 		stream_path = 'stream/' + session_id
-		rtp_port = whip_relay.create_session(stream_path)
+		rtp_port, audio_port = whip_relay.create_session(stream_path)
 
 		if not rtp_port:
 			logger.error('failed to create relay session', __name__)
 			await websocket.close()
 			return
 
+		audio_sock = sock.socket(sock.AF_INET, sock.SOCK_DGRAM) if audio_port else None
+
 		latest_frame_holder : list = [None]
 		whep_sent = False
 		lock = threading.Lock()
@@ -625,10 +630,30 @@ async def websocket_stream_whip_dc(websocket : WebSocket) -> None:
 							with lock:
 								latest_frame_holder[0] = frame
 
+					if data[:2] != JPEG_MAGIC and audio_sock and audio_port:
+						encoder = rtc_audio.get_opus_encoder()
+						pcm = numpy.frombuffer(data, dtype = numpy.int16).reshape(1, -1)
+						samples = pcm.shape[1] // (2 * 960) * 960 * 2
+
+						if samples > 0:
+							for offset in range(0, samples, 960 * 2):
+								chunk = pcm[:, offset:offset + 960 * 2]
+
+								if chunk.shape[1] == 960 * 2:
+									frame = av.AudioFrame.from_ndarray(chunk, format = 's16', layout = 'stereo')
+									frame.sample_rate = 48000
+
+									for packet in encoder.encode(frame):
+										audio_sock.sendto(bytes(packet), ('127.0.0.1', audio_port))
+
 		except Exception as exception:
 			logger.error(str(exception), __name__)
 
 		stop_event.set()
+
+		if audio_sock:
+			audio_sock.close()
+
 		loop = asyncio.get_running_loop()
 		await loop.run_in_executor(None, worker.join, 10)
 		return
diff --git a/facefusion/rtc.py b/facefusion/rtc.py
index 7379046d..a93f65cc 100644
--- a/facefusion/rtc.py
+++ b/facefusion/rtc.py
@@ -270,6 +270,7 @@ send_start_time : float = 0
 opus_encoder : Optional[av.CodecContext] = None
 audio_buffer : bytearray = bytearray()
 audio_lock : threading.Lock = threading.Lock()
+audio_pts : int = 0
 OPUS_FRAME_SAMPLES : int = 960
 
 
@@ -320,6 +321,8 @@ def get_opus_encoder() -> av.CodecContext:
 
 
 def send_audio(stream_path : str, pcm_data : bytes) -> None:
+	global audio_pts
+
 	session = sessions.get(stream_path)
 
 	if not session:
@@ -342,10 +345,11 @@ def send_audio(stream_path : str, pcm_data : bytes) -> None:
 			pcm = numpy.frombuffer(chunk, dtype = numpy.int16).reshape(1, -1)
 			frame = av.AudioFrame.from_ndarray(pcm, format = 's16', layout = 'stereo')
 			frame.sample_rate = 48000
-			frame.pts = None
+			frame.pts = audio_pts
 
 			for packet in encoder.encode(frame):
 				opus_data = bytes(packet)
+				buf = ctypes.create_string_buffer(opus_data)
 
 				for viewer in viewers:
 					if not viewer.get('connected'):
@@ -359,12 +363,11 @@ def send_audio(stream_path : str, pcm_data : bytes) -> None:
 					if not lib.rtcIsOpen(audio_track_id):
 						continue
 
-					elapsed = _time.monotonic() - send_start_time if send_start_time > 0 else 0
-					timestamp = int(elapsed * 48000) & 0xFFFFFFFF
-					buf = ctypes.create_string_buffer(opus_data)
-					lib.rtcSetTrackRtpTimestamp(audio_track_id, timestamp)
+					lib.rtcSetTrackRtpTimestamp(audio_track_id, audio_pts & 0xFFFFFFFF)
 					lib.rtcSendMessage(audio_track_id, buf, len(opus_data))
 
+			audio_pts += OPUS_FRAME_SAMPLES
+
 
 h264_au_buffer : Dict[str, bytes] = {}
 
diff --git a/facefusion/whip_relay.py b/facefusion/whip_relay.py
index 230ba726..1fe4da88 100644
--- a/facefusion/whip_relay.py
+++ b/facefusion/whip_relay.py
@@ -88,12 +88,16 @@ def is_session_ready(stream_path : str) -> bool:
 	return False
 
 
-def create_session(stream_path : str) -> int:
+def create_session(stream_path : str) -> tuple:
 	try:
 		response = httpx.post('http://localhost:' + str(RELAY_PORT) + '/' + stream_path + '/create', timeout = 5)
 
 		if response.status_code == 200:
-			return int(response.text)
+			parts = response.text.split(',')
+
+			if len(parts) >= 2:
+				return int(parts[0]), int(parts[1])
+			return int(parts[0]), 0
 	except Exception:
 		pass
-	return 0
+	return 0, 0
diff --git a/test_stream.html b/test_stream.html
index 653e3531..879ed8da 100644
--- a/test_stream.html
+++ b/test_stream.html
@@ -3,7 +3,7 @@
 <head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>WHIP Stream Monitor</title>
+<title>Video Stream</title>
 <style>
   * { box-sizing: border-box; margin: 0; padding: 0; }
   html, body { overflow: hidden; height: 100vh; }
@@ -107,7 +107,7 @@
 <body>
 <div class="layout">
   <div class="sidebar">
-    <h2>WHIP Stream <span class="badge">LIVE</span></h2>
+    <h2>Video Stream <span class="badge">LIVE</span></h2>
 
     <div class="section">
       <div class="section-title"><span class="step-dot" id="dotSession">1</span> Session</div>
@@ -144,12 +144,11 @@
         <label>Approach
           <select id="streamMode">
             <option value="whip-mediamtx">FFmpeg WHIP + MediaMTX</option>
-            <option value="whip-python">aiortc in-process WebRTC</option>
+            <option value="whip-python">aiortc WebRTC (no ext. deps)</option>
             <option value="whip-datachannel">FFmpeg WHIP + libdatachannel relay</option>
             <option value="ws-fmp4">FFmpeg fMP4 + WebSocket (MSE)</option>
             <option value="datachannel-direct">libdatachannel direct</option>
-            <option value="whip-aiortc">aiortc WebRTC + audio (no ext. deps)</option>
-            <option value="ws-mjpeg">MJPEG over WebSocket (no deps)</option>
+<option value="ws-mjpeg">MJPEG over WebSocket (no deps)</option>
           </select>
         </label>
       </div>
@@ -324,8 +323,7 @@ var MODE_CONFIG = {
   'whip-datachannel':    { wsPath: '/stream/whip-dc',  playback: 'whep' },
   'ws-fmp4':             { wsPath: '/stream/live',     playback: 'mse' },
   'datachannel-direct':  { wsPath: '/stream/rtc',      playback: 'whep' },
-  'whip-aiortc':         { wsPath: '/stream/whip-aio',  playback: 'whep' },
-  'ws-mjpeg':            { wsPath: '/stream/mjpeg',    playback: 'mjpeg' }
+'ws-mjpeg':            { wsPath: '/stream/mjpeg',    playback: 'mjpeg' }
 };
 
 function getMode() {
@@ -1020,6 +1018,23 @@ async function connect() {
   var mode = getMode();
   framesSent = 0;
 
+  var outputVideo = document.getElementById('outputVideo');
+  outputVideo.srcObject = null;
+  outputVideo.removeAttribute('src');
+  outputVideo.load();
+  outputVideo.style.display = '';
+
+  var mjpegImg = outputVideo._mjpegImg;
+
+  if (mjpegImg) {
+    if (mjpegImg._prevUrl) URL.revokeObjectURL(mjpegImg._prevUrl);
+    mjpegImg.remove();
+    outputVideo._mjpegImg = null;
+  }
+
+  cleanupMse();
+  whepUrlFromServer = null;
+
   var wsUrl = wsBase() + config.wsPath;
   var protocols = ['access_token.' + accessToken];
   var t0 = performance.now();
diff --git a/tools/whip_relay b/tools/whip_relay
new file mode 100755
index 0000000000000000000000000000000000000000..5b943d3f4f843377da605368bcfafe9f5be2128c
GIT binary patch
literal 31328
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
ZFEdrSN_HwvM$_Lx12fX)HU%5Y{u6R3tLp#&

literal 0
HcmV?d00001

diff --git a/tools/whip_relay.c b/tools/whip_relay.c
new file mode 100644
index 00000000..d6c9a15e
--- /dev/null
+++ b/tools/whip_relay.c
@@ -0,0 +1,664 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <sys/time.h>
+#include <signal.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <rtc/rtc.h>
+
+#define MAX_SESSIONS 16
+#define MAX_VIEWERS 8
+#define MAX_TRACKS 4
+#define SDP_BUF_SIZE 16384
+#define HTTP_BUF_SIZE 65536
+
+typedef struct
+{
+	int pc;
+	int tracks[MAX_TRACKS];
+	int track_count;
+	int audio_track;
+	int connected;
+} Viewer;
+
+typedef struct
+{
+	char path[256];
+	int rtp_port;
+	int rtp_fd;
+	int audio_port;
+	int audio_fd;
+	Viewer viewers[MAX_VIEWERS];
+	int viewer_count;
+	int active;
+	uint32_t audio_pts;
+	pthread_mutex_t lock;
+} Session;
+
+typedef struct
+{
+	Session *session;
+	int viewer_index;
+	int gathering_done;
+	pthread_mutex_t gather_lock;
+	pthread_cond_t gather_cond;
+} ViewerCtx;
+
+static Session sessions[MAX_SESSIONS];
+static pthread_mutex_t sessions_lock = PTHREAD_MUTEX_INITIALIZER;
+static volatile int running = 1;
+static int next_rtp_port = 15000;
+
+static Session *find_session(const char *path)
+{
+	for (int i = 0; i < MAX_SESSIONS; i++)
+	{
+		if (sessions[i].active && strcmp(sessions[i].path, path) == 0)
+		{
+			return &sessions[i];
+		}
+	}
+	return NULL;
+}
+
+static double get_elapsed_seconds(struct timeval *start)
+{
+	struct timeval now;
+	gettimeofday(&now, NULL);
+	return (now.tv_sec - start->tv_sec) + (now.tv_usec - start->tv_usec) / 1000000.0;
+}
+
+static void *rtp_receiver_thread(void *arg)
+{
+	Session *session = (Session *)arg;
+	char buf[256 * 1024];
+	struct timeval start_time;
+	int started = 0;
+
+	while (running && session->active)
+	{
+		struct sockaddr_in from;
+		socklen_t fromlen = sizeof(from);
+		int n = recvfrom(session->rtp_fd, buf, sizeof(buf), 0, (struct sockaddr *)&from, &fromlen);
+
+		if (n <= 0)
+		{
+			continue;
+		}
+
+		if (!started)
+		{
+			gettimeofday(&start_time, NULL);
+			started = 1;
+		}
+
+		double elapsed = get_elapsed_seconds(&start_time);
+		uint32_t timestamp = (uint32_t)(elapsed * 90000.0);
+
+		pthread_mutex_lock(&session->lock);
+
+		for (int v = 0; v < session->viewer_count; v++)
+		{
+			Viewer *viewer = &session->viewers[v];
+
+			if (!viewer->connected)
+			{
+				continue;
+			}
+
+			for (int t = 0; t < viewer->track_count; t++)
+			{
+				if (!rtcIsOpen(viewer->tracks[t]))
+				{
+					continue;
+				}
+
+				rtcSetTrackRtpTimestamp(viewer->tracks[t], timestamp);
+				rtcSendMessage(viewer->tracks[t], buf, n);
+			}
+		}
+
+		pthread_mutex_unlock(&session->lock);
+	}
+
+	return NULL;
+}
+
+static void *audio_receiver_thread(void *arg)
+{
+	Session *session = (Session *)arg;
+	char buf[4096];
+
+	while (running && session->active)
+	{
+		struct sockaddr_in from;
+		socklen_t fromlen = sizeof(from);
+		int n = recvfrom(session->audio_fd, buf, sizeof(buf), 0, (struct sockaddr *)&from, &fromlen);
+
+		if (n <= 0)
+		{
+			continue;
+		}
+
+		uint32_t ts = session->audio_pts;
+		session->audio_pts += 960;
+
+		pthread_mutex_lock(&session->lock);
+
+		for (int v = 0; v < session->viewer_count; v++)
+		{
+			Viewer *viewer = &session->viewers[v];
+
+			if (!viewer->connected || viewer->audio_track <= 0)
+			{
+				continue;
+			}
+
+			if (!rtcIsOpen(viewer->audio_track))
+			{
+				continue;
+			}
+
+			rtcSetTrackRtpTimestamp(viewer->audio_track, ts);
+			rtcSendMessage(viewer->audio_track, buf, n);
+		}
+
+		pthread_mutex_unlock(&session->lock);
+	}
+
+	return NULL;
+}
+
+static Session *create_session_slot(const char *path)
+{
+	for (int i = 0; i < MAX_SESSIONS; i++)
+	{
+		if (!sessions[i].active)
+		{
+			memset(&sessions[i], 0, sizeof(Session));
+			strncpy(sessions[i].path, path, sizeof(sessions[i].path) - 1);
+			sessions[i].active = 1;
+			sessions[i].rtp_port = next_rtp_port++;
+			pthread_mutex_init(&sessions[i].lock, NULL);
+
+			int fd = socket(AF_INET, SOCK_DGRAM, 0);
+			struct sockaddr_in addr;
+			memset(&addr, 0, sizeof(addr));
+			addr.sin_family = AF_INET;
+			addr.sin_addr.s_addr = inet_addr("127.0.0.1");
+			addr.sin_port = htons(sessions[i].rtp_port);
+
+			if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
+			{
+				perror("bind rtp");
+				close(fd);
+				sessions[i].active = 0;
+				return NULL;
+			}
+
+			struct timeval tv;
+			tv.tv_sec = 1;
+			tv.tv_usec = 0;
+			setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
+
+			sessions[i].rtp_fd = fd;
+
+			sessions[i].audio_port = next_rtp_port++;
+			int afd = socket(AF_INET, SOCK_DGRAM, 0);
+			struct sockaddr_in aaddr;
+			memset(&aaddr, 0, sizeof(aaddr));
+			aaddr.sin_family = AF_INET;
+			aaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
+			aaddr.sin_port = htons(sessions[i].audio_port);
+			bind(afd, (struct sockaddr *)&aaddr, sizeof(aaddr));
+			setsockopt(afd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
+			sessions[i].audio_fd = afd;
+			sessions[i].audio_pts = 0;
+
+			pthread_t tid;
+			pthread_create(&tid, NULL, rtp_receiver_thread, &sessions[i]);
+			pthread_detach(tid);
+
+			pthread_t atid;
+			pthread_create(&atid, NULL, audio_receiver_thread, &sessions[i]);
+			pthread_detach(atid);
+
+			return &sessions[i];
+		}
+	}
+	return NULL;
+}
+
+static ViewerCtx viewer_contexts[MAX_SESSIONS * MAX_VIEWERS];
+static int viewer_ctx_count = 0;
+
+static void on_viewer_state(int pc, rtcState state, void *ptr)
+{
+	ViewerCtx *ctx = (ViewerCtx *)ptr;
+
+	if (state == RTC_CONNECTED && ctx->session)
+	{
+		pthread_mutex_lock(&ctx->session->lock);
+
+		if (ctx->viewer_index < ctx->session->viewer_count)
+		{
+			ctx->session->viewers[ctx->viewer_index].connected = 1;
+		}
+
+		pthread_mutex_unlock(&ctx->session->lock);
+	}
+}
+
+static void on_viewer_gathering(int pc, rtcGatheringState state, void *ptr)
+{
+	ViewerCtx *ctx = (ViewerCtx *)ptr;
+
+	if (state == RTC_GATHERING_COMPLETE)
+	{
+		pthread_mutex_lock(&ctx->gather_lock);
+		ctx->gathering_done = 1;
+		pthread_cond_signal(&ctx->gather_cond);
+		pthread_mutex_unlock(&ctx->gather_lock);
+	}
+}
+
+static int create_viewer_pc(Session *session, const char *offer_sdp, char *answer_buf, int answer_size)
+{
+	if (session->viewer_count >= MAX_VIEWERS)
+	{
+		return -1;
+	}
+
+	rtcConfiguration config;
+	memset(&config, 0, sizeof(config));
+	config.forceMediaTransport = true;
+	config.enableIceUdpMux = true;
+
+	int pc = rtcCreatePeerConnection(&config);
+
+	if (pc < 0)
+	{
+		return -1;
+	}
+
+	ViewerCtx *ctx = &viewer_contexts[viewer_ctx_count++];
+	ctx->session = session;
+	ctx->viewer_index = session->viewer_count;
+	ctx->gathering_done = 0;
+	pthread_mutex_init(&ctx->gather_lock, NULL);
+	pthread_cond_init(&ctx->gather_cond, NULL);
+
+	Viewer *viewer = &session->viewers[session->viewer_count];
+	viewer->pc = pc;
+	viewer->connected = 0;
+	viewer->track_count = 0;
+
+	rtcSetUserPointer(pc, ctx);
+	rtcSetGatheringStateChangeCallback(pc, on_viewer_gathering);
+	rtcSetStateChangeCallback(pc, on_viewer_state);
+
+	int video_track = rtcAddTrack(pc,
+		"m=video 9 UDP/TLS/RTP/SAVPF 96\r\n"
+		"a=rtpmap:96 VP8/90000\r\n"
+		"a=sendonly\r\na=mid:0\r\na=rtcp-mux\r\n");
+
+	if (video_track >= 0)
+	{
+		rtcPacketizerInit packetizer;
+		memset(&packetizer, 0, sizeof(packetizer));
+		packetizer.ssrc = 42;
+		packetizer.cname = "video";
+		packetizer.payloadType = 96;
+		packetizer.clockRate = 90000;
+		packetizer.maxFragmentSize = 1200;
+		rtcSetVP8Packetizer(video_track, &packetizer);
+		rtcChainRtcpSrReporter(video_track);
+		rtcChainRtcpNackResponder(video_track, 512);
+
+		viewer->tracks[viewer->track_count++] = video_track;
+	}
+
+	int audio_track = rtcAddTrack(pc,
+		"m=audio 9 UDP/TLS/RTP/SAVPF 111\r\n"
+		"a=rtpmap:111 opus/48000/2\r\n"
+		"a=sendonly\r\na=mid:1\r\na=rtcp-mux\r\n");
+
+	if (audio_track >= 0)
+	{
+		rtcPacketizerInit audio_packetizer;
+		memset(&audio_packetizer, 0, sizeof(audio_packetizer));
+		audio_packetizer.ssrc = 43;
+		audio_packetizer.cname = "audio";
+		audio_packetizer.payloadType = 111;
+		audio_packetizer.clockRate = 48000;
+		rtcSetOpusPacketizer(audio_track, &audio_packetizer);
+		rtcChainRtcpSrReporter(audio_track);
+		viewer->audio_track = audio_track;
+	}
+
+	rtcSetRemoteDescription(pc, offer_sdp, "offer");
+
+	struct timespec ts;
+	clock_gettime(CLOCK_REALTIME, &ts);
+	ts.tv_sec += 5;
+
+	pthread_mutex_lock(&ctx->gather_lock);
+
+	while (!ctx->gathering_done)
+	{
+		if (pthread_cond_timedwait(&ctx->gather_cond, &ctx->gather_lock, &ts) != 0)
+		{
+			break;
+		}
+	}
+
+	pthread_mutex_unlock(&ctx->gather_lock);
+
+	int len = rtcGetLocalDescription(pc, answer_buf, answer_size);
+
+	if (len < 0)
+	{
+		return -1;
+	}
+
+	pthread_mutex_lock(&session->lock);
+	session->viewer_count++;
+	pthread_mutex_unlock(&session->lock);
+
+	return 0;
+}
+
+static void parse_http_request(const char *buf, int len, char *method, char *path, char *body, int *body_len)
+{
+	method[0] = 0;
+	path[0] = 0;
+	body[0] = 0;
+	*body_len = 0;
+
+	sscanf(buf, "%15s %255s", method, path);
+
+	const char *body_start = strstr(buf, "\r\n\r\n");
+
+	if (body_start)
+	{
+		body_start += 4;
+		*body_len = len - (body_start - buf);
+
+		if (*body_len > 0)
+		{
+			memcpy(body, body_start, *body_len);
+			body[*body_len] = 0;
+		}
+	}
+}
+
+static void send_http_response(int fd, int status, const char *content_type, const char *body, int body_len)
+{
+	char header[1024];
+	const char *status_text = status == 201 ? "Created" : status == 200 ? "OK" : "Not Found";
+
+	int hlen = snprintf(header, sizeof(header),
+		"HTTP/1.1 %d %s\r\n"
+		"Content-Type: %s\r\n"
+		"Content-Length: %d\r\n"
+		"Access-Control-Allow-Origin: *\r\n"
+		"Access-Control-Allow-Methods: POST, DELETE, OPTIONS, GET\r\n"
+		"Access-Control-Allow-Headers: Content-Type\r\n"
+		"Connection: close\r\n"
+		"\r\n",
+		status, status_text, content_type, body_len);
+
+	write(fd, header, hlen);
+
+	if (body_len > 0)
+	{
+		write(fd, body, body_len);
+	}
+}
+
+static void handle_client(int client_fd)
+{
+	char buf[HTTP_BUF_SIZE];
+	int total = 0;
+	int n;
+
+	while (total < HTTP_BUF_SIZE - 1)
+	{
+		n = read(client_fd, buf + total, HTTP_BUF_SIZE - 1 - total);
+
+		if (n <= 0)
+		{
+			break;
+		}
+
+		total += n;
+
+		if (strstr(buf, "\r\n\r\n"))
+		{
+			int content_length = 0;
+			char *cl = strstr(buf, "Content-Length:");
+
+			if (!cl)
+			{
+				cl = strstr(buf, "content-length:");
+			}
+
+			if (cl)
+			{
+				content_length = atoi(cl + 15);
+			}
+
+			char *body_start = strstr(buf, "\r\n\r\n") + 4;
+			int header_len = body_start - buf;
+			int body_so_far = total - header_len;
+
+			while (body_so_far < content_length && total < HTTP_BUF_SIZE - 1)
+			{
+				n = read(client_fd, buf + total, HTTP_BUF_SIZE - 1 - total);
+
+				if (n <= 0)
+				{
+					break;
+				}
+
+				total += n;
+				body_so_far = total - header_len;
+			}
+
+			break;
+		}
+	}
+
+	buf[total] = 0;
+
+	char method[16], path[256], body[SDP_BUF_SIZE];
+	int body_len;
+	parse_http_request(buf, total, method, path, body, &body_len);
+
+	if (strcmp(method, "OPTIONS") == 0)
+	{
+		send_http_response(client_fd, 200, "text/plain", "", 0);
+		close(client_fd);
+		return;
+	}
+
+	if (strcmp(method, "GET") == 0 && strcmp(path, "/health") == 0)
+	{
+		send_http_response(client_fd, 200, "text/plain", "ok", 2);
+		close(client_fd);
+		return;
+	}
+
+	if (strcmp(method, "POST") == 0 && strstr(path, "/create"))
+	{
+		char stream_path[256];
+		strncpy(stream_path, path + 1, sizeof(stream_path) - 1);
+		char *create_pos = strstr(stream_path, "/create");
+
+		if (create_pos)
+		{
+			*create_pos = 0;
+		}
+
+		pthread_mutex_lock(&sessions_lock);
+		Session *session = find_session(stream_path);
+
+		if (!session)
+		{
+			session = create_session_slot(stream_path);
+		}
+
+		pthread_mutex_unlock(&sessions_lock);
+
+		if (session)
+		{
+			char port_str[64];
+			snprintf(port_str, sizeof(port_str), "%d,%d", session->rtp_port, session->audio_port);
+			send_http_response(client_fd, 200, "text/plain", port_str, strlen(port_str));
+		}
+		else
+		{
+			send_http_response(client_fd, 500, "text/plain", "failed", 6);
+		}
+
+		close(client_fd);
+		return;
+	}
+
+	if (strcmp(method, "GET") == 0 && strncmp(path, "/session/", 9) == 0)
+	{
+		const char *check_path = path + 9;
+		pthread_mutex_lock(&sessions_lock);
+		Session *s = find_session(check_path);
+		pthread_mutex_unlock(&sessions_lock);
+
+		if (s)
+		{
+			send_http_response(client_fd, 200, "text/plain", "ok", 2);
+		}
+		else
+		{
+			send_http_response(client_fd, 404, "text/plain", "no", 2);
+		}
+
+		close(client_fd);
+		return;
+	}
+
+	if (strcmp(method, "POST") != 0 || !strstr(path, "/whep"))
+	{
+		send_http_response(client_fd, 404, "text/plain", "not found", 9);
+		close(client_fd);
+		return;
+	}
+
+	char stream_path[256];
+	char *whep_pos = strstr(path + 1, "/whep");
+	int plen = whep_pos - path - 1;
+	strncpy(stream_path, path + 1, plen);
+	stream_path[plen] = 0;
+
+	char answer[SDP_BUF_SIZE];
+
+	pthread_mutex_lock(&sessions_lock);
+	Session *session = find_session(stream_path);
+	pthread_mutex_unlock(&sessions_lock);
+
+	if (!session)
+	{
+		send_http_response(client_fd, 404, "text/plain", "no session", 10);
+		close(client_fd);
+		return;
+	}
+
+	int rc = create_viewer_pc(session, body, answer, SDP_BUF_SIZE);
+
+	if (rc < 0)
+	{
+		send_http_response(client_fd, 500, "text/plain", "failed", 6);
+	}
+	else
+	{
+		send_http_response(client_fd, 201, "application/sdp", answer, strlen(answer));
+	}
+
+	close(client_fd);
+}
+
+static void signal_handler(int sig)
+{
+	running = 0;
+}
+
+int main(int argc, char *argv[])
+{
+	int port = 8891;
+
+	if (argc > 1)
+	{
+		port = atoi(argv[1]);
+	}
+
+	signal(SIGINT, signal_handler);
+	signal(SIGTERM, signal_handler);
+
+	rtcInitLogger(RTC_LOG_WARNING, NULL);
+
+	memset(sessions, 0, sizeof(sessions));
+
+	int server_fd = socket(AF_INET, SOCK_STREAM, 0);
+
+	if (server_fd < 0)
+	{
+		perror("socket");
+		return 1;
+	}
+
+	int opt = 1;
+	setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+
+	struct sockaddr_in addr;
+	memset(&addr, 0, sizeof(addr));
+	addr.sin_family = AF_INET;
+	addr.sin_addr.s_addr = INADDR_ANY;
+	addr.sin_port = htons(port);
+
+	if (bind(server_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
+	{
+		perror("bind");
+		close(server_fd);
+		return 1;
+	}
+
+	if (listen(server_fd, 16) < 0)
+	{
+		perror("listen");
+		close(server_fd);
+		return 1;
+	}
+
+	fprintf(stderr, "whip_relay listening on port %d\n", port);
+
+	while (running)
+	{
+		struct sockaddr_in client_addr;
+		socklen_t client_len = sizeof(client_addr);
+
+		int client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_len);
+
+		if (client_fd < 0)
+		{
+			continue;
+		}
+
+		handle_client(client_fd);
+	}
+
+	close(server_fd);
+	rtcCleanup();
+	return 0;
+}