obs-webrtc: Add custom User-Agent and randomize SSRCs

Adds a custom User-Agent header to REST requests identifying OBS as the
client.

Randomizes SSRCs to avoid potential issues with servers that do not
rewrite them before forwarding.

plugins/obs-webrtc/CMakeLists.txt

@@ -14,7 +14,8 @@ find_package(CURL REQUIRED)
 add_library(obs-webrtc MODULE)
 add_library(OBS::webrtc ALIAS obs-webrtc)
 
-target_sources(obs-webrtc PRIVATE obs-webrtc.cpp whip-output.cpp whip-output.h whip-service.cpp whip-service.h)
+target_sources(obs-webrtc PRIVATE obs-webrtc.cpp whip-output.cpp whip-output.h whip-service.cpp whip-service.h
+                                  whip-utils.h)
 
 target_link_libraries(obs-webrtc PRIVATE OBS::libobs LibDataChannel::LibDataChannel CURL::libcurl)
 

plugins/obs-webrtc/cmake/legacy.cmake

@@ -12,7 +12,8 @@ find_package(CURL REQUIRED)
 add_library(obs-webrtc MODULE)
 add_library(OBS::webrtc ALIAS obs-webrtc)
 
-target_sources(obs-webrtc PRIVATE obs-webrtc.cpp whip-output.cpp whip-output.h whip-service.cpp whip-service.h)
+target_sources(obs-webrtc PRIVATE obs-webrtc.cpp whip-output.cpp whip-output.h whip-service.cpp whip-service.h
+                                  whip-utils.h)
 
 target_link_libraries(obs-webrtc PRIVATE OBS::libobs LibDataChannel::LibDataChannel CURL::libcurl)
 

plugins/obs-webrtc/whip-output.cpp

@@ -1,16 +1,24 @@
 #include "whip-output.h"
+#include "whip-utils.h"
+
+/*
+ * Sets the maximum size for a video fragment. Effective range is
+ * 576-1470, with a lower value equating to more packets created,
+ * but also better network compatability.
+ */
+static uint16_t MAX_VIDEO_FRAGMENT_SIZE = 1200;
 
 const int signaling_media_id_length = 16;
 const char signaling_media_id_valid_char[] = "0123456789"
 					     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 					     "abcdefghijklmnopqrstuvwxyz";
 
-const uint32_t audio_ssrc = 5002;
+const std::string user_agent = generate_user_agent();
+
 const char *audio_mid = "0";
 const uint32_t audio_clockrate = 48000;
 const uint8_t audio_payload_type = 111;
 
-const uint32_t video_ssrc = 5000;
 const char *video_mid = "1";
 const uint32_t video_clockrate = 90000;
 const uint8_t video_payload_type = 96;
@@ -23,6 +31,7 @@ WHIPOutput::WHIPOutput(obs_data_t *, obs_output_t *output)
 	  running(false),
 	  start_stop_mutex(),
 	  start_stop_thread(),
+	  base_ssrc(generate_random_u32()),
 	  peer_connection(-1),
 	  audio_track(-1),
 	  video_track(-1),
