Packman Build Service PMBS

libdatachannel.spec Changed

_service Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/.github/workflows/build-gnutls.yml -> _service:obs_scm:libdatachannel-0.24.3.obscpio/.github/workflows/build-gnutls.yml Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/.github/workflows/build-mbedtls.yml -> _service:obs_scm:libdatachannel-0.24.3.obscpio/.github/workflows/build-mbedtls.yml Changed

@@ -8,15 +8,15 @@
   build-linux:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Set up Homebrew
       uses: Homebrew/actions/setup-homebrew@master
     - name: Install Mbed TLS
-      run: brew update && brew install mbedtls
+      run: brew update && brew install mbedtls@3
     - name: submodules
       run: git submodule update --init --recursive --depth 1
     - name: cmake
-      run: cmake -B build -DUSE_MBEDTLS=1 -DWARNINGS_AS_ERRORS=1  -DCMAKE_PREFIX_PATH=$(brew --prefix mbedtls)
+      run: cmake -B build -DUSE_MBEDTLS=1 -DWARNINGS_AS_ERRORS=1  -DCMAKE_PREFIX_PATH=$(brew --prefix mbedtls@3)
     - name: make
       run: (cd build; make -j2)
     - name: test
@@ -24,13 +24,13 @@
   build-macos:
     runs-on: macos-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Install Mbed TLS
-      run: brew update && brew install mbedtls
+      run: brew update && brew install mbedtls@3
     - name: submodules
       run: git submodule update --init --recursive --depth 1
     - name: cmake
-      run: cmake -B build -DUSE_MBEDTLS=1 -DWARNINGS_AS_ERRORS=1 -DENABLE_LOCAL_ADDRESS_TRANSLATION=1  -DCMAKE_PREFIX_PATH=$(brew --prefix mbedtls)
+      run: cmake -B build -DUSE_MBEDTLS=1 -DWARNINGS_AS_ERRORS=1 -DENABLE_LOCAL_ADDRESS_TRANSLATION=1 -DCMAKE_PREFIX_PATH=$(brew --prefix mbedtls@3)
     - name: make
       run: (cd build; make -j2)
     - name: test

_service:obs_scm:libdatachannel-0.23.3.obscpio/.github/workflows/build-nice.yml -> _service:obs_scm:libdatachannel-0.24.3.obscpio/.github/workflows/build-nice.yml Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/.github/workflows/build-nomedia.yml -> _service:obs_scm:libdatachannel-0.24.3.obscpio/.github/workflows/build-nomedia.yml Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/.github/workflows/build-nowebsocket.yml -> _service:obs_scm:libdatachannel-0.24.3.obscpio/.github/workflows/build-nowebsocket.yml Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/.github/workflows/build-openssl.yml -> _service:obs_scm:libdatachannel-0.24.3.obscpio/.github/workflows/build-openssl.yml Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/.github/workflows/check-version.yml -> _service:obs_scm:libdatachannel-0.24.3.obscpio/.github/workflows/check-version.yml Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/CMakeLists.txt -> _service:obs_scm:libdatachannel-0.24.3.obscpio/CMakeLists.txt Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/DOC.md -> _service:obs_scm:libdatachannel-0.24.3.obscpio/DOC.md Changed

@@ -103,7 +103,7 @@
   - `bindAddress` (optional): if non-NULL, bind only to the given local address (ignored with libnice as ICE backend)
   - `certificateType` (optional): certificate type, either `RTC_CERTIFICATE_ECDSA` or `RTC_CERTIFICATE_RSA` (0 or `RTC_CERTIFICATE_DEFAULT` if default)
   - `iceTransportPolicy` (optional): ICE transport policy, if set to `RTC_TRANSPORT_POLICY_RELAY`, the PeerConnection will emit only relayed candidates (0 or `RTC_TRANSPORT_POLICY_ALL` if default)
-  - `enableIceTcp`: if true, generate TCP candidates for ICE (ignored with libjuice as ICE backend)
+  - `enableIceTcp`: if true, generate TCP candidates for ICE
   - `enableIceUdpMux`: if true, connections are multiplexed on the same UDP port (should be combined with `portRangeBegin` and `portRangeEnd`, ignored with libnice as ICE backend)
   - `disableAutoNegotiation`: if true, the user is responsible for calling `rtcSetLocalDescription` after creating a Data Channel and after setting the remote description
   - `forceMediaTransport`: if true, the connection allocates the SRTP media transport even if no tracks are present (necessary to add tracks during later renegotiation)

_service:obs_scm:libdatachannel-0.23.3.obscpio/README.md -> _service:obs_scm:libdatachannel-0.24.3.obscpio/README.md Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/include/rtc/configuration.hpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/include/rtc/configuration.hpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/include/rtc/description.hpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/include/rtc/description.hpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/include/rtc/global.hpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/include/rtc/global.hpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/include/rtc/pacinghandler.hpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/include/rtc/pacinghandler.hpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/include/rtc/rtc.h -> _service:obs_scm:libdatachannel-0.24.3.obscpio/include/rtc/rtc.h Changed

@@ -191,7 +191,7 @@
 	const char *bindAddress; // libjuice only, NULL means any
 	rtcCertificateType certificateType;
 	rtcTransportPolicy iceTransportPolicy;
-	bool enableIceTcp;    // libnice only
+	bool enableIceTcp;
 	bool enableIceUdpMux; // libjuice only
 	bool disableAutoNegotiation;
 	bool forceMediaTransport;
@@ -352,6 +352,14 @@
 	uint8_t playoutDelayId;
 	uint16_t playoutDelayMin;
 	uint16_t playoutDelayMax;
+
+	uint8_t colorSpaceId;
+	uint8_t colorChromaSitingHorz;
+	uint8_t colorChromaSitingVert;
+	uint8_t colorRange;
+	uint8_t colorPrimaries;
+	uint8_t colorTransfer;
+	uint8_t colorMatrix;
 } rtcPacketizerInit;
 
 // Deprecated, do not use
@@ -505,12 +513,10 @@
 
 #endif
 
-// Optional global preload and cleanup
-
-RTC_C_EXPORT void rtcPreload(void);
-RTC_C_EXPORT void rtcCleanup(void);
+// Global settings
 
-// SCTP global settings
+// Note: Applied when threads are spawned
+RTC_C_EXPORT int rtcSetThreadPoolSize(unsigned int count);
 
 typedef struct {
 	int recvBufferSize;          // in bytes, <= 0 means optimized default
@@ -530,6 +536,10 @@
 // Note: SCTP settings apply to newly-created PeerConnections only
 RTC_C_EXPORT int rtcSetSctpSettings(const rtcSctpSettings *settings);
 
+// Optional global preload and cleanup
+RTC_C_EXPORT void rtcPreload(void);
+RTC_C_EXPORT void rtcCleanup(void);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

_service:obs_scm:libdatachannel-0.23.3.obscpio/include/rtc/rtcpreceivingsession.hpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/include/rtc/rtcpreceivingsession.hpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/include/rtc/rtp.hpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/include/rtc/rtp.hpp Changed

@@ -169,8 +169,8 @@
 	nodiscard uint32_t octetCount() const;
 	nodiscard uint32_t senderSSRC() const;
 
-	nodiscard const RtcpReportBlock *getReportBlock(int num) const;
-	nodiscard RtcpReportBlock *getReportBlock(int num);
+	nodiscard const RtcpReportBlock *getReportBlock(int num) const; // nullptr if out-of-bounds
+	nodiscard RtcpReportBlock *getReportBlock(int num); // nullptr if out-of-bounds
 	nodiscard unsigned int size(unsigned int reportCount);
 	nodiscard size_t getSize() const;
 
@@ -254,8 +254,8 @@
 	bool isSenderReport();
 	bool isReceiverReport();
 
-	nodiscard RtcpReportBlock *getReportBlock(int num);
-	nodiscard const RtcpReportBlock *getReportBlock(int num) const;
+	nodiscard RtcpReportBlock *getReportBlock(int num); // nullptr if out-of-bounds
+	nodiscard const RtcpReportBlock *getReportBlock(int num) const; // nullptr if out-of-bounds
 	nodiscard size_t getSize() const;
 
 	void preparePacket(SSRC senderSSRC, uint8_t reportCount);
@@ -269,7 +269,7 @@
 
 	char _id4;       // Unique identifier ('R' 'E' 'M' 'B')
 	uint32_t _bitrate; // Num SSRC, Br Exp, Br Mantissa (bit mask)
-	SSRC _ssrc1;
+	SSRC _ssrcs1;
 
 	nodiscard static size_t SizeWithSSRCs(int count);
 
@@ -277,8 +277,16 @@
 
 	void preparePacket(SSRC senderSSRC, unsigned int numSSRC, unsigned int in_bitrate);
 	void setBitrate(unsigned int numSSRC, unsigned int in_bitrate);
-	void setSsrc(int iterator, SSRC newSssrc);
-	unsigned int getNumSSRC();
+	SSRC getSSRC(int num) const;
+	void setSSRC(int num, SSRC newSsrc);
+	bool hasValidId() const;
+	int getSSRCCount() const;
+	unsigned int getBitrate() const;
+
+	// Deprecated
+	deprecated("use setSSRC") void setSsrc(int num, SSRC newSssrc);
+	deprecated("use getSSRCCount") unsigned int getNumSSRC() const;
+	deprecated("use getSSRCCount") unsigned int getNumSSRC();
 	unsigned int getBitrate();
 };

