mediasoup 3.15.7 → 3.15.8

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mediasoup",
-	"version": "3.15.7",
+	"version": "3.15.8",
 	"description": "Cutting Edge WebRTC Video Conferencing",
 	"contributors": [
 		"Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -90,7 +90,7 @@
 	},
 	"dependencies": {
 		"@types/ini": "^4.1.1",
-		"debug": "^4.4.0",
+		"debug": "^4.4.1",
 		"flatbuffers": "^25.2.10",
 		"h264-profile-level-id": "^2.2.0",
 		"ini": "^5.0.0",
@@ -99,24 +99,24 @@
 		"tar": "^7.4.3"
 	},
 	"devDependencies": {
-		"@eslint/js": "^9.23.0",
+		"@eslint/js": "^9.26.0",
 		"@octokit/rest": "^21.1.1",
 		"@types/debug": "^4.1.12",
 		"@types/jest": "^29.5.14",
-		"@types/node": "^22.13.13",
-		"eslint": "^9.23.0",
-		"eslint-config-prettier": "^10.1.1",
+		"@types/node": "^22.15.18",
+		"eslint": "^9.26.0",
+		"eslint-config-prettier": "^10.1.5",
 		"eslint-plugin-jest": "^28.11.0",
-		"eslint-plugin-prettier": "^5.2.4",
-		"globals": "^16.0.0",
+		"eslint-plugin-prettier": "^5.4.0",
+		"globals": "^16.1.0",
 		"jest": "^29.7.0",
-		"marked": "^15.0.7",
+		"marked": "^15.0.11",
 		"open-cli": "^8.0.0",
 		"pick-port": "^2.1.0",
 		"prettier": "^3.5.3",
 		"sctp": "^1.0.0",
-		"ts-jest": "^29.3.0",
-		"typescript": "^5.8.2",
-		"typescript-eslint": "^8.28.0"
+		"ts-jest": "^29.3.3",
+		"typescript": "^5.8.3",
+		"typescript-eslint": "^8.32.1"
 	}
 }

package/worker/fuzzer/include/RTC/SCTP/association/FuzzerStateCookie.hpp

@@ -0,0 +1,20 @@
+#ifndef MS_FUZZER_RTC_SCTP_STATE_COOKIE_HPP
+#define MS_FUZZER_RTC_SCTP_STATE_COOKIE_HPP
+
+#include "common.hpp"
+
+namespace Fuzzer
+{
+	namespace RTC
+	{
+		namespace SCTP
+		{
+			namespace StateCookie
+			{
+				void Fuzz(const uint8_t* data, size_t len);
+			}
+		} // namespace SCTP
+	}   // namespace RTC
+} // namespace Fuzzer
+
+#endif

package/worker/fuzzer/include/RTC/SCTP/packet/FuzzerPacket.hpp

@@ -0,0 +1,20 @@
+#ifndef MS_FUZZER_RTC_SCTP_PACKET_HPP
+#define MS_FUZZER_RTC_SCTP_PACKET_HPP
+
+#include "common.hpp"
+
+namespace Fuzzer
+{
+	namespace RTC
+	{
+		namespace SCTP
+		{
+			namespace Packet
+			{
+				void Fuzz(const uint8_t* data, size_t len);
+			}
+		} // namespace SCTP
+	}   // namespace RTC
+} // namespace Fuzzer
+
+#endif

package/worker/fuzzer/src/FuzzerUtils.cpp

@@ -45,8 +45,11 @@ void Fuzzer::Utils::Fuzz(const uint8_t* data, size_t len)
 	::Utils::Byte::Set3Bytes(data2, len, uint32_t{ 666u });
 	::Utils::Byte::Set4Bytes(data2, len, uint32_t{ 666u });
 	::Utils::Byte::Set8Bytes(data2, 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));
+	::Utils::Byte::PadTo4Bytes(static_cast<uint64_t>(len));
+	::Utils::Byte::PadTo4Bytes(len);
 
 	/* Bits class. */
 

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

