mediasoup 3.21.0 → 3.21.2

package/node/lib/test/test-Consumer.js

@@ -1022,6 +1022,117 @@ test('transport.consume() for a simulcast producer honors preferredLayers', asyn
         temporalLayer: 4,
     });
 }, 2000);
+test('transport.consume() from a single-encoding no temporal layer producer is of type simple', async () => {
+    const router = await ctx.worker.createRouter({
+        mediaCodecs: ctx.vpxMediaCodecs,
+    });
+    const transport1 = await router.createWebRtcTransport({
+        listenIps: ['127.0.0.1'],
+    });
+    const transport2 = await router.createWebRtcTransport({
+        listenIps: ['127.0.0.1'],
+    });
+    const producer = await transport1.produce({
+        kind: 'video',
+        rtpParameters: {
+            codecs: [
+                {
+                    mimeType: 'video/VP8',
+                    payloadType: 96,
+                    clockRate: 90000,
+                    rtcpFeedback: [
+                        { type: 'nack', parameter: '' },
+                        { type: 'nack', parameter: 'pli' },
+                    ],
+                },
+            ],
+            headerExtensions: [],
+            encodings: [{ ssrc: 11111111 }],
+            rtcp: { cname: 'test' },
+        },
+    });
+    expect(producer.type).toBe('simple');
+    const consumer = await transport2.consume({
+        producerId: producer.id,
+        rtpCapabilities: ctx.vpxConsumerDeviceCapabilities,
+    });
+    expect(consumer.type).toBe('simple');
+}, 2000);
+test('transport.consume() from a single-encoding multiple temporal layer producer is of type svc', async () => {
+    const router = await ctx.worker.createRouter({
+        mediaCodecs: ctx.vpxMediaCodecs,
+    });
+    const transport1 = await router.createWebRtcTransport({
+        listenIps: ['127.0.0.1'],
+    });
+    const transport2 = await router.createWebRtcTransport({
+        listenIps: ['127.0.0.1'],
+    });
+    const producer = await transport1.produce({
+        kind: 'video',
+        rtpParameters: {
+            codecs: [
+                {
+                    mimeType: 'video/VP8',
+                    payloadType: 96,
+                    clockRate: 90000,
+                    rtcpFeedback: [
+                        { type: 'nack', parameter: '' },
+                        { type: 'nack', parameter: 'pli' },
+                    ],
+                },
+            ],
+            headerExtensions: [],
+            encodings: [{ ssrc: 55555555, scalabilityMode: 'L1T3' }],
+            rtcp: { cname: 'test' },
+        },
+    });
+    expect(producer.type).toBe('svc');
+    const consumer = await transport2.consume({
+        producerId: producer.id,
+        rtpCapabilities: ctx.vpxConsumerDeviceCapabilities,
+    });
+    expect(consumer.type).toBe('svc');
+}, 2000);
+test('transport.consume() from a multiple-encoding producer is of type simulcast', async () => {
+    const router = await ctx.worker.createRouter({
+        mediaCodecs: ctx.vpxMediaCodecs,
+    });
+    const transport1 = await router.createWebRtcTransport({
+        listenIps: ['127.0.0.1'],
+    });
+    const transport2 = await router.createWebRtcTransport({
+        listenIps: ['127.0.0.1'],
+    });
+    const producer = await transport1.produce({
+        kind: 'video',
+        rtpParameters: {
+            codecs: [
+                {
+                    mimeType: 'video/VP8',
+                    payloadType: 96,
+                    clockRate: 90000,
+                    rtcpFeedback: [
+                        { type: 'nack', parameter: '' },
+                        { type: 'nack', parameter: 'pli' },
+                    ],
+                },
+            ],
+            headerExtensions: [],
+            encodings: [
+                { ssrc: 11111111, scalabilityMode: 'L1T3' },
+                { ssrc: 22222222, scalabilityMode: 'L1T3' },
+            ],
+            rtcp: { cname: 'test' },
+        },
+    });
+    expect(producer.type).toBe('simulcast');
+    const consumer = await transport2.consume({
+        producerId: producer.id,
+        rtpCapabilities: ctx.vpxConsumerDeviceCapabilities,
+    });
+    expect(consumer.type).toBe('simulcast');
+}, 2000);
 test('consumer.setPriority() succeed', async () => {
     const videoConsumer = await ctx.webRtcTransport2.consume({
         producerId: ctx.videoProducer.id,

package/node/lib/test/test-Producer.js

@@ -442,6 +442,60 @@ test('transport.produce() with no MID and with single encoding without RID or SS
         },
     })).rejects.toThrow(Error);
 }, 2000);