_service:obs_scm:libdatachannel-0.23.3.obscpio/include/rtc/rtppacketizationconfig.hpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/include/rtc/rtppacketizationconfig.hpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/include/rtc/version.h -> _service:obs_scm:libdatachannel-0.24.3.obscpio/include/rtc/version.h Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/pages/content/pages/reference.md -> _service:obs_scm:libdatachannel-0.24.3.obscpio/pages/content/pages/reference.md Changed

@@ -106,7 +106,7 @@
   - `bindAddress` (optional): if non-NULL, bind only to the given local address (ignored with libnice as ICE backend)
   - `certificateType` (optional): certificate type, either `RTC_CERTIFICATE_ECDSA` or `RTC_CERTIFICATE_RSA` (0 or `RTC_CERTIFICATE_DEFAULT` if default)
   - `iceTransportPolicy` (optional): ICE transport policy, if set to `RTC_TRANSPORT_POLICY_RELAY`, the PeerConnection will emit only relayed candidates (0 or `RTC_TRANSPORT_POLICY_ALL` if default)
-  - `enableIceTcp`: if true, generate TCP candidates for ICE (ignored with libjuice as ICE backend)
+  - `enableIceTcp`: if true, generate TCP candidates for ICE
   - `enableIceUdpMux`: if true, connections are multiplexed on the same UDP port (should be combined with `portRangeBegin` and `portRangeEnd`, ignored with libnice as ICE backend)
   - `disableAutoNegotiation`: if true, the user is responsible for calling `rtcSetLocalDescription` after creating a Data Channel and after setting the remote description
   - `forceMediaTransport`: if true, the connection allocates the SRTP media transport even if no tracks are present (necessary to add tracks during later renegotiation)
@@ -872,6 +872,7 @@
 
 typedef struct {
 	bool disableTlsVerification;
+	const char *proxyServer;
 	const char **protocols;
 	int protocolsCount;
 	int connectionTimeoutMs;
@@ -887,6 +888,7 @@
 - `url`: a null-terminated string representing the fully-qualified URL to open.
 - `config`: a structure with the following parameters:
   - `disableTlsVerification`: if true, don't verify the TLS certificate, else try to verify it if possible
+  - `proxyServer` (optional): address of proxy server as string, only non-authenticated HTTP for now (NULL if unused)
   - `protocols` (optional): an array of pointers on null-terminated protocol names (NULL if unused)
   - `protocolsCount` (optional): number of URLs in the array pointed by `protocols` (0 if unused)
   - `connectionTimeoutMs` (optional): connection timeout in milliseconds (0 if default, < 0 if disabled)

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/av1rtppacketizer.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/av1rtppacketizer.cpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/capi.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/capi.cpp Changed

@@ -278,6 +278,13 @@
 	config->playoutDelayId = init->playoutDelayId;
 	config->playoutDelayMin = init->playoutDelayMin;
 	config->playoutDelayMax = init->playoutDelayMax;
+	config->colorSpaceId = init->colorSpaceId;
+	config->colorChromaSitingHorz = init->colorChromaSitingHorz;
+	config->colorChromaSitingVert = init->colorChromaSitingVert;
+	config->colorRange = init->colorRange;
+	config->colorPrimaries = init->colorPrimaries;
+	config->colorTransfer = init->colorTransfer;
+	config->colorMatrix = init->colorMatrix;
 	return config;
 }
 
@@ -1089,7 +1096,7 @@
 		case RTC_CODEC_OPUS:
 		case RTC_CODEC_PCMU:
 		case RTC_CODEC_PCMA:
-		case RTC_CODEC_AAC: 
+		case RTC_CODEC_AAC:
 		case RTC_CODEC_G722: {
 			auto audio = std::make_unique<Description::Audio>(mid, direction);
 			switch (init->codec) {
@@ -1680,28 +1687,11 @@
 
 #endif
 
-void rtcPreload() {
-	try {
-		rtc::Preload();
-	} catch (const std::exception &e) {
-		PLOG_ERROR << e.what();
-	}
-}
-
-void rtcCleanup() {
-	try {
-		size_t count = eraseAll();
-		if (count != 0) {
-			PLOG_INFO << count << " objects were not properly destroyed before cleanup";
-		}
-
-		if (rtc::Cleanup().wait_for(10s) == std::future_status::timeout)
-			throw std::runtime_error(
-			    "Cleanup timeout (possible deadlock or undestructible object)");
-
-	} catch (const std::exception &e) {
-		PLOG_ERROR << e.what();
-	}
+int rtcSetThreadPoolSize(unsigned int count) {
+	return wrap(& {
+		SetThreadPoolSize(count);
+		return RTC_ERR_SUCCESS;
+	});
 }
 
 int rtcSetSctpSettings(const rtcSctpSettings *settings) {
@@ -1752,3 +1742,28 @@
 		return RTC_ERR_SUCCESS;
 	});
 }
+
+void rtcPreload() {
+	try {
+		rtc::Preload();
+	} catch (const std::exception &e) {
+		PLOG_ERROR << e.what();
+	}
+}
+
+void rtcCleanup() {
+	try {
+		size_t count = eraseAll();
+		if (count != 0) {
+			PLOG_INFO << count << " objects were not properly destroyed before cleanup";
+		}
+
+		if (rtc::Cleanup().wait_for(10s) == std::future_status::timeout)
+			throw std::runtime_error(
+			    "Cleanup timeout (possible deadlock or undestructible object)");
+
+	} catch (const std::exception &e) {
+		PLOG_ERROR << e.what();
+	}
+}
+

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/description.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/description.cpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/global.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/global.cpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/impl/certificate.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/impl/certificate.cpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/impl/dtlstransport.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/impl/dtlstransport.cpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/impl/icetransport.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/impl/icetransport.cpp Changed

@@ -90,10 +90,6 @@
 	jconfig.cb_recv = IceTransport::RecvCallback;
 	jconfig.user_ptr = this;
 
-	if (config.enableIceTcp) {
-		PLOG_WARNING << "ICE-TCP is not supported with libjuice";
-	}
-
 	if (config.enableIceUdpMux) {
 		PLOG_DEBUG << "Enabling ICE UDP mux";
 		jconfig.concurrency_mode = JUICE_CONCURRENCY_MODE_MUX;
@@ -134,6 +130,10 @@
 	if (!mAgent)
 		throw std::runtime_error("Failed to create the ICE agent");
 
+	// ICE-TCP
+	juice_set_ice_tcp_mode(mAgent.get(), config.enableIceTcp ? JUICE_ICE_TCP_MODE_ACTIVE
+	                                                         : JUICE_ICE_TCP_MODE_NONE);
+
 	// Add TURN servers
 	for (const auto &server : servers)
 		if (!server.hostname.empty() && server.type != IceServer::Type::Stun)
@@ -451,7 +451,8 @@
 	// has been deprecated in this specification.
 	// libnice defaults to aggressive nomation therefore we change to regular nomination.
 	// See https://gitlab.freedesktop.org/libnice/libnice/-/merge_requests/125
-	NiceAgentOption flags = NICE_AGENT_OPTION_REGULAR_NOMINATION;
+	// Enable RFC 7675 ICE consent freshness support (requires libnice 0.1.19)
+	NiceAgentOption flags = static_cast<NiceAgentOption>(NICE_AGENT_OPTION_REGULAR_NOMINATION | NICE_AGENT_OPTION_CONSENT_FRESHNESS);
 
 	// Create agent
 	mNiceAgent = decltype(mNiceAgent)(
@@ -481,10 +482,7 @@
 	// the characteristics of the associated data.
 	g_object_set(G_OBJECT(mNiceAgent.get()), "stun-pacing-timer", 25, nullptr);
 
-	// Enable RFC 7675 ICE consent freshness support (requires libnice 0.1.19)
 	g_object_set(G_OBJECT(mNiceAgent.get()), "keepalive-conncheck", TRUE, nullptr);
-	g_object_set(G_OBJECT(mNiceAgent.get()), "consent-freshness", TRUE, nullptr);
-
 	g_object_set(G_OBJECT(mNiceAgent.get()), "upnp", FALSE, nullptr);
 	g_object_set(G_OBJECT(mNiceAgent.get()), "upnp-timeout", 200, nullptr);
 
@@ -657,8 +655,17 @@
 
 IceTransport::~IceTransport() {
 	PLOG_DEBUG << "Destroying ICE transport";
+
+	g_signal_handlers_disconnect_by_func(G_OBJECT(mNiceAgent.get()),
+	                 (gpointer)StateChangeCallback, this);
+	g_signal_handlers_disconnect_by_func(G_OBJECT(mNiceAgent.get()),
+	                 (gpointer)CandidateCallback, this);
+	g_signal_handlers_disconnect_by_func(G_OBJECT(mNiceAgent.get()),
+	                 (gpointer)GatheringDoneCallback, this);
+
 	nice_agent_attach_recv(mNiceAgent.get(), mStreamId, 1, g_main_loop_get_context(MainLoop->get()),
 	                       NULL, NULL);
+
 	nice_agent_remove_stream(mNiceAgent.get(), mStreamId);
 	mNiceAgent.reset();

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/impl/init.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/impl/init.cpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/impl/init.hpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/impl/init.hpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/impl/internals.hpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/impl/internals.hpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/impl/peerconnection.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/impl/peerconnection.cpp Changed

@@ -162,52 +162,52 @@
 		auto transport = std::make_shared<IceTransport>(
 		    config, weak_bind(&PeerConnection::processLocalCandidate, this, _1),
 		    this, weak_this = weak_from_this()(IceTransport::State transportState) {
-			    auto shared_this = weak_this.lock();
-			    if (!shared_this)
-				    return;
-			    switch (transportState) {
-			    case IceTransport::State::Connecting:
-				    changeIceState(IceState::Checking);
-				    changeState(State::Connecting);
-				    break;
-			    case IceTransport::State::Connected:
-				    changeIceState(IceState::Connected);
-				    initDtlsTransport();
-				    break;
-			    case IceTransport::State::Completed:
-				    changeIceState(IceState::Completed);
-				    break;
-			    case IceTransport::State::Failed:
-				    changeIceState(IceState::Failed);
-				    changeState(State::Failed);
-				    mProcessor.enqueue(&PeerConnection::remoteClose, shared_from_this());
-				    break;
-			    case IceTransport::State::Disconnected:
-				    changeIceState(IceState::Disconnected);
-				    changeState(State::Disconnected);
-				    mProcessor.enqueue(&PeerConnection::remoteClose, shared_from_this());
-				    break;
-			    default:
-				    // Ignore
-				    break;
-			    }
+			    if (auto locked = weak_this.lock())
+				    std::invoke(=() {
+					    switch (transportState) {
+					    case IceTransport::State::Connecting:
+						    changeIceState(IceState::Checking);
+						    changeState(State::Connecting);
+						    break;
+					    case IceTransport::State::Connected:
+						    changeIceState(IceState::Connected);
+						    initDtlsTransport();
+						    break;
+					    case IceTransport::State::Completed:
+						    changeIceState(IceState::Completed);
+						    break;
+					    case IceTransport::State::Failed:
+						    changeIceState(IceState::Failed);
+						    changeState(State::Failed);
+						    mProcessor.enqueue(&PeerConnection::remoteClose, shared_from_this());
+						    break;
+					    case IceTransport::State::Disconnected:
+						    changeIceState(IceState::Disconnected);
+						    changeState(State::Disconnected);
+						    mProcessor.enqueue(&PeerConnection::remoteClose, shared_from_this());
+						    break;
+					    default:
+						    // Ignore
+						    break;
+					    }
+				    });
 		    },
 		    this, weak_this = weak_from_this()(IceTransport::GatheringState gatheringState) {
-			    auto shared_this = weak_this.lock();
-			    if (!shared_this)
-				    return;
-			    switch (gatheringState) {
-			    case IceTransport::GatheringState::InProgress:
-				    changeGatheringState(GatheringState::InProgress);
-				    break;
-			    case IceTransport::GatheringState::Complete:
-				    endLocalCandidates();
-				    changeGatheringState(GatheringState::Complete);
-				    break;
-			    default:
-				    // Ignore
-				    break;
-			    }
+			    if (auto locked = weak_this.lock())
+				    std::invoke(=() {
+					    switch (gatheringState) {
+					    case IceTransport::GatheringState::InProgress:
+						    changeGatheringState(GatheringState::InProgress);
+						    break;
+					    case IceTransport::GatheringState::Complete:
+						    endLocalCandidates();
+						    changeGatheringState(GatheringState::Complete);
+						    break;
+					    default:
+						    // Ignore
+						    break;
+					    }
+				    });
 		    });
 
 		return emplaceTransport(this, &mIceTransport, std::move(transport));
@@ -241,34 +241,33 @@
 
 		auto certificate = mCertificate.get();
 		auto verifierCallback = weak_bind(&PeerConnection::checkFingerprint, this, _1);
-		auto dtlsStateChangeCallback =
-		    this, weak_this = weak_from_this()(DtlsTransport::State transportState) {
-			    auto shared_this = weak_this.lock();
-			    if (!shared_this)
-				    return;
-
-			    switch (transportState) {
-			    case DtlsTransport::State::Connected:
-				    if (auto remote = remoteDescription(); remote && remote->hasApplication())
-					    initSctpTransport();
-				    else
-					    changeState(State::Connected);
-
-				    mProcessor.enqueue(&PeerConnection::openTracks, shared_from_this());
-				    break;
-			    case DtlsTransport::State::Failed:
-				    changeState(State::Failed);
-				    mProcessor.enqueue(&PeerConnection::remoteClose, shared_from_this());
-				    break;
-			    case DtlsTransport::State::Disconnected:
-				    changeState(State::Disconnected);
-				    mProcessor.enqueue(&PeerConnection::remoteClose, shared_from_this());
-				    break;
-			    default:
-				    // Ignore
-				    break;
-			    }
-		    };
+		auto dtlsStateChangeCallback = this, weak_this = weak_from_this()(
+		                                   DtlsTransport::State transportState) {
+			if (auto locked = weak_this.lock())
+				std::invoke(=() {
+					switch (transportState) {
+					case DtlsTransport::State::Connected:
+						if (auto remote = remoteDescription(); remote && remote->hasApplication())
+							initSctpTransport();
+						else
+							changeState(State::Connected);
+
+						mProcessor.enqueue(&PeerConnection::openTracks, shared_from_this());
+						break;
+					case DtlsTransport::State::Failed:
+						changeState(State::Failed);
+						mProcessor.enqueue(&PeerConnection::remoteClose, shared_from_this());
+						break;
+					case DtlsTransport::State::Disconnected:
+						changeState(State::Disconnected);
+						mProcessor.enqueue(&PeerConnection::remoteClose, shared_from_this());
+						break;
+					default:
+						// Ignore
+						break;
+					}
+				});
+		};
 
 		shared_ptr<DtlsTransport> transport;
 		auto local = localDescription();
@@ -329,28 +328,28 @@
 		    lower, config, std::move(ports), weak_bind(&PeerConnection::forwardMessage, this, _1),
 		    weak_bind(&PeerConnection::forwardBufferedAmount, this, _1, _2),
 		    this, weak_this = weak_from_this()(SctpTransport::State transportState) {
-			    auto shared_this = weak_this.lock();
-			    if (!shared_this)
-				    return;
-
-			    switch (transportState) {
-			    case SctpTransport::State::Connected:
-				    changeState(State::Connected);
-				    assignDataChannels();
-				    mProcessor.enqueue(&PeerConnection::openDataChannels, shared_from_this());
-				    break;
-			    case SctpTransport::State::Failed:
-				    changeState(State::Failed);
-				    mProcessor.enqueue(&PeerConnection::remoteClose, shared_from_this());
-				    break;
-			    case SctpTransport::State::Disconnected:
-				    changeState(State::Disconnected);
-				    mProcessor.enqueue(&PeerConnection::remoteClose, shared_from_this());
-				    break;
-			    default:
-				    // Ignore
-				    break;
-			    }
+			    if (auto locked = weak_this.lock())
+				    std::invoke(=() {
+					    switch (transportState) {
+					    case SctpTransport::State::Connected:
+						    changeState(State::Connected);
+						    assignDataChannels();
+						    mProcessor.enqueue(&PeerConnection::openDataChannels,
+						                       shared_from_this());
+						    break;
+					    case SctpTransport::State::Failed:
+						    changeState(State::Failed);
+						    mProcessor.enqueue(&PeerConnection::remoteClose, shared_from_this());
+						    break;
+					    case SctpTransport::State::Disconnected:
+						    changeState(State::Disconnected);
+						    mProcessor.enqueue(&PeerConnection::remoteClose, shared_from_this());
+						    break;
+					    default:
+						    // Ignore
+						    break;
+					    }
+				    });
 		    });
 
 		return emplaceTransport(this, &mSctpTransport, std::move(transport));
@@ -571,39 +570,66 @@
 	if (message->type == Message::Control) {
 		std::set<uint32_t> ssrcs;
 		size_t offset = 0;
-		while ((sizeof(RtcpHeader) + offset) <= message->size()) {
+		while (offset + sizeof(RtcpHeader) <= message->size()) {
 			auto header = reinterpret_cast<RtcpHeader *>(message->data() + offset);
-			if (header->lengthInBytes() > message->size() - offset) {
+			size_t length = header->lengthInBytes();
+			if (offset + length > message->size()) {
 				COUNTER_MEDIA_TRUNCATED++;
 				break;
 			}
-			offset += header->lengthInBytes();
-			if (header->payloadType() == 205 || header->payloadType() == 206) {
-				auto rtcpfb = reinterpret_cast<RtcpFbHeader *>(header);
-				ssrcs.insert(rtcpfb->packetSenderSSRC());
-				ssrcs.insert(rtcpfb->mediaSourceSSRC());
-
-			} else if (header->payloadType() == 200) {
-				auto rtcpsr = reinterpret_cast<RtcpSr *>(header);
-				ssrcs.insert(rtcpsr->senderSSRC());
-				for (int i = 0; i < rtcpsr->header.reportCount(); ++i)
-					ssrcs.insert(rtcpsr->getReportBlock(i)->getSSRC());
-			} else if (header->payloadType() == 201) {
-				auto rtcprr = reinterpret_cast<RtcpRr *>(header);
-				ssrcs.insert(rtcprr->senderSSRC());
-				for (int i = 0; i < rtcprr->header.reportCount(); ++i)
-					ssrcs.insert(rtcprr->getReportBlock(i)->getSSRC());
-			} else if (header->payloadType() == 202) {
-				auto sdes = reinterpret_cast<RtcpSdes *>(header);
-				if (!sdes->isValid()) {
-					PLOG_WARNING << "RTCP SDES packet is invalid";
-					continue;
+			switch(header->payloadType()) {
+			case 200: // SR
+				if (length >= sizeof(RtcpSr)) {
+					auto rtcpsr = reinterpret_cast<RtcpSr *>(header);
+					ssrcs.insert(rtcpsr->senderSSRC());
+					for (int i = 0; i < rtcpsr->header.reportCount(); ++i)
+						if (const auto *reportBlock = rtcpsr->getReportBlock(i))
+							ssrcs.insert(reportBlock->getSSRC());
 				}
-				for (unsigned int i = 0; i < sdes->chunksCount(); i++) {
-					auto chunk = sdes->getChunk(i);
-					ssrcs.insert(chunk->ssrc());
+				break;
+
+			case 201: // RR
+				if (length >= sizeof(RtcpRr)) {
+					auto rtcprr = reinterpret_cast<RtcpRr *>(header);
+					ssrcs.insert(rtcprr->senderSSRC());
+					for (int i = 0; i < rtcprr->header.reportCount(); ++i)
+						if (const auto *reportBlock = rtcprr->getReportBlock(i))
+							ssrcs.insert(reportBlock->getSSRC());
 				}
-			} else {
+				break;
+
+			case 202: // SDES
+				if (length >= sizeof(RtcpSdes)) {
+					auto sdes = reinterpret_cast<RtcpSdes *>(header);
+					if (!sdes->isValid()) {
+						PLOG_WARNING << "RTCP SDES packet is invalid";
+						continue;
+					}
+					for (unsigned int i = 0; i < sdes->chunksCount(); i++) {
+						auto chunk = sdes->getChunk(i);
+						ssrcs.insert(chunk->ssrc());
+					}
+				}
+				break;
+
+
+			case 205: // FB
+			case 206:
+				if (length >= sizeof(RtcpFbHeader)) {
+					auto rtcpfb = reinterpret_cast<RtcpFbHeader *>(header);
+					ssrcs.insert(rtcpfb->packetSenderSSRC());
+					ssrcs.insert(rtcpfb->mediaSourceSSRC());
+					if (header->payloadType() == 206 && header->reportCount() == 15 &&
+						length >= sizeof(RtcpRemb)) {
+						auto remb = reinterpret_cast<RtcpRemb *>(header);
+						if (remb->hasValidId())
+							for (int i = 0; i < remb->getSSRCCount(); ++i)
+								ssrcs.insert(remb->getSSRC(i));
+					}
+				}
+				break;
+
+			default:
 				// PT=203 == Goodbye
 				// PT=204 == Application Specific
 				// PT=207 == Extended Report
@@ -611,7 +637,9 @@
 				    header->payloadType() != 207) {
 					COUNTER_UNKNOWN_PACKET_TYPE++;
 				}
+				break;
 			}
+			offset += header->lengthInBytes();
 		}
 
 		if (!ssrcs.empty()) {
@@ -890,7 +918,6 @@
 }
 
 void PeerConnection::closeTracks() {
-	std::shared_lock lock(mTracksMutex); // read-only
 	iterateTracks(&(shared_ptr<Track> track) { track->close(); });
 }

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/impl/queue.hpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/impl/queue.hpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/impl/sctptransport.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/impl/sctptransport.cpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/impl/tlstransport.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/impl/tlstransport.cpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/impl/track.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/impl/track.cpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/impl/transport.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/impl/transport.cpp Changed

@@ -38,7 +38,24 @@
 
 Transport::State Transport::state() const { return mState; }
 
-void Transport::onRecv(message_callback callback) { mRecvCallback = std::move(callback); }
+void Transport::onRecv(message_callback callback) {
+	std::vector<message_ptr> pending;
+	{
+		std::lock_guard lock(mPendingMutex);
+		mRecvCallback = std::move(callback);
+		if (mRecvCallback)
+			pending = std::move(mPendingRecv);
+		else
+			mPendingRecv.clear();
+	}
+	for (auto &msg : pending) {
+		try {
+			mRecvCallback(msg);
+		} catch (const std::exception &e) {
+			PLOG_WARNING << e.what();
+		}
+	}
+}
 
 void Transport::onStateChange(state_callback callback) {
 	mStateChangeCallback = std::move(callback);
@@ -52,6 +69,17 @@
 
 void Transport::recv(message_ptr message) {
 	try {
+		std::unique_lock lock(mPendingMutex);
+		if (!mRecvCallback) {
+			// No callback registered yet; buffer the message for replay when
+			// onRecv() is called.  Bounded to avoid unbounded growth.
+			if (mPendingRecv.size() < 8)
+				mPendingRecv.push_back(std::move(message));
+			else
+				PLOG_WARNING << "dropping incoming message, no receive callback";
+			return;
+		}
+		lock.unlock();
 		mRecvCallback(message);
 	} catch (const std::exception &e) {
 		PLOG_WARNING << e.what();

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/impl/transport.hpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/impl/transport.hpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/impl/websocket.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/impl/websocket.cpp Changed

@@ -235,30 +235,30 @@
 		transport->onBufferedAmount(weak_bind(&WebSocket::triggerBufferedAmount, this, _1));
 
 		transport->onStateChange(this, weak_this = weak_from_this()(State transportState) {
-			auto shared_this = weak_this.lock();
-			if (!shared_this)
-				return;
-			switch (transportState) {
-			case State::Connected:
-				if (config.proxyServer)
-					initProxyTransport();
-				else if (mIsSecure)
-					initTlsTransport();
-				else
-					initWsTransport();
-				break;
-			case State::Failed:
-				triggerError("TCP connection failed");
-				remoteClose();
-				break;
-			case State::Disconnected:
-				if(state == WebSocket::State::Connecting)
-					remoteClose();
-				break;
-			default:
-				// Ignore
-				break;
-			}
+			if(auto locked = weak_this.lock())
+				std::invoke(=() {
+					switch (transportState) {
+					case State::Connected:
+						if (config.proxyServer)
+							initProxyTransport();
+						else if (mIsSecure)
+							initTlsTransport();
+						else
+							initWsTransport();
+						break;
+					case State::Failed:
+						triggerError("TCP connection failed");
+						remoteClose();
+						break;
+					case State::Disconnected:
+						if(state == WebSocket::State::Connecting)
+							remoteClose();
+						break;
+					default:
+						// Ignore
+						break;
+					}
+				});
 		});
 
 		// WS transport sends a ping on read timeout
@@ -289,28 +289,28 @@
 			throw std::logic_error("No underlying TCP transport for Proxy transport");
 
 		auto stateChangeCallback = this, weak_this = weak_from_this()(State transportState) {
-			auto shared_this = weak_this.lock();
-			if (!shared_this)
-				return;
-			switch (transportState) {
-			case State::Connected:
-				if (mIsSecure)
-					initTlsTransport();
-				else
-					initWsTransport();
-				break;
-			case State::Failed:
-				triggerError("Proxy connection failed");
-				remoteClose();
-				break;
-			case State::Disconnected:
-				if(state == WebSocket::State::Connecting)
-					remoteClose();
-				break;
-			default:
-				// Ignore
-				break;
-			}
+			if(auto locked = weak_this.lock())
+				std::invoke(=() {
+					switch (transportState) {
+					case State::Connected:
+						if (mIsSecure)
+							initTlsTransport();
+						else
+							initWsTransport();
+						break;
+					case State::Failed:
+						triggerError("Proxy connection failed");
+						remoteClose();
+						break;
+					case State::Disconnected:
+						if(state == WebSocket::State::Connecting)
+							remoteClose();
+						break;
+					default:
+						// Ignore
+						break;
+					}
+				});
 		};
 
 		auto transport = std::make_shared<HttpProxyTransport>(
@@ -348,25 +348,25 @@
 		}
 
 		auto stateChangeCallback = this, weak_this = weak_from_this()(State transportState) {
-			auto shared_this = weak_this.lock();
-			if (!shared_this)
-				return;
-			switch (transportState) {
-			case State::Connected:
-				initWsTransport();
-				break;
-			case State::Failed:
-				triggerError("TLS connection failed");
-				remoteClose();
-				break;
-			case State::Disconnected:
-				if(state == WebSocket::State::Connecting)
-					remoteClose();
-				break;
-			default:
-				// Ignore
-				break;
-			}
+			if(auto locked = weak_this.lock())
+				std::invoke(=() {
+					switch (transportState) {
+					case State::Connected:
+						initWsTransport();
+						break;
+					case State::Failed:
+						triggerError("TLS connection failed");
+						remoteClose();
+						break;
+					case State::Disconnected:
+						if(state == WebSocket::State::Connecting)
+							remoteClose();
+						break;
+					default:
+						// Ignore
+						break;
+					}
+				});
 		};
 
 		bool verify = mHostname.has_value() && !config.disableTlsVerification;
@@ -428,28 +428,28 @@
 			atomic_store(&mWsHandshake, std::make_shared<WsHandshake>());
 
 		auto stateChangeCallback = this, weak_this = weak_from_this()(State transportState) {
-			auto shared_this = weak_this.lock();
-			if (!shared_this)
-				return;
-			switch (transportState) {
-			case State::Connected:
-				if (state == WebSocket::State::Connecting) {
-					PLOG_DEBUG << "WebSocket open";
-					if (changeState(WebSocket::State::Open))
-						triggerOpen();
-				}
-				break;
-			case State::Failed:
-				triggerError("WebSocket connection failed");
-				remoteClose();
-				break;
-			case State::Disconnected:
-				remoteClose();
-				break;
-			default:
-				// Ignore
-				break;
-			}
+			if(auto locked = weak_this.lock())
+				std::invoke(=() {
+					switch (transportState) {
+					case State::Connected:
+						if (state == WebSocket::State::Connecting) {
+							PLOG_DEBUG << "WebSocket open";
+							if (changeState(WebSocket::State::Open))
+								triggerOpen();
+						}
+						break;
+					case State::Failed:
+						triggerError("WebSocket connection failed");
+						remoteClose();
+						break;
+					case State::Disconnected:
+						remoteClose();
+						break;
+					default:
+						// Ignore
+						break;
+					}
+				});
 		};
 
 		auto transport = std::make_shared<WsTransport>(lower, mWsHandshake, config,

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/impl/wstransport.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/impl/wstransport.cpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/pacinghandler.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/pacinghandler.cpp Changed

@@ -18,41 +18,36 @@
 namespace rtc {
 
 PacingHandler::PacingHandler(double bitsPerSecond, std::chrono::milliseconds sendInterval)
-    : mBytesPerSecond(bitsPerSecond / 8), mBudget(0.), mSendInterval(sendInterval){};
+    : mBytesPerSecond(bitsPerSecond / 8), mBudget(0.), mSendInterval(sendInterval) {};
 
 void PacingHandler::schedule(const message_callback &send) {
-	if (mHaveScheduled.exchange(true)) {
-		return;
+	if (!mHaveScheduled.exchange(true))
+		impl::ThreadPool::Instance().schedule(mSendInterval,
+		                                      weak_bind(&PacingHandler::run, this, send));
+}
+
+void PacingHandler::run(const message_callback &send) {
+	const std::lock_guard<std::mutex> lock(mMutex);
+	mHaveScheduled.store(false);
+
+	// Update the budget and cap it
+	auto now = std::chrono::high_resolution_clock::now();
+	auto newBudget = std::chrono::duration<double>(now - mLastRun).count() * mBytesPerSecond;
+	auto maxBudget = std::chrono::duration<double>(mSendInterval).count() * mBytesPerSecond;
+	mBudget = std::min(mBudget + newBudget, maxBudget);
+	mLastRun = std::chrono::high_resolution_clock::now();
+
+	// Send packets while there is budget, allow a single partial packet over budget
+	while (!mRtpBuffer.empty() && mBudget > 0) {
+		auto size = int(mRtpBuffer.front()->size());
+		send(std::move(mRtpBuffer.front()));
+		mRtpBuffer.pop();
+		mBudget -= size;
 	}
 
-	impl::ThreadPool::Instance().schedule(mSendInterval, this, weak_this = weak_from_this(),
-	                                                      send() {
-		if (auto locked = weak_this.lock()) {
-			const std::lock_guard<std::mutex> lock(mMutex);
-			mHaveScheduled.store(false);
-
-			// Update the budget and cap it
-			auto newBudget =
-			    std::chrono::duration<double>(std::chrono::high_resolution_clock::now() - mLastRun)
-			        .count() *
-			    mBytesPerSecond;
-			auto maxBudget = std::chrono::duration<double>(mSendInterval).count() * mBytesPerSecond;
-			mBudget = std::min(mBudget + newBudget, maxBudget);
-			mLastRun = std::chrono::high_resolution_clock::now();
-
-			// Send packets while there is budget, allow a single partial packet over budget
-			while (!mRtpBuffer.empty() && mBudget > 0) {
-				auto size = int(mRtpBuffer.front()->size());
-				send(std::move(mRtpBuffer.front()));
-				mRtpBuffer.pop();
-				mBudget -= size;
-			}
-
-			if (!mRtpBuffer.empty()) {
-				schedule(send);
-			}
-		}
-	});
+	if (!mRtpBuffer.empty()) {
+		schedule(send);
+	}
 }
 
 void PacingHandler::outgoing(message_vector &messages, const message_callback &send) {

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/rembhandler.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/rembhandler.cpp Changed

@@ -9,6 +9,8 @@
 #include "rembhandler.hpp"
 #include "rtp.hpp"
 
+#include "impl/internals.hpp"
+
 #ifdef _WIN32
 #include <winsock2.h>
 #else
@@ -24,15 +26,21 @@
 void RembHandler::incoming(message_vector &messages, maybe_unused const message_callback &send) {
 	for (const auto &message : messages) {
 		size_t offset = 0;
-		while ((sizeof(RtcpHeader) + offset) <= message->size()) {
+		while (offset + sizeof(RtcpHeader) <= message->size()) {
 			auto header = reinterpret_cast<RtcpHeader *>(message->data() + offset);
-			uint8_t payload_type = header->payloadType();
+			size_t length = header->lengthInBytes();
+			if (offset + length > message->size())
+				break;
 
-			if (payload_type == 206 && header->reportCount() == 15 && header->lengthInBytes() == sizeof(RtcpRemb)) {
-				auto remb = reinterpret_cast<RtcpRemb *>(message->data() + offset);
+			if (header->payloadType() == 206 && header->reportCount() == 15 && length >= sizeof(RtcpRemb)) {
+				if (offset + sizeof(RtcpRemb) > message->size())
+					break;
 
-				if (remb->_id0 == 'R' && remb->_id1 == 'E' && remb->_id2 == 'M' && remb->_id3 == 'B') {
-					mOnRemb(remb->getBitrate());
+				auto remb = reinterpret_cast<RtcpRemb *>(message->data() + offset);
+				if (remb->hasValidId()) {
+					unsigned int bitrate = remb->getBitrate();
+					PLOG_DEBUG << "Got REMB, bitrate=" << bitrate;
+					mOnRemb(bitrate);
 					break;
 				}
 			}

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/rtcpreceivingsession.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/rtcpreceivingsession.cpp Changed

@@ -15,6 +15,7 @@
 #include "impl/logcounter.hpp"
 
 #include <cmath>
+#include <mutex>
 #include <utility>
 
 #ifdef _WIN32
@@ -26,12 +27,18 @@
 namespace rtc {
 
 static impl::LogCounter COUNTER_BAD_RTP_HEADER(plog::warning, "Number of malformed RTP headers");
+static impl::LogCounter COUNTER_BAD_RTCP_HEADER(plog::warning, "Number of malformed RTCP headers");
 static impl::LogCounter COUNTER_UNKNOWN_PPID(plog::warning, "Number of Unknown PPID messages");
 static impl::LogCounter COUNTER_BAD_NOTIF_LEN(plog::warning,
                                               "Number of Bad-Lengthed notifications");
 static impl::LogCounter COUNTER_BAD_SCTP_STATUS(plog::warning,
                                                 "Number of unknown SCTP_STATUS errors");
 
+RtcpReceivingSession::SyncTimestamps RtcpReceivingSession::getSyncTimestamps(){
+	std::lock_guard lock(mSyncMutex);
+	return mSyncTimestamps;
+}
+
 void RtcpReceivingSession::incoming(message_vector &messages, const message_callback &send) {
 	message_vector result;
 	for (auto message : messages) {
@@ -67,15 +74,34 @@
 		}
 
 		case Message::Control: {
-			auto rr = reinterpret_cast<const RtcpRr *>(message->data());
-			if (rr->header.payloadType() == 201) { // RR
+			if (message->size() < sizeof(RtcpHeader)) {
+				COUNTER_BAD_RTCP_HEADER++;
+				PLOG_VERBOSE << "RTCP packet is too small, size=" << message->size();
+				continue;
+			}
+			auto header = reinterpret_cast<const RtcpHeader *>(message->data());
+			if (header->payloadType() == 201) { // RR
+				if (message->size() < RtcpRr::SizeWithReportBlocks(0)) {
+					COUNTER_BAD_RTCP_HEADER++;
+					PLOG_VERBOSE << "RTCP RR is too small, size=" << message->size();
+					continue;
+				}
+				auto rr = reinterpret_cast<const RtcpRr *>(message->data());
 				mSsrc = rr->senderSSRC();
 				rr->log();
-			} else if (rr->header.payloadType() == 200) { // SR
-				mSsrc = rr->senderSSRC();
+			} else if (header->payloadType() == 200) { // SR
+				if (message->size() < RtcpSr::Size(0)) {
+					COUNTER_BAD_RTCP_HEADER++;
+					PLOG_VERBOSE << "RTCP SR is too small, size=" << message->size();
+					continue;
+				}
 				auto sr = reinterpret_cast<const RtcpSr *>(message->data());
-				mSyncRTPTS = sr->rtpTimestamp();
-				mSyncNTPTS = sr->ntpTimestamp();
+				mSsrc = sr->senderSSRC();
+				{
+					std::lock_guard lock(mSyncMutex);
+					mSyncTimestamps.rtpTimestamp = sr->rtpTimestamp();
+					mSyncTimestamps.ntpTimestamp = sr->ntpTimestamp();
+				}
 				sr->log();
 
 				// TODO For the time being, we will send RR's/REMB's when we get an SR
@@ -105,7 +131,7 @@
 	auto message = make_message(RtcpRemb::SizeWithSSRCs(1), Message::Control);
 	auto remb = reinterpret_cast<RtcpRemb *>(message->data());
 	remb->preparePacket(mSsrc, 1, bitrate);
-	remb->setSsrc(0, mSsrc);
+	remb->setSSRC(0, mSsrc);
 	send(message);
 }
 
@@ -120,7 +146,7 @@
 	auto lost = 0;
 	if (mReceived > 0) {
 		lost = expected - mReceived;
-	} 
+	}
 
 	auto expected_interval = expected - mExpectedPrior;
     mExpectedPrior = expected;
@@ -130,15 +156,17 @@
 
 	uint8_t fraction;
 
-	if (expected_interval == 0 || lost_interval <= 0) {  
+	if (expected_interval == 0 || lost_interval <= 0) {
 		fraction = 0;
-	}	
-	else { 
+	}
+	else {
 		fraction = (lost_interval << 8) / expected_interval;
 	}
-
-	rr->getReportBlock(0)->preparePacket(mSsrc, fraction, lost, uint16_t(mGreatestSeqNo), mMaxSeq, 0, mSyncNTPTS,
-	                                     lastSrDelay);
+	auto syncTimestamps = getSyncTimestamps();
+	auto reportBlock = rr->getReportBlock(0);
+	assert(reportBlock);
+	reportBlock->preparePacket(mSsrc, fraction, lost, uint16_t(mGreatestSeqNo), mMaxSeq, 0, syncTimestamps.ntpTimestamp,
+	                           lastSrDelay);
 	rr->log();
 	send(message);
 }

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/rtp.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/rtp.cpp Changed

@@ -183,7 +183,7 @@
 	setSSRC(in_ssrc);
 
 	setPacketsLost(fraction, totalPacketsLost);
-	
+
 	// Middle 32 bits of NTP Timestamp
 	// _lastReport = lastSR_NTP >> 16u;
 	setNTPOfSR(uint64_t(lastSR_NTP));
@@ -306,9 +306,19 @@
 	this->_senderSSRC = htonl(senderSSRC);
 }
 
-const RtcpReportBlock *RtcpSr::getReportBlock(int num) const { return &_reportBlocks + num; }
+const RtcpReportBlock *RtcpSr::getReportBlock(int num) const {
+	if (num < 0 || num >= int((header.lengthInBytes() - 24) / sizeof(RtcpReportBlock)))
+		return nullptr;
+
+	return &_reportBlocks + num;
+}
+
+RtcpReportBlock *RtcpSr::getReportBlock(int num) {
+	if (num < 0 || num >= int((header.lengthInBytes() - 24) / sizeof(RtcpReportBlock)))
+		return nullptr;
 
-RtcpReportBlock *RtcpSr::getReportBlock(int num) { return &_reportBlocks + num; }
+	return &_reportBlocks + num;
+}
 
 size_t RtcpSr::getSize() const {
 	// "length" in packet is one less than the number of 32 bit words in the packet.
@@ -333,9 +343,9 @@
 	             << ", RtpTS=" << rtpTimestamp() << ", packetCount=" << packetCount()
 	             << ", octetCount=" << octetCount();
 
-	for (unsigned i = 0; i < unsigned(header.reportCount()); i++) {
-		getReportBlock(i)->log();
-	}
+	for (int i = 0; i < header.reportCount(); i++)
+		if (const auto *reportBlock = getReportBlock(i))
+			reportBlock->log();
 }
 
 unsigned int RtcpSdesItem::Size(uint8_t textLength) { return textLength + 2; }
@@ -420,6 +430,7 @@
 			return -1;
 		}
 		textsLength.push_back(itemLength);
+		size += RtcpSdesItem::Size(itemLength);
 		// safely to access next item
 		item = getItem(++i);
 	}
@@ -505,9 +516,19 @@
 	header.prepareHeader(202, chunkCount, length);
 }
 
-const RtcpReportBlock *RtcpRr::getReportBlock(int num) const { return &_reportBlocks + num; }
+const RtcpReportBlock *RtcpRr::getReportBlock(int num) const {
+	if (num < 0 || num >= int((header.lengthInBytes() - 4) / sizeof(RtcpReportBlock)))
+		return nullptr;
+
+	return &_reportBlocks + num;
+}
 
-RtcpReportBlock *RtcpRr::getReportBlock(int num) { return &_reportBlocks + num; }
+RtcpReportBlock *RtcpRr::getReportBlock(int num) {
+	if (num < 0 || num >= int((header.lengthInBytes() - 4) / sizeof(RtcpReportBlock)))
+		return nullptr;
+
+	return &_reportBlocks + num;
+}
 
 size_t RtcpRr::SizeWithReportBlocks(uint8_t reportCount) {
 	return sizeof(header) + 4 + size_t(reportCount) * sizeof(RtcpReportBlock);
@@ -538,9 +559,9 @@
 	PLOG_VERBOSE << "RTCP RR: "
 	             << " SSRC=" << ntohl(_senderSSRC);
 
-	for (unsigned i = 0; i < unsigned(header.reportCount()); i++) {
-		getReportBlock(i)->log();
-	}
+	for (int i = 0; i < header.reportCount(); i++)
+		if (const auto *reportBlock = getReportBlock(i))
+			reportBlock->log();
 }
 
 size_t RtcpRemb::SizeWithSSRCs(int count) { return sizeof(RtcpRemb) + (count - 1) * sizeof(SSRC); }
@@ -576,21 +597,56 @@
 	}
 
 	// "length" in packet is one less than the number of 32 bit words in the packet.
-	header.header.setLength(uint16_t((offsetof(RtcpRemb, _ssrc) / sizeof(uint32_t)) - 1 + numSSRC));
+	header.header.setLength(uint16_t((offsetof(RtcpRemb, _ssrcs) / sizeof(uint32_t)) + numSSRC - 1));
 
 	_bitrate = htonl((numSSRC << (32u - 8u)) | (exp << (32u - 8u - 6u)) | in_bitrate);
 }
 
-void RtcpRemb::setSsrc(int iterator, SSRC newSssrc) { _ssrciterator = htonl(newSssrc); }
+SSRC RtcpRemb::getSSRC(int num) const {
+    if (num < 0 || num >= getSSRCCount())
+        throw std::out_of_range("SSRC num out of range");
+    return ntohl(_ssrcsnum);
+}
+void RtcpRemb::setSSRC(int num, SSRC newSsrc) {
+    if (num < 0 || num >= getSSRCCount())
+        throw std::out_of_range("SSRC num out of range");
+    _ssrcsnum = htonl(newSsrc);
+}
 
-unsigned int RtcpRemb::getNumSSRC() { return ntohl(_bitrate) >> 24u; }
+bool RtcpRemb::hasValidId() const {
+	return _id0 == 'R' && _id1 == 'E' && _id2 == 'M' && _id3 == 'B';
+}
 
-unsigned int RtcpRemb::getBitrate() {
+int RtcpRemb::getSSRCCount() const {
+	return std::min(
+		int(ntohl(_bitrate) >> 24u),
+		std::max(int(header.header.length() + 1 - offsetof(RtcpRemb, _ssrcs) / sizeof(uint32_t)), 0));
+}
+
+unsigned int RtcpRemb::getBitrate() const {
 	uint32_t br = ntohl(_bitrate);
 	uint8_t exp = (br << 8u) >> 26u;
 	return (br & 0x3FFFF) * static_cast<unsigned int>(pow(2, exp));
 }
 
+void RtcpRemb::setSsrc(int num, SSRC newSsrc) {
+    if (num < 0 || num >= getSSRCCount())
+		throw std::out_of_range("SSRC num out of range");
+    _ssrcsnum = htonl(newSsrc);
+}
+
+unsigned int RtcpRemb::getNumSSRC() const {
+	return unsigned(getSSRCCount());
+}
+
+unsigned int RtcpRemb::getNumSSRC() {
+	return unsigned(getSSRCCount());
+}
+
+unsigned int RtcpRemb::getBitrate() {
+	return std::as_const(*this).getBitrate();
+}
+
 unsigned int RtcpPli::Size() { return sizeof(RtcpFbHeader); }
 
 void RtcpPli::preparePacket(SSRC messageSSRC) {
@@ -640,7 +696,12 @@
 	return offsetof(RtcpNack, parts) + sizeof(RtcpNackPart) * discreteSeqNoCount;
 }
 
-unsigned int RtcpNack::getSeqNoCount() { return header.header.length() - 2; }
+unsigned int RtcpNack::getSeqNoCount() {
+	if (header.header.length() < 2)
+		return 0;
+
+	return header.header.length() - 2;
+}
 
 void RtcpNack::preparePacket(SSRC ssrc, unsigned int discreteSeqNoCount) {
 	header.header.prepareHeader(205, 1, 2 + uint16_t(discreteSeqNoCount));
@@ -677,10 +738,12 @@
 size_t RtpRtx::getSize() const { return header.getSize() + sizeof(uint16_t); }
 
 size_t RtpRtx::normalizePacket(size_t totalSize, SSRC originalSSRC, uint8_t originalPayloadType) {
+	if (totalSize < getSize())
+		throw std::invalid_argument("Packet size is too small for RTX");
+
 	header.setSeqNumber(getOriginalSeqNo());
 	header.setSsrc(originalSSRC);
 	header.setPayloadType(originalPayloadType);
-	// TODO, the -12 is the size of the header (which is variable!)
 	memmove(header.getBody(), getBody(), totalSize - getSize());
 	return totalSize - 2;
 }

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/rtpdepacketizer.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/rtpdepacketizer.cpp Changed

@@ -35,10 +35,16 @@
 			continue;
 		}
 
-		auto pkt = reinterpret_cast<const rtc::RtpHeader *>(message->data());
-		auto headerSize = sizeof(rtc::RtpHeader) + pkt->csrcCount() + pkt->getExtensionHeaderSize();
-		result.push_back(make_message(message->begin() + headerSize, message->end(),
-		                              createFrameInfo(pkt->timestamp(), pkt->payloadType())));
+		auto header = reinterpret_cast<const rtc::RtpHeader *>(message->data());
+		if (message->size() < header->getSize())
+			continue; // truncated header
+
+		auto totalHeaderSize = header->getSize() + header->getExtensionHeaderSize();
+		if (message->size() < totalHeaderSize)
+			continue; // truncated header
+
+		result.push_back(make_message(message->begin() + totalHeaderSize, message->end(),
+		                              createFrameInfo(header->timestamp(), header->payloadType())));
 	}
 
 	messages.swap(result);
@@ -73,6 +79,8 @@
 		}
 
 		auto header = reinterpret_cast<const RtpHeader *>(message->data());
+		if (message->size() < header->getSize())
+			continue; // truncated header
 
 		if (!mBuffer.empty()) {
 			auto first = *mBuffer.begin();

_service:obs_scm:libdatachannel-0.23.3.obscpio/src/rtppacketizer.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/src/rtppacketizer.cpp Changed

_service:obs_scm:libdatachannel-0.23.3.obscpio/test/main.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/test/main.cpp Changed

@@ -72,7 +72,7 @@
     Test("WebRTC broken fingerprint", test_connectivity_fail_on_wrong_fingerprint),
     Test("pem", test_pem),
     // TODO: Temporarily disabled as the Open Relay TURN server is unreliable
-    // new Test("WebRTC TURN connectivity", test_turn_connectivity),
+    // Test("WebRTC TURN connectivity", test_turn_connectivity),
     Test("WebRTC negotiated DataChannel", test_negotiated),
     Test("WebRTC reliability mode", test_reliability),
 #if RTC_ENABLE_MEDIA
@@ -80,7 +80,7 @@
 #endif
 #if RTC_ENABLE_WEBSOCKET
     // TODO: Temporarily disabled as the echo service is unreliable
-    // new Test("WebSocket", test_websocket),
+    // Test("WebSocket", test_websocket),
     Test("WebSocketServer", test_websocketserver),
 #endif
     Test("Cleanup", test_cleanup),
@@ -96,6 +96,8 @@
 };
 
 int main(int argc, char **argv) {
+	rtc::SetThreadPoolSize(4);
+
 	int success_tests = 0;
 	int failed_tests = 0;
 	steady_clock::time_point startTime, endTime;
@@ -118,6 +120,7 @@
 	cout << "Finished " << success_tests + failed_tests << " tests in " << durationS.count()
 	     << "s (" << durationMs.count() << " ms). Succeeded: " << success_tests
 	     << ". Failed: " << failed_tests << "." << endl;
+
 	/*
 	    // Benchmark
 	    try {

_service:obs_scm:libdatachannel-0.23.3.obscpio/test/track.cpp -> _service:obs_scm:libdatachannel-0.24.3.obscpio/test/track.cpp Changed

@@ -137,8 +137,8 @@
 	media2.setBitrate(3000);
 	media2.addSSRC(2468, "video-send");
 
-	// NOTE: Overwriting the old shared_ptr for t1 will cause it's respective
-	//       track to be dropped (so it's SSRCs won't be on the description next time)
+	// NOTE: Overwriting the old shared_ptr for t1 will cause the respective
+	//       track to be dropped (so its SSRCs won't be on the description next time)
 	t1 = pc1.addTrack(media2);
 
 	pc1.setLocalDescription();
@@ -151,14 +151,16 @@
 	if (!at2 || !at2->isOpen() || !t1->isOpen())
 		return TestResult(false, "Renegotiated track is not open");
 
+#if RTC_ENABLE_MEDIA
+	// RTP test
 	std::vector<std::byte> payload = {std::byte{0}, std::byte{1}, std::byte{2}, std::byte{3}};
 	std::vector<std::byte> rtpRaw(sizeof(RtpHeader) + payload.size());
 	auto *rtp = reinterpret_cast<RtpHeader *>(rtpRaw.data());
+	rtp->preparePacket();
 	rtp->setPayloadType(96);
 	rtp->setSeqNumber(1);
 	rtp->setTimestamp(3000);
 	rtp->setSsrc(2468);
-	rtp->preparePacket();
 	std::memcpy(rtpRaw.data() + sizeof(RtpHeader), payload.data(), payload.size());
 
 	if (!t1->send(rtpRaw.data(), rtpRaw.size())) {
@@ -167,7 +169,7 @@
 
 	// wait for an RTP packet to be received
 	auto future = recvRtpPromise.get_future();
-	if (future.wait_for(5s) == std::future_status::timeout) {
+	if (future.wait_for(2s) == std::future_status::timeout) {
 		throw runtime_error("Didn't receive RTP packet on pc2");
 	}
 
@@ -181,6 +183,32 @@
 		throw runtime_error("Received RTP packet is different than the packet that was sent");
 	}
 
+	// RTCP REMB test
+	std::promise<unsigned int> rembPromise;
+	t1->setMediaHandler(make_shared<RembHandler>(&rembPromise(unsigned int bitrate) {
+		rembPromise.set_value(bitrate);
+	}));
+
+	std::vector<std::byte> rtcpRembRaw(RtcpRemb::SizeWithSSRCs(2));
+	auto *rtcpRemb = reinterpret_cast<RtcpRemb*>(rtcpRembRaw.data());
+	rtcpRemb->preparePacket(6666, 2, 1000000);
+	rtcpRemb->setSSRC(0, 2468);
+	rtcpRemb->setSSRC(1, 2469);
+	if (!t2->send(rtcpRembRaw.data(), rtcpRembRaw.size())) {
+		throw runtime_error("Couldn't send RTCP REMB message");
+	}
+
+	auto rembFuture = rembPromise.get_future();
+	if (rembFuture.wait_for(2s) == std::future_status::timeout) {
+		throw runtime_error("Didn't receive REMB message");
+	}
+
+	unsigned int bitrate = rembFuture.get();
+	if (bitrate != 1000000) {
+		throw runtime_error("Incorrect bitrate in REMB message");
+	}
+#endif
+
 	// Delay close of peer 2 to check closing works properly
 	pc1.close();
 	this_thread::sleep_for(1s);

_service:obs_scm:libdatachannel.obsinfo Changed

Changes of Revision 8