@@ -0,0 +1,73 @@
+#include "RTC/SCTP/association/FuzzerStateCookie.hpp"
+#include "Utils.hpp"
+#include "RTC/SCTP/association/StateCookie.hpp"
+#include <cstdlib> // std::malloc(), std::free()
+#include <cstring> // std::memcpy()
+
+thread_local static uint8_t StateCookieSerializeBuffer[65536];
+thread_local static uint8_t StateCookieCloneBuffer[65536];
+
+void Fuzzer::RTC::SCTP::StateCookie::Fuzz(const uint8_t* data, size_t len)
+{
+	auto* clonedData = static_cast<uint8_t*>(std::malloc(len));
+
+	std::memcpy(clonedData, data, len);
+
+	// We need to force `data` to be a StateCookie since it's too hard that random
+	// data matches it.
+	if (len > ::RTC::SCTP::StateCookie::StateCookieLength)
+	{
+		len = ::Utils::Crypto::GetRandomUInt(
+		  ::RTC::SCTP::StateCookie::StateCookieLength, ::RTC::SCTP::StateCookie::StateCookieLength + 10);
+
+		if (len < ::RTC::SCTP::StateCookie::StateCookieLength + 5)
+		{
+			::Utils::Byte::Set4Bytes(clonedData, 0, ::RTC::SCTP::StateCookie::MagicValue1);
+			::Utils::Byte::Set2Bytes(clonedData, 34, ::RTC::SCTP::StateCookie::MagicValue2);
+		}
+	}
+
+	::RTC::SCTP::StateCookie* stateCookie = ::RTC::SCTP::StateCookie::Parse(clonedData, len);
+
+	if (!stateCookie)
+	{
+		std::free(clonedData);
+
+		return;
+	}
+
+	stateCookie->GetMyVerificationTag();
+	stateCookie->GetPeerVerificationTag();
+	stateCookie->GetMyInitialTsn();
+	stateCookie->GetPeerInitialTsn();
+	stateCookie->GetMyAdvertisedReceiverWindowCredit();
+	stateCookie->GetTieTag();
+	stateCookie->GetNegotiatedCapabilities();
+
+	stateCookie->Serialize(StateCookieSerializeBuffer, len);
+
+	stateCookie->GetMyVerificationTag();
+	stateCookie->GetPeerVerificationTag();
+	stateCookie->GetMyInitialTsn();
+	stateCookie->GetPeerInitialTsn();
+	stateCookie->GetMyAdvertisedReceiverWindowCredit();
+	stateCookie->GetTieTag();
+	stateCookie->GetNegotiatedCapabilities();
+
+	auto* clonedStateCookie = stateCookie->Clone(StateCookieCloneBuffer, len);
+
+	delete stateCookie;
+
+	clonedStateCookie->GetMyVerificationTag();
+	clonedStateCookie->GetPeerVerificationTag();
+	clonedStateCookie->GetMyInitialTsn();
+	clonedStateCookie->GetPeerInitialTsn();
+	clonedStateCookie->GetMyAdvertisedReceiverWindowCredit();
+	clonedStateCookie->GetTieTag();
+	clonedStateCookie->GetNegotiatedCapabilities();
+
+	clonedStateCookie->Serialize(StateCookieSerializeBuffer, len);
+
+	std::free(clonedData);
+	delete clonedStateCookie;
+}

package/worker/fuzzer/src/RTC/SCTP/packet/FuzzerPacket.cpp