+test('transport.produce() with single encoding and no temporal layers is of type simple', async () => {
+    const producer = await ctx.webRtcTransport1.produce({
+        kind: 'video',
+        rtpParameters: {
+            codecs: [
+                {
+                    mimeType: 'video/VP8',
+                    payloadType: 96,
+                    clockRate: 90000,
+                },
+            ],
+            encodings: [{ ssrc: 11111111 }],
+            rtcp: { cname: 'test' },
+        },
+    });
+    expect(producer.type).toBe('simple');
+}, 2000);
+test('transport.produce() with single encoding and temporal layers is of type svc', async () => {
+    const producer = await ctx.webRtcTransport1.produce({
+        kind: 'video',
+        rtpParameters: {
+            codecs: [
+                {
+                    mimeType: 'video/VP8',
+                    payloadType: 96,
+                    clockRate: 90000,
+                },
+            ],
+            encodings: [{ ssrc: 11111111, scalabilityMode: 'L1T3' }],
+            rtcp: { cname: 'test' },
+        },
+    });
+    expect(producer.type).toBe('svc');
+}, 2000);
+test('transport.produce() with multiple encodings is of type simulcast', async () => {
+    const producer = await ctx.webRtcTransport1.produce({
+        kind: 'video',
+        rtpParameters: {
+            codecs: [
+                {
+                    mimeType: 'video/VP8',
+                    payloadType: 96,
+                    clockRate: 90000,
+                },
+            ],
+            encodings: [
+                { ssrc: 11111111, scalabilityMode: 'L1T3' },
+                { ssrc: 22222222, scalabilityMode: 'L1T3' },
+            ],
+            rtcp: { cname: 'test' },
+        },
+    });
+    expect(producer.type).toBe('simulcast');
+}, 2000);
 test('producer.dump() succeeds', async () => {
     const audioProducer = await ctx.webRtcTransport1.produce(ctx.audioProducerOptions);
     const dump1 = await audioProducer.dump();

package/npm-scripts.mjs

@@ -19,7 +19,6 @@ const WORKER_RELEASE_BIN = IS_WINDOWS
 	: 'mediasoup-worker';
 const WORKER_RELEASE_BIN_PATH = `${WORKER_RELEASE_DIR}/${WORKER_RELEASE_BIN}`;
 const WORKER_PREBUILD_DIR = 'worker/prebuild';
-
 // Paths for ESLint to check.
 const ESLINT_PATHS = [
 	'eslint.config.mjs',
@@ -30,10 +29,8 @@ const ESLINT_PATHS = [
 	'rust-scripts.mjs',
 	'worker/scripts',
 ];
-
 // Paths for ESLint to ignore.
 const ESLINT_IGNORE_PATHS = ['node/src/fbs'];
-
 // Paths for Prettier to check/write.
 // NOTE: Prettier ignores paths in .gitignore so we don't need to care about
 // node/src/fbs.
@@ -457,7 +454,6 @@ async function flatcNode({ force }) {
 		})
 	);
 	const flatbuffersDir = flatbuffersWrap['wrap-file']['directory'];
-
 	const flatc = path.resolve(
 		path.join(
 			'worker',
@@ -709,7 +705,6 @@ async function downloadPrebuiltWorker() {
 		`${pkg.repository.url
 			.replace(/^git\+/, '')
 			.replace(/\.git$/, '')}/releases/download`;
-
 	const workerPrebuildTar = getWorkerPrebuildTarName();
 	const workerPrebuildTarUrl = `${releaseBase}/${pkg.version}/${workerPrebuildTar}`;
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mediasoup",
-	"version": "3.21.0",
+	"version": "3.21.2",
 	"description": "Cutting Edge WebRTC Video Conferencing",
 	"contributors": [
 		"Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -42,6 +42,7 @@
 		}
 	},
 	"files": [
+		"CHANGELOG.md",
 		"LICENSE",
 		"README.md",
 		"node/lib",
@@ -113,29 +114,29 @@
 		"h264-profile-level-id": "^2.3.3",
 		"node-fetch": "^3.3.2",
 		"supports-color": "^10.2.2",
-		"tar": "^7.5.19"
+		"tar": "^7.5.20"
 	},
 	"devDependencies": {
 		"@eslint/js": "^10.0.1",
 		"@types/debug": "^4.1.13",
 		"@types/ini": "^4.1.1",
 		"@types/jest": "^30.0.0",
-		"@types/node": "^26.1.0",
-		"eslint": "^10.6.0",
+		"@types/node": "^26.1.1",
+		"eslint": "^10.7.0",
 		"eslint-config-prettier": "^10.1.8",
 		"eslint-plugin-jest": "^29.15.4",
 		"eslint-plugin-prettier": "^5.5.6",
 		"globals": "^17.7.0",
 		"ini": "^7.0.0",
 		"jest": "^30.4.2",
-		"knip": "^6.24.0",
-		"marked": "^18.0.5",
+		"knip": "^6.27.0",
+		"marked": "^18.0.6",
 		"open-cli": "^9.0.0",
 		"pick-port": "^2.2.1",
-		"prettier": "^3.9.4",
+		"prettier": "^3.9.5",
 		"ts-jest": "^29.4.11",
 		"typescript": "^6.0.3",
-		"typescript-eslint": "^8.62.1",
+		"typescript-eslint": "^8.64.0",
 		"werift-sctp": "^0.0.11"
 	}
 }

package/worker/fuzzer/src/RTC/SCTP/association/FuzzerStateCookie.cpp

@@ -27,9 +27,7 @@ void FuzzerRtcSctpStateCookie::Fuzz(const uint8_t* data, size_t len)
 		{
 			Utils::Byte::Set8Bytes(DataBuffer, 0, RTC::SCTP::StateCookie::Magic1);
 			Utils::Byte::Set2Bytes(
-			  DataBuffer,
-			  RTC::SCTP::StateCookie::NegotiatedCapabilitiesOffset,
-			  RTC::SCTP::StateCookie::Magic2);
+			  DataBuffer, RTC::SCTP::StateCookie::RemoteCapabilitiesOffset, RTC::SCTP::StateCookie::Magic2);
 		}
 	}
 