@@ -92,23 +101,28 @@ void WHIPOutput::ConfigureAudioTrack(std::string media_stream_id,
 {
 	auto media_stream_track_id = std::string(media_stream_id + "-audio");
 
+	uint32_t ssrc = base_ssrc;
+
 	rtcTrackInit track_init = {
 		RTC_DIRECTION_SENDONLY,
 		RTC_CODEC_OPUS,
 		audio_payload_type,
-		audio_ssrc,
+		ssrc,
 		audio_mid,
 		cname.c_str(),
 		media_stream_id.c_str(),
 		media_stream_track_id.c_str(),
 	};
 
-	rtcPacketizationHandlerInit packetizer_init = {audio_ssrc,
+	// Generate a random starting timestamp for the audio track
+	uint32_t rtp_audio_timestamp = generate_random_u32();
+
+	rtcPacketizationHandlerInit packetizer_init = {ssrc,
 						       cname.c_str(),
 						       audio_payload_type,
 						       audio_clockrate,
 						       0,
-						       0,
+						       rtp_audio_timestamp,
 						       RTC_NAL_SEPARATOR_LENGTH,
 						       0};
 
@@ -123,26 +137,32 @@ void WHIPOutput::ConfigureVideoTrack(std::string media_stream_id,
 {
 	auto media_stream_track_id = std::string(media_stream_id + "-video");
 
+	// More predictable SSRC values between audio and video
+	uint32_t ssrc = base_ssrc + 1;
+
 	rtcTrackInit track_init = {
 		RTC_DIRECTION_SENDONLY,
 		RTC_CODEC_H264,
 		video_payload_type,
-		video_ssrc,
+		ssrc,
 		video_mid,
 		cname.c_str(),
 		media_stream_id.c_str(),
 		media_stream_track_id.c_str(),
 	};
 
+	// Generate a random starting timestamp for the video track
+	uint32_t rtp_video_timestamp = generate_random_u32();
+
 	rtcPacketizationHandlerInit packetizer_init = {
-		video_ssrc,
+		ssrc,
 		cname.c_str(),
 		video_payload_type,
 		video_clockrate,
 		0,
-		0,
+		rtp_video_timestamp,
 		RTC_NAL_SEPARATOR_START_SEQUENCE,
-		0};
+		MAX_VIDEO_FRAGMENT_SIZE};
 
 	video_track = rtcAddTrackEx(peer_connection, &track_init);
 	rtcSetH264PacketizationHandler(video_track, &packetizer_init);
@@ -150,8 +170,19 @@ void WHIPOutput::ConfigureVideoTrack(std::string media_stream_id,
 	rtcChainRtcpNackResponder(video_track, 1000);
 }
 
-bool WHIPOutput::Setup()
+/**
+ * @brief Initialize encoders and store connect info provided by the service.
+ *
+ * @return bool
+ */
+bool WHIPOutput::Init()
 {
+	if (!obs_output_can_begin_data_capture(output, 0))
+		return false;
+
+	if (!obs_output_initialize_encoders(output, 0))
+		return false;
+
 	obs_service_t *service = obs_output_get_service(output);
 	if (!service) {
 		obs_output_signal_stop(output, OBS_OUTPUT_ERROR);
@@ -164,9 +195,20 @@ bool WHIPOutput::Setup()
 		obs_output_signal_stop(output, OBS_OUTPUT_BAD_PATH);
 		return false;
 	}
+
 	bearer_token = obs_service_get_connect_info(
 		service, OBS_SERVICE_CONNECT_INFO_BEARER_TOKEN);
 
+	return true;
+}
+
+/**
+ * @brief Set up the PeerConnection and media tracks.
+ *
+ * @return bool
+ */
+bool WHIPOutput::Setup()
+{
 	rtcConfiguration config;
 	memset(&config, 0, sizeof(config));
 
@@ -249,13 +291,22 @@ bool WHIPOutput::Connect()
 
 	std::string read_buffer;
 	std::string location_header;
+
 	char offer_sdp[4096] = {0};
 	rtcGetLocalDescription(peer_connection, offer_sdp, sizeof(offer_sdp));
 
+#ifdef DEBUG_SDP
+	do_log(LOG_DEBUG, "Offer SDP:\n%s", offer_sdp);
+#endif
+
+	// Add user-agent to our requests
+	headers = curl_slist_append(headers, user_agent.c_str());
+
 	CURL *c = curl_easy_init();
 	curl_easy_setopt(c, CURLOPT_WRITEFUNCTION, curl_writefunction);
 	curl_easy_setopt(c, CURLOPT_WRITEDATA, (void *)&read_buffer);
-	curl_easy_setopt(c, CURLOPT_HEADERFUNCTION, curl_headerfunction);
+	curl_easy_setopt(c, CURLOPT_HEADERFUNCTION,
+			 curl_header_location_function);
 	curl_easy_setopt(c, CURLOPT_HEADERDATA, (void *)&location_header);
 	curl_easy_setopt(c, CURLOPT_HTTPHEADER, headers);
 	curl_easy_setopt(c, CURLOPT_URL, endpoint_url.c_str());
@@ -318,6 +369,10 @@ bool WHIPOutput::Connect()
 		curl_url_cleanup(h);
 	}
 
+#ifdef DEBUG_SDP
+	do_log(LOG_DEBUG, "Answer SDP:\n%s", read_buffer.c_str());
+#endif
+
 	rtcSetRemoteDescription(peer_connection, read_buffer.c_str(), "answer");
 	cleanup();
 	return true;
@@ -325,6 +380,9 @@ bool WHIPOutput::Connect()
 
 void WHIPOutput::StartThread()
 {
+	if (!Init())
+		return;
+
 	if (!Setup())
 		return;
 
@@ -356,6 +414,9 @@ void WHIPOutput::SendDelete()
 			curl_slist_append(headers, bearer_token_header.c_str());
 	}
 
+	// Add user-agent to our requests
+	headers = curl_slist_append(headers, user_agent.c_str());
+
 	CURL *c = curl_easy_init();
 	curl_easy_setopt(c, CURLOPT_HTTPHEADER, headers);
 	curl_easy_setopt(c, CURLOPT_URL, resource_url.c_str());
@@ -403,12 +464,14 @@ void WHIPOutput::StopThread(bool signal)
 
 	SendDelete();
 
-	// "signal" exists because we have to preserve the "running" state
-	// across reconnect attempts. If we don't emit a signal if
-	// something calls obs_output_stop() and it's reconnecting, you'll
-	// desync the UI, as the output will be "stopped" and not
-	// "reconnecting", but the "stop" signal will have never been
-	// emitted.
+	/*
+	 * "signal" exists because we have to preserve the "running" state
+	 * across reconnect attempts. If we don't emit a signal if
+	 * something calls obs_output_stop() and it's reconnecting, you'll
+	 * desync the UI, as the output will be "stopped" and not
+	 * "reconnecting", but the "stop" signal will have never been
+	 * emitted.
+	 */
 	if (running && signal) {
 		obs_output_signal_stop(output, OBS_OUTPUT_SUCCESS);
 		running = false;
@@ -426,15 +489,15 @@ void WHIPOutput::Send(void *data, uintptr_t size, uint64_t duration, int track)
 	if (!running)
 		return;
 
-	// sample time is in us, we need to convert it to seconds
+	// Sample time is in microseconds, we need to convert it to seconds
 	auto elapsed_seconds = double(duration) / (1000.0 * 1000.0);
 
-	// get elapsed time in clock rate
+	// Get elapsed time in clock rate
 	uint32_t elapsed_timestamp = 0;
 	rtcTransformSecondsToTimestamp(track, elapsed_seconds,
 				       &elapsed_timestamp);
 
-	// set new timestamp
+	// Set new timestamp
 	uint32_t current_timestamp = 0;
 	rtcGetCurrentTrackTimestamp(track, &current_timestamp);
 	rtcSetTrackRtpTimestamp(track, current_timestamp + elapsed_timestamp);

plugins/obs-webrtc/whip-output.h

@@ -1,4 +1,5 @@
 #pragma once
+
 #include <obs-module.h>
 #include <util/curl/curl-helper.h>
 #include <util/platform.h>
@@ -12,13 +13,6 @@
 
 #include <rtc/rtc.h>
 
-#define do_log(level, format, ...)                              \
-	blog(level, "[obs-webrtc] [whip_output: '%s'] " format, \
-	     obs_output_get_name(output), ##__VA_ARGS__)
-#define do_log_s(level, format, ...)                            \
-	blog(level, "[obs-webrtc] [whip_output: '%s'] " format, \
-	     obs_output_get_name(whipOutput->output), ##__VA_ARGS__)
-
 class WHIPOutput {
 public:
 	WHIPOutput(obs_data_t *settings, obs_output_t *output);
@@ -37,10 +31,10 @@ private:
 				 std::string cname);
 	void ConfigureVideoTrack(std::string media_stream_id,
 				 std::string cname);
+	bool Init();
 	bool Setup();
 	bool Connect();
 	void StartThread();
-
 	void SendDelete();
 	void StopThread(bool signal);
 
@@ -57,6 +51,7 @@ private:
 	std::mutex start_stop_mutex;
 	std::thread start_stop_thread;
 
+	uint32_t base_ssrc;
 	int peer_connection;
 	int audio_track;
 	int video_track;
@@ -69,43 +64,3 @@ private:
 };
 
 void register_whip_output();
-
-static std::string trim_string(const std::string &source)
-{
-	std::string ret(source);
-	ret.erase(0, ret.find_first_not_of(" \n\r\t"));
-	ret.erase(ret.find_last_not_of(" \n\r\t") + 1);
-	return ret;
-}
-
-static size_t curl_writefunction(char *data, size_t size, size_t nmemb,
-				 void *priv_data)
-{
-	auto read_buffer = static_cast<std::string *>(priv_data);
-
-	size_t real_size = size * nmemb;
-
-	read_buffer->append(data, real_size);
-	return real_size;
-}
-
-#define LOCATION_HEADER_LENGTH 10
-
-static size_t curl_headerfunction(char *data, size_t size, size_t nmemb,
-				  void *priv_data)
-{
-	auto header_buffer = static_cast<std::string *>(priv_data);
-
-	size_t real_size = size * nmemb;
-
-	if (real_size < LOCATION_HEADER_LENGTH)
-		return real_size;
-
-	if (!astrcmpi_n(data, "location: ", LOCATION_HEADER_LENGTH)) {
-		char *val = data + LOCATION_HEADER_LENGTH;
-		header_buffer->append(val, real_size - LOCATION_HEADER_LENGTH);
-		*header_buffer = trim_string(*header_buffer);
-	}
-
-	return real_size;
-}

plugins/obs-webrtc/whip-utils.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <obs.h>
+
+#include <string>
+#include <random>
+#include <sstream>
+
+#define do_log(level, format, ...)                              \
+	blog(level, "[obs-webrtc] [whip_output: '%s'] " format, \
+	     obs_output_get_name(output), ##__VA_ARGS__)
+#define do_log_s(level, format, ...)                            \
+	blog(level, "[obs-webrtc] [whip_output: '%s'] " format, \
+	     obs_output_get_name(whipOutput->output), ##__VA_ARGS__)
+
+static uint32_t generate_random_u32()
+{
+	std::random_device rd;
+	std::mt19937 gen(rd());
+	std::uniform_int_distribution<uint32_t> dist(1, (UINT32_MAX - 1));
+	return dist(gen);
+}
+
+static std::string trim_string(const std::string &source)
+{
+	std::string ret(source);
+	ret.erase(0, ret.find_first_not_of(" \n\r\t"));
+	ret.erase(ret.find_last_not_of(" \n\r\t") + 1);
+	return ret;
+}
+
+static size_t curl_writefunction(char *data, size_t size, size_t nmemb,
+				 void *priv_data)
+{
+	auto read_buffer = static_cast<std::string *>(priv_data);
+
+	size_t real_size = size * nmemb;
+
+	read_buffer->append(data, real_size);
+	return real_size;
+}
+
+#define LOCATION_HEADER_LENGTH 10
+
+static size_t curl_header_location_function(char *data, size_t size,
+					    size_t nmemb, void *priv_data)
+{
+	auto header_buffer = static_cast<std::string *>(priv_data);
+
+	size_t real_size = size * nmemb;
+
+	if (real_size < LOCATION_HEADER_LENGTH)
+		return real_size;
+
+	if (!astrcmpi_n(data, "location: ", LOCATION_HEADER_LENGTH)) {
+		char *val = data + LOCATION_HEADER_LENGTH;
+		header_buffer->append(val, real_size - LOCATION_HEADER_LENGTH);
+		*header_buffer = trim_string(*header_buffer);
+	}
+
+	return real_size;
+}
+
+static inline std::string generate_user_agent()
+{
+#ifdef _WIN64
+#define OS_NAME "Windows x86_64"
+#elif __APPLE__
+#define OS_NAME "Mac OS X"
+#elif __OpenBSD__
+#define OS_NAME "OpenBSD"
+#elif __FreeBSD__
+#define OS_NAME "FreeBSD"
+#elif __linux__ && __LP64__
+#define OS_NAME "Linux x86_64"
+#else
+#define OS_NAME "Linux"
+#endif
+
+	// Build the user-agent string
+	std::stringstream ua;
+	// User agent header prefix
+	ua << "User-Agent: Mozilla/5.0 ";
+	// OBS version info
+	ua << "(OBS-Studio/" << obs_get_version_string() << "; ";
+	// Operating system version info
+	ua << OS_NAME << "; " << obs_get_locale() << ")";
+
+	return ua.str();
+}