@@ -0,0 +1,73 @@
+#include "RTC/SCTP/packet/FuzzerPacket.hpp"
+#include "RTC/SCTP/packet/Packet.hpp"
+
+thread_local static uint8_t PacketSerializeBuffer[65536];
+thread_local static uint8_t PacketCloneBuffer[65536];
+
+void Fuzzer::RTC::SCTP::Packet::Fuzz(const uint8_t* data, size_t len)
+{
+	::RTC::SCTP::Packet* packet = ::RTC::SCTP::Packet::Parse(data, len);
+
+	if (!packet)
+	{
+		return;
+	}
+
+	packet->GetSourcePort();
+	packet->GetDestinationPort();
+	packet->GetVerificationTag();
+	packet->GetChecksum();
+	packet->ValidateCRC32cChecksum();
+	packet->HasChunks();
+	packet->GetChunksCount();
+	packet->GetChunkAt(0);
+	packet->GetChunkAt(1);
+	packet->GetChunkAt(2);
+	packet->GetChunkAt(666);
+
+	packet->Serialize(PacketSerializeBuffer, len);
+
+	packet->GetSourcePort();
+	packet->SetSourcePort(12345);
+	packet->GetDestinationPort();
+	packet->SetDestinationPort(54321);
+	packet->GetVerificationTag();
+	packet->SetVerificationTag(12345678);
+	packet->GetChecksum();
+	packet->ValidateCRC32cChecksum();
+	packet->SetChecksum(999999);
+	packet->SetCRC32cChecksum();
+	packet->ValidateCRC32cChecksum();
+	packet->HasChunks();
+	packet->GetChunksCount();
+	packet->GetChunkAt(0);
+	packet->GetChunkAt(1);
+	packet->GetChunkAt(2);
+	packet->GetChunkAt(666);
+
+	auto* clonedPacket = packet->Clone(PacketCloneBuffer, len);
+
+	delete packet;
+
+	clonedPacket->GetSourcePort();
+	clonedPacket->SetSourcePort(12345);
+	clonedPacket->GetDestinationPort();
+	clonedPacket->SetDestinationPort(54321);
+	clonedPacket->GetVerificationTag();
+	clonedPacket->SetVerificationTag(12345678);
+	clonedPacket->GetChecksum();
+	clonedPacket->ValidateCRC32cChecksum();
+	clonedPacket->SetChecksum(999999);
+	clonedPacket->SetCRC32cChecksum();
+	clonedPacket->ValidateCRC32cChecksum();
+	clonedPacket->HasChunks();
+	clonedPacket->GetChunksCount();
+	clonedPacket->GetChunkAt(0);
+	clonedPacket->GetChunkAt(1);
+	clonedPacket->GetChunkAt(2);
+	clonedPacket->GetChunkAt(666);
+
+	clonedPacket->Serialize(PacketSerializeBuffer, len);
+
+	delete clonedPacket;
+}

package/worker/fuzzer/src/fuzzer.cpp

@@ -6,7 +6,6 @@
 #include "DepOpenSSL.hpp"
 #include "DepUsrSCTP.hpp"
 #include "FuzzerUtils.hpp"
-#include "LogLevel.hpp"
 #include "Settings.hpp"
 #include "Utils.hpp"
 #include "RTC/Codecs/FuzzerH264.hpp"
@@ -24,13 +23,19 @@
 #include "RTC/FuzzerStunPacket.hpp"
 #include "RTC/FuzzerTrendCalculator.hpp"
 #include "RTC/RTCP/FuzzerPacket.hpp"
+#include "RTC/SCTP/association/FuzzerStateCookie.hpp"
+#include "RTC/SCTP/packet/FuzzerPacket.hpp"
 #include <cstdlib> // std::getenv()
 #include <iostream>
+#include <sstream> // std::istringstream()
 #include <stddef.h>
 #include <stdint.h>
+#include <string>
+#include <vector>
 
 bool fuzzStun   = false;
 bool fuzzDtls   = false;
+bool fuzzSctp   = false;
 bool fuzzRtp    = false;
 bool fuzzRtcp   = false;
 bool fuzzCodecs = false;
@@ -58,6 +63,12 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t len)
 		Fuzzer::RTC::DtlsTransport::Fuzz(data, len);
 	}
 
+	if (fuzzSctp)
+	{
+		Fuzzer::RTC::SCTP::Packet::Fuzz(data, len);
+		Fuzzer::RTC::SCTP::StateCookie::Fuzz(data, len);
+	}
+
 	if (fuzzRtp)
 	{
 		Fuzzer::RTC::RtpPacket::Fuzz(data, len);
@@ -92,25 +103,35 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t len)
 
 int Init()
 {
-	LogLevel logLevel{ LogLevel::LOG_NONE };
+	std::string logLevel{ "none" };
+	std::vector<std::string> logTags = { "info" };
+
+	const auto* logLevelPtr = std::getenv("MS_FUZZ_LOG_LEVEL");
+	const auto* logTagsPtr  = std::getenv("MS_FUZZ_LOG_TAGS");
 
 	// Get logLevel from ENV variable.
-	if (std::getenv("MS_FUZZ_LOG_LEVEL"))
+	if (logLevelPtr)
 	{
-		if (std::string(std::getenv("MS_FUZZ_LOG_LEVEL")) == "debug")
-		{
-			logLevel = LogLevel::LOG_DEBUG;
-		}
-		else if (std::string(std::getenv("MS_FUZZ_LOG_LEVEL")) == "warn")
-		{
-			logLevel = LogLevel::LOG_WARN;
-		}
-		else if (std::string(std::getenv("MS_FUZZ_LOG_LEVEL")) == "error")
+		logLevel = std::string(logLevelPtr);
+	}
+
+	// Get logTags from ENV variable.
+	if (logTagsPtr)
+	{
+		auto logTagsStr = std::string(logTagsPtr);
+		std::istringstream iss(logTagsStr);
+		std::string logTag;
+
+		while (iss >> logTag)
 		{
-			logLevel = LogLevel::LOG_ERROR;
+			logTags.push_back(logTag);
 		}
 	}
 
+	Settings::SetLogLevel(logLevel);
+	Settings::SetLogTags(logTags);
+	Settings::PrintConfiguration();
+
 	// Select what to fuzz.
 
 	if (std::getenv("MS_FUZZ_STUN") && std::string(std::getenv("MS_FUZZ_STUN")) == "1")
@@ -119,50 +140,62 @@ int Init()
 
 		fuzzStun = true;
 	}