@@ -46,7 +44,7 @@ void FuzzerRtcSctpStateCookie::Fuzz(const uint8_t* data, size_t len)
 	stateCookie->GetRemoteInitialTsn();
 	stateCookie->GetRemoteAdvertisedReceiverWindowCredit();
 	stateCookie->GetTieTag();
-	stateCookie->GetNegotiatedCapabilities();
+	stateCookie->GetRemoteCapabilities();
 
 	stateCookie->Serialize(StateCookieSerializeBuffer, len);
 
@@ -56,7 +54,7 @@ void FuzzerRtcSctpStateCookie::Fuzz(const uint8_t* data, size_t len)
 	stateCookie->GetRemoteInitialTsn();
 	stateCookie->GetRemoteAdvertisedReceiverWindowCredit();
 	stateCookie->GetTieTag();
-	stateCookie->GetNegotiatedCapabilities();
+	stateCookie->GetRemoteCapabilities();
 
 	auto* clonedStateCookie = stateCookie->Clone(StateCookieCloneBuffer, len);
 
@@ -68,7 +66,7 @@ void FuzzerRtcSctpStateCookie::Fuzz(const uint8_t* data, size_t len)
 	clonedStateCookie->GetRemoteInitialTsn();
 	clonedStateCookie->GetRemoteAdvertisedReceiverWindowCredit();
 	clonedStateCookie->GetTieTag();
-	clonedStateCookie->GetNegotiatedCapabilities();
+	clonedStateCookie->GetRemoteCapabilities();
 
 	clonedStateCookie->Serialize(StateCookieSerializeBuffer, len);
 

package/worker/include/RTC/NEW_RTCP/packet/ByePacket.hpp

