mediasoup 3.19.18 → 3.19.19

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mediasoup",
-	"version": "3.19.18",
+	"version": "3.19.19",
 	"description": "Cutting Edge WebRTC Video Conferencing",
 	"contributors": [
 		"Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -102,30 +102,30 @@
 		"h264-profile-level-id": "^2.3.2",
 		"node-fetch": "^3.3.2",
 		"supports-color": "^10.2.2",
-		"tar": "^7.5.11"
+		"tar": "^7.5.13"
 	},
 	"devDependencies": {
 		"@eslint/js": "^10.0.1",
 		"@octokit/rest": "^22.0.1",
-		"@types/debug": "^4.1.12",
+		"@types/debug": "^4.1.13",
 		"@types/ini": "^4.1.1",
 		"@types/jest": "^30.0.0",
 		"@types/node": "^24.10.1",
-		"eslint": "^10.0.3",
+		"eslint": "^10.1.0",
 		"eslint-config-prettier": "^10.1.8",
 		"eslint-plugin-jest": "^29.15.0",
 		"eslint-plugin-prettier": "^5.5.5",
 		"globals": "^17.4.0",
 		"ini": "^6.0.0",
 		"jest": "^30.3.0",
-		"knip": "^5.86.0",
-		"marked": "^17.0.4",
+		"knip": "^6.0.4",
+		"marked": "^17.0.5",
 		"open-cli": "^8.0.0",
 		"pick-port": "^2.2.0",
 		"prettier": "^3.8.1",
 		"ts-jest": "^29.4.6",
 		"typescript": "^5.9.3",
-		"typescript-eslint": "^8.57.0",
+		"typescript-eslint": "^8.57.2",
 		"werift-sctp": "^0.0.11"
 	}
 }

package/worker/Makefile

@@ -42,7 +42,9 @@ endif
 	docker \
 	docker-run \
 	docker-alpine \
-	docker-alpine-run
+	docker-alpine-run \
+	docker-386 \
+	docker-386-run
 
 default: mediasoup-worker
 
@@ -131,3 +133,9 @@ docker-alpine: invoke
 
 docker-alpine-run: invoke
 	"$(PYTHON)" -m invoke docker-alpine-run
+
+docker-386: invoke
+	"$(PYTHON)" -m invoke docker-386
+
+docker-386-run: invoke
+	"$(PYTHON)" -m invoke docker-386-run

package/worker/fuzzer/src/FuzzerUtils.cpp

@@ -1,33 +1,37 @@
 #include "FuzzerUtils.hpp"
 #include "MediaSoupErrors.hpp"
 #include "Utils.hpp"
-#include <cstring> // std::memory()
+#include <cstring> // std::memcpy()
 #include <string>
 
-void FuzzerUtils::Fuzz(const uint8_t* data, size_t len)
+namespace
 {
-	// For some fuzzers below.
-	const std::unique_ptr<uint8_t[]> data2(new uint8_t[len + (INET6_ADDRSTRLEN * 3)]);
+	alignas(4) thread_local uint8_t DataBuffer[65536];
+}
 