+
 	if (std::getenv("MS_FUZZ_DTLS") && std::string(std::getenv("MS_FUZZ_DTLS")) == "1")
 	{
 		std::cout << "[fuzzer] DTLS fuzzer enabled" << std::endl;
 
 		fuzzDtls = true;
 	}
+
+	if (std::getenv("MS_FUZZ_SCTP") && std::string(std::getenv("MS_FUZZ_SCTP")) == "1")
+	{
+		std::cout << "[fuzzer] SCTP fuzzer enabled" << std::endl;
+
+		fuzzSctp = true;
+	}
+
 	if (std::getenv("MS_FUZZ_RTP") && std::string(std::getenv("MS_FUZZ_RTP")) == "1")
 	{
 		std::cout << "[fuzzer] RTP fuzzer enabled" << std::endl;
 
 		fuzzRtp = true;
 	}
+
 	if (std::getenv("MS_FUZZ_RTCP") && std::string(std::getenv("MS_FUZZ_RTCP")) == "1")
 	{
 		std::cout << "[fuzzer] RTCP fuzzer enabled" << std::endl;
 
 		fuzzRtcp = true;
 	}
+
 	if (std::getenv("MS_FUZZ_CODECS") && std::string(std::getenv("MS_FUZZ_CODECS")) == "1")
 	{
 		std::cout << "[fuzzer] codecs fuzzer enabled" << std::endl;
 
 		fuzzCodecs = true;
 	}
+
 	if (std::getenv("MS_FUZZ_UTILS") && std::string(std::getenv("MS_FUZZ_UTILS")) == "1")
 	{
 		std::cout << "[fuzzer] Utils fuzzer enabled" << std::endl;
 
 		fuzzUtils = true;
 	}
-	if (!fuzzStun && !fuzzDtls && !fuzzRtp && !fuzzRtcp && !fuzzCodecs && !fuzzUtils)
+
+	if (!fuzzStun && !fuzzDtls && !fuzzSctp && !fuzzRtp && !fuzzRtcp && !fuzzCodecs && !fuzzUtils)
 	{
 		std::cout << "[fuzzer] all fuzzers enabled" << std::endl;
 
 		fuzzStun   = true;
 		fuzzDtls   = true;
+		fuzzSctp   = true;
 		fuzzRtp    = true;
 		fuzzRtcp   = true;
 		fuzzCodecs = true;
 		fuzzUtils  = true;
 	}
 
-	Settings::configuration.logLevel = logLevel;
-
 	// Initialize static stuff.
 	DepLibUV::ClassInit();
 	DepOpenSSL::ClassInit();

package/worker/include/Logger.hpp

@@ -11,7 +11,7 @@
  *
  * If the macro MS_LOG_STD is defined, all the macros log to stdout/stderr.
  *
- * If the macro MS_LOG_FILE_LINE is defied, all the logging macros print more
+ * If the macro MS_LOG_FILE_LINE is defined, all the logging macros print more
  * verbose information, including current file and line.
  *
  * MS_TRACE()
@@ -64,9 +64,17 @@
  * 	 Example:
  * 	   MS_DUMP("foo");
  *
+ * MS_DUMP_CLEAN(indentation, ...)
+ *
+ *   Log always. Useful for Dump() methods in packets. It doesn't print the
+ *   class and method names.
+ *   `indentation` mandatory argument must be 0, 1, 2 or 3, and it affects the
+ *   output by adding indentation at the start of the string.
+ *
  * MS_DUMP_DATA(const uint8_t* data, size_t len)
  *
- *   Logs always. Prints the given data in hexadecimal format (Wireshark friendly).
+ *   Logs always. Prints the given data in hexadecimal format (Wireshark
+ *   friendly).
  *
  * MS_ERROR(...)
  *
@@ -350,15 +358,37 @@ public:
 	} \
 	while (false)
 
+#define MS_DUMP_CLEAN(indentation, desc, ...) \
+	do \
+	{ \
+		const char* spaces = (indentation == 1) ? "  " : \
+			((indentation == 2) ? "    " : \
+			((indentation == 3) ? "      " : "")); \
+		const int loggerWritten = std::snprintf(Logger::buffer, Logger::BufferSize, "X%s" desc, spaces, ##__VA_ARGS__); \
+		Logger::channel->SendLog(Logger::buffer, static_cast<uint32_t>(loggerWritten)); \
+	} \
+	while (false)
+
+#define MS_DUMP_CLEAN_STD(indentation, desc, ...) \
+	do \
+	{ \
+		const char* spaces = (indentation == 1) ? "  " : \
+			((indentation == 2) ? "    " : \
+			((indentation == 3) ? "      " : "")); \
+		std::fprintf(stdout, "%s" desc _MS_LOG_SEPARATOR_CHAR_STD, spaces, ##__VA_ARGS__); \
+		std::fflush(stdout); \
+	} \
+	while (false)
+
 #define MS_DUMP_DATA(data, len) \
 	do \
 	{ \
-		const int loggerWritten = std::snprintf(Logger::buffer, Logger::BufferSize, "X(data) " _MS_LOG_STR, _MS_LOG_ARG); \
+		const int loggerWritten = std::snprintf(Logger::buffer, Logger::BufferSize, "X" _MS_LOG_STR, _MS_LOG_ARG); \
 		Logger::channel->SendLog(Logger::buffer, static_cast<uint32_t>(loggerWritten)); \
 		size_t bufferDataLen{ 0 }; \
 		for (size_t i{0}; i < len; ++i) \
 		{ \
-		  if (i % 8 == 0) \
+		  if (i % 4 == 0) \
 		  { \
 		  	if (bufferDataLen != 0) \
 		  	{ \
@@ -381,11 +411,11 @@ public:
 #define MS_DUMP_DATA_STD(data, len) \
 	do \
 	{ \
-		std::fprintf(stdout, "(data) " _MS_LOG_STR _MS_LOG_SEPARATOR_CHAR_STD, _MS_LOG_ARG); \
+		std::fprintf(stdout, _MS_LOG_STR _MS_LOG_SEPARATOR_CHAR_STD, _MS_LOG_ARG); \
 		size_t bufferDataLen{ 0 }; \
 		for (size_t i{0}; i < len; ++i) \
 		{ \
-		  if (i % 8 == 0) \
+		  if (i % 4 == 0) \
 		  { \
 		  	if (bufferDataLen != 0) \
 		  	{ \
@@ -462,6 +492,8 @@ public:
 	#define MS_WARN_DEV MS_WARN_DEV_STD
 	#undef MS_DUMP
 	#define MS_DUMP MS_DUMP_STD
+	#undef MS_DUMP_CLEAN
+	#define MS_DUMP_CLEAN MS_DUMP_CLEAN_STD
 	#undef MS_DUMP_DATA
 	#define MS_DUMP_DATA MS_DUMP_DATA_STD
 	#undef MS_ERROR

package/worker/include/RTC/Codecs/H264.hpp

@@ -15,7 +15,7 @@ namespace RTC
 			struct PayloadDescriptor : public RTC::Codecs::PayloadDescriptor
 			{
 				/* Pure virtual methods inherited from RTC::Codecs::PayloadDescriptor. */
-				~PayloadDescriptor() = default;
+				~PayloadDescriptor() override = default;
 
 				void Dump() const override;
 
@@ -66,7 +66,7 @@ namespace RTC
 			{
 			public:
 				explicit PayloadDescriptorHandler(PayloadDescriptor* payloadDescriptor);
-				~PayloadDescriptorHandler() = default;
+				~PayloadDescriptorHandler() override = default;
 
 			public:
 				void Dump() const override
@@ -74,7 +74,16 @@ namespace RTC
 					this->payloadDescriptor->Dump();
 				}
 				bool Process(RTC::Codecs::EncodingContext* encodingContext, uint8_t* data, bool& marker) override;
-				void Restore(uint8_t* data) override;
+				std::unique_ptr<RTC::Codecs::PayloadDescriptor::Encoder> GetEncoder() const override
+				{
+					return nullptr;
+				}
+				void Encode(uint8_t* data, Codecs::PayloadDescriptor::Encoder* encoder) override
+				{
+				}
+				void Restore(uint8_t* data) override
+				{
+				}
 				uint8_t GetSpatialLayer() const override
 				{
 					return 0u;

package/worker/include/RTC/Codecs/H264_SVC.hpp

@@ -15,7 +15,7 @@ namespace RTC
 		public:
 			struct PayloadDescriptor : public RTC::Codecs::PayloadDescriptor
 			{
-				~PayloadDescriptor() = default;
+				~PayloadDescriptor() override = default;
 
 				void Dump() const override;
 
@@ -80,7 +80,7 @@ namespace RTC
 			{
 			public:
 				explicit PayloadDescriptorHandler(PayloadDescriptor* payloadDescriptor);
-				~PayloadDescriptorHandler() = default;
+				~PayloadDescriptorHandler() override = default;
 
 			public:
 				void Dump() const override
@@ -88,7 +88,16 @@ namespace RTC
 					this->payloadDescriptor->Dump();
 				}
 				bool Process(RTC::Codecs::EncodingContext* encodingContext, uint8_t* data, bool& marker) override;
-				void Restore(uint8_t* data) override;
+				std::unique_ptr<RTC::Codecs::PayloadDescriptor::Encoder> GetEncoder() const override
+				{
+					return nullptr;
+				}
+				void Encode(uint8_t* data, Codecs::PayloadDescriptor::Encoder* encoder) override
+				{
+				}
+				void Restore(uint8_t* data) override
+				{
+				}
 				uint8_t GetSpatialLayer() const override
 				{
 					// return 0u;

package/worker/include/RTC/Codecs/Opus.hpp

@@ -16,7 +16,7 @@ namespace RTC
 			struct PayloadDescriptor : public RTC::Codecs::PayloadDescriptor
 			{
 				/* Pure virtual methods inherited from RTC::Codecs::PayloadDescriptor. */
-				~PayloadDescriptor() = default;
+				~PayloadDescriptor() override = default;
 
 				void Dump() const override;
 
@@ -57,7 +57,7 @@ namespace RTC
 			{
 			public:
 				explicit PayloadDescriptorHandler(PayloadDescriptor* payloadDescriptor);
-				~PayloadDescriptorHandler() = default;
+				~PayloadDescriptorHandler() override = default;
 
 			public:
 				void Dump() const override
@@ -65,10 +65,16 @@ namespace RTC
 					this->payloadDescriptor->Dump();
 				}
 				bool Process(RTC::Codecs::EncodingContext* encodingContext, uint8_t* data, bool& marker) override;
+				std::unique_ptr<RTC::Codecs::PayloadDescriptor::Encoder> GetEncoder() const override
+				{
+					return nullptr;
+				}
+				void Encode(uint8_t* data, Codecs::PayloadDescriptor::Encoder* encoder) override
+				{
+				}
 				void Restore(uint8_t* data) override
 				{
-					return;
-				};
+				}
 				uint8_t GetSpatialLayer() const override
 				{
 					return 0u;

package/worker/include/RTC/Codecs/PayloadDescriptorHandler.hpp

@@ -12,6 +12,11 @@ namespace RTC
 		// Codec payload descriptor.
 		struct PayloadDescriptor
 		{
+			struct Encoder
+			{
+				virtual ~Encoder() = default;
+			};
+
 			virtual ~PayloadDescriptor() = default;
 			virtual void Dump() const    = 0;
 		};
@@ -214,6 +219,8 @@ namespace RTC
 		public:
 			virtual void Dump() const                                                                = 0;
 			virtual bool Process(RTC::Codecs::EncodingContext* context, uint8_t* data, bool& marker) = 0;
+			virtual std::unique_ptr<PayloadDescriptor::Encoder> GetEncoder() const                   = 0;
+			virtual void Encode(uint8_t* data, PayloadDescriptor::Encoder* encoder)                  = 0;
 			virtual void Restore(uint8_t* data)                                                      = 0;
 			virtual uint8_t GetSpatialLayer() const                                                  = 0;
 			virtual uint8_t GetTemporalLayer() const                                                 = 0;