@@ -0,0 +1,165 @@
+#ifndef MS_RTC_NEW_RTCP_BYE_PACKET_HPP
+#define MS_RTC_NEW_RTCP_BYE_PACKET_HPP
+
+#include "common.hpp"
+#include "RTC/NEW_RTCP/packet/Packet.hpp"
+#include "Utils.hpp"
+#include <string_view>
+#include <vector>
+
+namespace RTC
+{
+	namespace NEW_RTCP
+	{
+		/**
+		 * BYE RTCP Packet (203)
+		 *
+		 * @see RFC 3550.
+		 *
+		 *        0                   1                   2                   3
+		 *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+		 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+		 * |V=2|P|    SC   |   PT=BYE=203  |             Length            |
+		 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+		 * |                           SSRC/CSRC                           |
+		 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+		 * :                              ...                              :
+		 * +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+		 * | Reason length |               Reason for leaving            ...
+		 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+		 *
+		 * - Packet type (8 bits): 203.
+		 * - Source count (SC) (5 bits): The number of SSRC/CSRC identifiers
+		 *   included in this BYE packet.
+		 * - Reason length (8 bits): Number of bytes of text indicating the reason
+		 *   for leaving.
+		 * - Reason for leaving (variable length): If the string fills the packet
+		 *   to the next 32-bit boundary, the string is not null terminated. If not,
+		 *   the BYE packet MUST be padded with null octets to the next 32-bit
+		 *   boundary.
+		 */
+
+		// Forward declaration.
+		class Packet;
+
+		class ByePacket : public Packet
+		{
+			// We need that compound packet calls protected and private methods in
+			// this class.
+			friend class CompoundPacket;
+
+		public:
+			/**
+			 * Parse a ByePacket.
+			 *
+			 * @remarks
+			 * `bufferLength` may exceed the exact length of the packet.
+			 */
+			static ByePacket* Parse(const uint8_t* buffer, size_t bufferLength);
+
+			/**
+			 * Create a ByePacket.
+			 *
+			 * @remarks
+			 * `bufferLength` could be greater than the packet real length.
+			 */
+			static ByePacket* Factory(uint8_t* buffer, size_t bufferLength);
+
+		private:
+			/**
+			 * Parse a ByePacket.
+			 *
+			 * @remarks
+			 * To be used only by `Packet::Parse()`.
+			 */
+			static ByePacket* ParseStrict(const uint8_t* buffer, size_t bufferLength, size_t packetLength);
+
+		private:
+			/**
+			 * Only used by Parse(), ParseStrict() and Factory() static methods.
+			 */
+			ByePacket(uint8_t* buffer, size_t bufferLength);
+
+		public:
+			~ByePacket() override;
+
+			void Dump(int indentation = 0) const final;
+
+			ByePacket* Clone(uint8_t* buffer, size_t bufferLength) const final;
+
+			std::vector<uint32_t> GetSsrcs() const;
+
+			void AddSsrc(uint32_t ssrc);
+
+			bool HasReason() const
+			{
+				return (GetBuffer() + GetLength()) > GetReasonLengthPointer();
+			}
+
+			const std::string_view GetReason() const
+			{
+				if (!HasReason())
+				{
+					return {};
+				}
+
+				const uint8_t reasonLength = GetReasonLength();
+				const auto* reason         = GetReasonPointer();
+
+				if (!reason)
+				{
+					return {};
+				}
+
+				// NOTE: Validation of the Reason length field is done outside this
+				// method.
+
+				return std::string_view(reinterpret_cast<const char*>(reason), reasonLength);
+			}
+
+			void SetReason(const std::string_view& reason);
+
+		protected:
+			ByePacket* SoftClone(const uint8_t* buffer) const final;
+
+		private:
+			uint8_t* GetSsrcsPointer() const
+			{
+				return GetVariableLengthValuePointer();
+			}
+
+			uint32_t GetSsrcAt(uint8_t idx) const
+			{
+				return Utils::Byte::Get4Bytes(GetSsrcsPointer(), (idx * 4));
+			}
+
+			uint8_t* GetReasonLengthPointer() const
+			{
+				return GetVariableLengthValuePointer() + (GetCount() * 4);
+			}
+
+			uint8_t* GetReasonPointer() const
+			{
+				return GetReasonLengthPointer() + 1;
+			}
+
+			/**
+			 * Returns the value of the Reason length field.
+			 *
+			 * @remarks
+			 * - This value must be validated outside.
+			 */
+			uint8_t GetReasonLength() const
+			{
+				if (!HasReason())
+				{
+					return 0;
+				}
+
+				return Utils::Byte::Get1Byte(GetReasonLengthPointer(), 0);
+			}
+		};
+	} // namespace NEW_RTCP
+} // namespace RTC
+
+#endif

package/worker/include/RTC/NEW_RTCP/packet/CompoundPacket.hpp