-	std::memcpy(data2.get(), data, len);
+void FuzzerUtils::Fuzz(const uint8_t* data, size_t len)
+{
+	// NOTE: We need to copy given data into another buffer because we are gonna
+	// write into it.
+	std::memcpy(DataBuffer, data, len);
 
 	/* IP class. */
 
 	std::string ip;
 
-	ip = std::string(reinterpret_cast<const char*>(data2.get()), INET6_ADDRSTRLEN / 2);
+	ip = std::string(reinterpret_cast<const char*>(DataBuffer), INET6_ADDRSTRLEN / 2);
 	Utils::IP::GetFamily(ip);
 
-	ip = std::string(reinterpret_cast<const char*>(data2.get()), INET6_ADDRSTRLEN);
+	ip = std::string(reinterpret_cast<const char*>(DataBuffer), INET6_ADDRSTRLEN);
 	Utils::IP::GetFamily(ip);
 
-	ip = std::string(reinterpret_cast<const char*>(data2.get()), INET6_ADDRSTRLEN * 2);
+	ip = std::string(reinterpret_cast<const char*>(DataBuffer), INET6_ADDRSTRLEN * 2);
 	Utils::IP::GetFamily(ip);
 
 	// Protect with try/catch since throws are legit.
 	try
 	{
-		auto ip = std::string(reinterpret_cast<const char*>(data2.get()), len);
+		auto ip = std::string(reinterpret_cast<const char*>(DataBuffer), len);
 
 		Utils::IP::NormalizeIp(ip);
 	}
@@ -37,16 +41,16 @@ void FuzzerUtils::Fuzz(const uint8_t* data, size_t len)
 
 	/* Byte class. */
 
-	Utils::Byte::Get1Byte(data2.get(), len);
-	Utils::Byte::Get2Bytes(data2.get(), len);
-	Utils::Byte::Get3Bytes(data2.get(), len);
-	Utils::Byte::Get4Bytes(data2.get(), len);
-	Utils::Byte::Get8Bytes(data2.get(), len);
-	Utils::Byte::Set1Byte(data2.get(), len, uint8_t{ 6u });
-	Utils::Byte::Set2Bytes(data2.get(), len, uint16_t{ 66u });
-	Utils::Byte::Set3Bytes(data2.get(), len, uint32_t{ 666u });
-	Utils::Byte::Set4Bytes(data2.get(), len, uint32_t{ 666u });
-	Utils::Byte::Set8Bytes(data2.get(), len, uint64_t{ 6666u });
+	Utils::Byte::Get1Byte(DataBuffer, len);
+	Utils::Byte::Get2Bytes(DataBuffer, len);
+	Utils::Byte::Get3Bytes(DataBuffer, len);
+	Utils::Byte::Get4Bytes(DataBuffer, len);
+	Utils::Byte::Get8Bytes(DataBuffer, len);
+	Utils::Byte::Set1Byte(DataBuffer, len, uint8_t{ 6u });
+	Utils::Byte::Set2Bytes(DataBuffer, len, uint16_t{ 66u });
+	Utils::Byte::Set3Bytes(DataBuffer, len, uint32_t{ 666u });
+	Utils::Byte::Set4Bytes(DataBuffer, len, uint32_t{ 666u });
+	Utils::Byte::Set8Bytes(DataBuffer, len, uint64_t{ 6666u });
 	Utils::Byte::PadTo4Bytes(static_cast<uint8_t>(len));
 	Utils::Byte::PadTo4Bytes(static_cast<uint16_t>(len));
 	Utils::Byte::PadTo4Bytes(static_cast<uint32_t>(len));
@@ -70,7 +74,7 @@ void FuzzerUtils::Fuzz(const uint8_t* data, size_t len)
 	  static_cast<uint64_t>(len), static_cast<uint64_t>(len + 1000000));
 	Utils::Crypto::GetRandomUInt<size_t>(len, len + 1000000);
 	Utils::Crypto::GetRandomString(len);
-	Utils::Crypto::GetCRC32(data2.get(), len);
+	Utils::Crypto::GetCRC32(DataBuffer, len);
 
 	/* String class. */
 
@@ -79,8 +83,8 @@ void FuzzerUtils::Fuzz(const uint8_t* data, size_t len)
 	{
 		size_t outLen;
 
-		Utils::String::Base64Encode(data2.get(), len);
-		Utils::String::Base64Decode(data2.get(), len, outLen);
+		Utils::String::Base64Encode(DataBuffer, len);
+		Utils::String::Base64Decode(DataBuffer, len, outLen);
 	}
 	catch (const MediaSoupError& error) // NOLINT(bugprone-empty-catch)
 	{

package/worker/fuzzer/src/RTC/ICE/FuzzerStunPacket.cpp

@@ -3,11 +3,11 @@
 #include <string_view>
 
 static constexpr size_t ResponseFactoryBufferLength{ 65536 };
-thread_local uint8_t ResponseFactoryBuffer[ResponseFactoryBufferLength];
+alignas(4) thread_local uint8_t ResponseFactoryBuffer[ResponseFactoryBufferLength];
 static constexpr size_t SerializeBufferLength{ 65536 };
-thread_local uint8_t SerializeBuffer[SerializeBufferLength];
+alignas(4) thread_local uint8_t SerializeBuffer[SerializeBufferLength];
 static constexpr size_t CloneBufferLength{ 65536 };
-thread_local uint8_t CloneBuffer[CloneBufferLength];
+alignas(4) thread_local uint8_t CloneBuffer[CloneBufferLength];
 
 void FuzzerRtcIceStunPacket::Fuzz(const uint8_t* data, size_t len)
 {

package/worker/fuzzer/src/RTC/RTCP/FuzzerPacket.cpp

@@ -7,6 +7,12 @@
 #include "RTC/RTCP/FuzzerSenderReport.hpp"
 #include "RTC/RTCP/FuzzerXr.hpp"
 #include "RTC/RTCP/Packet.hpp"
+#include <cstring> // std::memcpy()
+
+namespace
+{
+	alignas(4) thread_local uint8_t DataBuffer[65536];
+} // namespace
 
 void FuzzerRtcRtcpPacket::Fuzz(const uint8_t* data, size_t len)
 {
@@ -15,13 +21,11 @@ void FuzzerRtcRtcpPacket::Fuzz(const uint8_t* data, size_t len)
 		return;
 	}
 
-	// We need to clone the given data into a separate buffer because setters
-	// below will try to write into packet memory.
-	const std::unique_ptr<uint8_t[]> data2(new uint8_t[len]);
-
-	std::memcpy(data2.get(), data, len);
+	// NOTE: We need to copy given data into another buffer because we are gonna
+	// write into it.
+	std::memcpy(DataBuffer, data, len);
 
-	RTC::RTCP::Packet* packet = RTC::RTCP::Packet::Parse(data2.get(), len);
+	RTC::RTCP::Packet* packet = RTC::RTCP::Packet::Parse(DataBuffer, len);
 
 	if (!packet)
 	{

package/worker/fuzzer/src/RTC/SCTP/{FuzzerStateCookie.cpp → association/FuzzerStateCookie.cpp}

@@ -1,17 +1,20 @@
 #include "RTC/SCTP/FuzzerStateCookie.hpp"
 #include "Utils.hpp"
-#include "RTC/SCTP/StateCookie.hpp"
-#include <cstdlib> // std::malloc(), std::free()
+#include "RTC/SCTP/association/StateCookie.hpp"
 #include <cstring> // std::memcpy()
 
-thread_local uint8_t StateCookieSerializeBuffer[65536];
-thread_local uint8_t StateCookieCloneBuffer[65536];
+namespace
+{
+	alignas(4) thread_local uint8_t DataBuffer[65536];
+	alignas(4) thread_local uint8_t StateCookieSerializeBuffer[65536];
+	alignas(4) thread_local uint8_t StateCookieCloneBuffer[65536];
+} // namespace
 
 void FuzzerRtcSctpStateCookie::Fuzz(const uint8_t* data, size_t len)
 {
-	auto* clonedData = static_cast<uint8_t*>(std::malloc(len));
-
-	std::memcpy(clonedData, data, len);
+	// NOTE: We need to copy given data into another buffer because we are gonna
+	// write into it.
+	std::memcpy(DataBuffer, data, len);
 
 	// We need to force `data` to be a StateCookie since it's too hard that
 	// random data matches it.
@@ -22,20 +25,18 @@ void FuzzerRtcSctpStateCookie::Fuzz(const uint8_t* data, size_t len)
 
 		if (len < RTC::SCTP::StateCookie::StateCookieLength + 5)
 		{
-			Utils::Byte::Set8Bytes(clonedData, 0, RTC::SCTP::StateCookie::Magic1);
+			Utils::Byte::Set8Bytes(DataBuffer, 0, RTC::SCTP::StateCookie::Magic1);
 			Utils::Byte::Set2Bytes(
-			  clonedData,
+			  DataBuffer,
 			  RTC::SCTP::StateCookie::NegotiatedCapabilitiesOffset,
 			  RTC::SCTP::StateCookie::Magic2);
 		}
 	}
 
-	RTC::SCTP::StateCookie* stateCookie = RTC::SCTP::StateCookie::Parse(clonedData, len);
+	RTC::SCTP::StateCookie* stateCookie = RTC::SCTP::StateCookie::Parse(DataBuffer, len);
 
 	if (!stateCookie)
 	{
-		std::free(clonedData);
-
 		return;
 	}
 
@@ -71,6 +72,5 @@ void FuzzerRtcSctpStateCookie::Fuzz(const uint8_t* data, size_t len)
 
 	clonedStateCookie->Serialize(StateCookieSerializeBuffer, len);
 
-	std::free(clonedData);
 	delete clonedStateCookie;
 }

package/worker/fuzzer/src/fuzzer.cpp

@@ -5,7 +5,9 @@
 #include "DepLibUV.hpp"
 #include "DepLibWebRTC.hpp"
 #include "DepOpenSSL.hpp"
+#ifndef MS_SCTP_STACK
 #include "DepUsrSCTP.hpp"
+#endif
 #include "FuzzerUtils.hpp"
 #include "Settings.hpp"
 #include "Utils.hpp"
@@ -145,7 +147,9 @@ namespace
 		DepLibUV::ClassInit();
 		DepOpenSSL::ClassInit();
 		DepLibSRTP::ClassInit();
+#ifndef MS_SCTP_STACK
 		DepUsrSCTP::ClassInit();
+#endif
 		DepLibWebRTC::ClassInit();
 		Utils::Crypto::ClassInit();
 		RTC::DtlsTransport::ClassInit();

package/worker/include/RTC/DataConsumer.hpp

@@ -11,9 +11,11 @@
 
 namespace RTC
 {
+#ifndef MS_SCTP_STACK
 	// Define class here such that we can use it even though we don't know what it looks like yet
 	// (this is to avoid circular dependencies).
 	class SctpAssociation;
+#endif
 
 	class DataConsumer : public Channel::ChannelSocket::RequestHandler
 	{
@@ -48,7 +50,9 @@ namespace RTC
 		  RTC::Shared* shared,
 		  const std::string& id,
 		  const std::string& dataProducerId,
+#ifndef MS_SCTP_STACK
 		  RTC::SctpAssociation* sctpAssociation,
+#endif
 		  RTC::DataConsumer::Listener* listener,
 		  const FBS::Transport::ConsumeDataRequest* data,
 		  size_t maxMessageSize);
@@ -98,7 +102,7 @@ namespace RTC
 		void SctpAssociationBufferedAmount(uint32_t bufferedAmount);
 		void SctpAssociationSendBufferFull();
 		void DataProducerClosed();
-		void SendMessage(
+		bool SendMessage(
 		  const uint8_t* msg,
 		  size_t len,
 		  uint32_t ppid,
@@ -118,7 +122,9 @@ namespace RTC
 	private:
 		// Passed by argument.
 		RTC::Shared* shared{ nullptr };
+#ifndef MS_SCTP_STACK
 		RTC::SctpAssociation* sctpAssociation{ nullptr };
+#endif
 		RTC::DataConsumer::Listener* listener{ nullptr };
 		size_t maxMessageSize{ 0u };
 		// Others.

package/worker/include/RTC/DirectTransport.hpp

@@ -36,7 +36,7 @@ namespace RTC
 		  size_t len,
 		  uint32_t ppid,
 		  onQueuedCallback* cb = nullptr) override;
-		void SendSctpData(const uint8_t* data, size_t len) override;
+		bool SendSctpData(const uint8_t* data, size_t len) override;
 		void RecvStreamClosed(uint32_t ssrc) override;
 		void SendStreamClosed(uint32_t ssrc) override;
 

package/worker/include/RTC/DtlsTransport.hpp

@@ -151,7 +151,8 @@ namespace RTC
 		{
 			return this->localRole;
 		}
-		void SendApplicationData(const uint8_t* data, size_t len);
+		// Returns a boolean indicating whether the data could be sent.
+		bool SendApplicationData(const uint8_t* data, size_t len);
 		// This method must be public since it's called within an OpenSSL callback.
 		void SendDtlsData(const uint8_t* data, size_t len);
 

package/worker/include/RTC/ICE/IceCandidate.hpp

@@ -37,27 +37,39 @@ namespace RTC
 
 		public:
 			IceCandidate(RTC::UdpSocket* udpSocket, uint32_t priority)
-			  : foundation("udpcandidate"), priority(priority), address(udpSocket->GetLocalIp()),
-			    protocol(Protocol::UDP), port(udpSocket->GetLocalPort())
+			  : foundation("udpcandidate"),
+			    priority(priority),
+			    address(udpSocket->GetLocalIp()),
+			    protocol(Protocol::UDP),
+			    port(udpSocket->GetLocalPort())
 			{
 			}
 
 			IceCandidate(RTC::UdpSocket* udpSocket, uint32_t priority, std::string& announcedAddress)
-			  : foundation("udpcandidate"), priority(priority), address(announcedAddress),
-			    protocol(Protocol::UDP), port(udpSocket->GetLocalPort())
+			  : foundation("udpcandidate"),
+			    priority(priority),
+			    address(announcedAddress),
+			    protocol(Protocol::UDP),
+			    port(udpSocket->GetLocalPort())
 			{
 			}
 
 			IceCandidate(RTC::TcpServer* tcpServer, uint32_t priority)
-			  : foundation("tcpcandidate"), priority(priority), address(tcpServer->GetLocalIp()),
-			    protocol(Protocol::TCP), port(tcpServer->GetLocalPort())
+			  : foundation("tcpcandidate"),
+			    priority(priority),
+			    address(tcpServer->GetLocalIp()),
+			    protocol(Protocol::TCP),
+			    port(tcpServer->GetLocalPort())
 
 			{
 			}
 
 			IceCandidate(RTC::TcpServer* tcpServer, uint32_t priority, std::string& announcedAddress)
-			  : foundation("tcpcandidate"), priority(priority), address(announcedAddress),
-			    protocol(Protocol::TCP), port(tcpServer->GetLocalPort())
+			  : foundation("tcpcandidate"),
+			    priority(priority),
+			    address(announcedAddress),
+			    protocol(Protocol::TCP),
+			    port(tcpServer->GetLocalPort())
 
 			{
 			}

package/worker/include/RTC/ICE/StunPacket.hpp

@@ -4,7 +4,6 @@
 #include "common.hpp"
 #include "Utils.hpp"
 #include "RTC/Serializable.hpp"
-#include <cstdint>
 #include <string_view>
 #include <unordered_map>
 
@@ -126,6 +125,12 @@ namespace RTC
 			};
 
 		private:
+			/**
+			 * @remarks
+			 * - This struct is NOT guaranteed to be aligned to any fixed number of
+			 *   bytes because it contains a `size_t`, which is 4 or 8 bytes depending
+			 *   on the architecture. Anyway we never cast any buffer to this struct.
+			 */
 			struct Attribute
 			{
 				Attribute(AttributeType type, uint16_t len, size_t offset)

package/worker/include/RTC/PipeTransport.hpp

@@ -54,7 +54,7 @@ namespace RTC
 		  size_t len,
 		  uint32_t ppid,
 		  onQueuedCallback* cb = nullptr) override;
-		void SendSctpData(const uint8_t* data, size_t len) override;
+		bool SendSctpData(const uint8_t* data, size_t len) override;
 		void RecvStreamClosed(uint32_t ssrc) override;
 		void SendStreamClosed(uint32_t ssrc) override;
 		void OnPacketReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen);

package/worker/include/RTC/PlainTransport.hpp

@@ -48,7 +48,7 @@ namespace RTC
 		  size_t len,
 		  uint32_t ppid,
 		  onQueuedCallback* cb = nullptr) override;
-		void SendSctpData(const uint8_t* data, size_t len) override;
+		bool SendSctpData(const uint8_t* data, size_t len) override;
 		void RecvStreamClosed(uint32_t ssrc) override;
 		void SendStreamClosed(uint32_t ssrc) override;
 		void OnPacketReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen);