@@ -0,0 +1,183 @@
+#ifndef MS_RTC_NEW_RTCP_COMPOUND_PACKET_HPP
+#define MS_RTC_NEW_RTCP_COMPOUND_PACKET_HPP
+
+#include "common.hpp"
+#include "RTC/NEW_RTCP/packet/Packet.hpp"
+#include "RTC/Serializable.hpp"
+#include <vector>
+
+namespace RTC
+{
+	namespace NEW_RTCP
+	{
+		/**
+		 * RTCP Compound Packet.
+		 *
+		 * @see RFC 3550.
+		 */
+		class CompoundPacket : public Serializable
+		{
+		public:
+			using PacketsIterator = typename std::vector<Packet*>::const_iterator;
+
+			/**
+			 * Parse an RTCP compound packet.
+			 *
+			 * @remarks
+			 * - `bufferLength` must be the exact length of the compound packet.
+			 */
+			static CompoundPacket* Parse(const uint8_t* buffer, size_t bufferLength);
+
+			/**
+			 * Create an RTCP compound packet.
+			 */
+			static CompoundPacket* Factory(uint8_t* buffer, size_t bufferLength);
+
+		protected:
+			/**
+			 * Constructor is protected because we only want to create packets
+			 * instances via Parse() and Factory() in subclasses.
+			 */
+			CompoundPacket(uint8_t* buffer, size_t bufferLength);
+
+		public:
+			~CompoundPacket() override;
+
+			void Dump(int indentation = 0) const final;
+
+			void Serialize(uint8_t* buffer, size_t bufferLength) final;
+
+			CompoundPacket* Clone(uint8_t* buffer, size_t bufferLength) const final;
+
+			bool HasPackets() const
+			{
+				return this->packets.size() > 0;
+			}
+
+			size_t GetPacketsCount() const
+			{
+				return this->packets.size();
+			}
+
+			PacketsIterator PacketsBegin() const
+			{
+				return this->packets.begin();
+			}
+
+			PacketsIterator PacketsEnd() const
+			{
+				return this->packets.end();
+			}
+
+			const Packet* GetPacketAt(size_t idx) const
+			{
+				if (idx >= this->packets.size())
+				{
+					return nullptr;
+				}
+
+				return this->packets[idx];
+			}
+
+			template<typename T>
+			const T* GetFirstPacketOfType() const
+			{
+				for (const auto* packet : this->packets)
+				{
+					if (typeid(*packet) == typeid(T))
+					{
+						return static_cast<const T*>(packet);
+					}
+				}
+
+				return nullptr;
+			}
+
+			/**
+			 * Clone given packet into compound packet's buffer.
+			 *
+			 * @remarks
+			 * - Once this method is called, the caller may want to free the original
+			 *   given packet (otherwise it will leak since the compound packet manages
+			 *   a clone of it).
+			 *
+			 * @throw
+			 * - MediaSoupError - If `BuildPacketInPlace()` was called before and the
+			 *   caller didn't invoke `Consolidate()` on the returned packet yet.
+			 */
+			void AddPacket(const Packet* packet);
+
+			/**
+			 * Build a packet within the compound packet's buffer and append it to the
+			 * list of packets. The caller can perform modifications in that packet
+			 * and those will affect the compound packet body where the packet is
+			 * serialzed. The desired packet class type is given via template argument.
+			 *
+			 * @returns Pointer of the created packet specific class.
+			 *
+			 * @throw
+			 * - MediaSoupError - If `BuildPacketInPlace()` was called before and the
+			 *   caller didn't invoke `Consolidate()` on the returned packet yet.
+			 *
+			 * @remarks
+			 * - The caller MUST invoke `Consolidate()` once the packet is completed.
+			 * - The caller MUST NOT call `BuildPacketInPlace()` while other packet is
+			 *   in progress.
+			 * - The caller MUST NOT free the obtained packet pointer since it's now
+			 *   part of the compound packet.
+			 * - The caller MUST free the obtained packet only in case the
+			 *   `Consolidate()` method on the packet throws.
+			 * - Method implemented in header file due to C++ template usage.
+			 *
+			 * @example
+			 * ```c++
+			 * auto* fooPacket = compoundPacket->BuildPacketInPlace<FooPacket>();
+			 * ```
+			 */
+			template<typename T>
+			T* BuildPacketInPlace()
+			{
+				AssertDoesNotNeedConsolidation();
+
+				// The new packet will be added after other packet in the compound
+				// packet, this is, at the end of the compound packet.
+				const auto* ptr = const_cast<uint8_t*>(GetBuffer()) + GetLength();
+				// The remaining length in the buffer is the potential buffer length
+				// of the packet.
+				const size_t packetMaxBufferLength = GetBufferLength() - (ptr - GetBuffer());
+
+				auto* packet = T::Factory(ptr, packetMaxBufferLength);
+
+				// NOTE: Do not fix/update the packet buffer length since the caller
+				// probably wants to modify the packet.
+
+				HandleInPlacePacket(packet);
+
+				return packet;
+			}
+
+			/**
+			 * Whether `BuildPacketInPlace()` was called and the caller didn't invoke
+			 * `Consolidate()` on the returned packet yet.
+			 */
+			bool NeedsConsolidation() const
+			{
+				return this->needsConsolidation;
+			}
+
+		private:
+			virtual void HandleInPlacePacket(Packet* packet) final;
+
+			virtual void AssertDoesNotNeedConsolidation() const final;
+
+		private:
+			// Packets.
+			std::vector<Packet*> packets;
+			// Whether `BuildPacketInPlace()` was called and the caller didn't invoke
+			// `Consolidate()` on the returned packet yet.
+			bool needsConsolidation{ false };
+		};
+	} // namespace NEW_RTCP
+} // namespace RTC
+
+#endif