package/worker/include/RTC/RTCP/Feedback.hpp

@@ -13,7 +13,12 @@ namespace RTC
 		class FeedbackPacket : public Packet
 		{
 		public:
-			/* Struct for RTP Feedback message. */
+			/**
+			 * Struct for RTP Feedback message.
+			 *
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 4 bytes.
+			 */
 			struct Header
 			{
 				uint32_t senderSsrc;

package/worker/include/RTC/RTCP/FeedbackPsFir.hpp

@@ -23,6 +23,10 @@ namespace RTC
 		class FeedbackPsFirItem : public FeedbackItem
 		{
 		public:
+			/**
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 4 bytes.
+			 */
 			struct Header
 			{
 				uint32_t ssrc;

package/worker/include/RTC/RTCP/FeedbackPsLei.hpp

@@ -20,6 +20,10 @@ namespace RTC
 		class FeedbackPsLeiItem : public FeedbackItem
 		{
 		public:
+			/**
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 4 bytes.
+			 */
 			struct Header
 			{
 				uint32_t ssrc;

package/worker/include/RTC/RTCP/FeedbackPsRpsi.hpp

@@ -25,6 +25,10 @@ namespace RTC
 			static const size_t MaxBitStringSize{ 6 };
 
 		public:
+			/**
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 1 byte.
+			 */
 			struct Header
 			{
 				uint8_t paddingBits;

package/worker/include/RTC/RTCP/FeedbackPsSli.hpp

@@ -20,6 +20,10 @@ namespace RTC
 		class FeedbackPsSliItem : public FeedbackItem
 		{
 		public:
+			/**
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 4 bytes.
+			 */
 			struct Header
 			{
 				uint32_t compact;

package/worker/include/RTC/RTCP/FeedbackPsTst.hpp

@@ -30,6 +30,11 @@ namespace RTC
 #else
 #define MEDIASOUP_PACKED __attribute__((packed))
 #endif
+			/**
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 1 byte due to the usage
+			 *   of `pack()` and `packed` macros.
+			 */
 			struct Header
 			{
 				uint32_t ssrc;

package/worker/include/RTC/RTCP/FeedbackPsVbcm.hpp

@@ -26,6 +26,10 @@ namespace RTC
 		class FeedbackPsVbcmItem : public FeedbackItem
 		{
 		public:
+			/**
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 4 bytes.
+			 */
 			struct Header
 			{
 				uint32_t ssrc;

package/worker/include/RTC/RTCP/FeedbackRtpEcn.hpp

@@ -30,6 +30,10 @@ namespace RTC
 		class FeedbackRtpEcnItem : public FeedbackItem
 		{
 		public:
+			/**
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 4 bytes.
+			 */
 			struct Header
 			{
 				uint32_t sequenceNumber;

package/worker/include/RTC/RTCP/FeedbackRtpNack.hpp

@@ -21,6 +21,10 @@ namespace RTC
 		class FeedbackRtpNackItem : public FeedbackItem
 		{
 		public:
+			/**
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 2 bytes.
+			 */
 			struct Header
 			{
 				uint16_t packetId;

package/worker/include/RTC/RTCP/FeedbackRtpTllei.hpp

@@ -20,6 +20,10 @@ namespace RTC
 		class FeedbackRtpTlleiItem : public FeedbackItem
 		{
 		public:
+			/**
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 2 bytes.
+			 */
 			struct Header
 			{
 				uint16_t packetId;

package/worker/include/RTC/RTCP/FeedbackRtpTmmb.hpp

@@ -24,6 +24,10 @@ namespace RTC
 		class FeedbackRtpTmmbItem : public FeedbackItem
 		{
 		public:
+			/**
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 4 bytes.
+			 */
 			struct Header
 			{
 				uint32_t ssrc;

package/worker/include/RTC/RTCP/Packet.hpp

@@ -32,7 +32,12 @@ namespace RTC
 		class Packet
 		{
 		public:
-			/* Struct for RTCP common header. */
+			/**
+			 * Struct for RTCP common header.
+			 *
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 2 bytes.
+			 */
 			struct CommonHeader
 			{
 #if defined(MS_LITTLE_ENDIAN)

package/worker/include/RTC/RTCP/ReceiverReport.hpp

@@ -13,7 +13,12 @@ namespace RTC
 		class ReceiverReport
 		{
 		public:
-			/* Struct for RTCP receiver report. */
+			/**
+			 * Struct for RTCP receiver report.
+			 *
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 4 bytes.
+			 */
 			struct Header
 			{
 				uint32_t ssrc;

package/worker/include/RTC/RTCP/Sdes.hpp

@@ -27,7 +27,15 @@ namespace RTC
 				PRIV
 			};
 
+#ifdef MS_TEST
+		public:
+#else
 		private:
+#endif
+			/**
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 1 byte.
+			 */
 			struct Header
 			{
 				SdesItem::Type type;

package/worker/include/RTC/RTCP/SenderReport.hpp

@@ -12,7 +12,12 @@ namespace RTC
 		class SenderReport
 		{
 		public:
-			/* Struct for RTCP sender report. */
+			/**
+			 * Struct for RTCP sender report.
+			 *
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 4 bytes.
+			 */
 			struct Header
 			{
 				uint32_t ssrc;

package/worker/include/RTC/RTCP/XR.hpp

@@ -37,12 +37,17 @@ namespace RTC
 			};
 
 		public:
-			/* Struct for Extended Report Block common header. */
+			/**
+			 * Struct for Extended Report Block common header.
+			 *
+			 * @remarks
+			 * - This struct is guaranteed to be aligned to 2 bytes.
+			 */
 			struct CommonHeader
 			{
-				uint8_t blockType : 8;
-				uint8_t reserved : 8;
-				uint16_t length : 16;
+				uint8_t blockType;
+				uint8_t reserved;
+				uint16_t length;
 			};
 
 		public: