mediasoup 3.21.0 → 3.21.2

package/worker/include/RTC/SCTP/packet/Chunk.hpp

@@ -43,7 +43,7 @@ namespace RTC
 
 		class Chunk : public TLV
 		{
-			// We need that packet calls protected and private methods in this class.
+			// We need that Packet calls protected and private methods in this class.
 			friend class Packet;
 
 		public:
@@ -148,6 +148,9 @@ namespace RTC
 			static constexpr size_t ChunkHeaderLength{ 4 };
 
 		public:
+			static const std::string& ChunkTypeToString(ChunkType chunkType);
+
+		protected:
 			/**
 			 * Whether given buffer could be a a valid chunk.
 			 *
@@ -168,8 +171,6 @@ namespace RTC
 			  uint16_t& chunkLength,
 			  uint8_t& padding);
 
-			static const std::string& ChunkTypeToString(ChunkType chunkType);
-
 		private:
 			static const ankerl::unordered_dense::map<ChunkType, std::string> ChunkType2String;
 
@@ -183,12 +184,15 @@ namespace RTC
 		public:
 			~Chunk() override;
 
+			/**
+			 * Must be overridden by each subclass.
+			 */
 			void Dump(int indentation = 0) const override = 0;
 
 			void Serialize(uint8_t* buffer, size_t bufferLength) final;
 
 			/**
-			 * Can be overridden by each subclass.
+			 * Must be overridden by each subclass.
 			 */
 			Chunk* Clone(uint8_t* buffer, size_t bufferLength) const override = 0;
 
@@ -323,7 +327,7 @@ namespace RTC
 				auto* ptr = const_cast<uint8_t*>(GetBuffer()) + GetLength();
 				// The remaining length in the buffer is the potential buffer length
 				// of the parameter.
-				size_t parameterMaxBufferLength = GetBufferLength() - (ptr - GetBuffer());
+				const size_t parameterMaxBufferLength = GetBufferLength() - (ptr - GetBuffer());
 
 				auto* parameter = T::Factory(ptr, parameterMaxBufferLength);
 
@@ -444,7 +448,7 @@ namespace RTC
 				auto* ptr = const_cast<uint8_t*>(GetBuffer()) + GetLength();
 				// The remaining length in the buffer is the potential buffer length
 				// of the error cause.
-				size_t errorCauseMaxBufferLength = GetBufferLength() - (ptr - GetBuffer());
+				const size_t errorCauseMaxBufferLength = GetBufferLength() - (ptr - GetBuffer());
 
 				auto* errorCause = T::Factory(ptr, errorCauseMaxBufferLength);
 
@@ -491,7 +495,7 @@ namespace RTC
 
 			virtual void SoftCloneInto(Chunk* chunk) const final;
 
-			virtual void InitializeHeader(ChunkType chunkType, uint8_t flags, uint16_t lengthFieldValue) final;
+			virtual void InitializeHeader(ChunkType chunkType, uint8_t flags, uint16_t length) final;
 
 			virtual bool GetBit0() const final
 			{

package/worker/include/RTC/SCTP/packet/ErrorCause.hpp

@@ -39,7 +39,7 @@ namespace RTC
 
 		class ErrorCause : public TLV
 		{
-			// We need that chunk calls protected and private methods in this class.
+			// We need that Chunk calls protected and private methods in this class.
 			friend class Chunk;
 
 		public:
@@ -88,6 +88,9 @@ namespace RTC
 			static constexpr size_t ErrorCauseHeaderLength{ 4 };
 
 		public:
+			static const std::string& ErrorCauseCodeToString(ErrorCauseCode causeCode);
+
+		protected:
 			/**
 			 * Whether given buffer could be a a valid error cause.
 			 *
@@ -108,8 +111,6 @@ namespace RTC
 			  uint16_t& causeLength,
 			  uint8_t& padding);
 
-			static const std::string& ErrorCauseCodeToString(ErrorCauseCode causeCode);
-
 		private:
 			static const ankerl::unordered_dense::map<ErrorCauseCode, std::string> ErrorCauseCode2String;
 
@@ -123,8 +124,14 @@ namespace RTC
 		public:
 			~ErrorCause() override;
 
+			/**
+			 * Must be overridden by each subclass.
+			 */
 			void Dump(int indentation = 0) const override = 0;
 
+			/**
+			 * Must be overridden by each subclass.
+			 */
 			ErrorCause* Clone(uint8_t* buffer, size_t bufferLength) const override = 0;
 
 			virtual ErrorCauseCode GetCode() const final
@@ -170,7 +177,7 @@ namespace RTC
 
 			virtual void SoftCloneInto(ErrorCause* errorCause) const final;
 
-			virtual void InitializeHeader(ErrorCauseCode errorCauseCode, uint16_t lengthFieldValue) final;
+			virtual void InitializeHeader(ErrorCauseCode errorCauseCode, uint16_t length) final;
 
 			/**
 			 * Error Cause subclasses with header bigger than default one (4 bytes)

package/worker/include/RTC/SCTP/packet/Packet.hpp

@@ -239,7 +239,7 @@ namespace RTC
 				auto* ptr = const_cast<uint8_t*>(GetBuffer()) + GetLength();
 				// The remaining length in the buffer is the potential buffer length
 				// of the chunk.
-				size_t chunkMaxBufferLength = GetBufferLength() - (ptr - GetBuffer());
+				const size_t chunkMaxBufferLength = GetBufferLength() - (ptr - GetBuffer());
 
 				auto* chunk = T::Factory(ptr, chunkMaxBufferLength);
 

package/worker/include/RTC/SCTP/packet/Parameter.hpp

@@ -40,7 +40,7 @@ namespace RTC
 
 		class Parameter : public TLV
 		{
-			// We need that chunk calls protected and private methods in this class.
+			// We need that Chunk calls protected and private methods in this class.
 			friend class Chunk;
 
 		public:
@@ -102,6 +102,9 @@ namespace RTC
 			static constexpr size_t ParameterHeaderLength{ 4 };
 
 		public:
+			static const std::string& ParameterTypeToString(ParameterType parameterType);
+
+		protected:
 			/**
 			 * Whether given buffer could be a a valid parameter.
 			 *
@@ -123,8 +126,6 @@ namespace RTC
 			  uint16_t& parameterLength,
 			  uint8_t& padding);
 
-			static const std::string& ParameterTypeToString(ParameterType parameterType);
-
 		private:
 			static const ankerl::unordered_dense::map<ParameterType, std::string> ParameterType2String;
 
@@ -138,8 +139,14 @@ namespace RTC
 		public:
 			~Parameter() override;
 
+			/**
+			 * Must be overridden by each subclass.
+			 */
 			void Dump(int indentation = 0) const override = 0;
 
+			/**
+			 * Must be overridden by each subclass.
+			 */
 			Parameter* Clone(uint8_t* buffer, size_t bufferLength) const override = 0;
 
 			virtual ParameterType GetType() const final
@@ -173,7 +180,7 @@ namespace RTC
 
 			virtual void SoftCloneInto(Parameter* parameter) const final;
 
-			virtual void InitializeHeader(ParameterType parameterType, uint16_t lengthFieldValue) final;
+			virtual void InitializeHeader(ParameterType parameterType, uint16_t length) final;
 
 			/**
 			 * Parameter subclasses with header bigger than default one (4 bytes)

package/worker/include/RTC/SCTP/packet/TLV.hpp

@@ -54,7 +54,7 @@ namespace RTC
 			 */
 			virtual void DumpCommon(int indentation) const;
 
-			virtual void InitializeTLVHeader(uint16_t lengthFieldValue) final;
+			virtual void InitializeTLVHeader(uint16_t length) final;
 
 			/**
 			 * Subclasses with header bigger than default one (4 bytes) must override
@@ -163,7 +163,7 @@ namespace RTC
 			 * @throw MediaSoupTypeError - If given `length` is higher than maximum
 			 *   allowed one (65535).
 			 */
-			virtual void SetLengthField(size_t lengthField) final;
+			virtual void SetLengthField(size_t length) final;
 		};
 	} // namespace SCTP
 } // namespace RTC

package/worker/include/RTC/SCTP/packet/parameters/StateCookieParameter.hpp

@@ -2,7 +2,7 @@
 #define MS_RTC_SCTP_STATE_COOKIE_PARAMETER_HPP
 
 #include "common.hpp"
-#include "RTC/SCTP/association/NegotiatedCapabilities.hpp"
+#include "RTC/SCTP/association/Capabilities.hpp"
 #include "RTC/SCTP/packet/Parameter.hpp"
 
 namespace RTC
@@ -104,7 +104,7 @@ namespace RTC
 			  uint32_t remoteInitialTsn,
 			  uint32_t remoteAdvertisedReceiverWindowCredit,
 			  uint64_t tieTag,
-			  const NegotiatedCapabilities& negotiatedCapabilities,
+			  const Capabilities& remoteCapabilities,
 			  uint64_t creationTimestampMs = 0,
 			  const uint8_t* macKey        = nullptr,
 			  size_t macKeyLength          = 0);

package/worker/include/RTC/Transport.hpp

@@ -201,23 +201,23 @@ namespace RTC
 
 	private:
 		virtual RTC::Producer* AssertAndGetProducerById(
-		  const std::string& producerId, const std::string& message) const final;
+		  const std::string& producerId, const std::string& method) const final;
 		virtual RTC::Consumer* AssertAndGetConsumerById(
-		  const std::string& consumerId, const std::string& message) const final;
+		  const std::string& consumerId, const std::string& method) const final;
 		virtual RTC::Consumer* GetConsumerByMediaSsrc(uint32_t ssrc) const final;
 		virtual RTC::Consumer* GetConsumerByRtxSsrc(uint32_t ssrc) const final;
 		virtual RTC::DataProducer* AssertAndGetDataProducerById(
-		  const std::string& dataProducerId, const std::string& message) const final;
+		  const std::string& dataProducerId, const std::string& method) const final;
 		virtual RTC::DataConsumer* AssertAndGetDataConsumerById(
-		  const std::string& dataConsumerId, const std::string& message) const final;
-		virtual RTC::DataConsumer* AssertAndGetSctpDataConsumerByStreamId(uint16_t streamId) const final;
-		virtual void CheckNoProducer(const std::string& producerId, const std::string& message) const final;
-		virtual void CheckNoConsumer(const std::string& consumerId, const std::string& message) const final;
+		  const std::string& dataConsumerId, const std::string& method) const final;
+		virtual RTC::DataConsumer* GetSctpDataConsumerByStreamId(uint16_t streamId) const final;
+		virtual void CheckNoProducer(const std::string& producerId, const std::string& method) const final;
+		virtual void CheckNoConsumer(const std::string& consumerId, const std::string& method) const final;
 		virtual void CheckNoDataProducer(
-		  const std::string& dataProducerId, const std::string& message) const final;
+		  const std::string& dataProducerId, const std::string& method) const final;
 		virtual void CheckNoDataConsumer(
-		  const std::string& dataConsumerId, const std::string& message) const final;
-		virtual void CheckNoSctpDataConsumer(uint16_t streamId, const std::string& message) const final;
+		  const std::string& dataConsumerId, const std::string& method) const final;
+		virtual void CheckNoSctpDataConsumer(uint16_t streamId, const std::string& method) const final;
 		virtual bool IsConnected() const = 0;
 		virtual void SendRtpPacket(
 		  RTC::Consumer* consumer, RTC::RTP::Packet* packet, const onSendCallback* cb = nullptr) = 0;

package/worker/include/Worker.hpp

@@ -27,10 +27,10 @@ private:
 	  flatbuffers::FlatBufferBuilder& builder) const;
 	void SetNewRouterId(std::string& routerId) const;
 	RTC::WebRtcServer* AssertAndGetWebRtcServerById(
-	  const std::string& webRtcServerId, const std::string& message) const;
-	RTC::Router* AssertAndGetRouterById(const std::string& routerId, const std::string& message) const;
-	void CheckNoWebRtcServer(const std::string& webRtcServerId, const std::string& message) const;
-	void CheckNoRouter(const std::string& routerId, const std::string& message) const;
+	  const std::string& webRtcServerId, const std::string& method) const;
+	RTC::Router* AssertAndGetRouterById(const std::string& routerId, const std::string& method) const;
+	void CheckNoWebRtcServer(const std::string& webRtcServerId, const std::string& method) const;
+	void CheckNoRouter(const std::string& routerId, const std::string& method) const;
 
 	/* Methods inherited from Channel::ChannelSocket::RequestHandler. */
 public:

package/worker/meson.build

@@ -202,8 +202,12 @@ common_sources = [
   'src/RTC/RTCP/XR.cpp',
   'src/RTC/RTCP/XrDelaySinceLastRr.cpp',
   'src/RTC/RTCP/XrReceiverReferenceTime.cpp',
+  'src/RTC/NEW_RTCP/packet/CompoundPacket.cpp',
+  'src/RTC/NEW_RTCP/packet/Packet.cpp',
+  'src/RTC/NEW_RTCP/packet/ByePacket.cpp',
   'src/RTC/SCTP/association/Association.cpp',
   'src/RTC/SCTP/association/AssociationListenerDeferrer.cpp',
+  'src/RTC/SCTP/association/Capabilities.cpp',
   'src/RTC/SCTP/association/HeartbeatHandler.cpp',
   'src/RTC/SCTP/association/NegotiatedCapabilities.cpp',
   'src/RTC/SCTP/association/PacketSender.cpp',
@@ -463,8 +467,11 @@ test_sources = [
   'test/src/RTC/RTCP/TestSenderReport.cpp',
   'test/src/RTC/RTCP/TestPacket.cpp',
   'test/src/RTC/RTCP/TestXr.cpp',
+  'test/src/RTC/NEW_RTCP/rtcpCommon.cpp',
+  'test/src/RTC/NEW_RTCP/packet/TestByePacket.cpp',
   'test/src/RTC/SCTP/sctpCommon.cpp',
   'test/src/RTC/SCTP/association/TestAssociation.cpp',
+  'test/src/RTC/SCTP/association/TestCapabilities.cpp',
   'test/src/RTC/SCTP/association/TestHeartbeatHandler.cpp',
   'test/src/RTC/SCTP/association/TestNegotiatedCapabilities.cpp',
   'test/src/RTC/SCTP/association/TestPacketSender.cpp',

package/worker/scripts/clang-scripts.mjs

@@ -170,6 +170,27 @@ function normalizeCompileCommands() {
 				// Convert to relative path from repo root.
 				entry.file = path.relative(ROOT_DIR, absolutePath);
 			}
+
+			// Make include search paths absolute. Meson emits them relative to the
+			// build directory, which makes clang-tidy report note locations (such as
+			// those coming from Catch2 macro expansions) with relative paths that
+			// ZedThree/clang-tidy-review fails to open (it resolves them against its
+			// own working directory). Absolutizing them avoids that.
+			if (entry.directory) {
+				if (typeof entry.command === 'string') {
+					entry.command = normalizeIncludePaths(
+						entry.command.split(/\s+/),
+						entry.directory
+					).join(' ');
+				}
+
+				if (Array.isArray(entry.arguments)) {
+					entry.arguments = normalizeIncludePaths(
+						entry.arguments,
+						entry.directory
+					);
+				}
+			}
 		}
 
 		fs.writeFileSync(compileCommandsFile, JSON.stringify(commands, null, 2));
@@ -182,6 +203,39 @@ function normalizeCompileCommands() {
 	}
 }
 
+function normalizeIncludePaths(tokens, directory) {
+	const includeFlags = ['-I', '-isystem', '-iquote', '-idirafter'];
+	const result = [];
+
+	for (let i = 0; i < tokens.length; ++i) {
+		const token = tokens[i];
+
+		// Attached form, e.g. `-I../../../subprojects/foo`.
+		const attachedFlag = includeFlags.find(
+			flag => token.startsWith(flag) && token.length > flag.length
+		);
+
+		if (attachedFlag) {
+			const includePath = token.slice(attachedFlag.length);
+
+			result.push(`${attachedFlag}${path.resolve(directory, includePath)}`);
+
+			continue;
+		}
+
+		// Separated form, e.g. `-isystem ../../../subprojects/foo`.
+		if (includeFlags.includes(token) && i + 1 < tokens.length) {
+			result.push(token, path.resolve(directory, tokens[++i]));
+
+			continue;
+		}
+
+		result.push(token);
+	}
+
+	return result;
+}
+
 function getClangToolBinary({ clangToolName, version, checkRequireVersion }) {
 	logInfo(
 		`getClangToolBinary() [clangToolName:${clangToolName}, version:${version}]`

package/worker/src/RTC/Consumer.cpp

@@ -33,12 +33,11 @@ namespace RTC
 	    producerId(producerId),
 	    shared(shared),
 	    listener(listener),
-	    kind(RTC::Media::Kind(data->kind())),
-	    type(RTC::RtpParameters::Type(data->type()))
+	    kind(RTC::Media::Kind(data->kind()))
 	{
 		MS_TRACE();
 
-		this->pipe = this->type == RTC::RtpParameters::Type::PIPE;
+		this->pipe = data->type() == FBS::RtpParameters::Type::PIPE;
 
 		// This may throw.
 		this->rtpParameters = RTC::RtpParameters(data->rtpParameters());
@@ -85,7 +84,7 @@ namespace RTC
 		}
 
 		// Ensure there are as many encodings as consumable encodings for pipe.
-		if (pipe && this->rtpParameters.encodings.size() != this->consumableRtpEncodings.size())
+		if (this->pipe && this->rtpParameters.encodings.size() != this->consumableRtpEncodings.size())
 		{
 			MS_THROW_TYPE_ERROR("number of rtpParameters.encodings and consumableRtpEncodings do not match");
 		}
@@ -203,6 +202,25 @@ namespace RTC
 		// Build preferred layers from FBS data.
 		RTC::ConsumerTypes::VideoLayers preferredLayers;
 
+		// Derive the stream type from consumableRtpEncodings.
+		if (this->pipe)
+		{
+			this->type = RTC::RtpParameters::Type::PIPE;
+		}
+		else if (this->consumableRtpEncodings.size() > 1u)
+		{
+			this->type = RTC::RtpParameters::Type::SIMULCAST;
+		}
+		else if (this->consumableRtpEncodings[0].spatialLayers > 1u || this->consumableRtpEncodings[0].temporalLayers > 1u)
+		{
+			// Single encoding with multiple layers is always SVC.
+			this->type = RTC::RtpParameters::Type::SVC;
+		}
+		else
+		{
+			this->type = RTC::RtpParameters::Type::SIMPLE;
+		}
+
 		// Create the appropriate ProducerStreamManager subclass based on type.
 		switch (this->type)
 		{

package/worker/src/RTC/NEW_RTCP/packet/ByePacket.cpp

@@ -0,0 +1,266 @@
+#define MS_CLASS "RTC::NEW_RTCP::ByePacket"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/NEW_RTCP/packet/ByePacket.hpp"
+#include "Logger.hpp"
+#include "MediaSoupErrors.hpp"
+#include <cstring> // std::memmove()
+#include <limits>  // std::numeric_limits
+
+namespace RTC
+{
+	namespace NEW_RTCP
+	{
+		/* Class methods. */
+
+		ByePacket* ByePacket::Parse(const uint8_t* buffer, size_t bufferLength)
+		{
+			MS_TRACE();
+
+			Packet::PacketType packetType;
+			size_t packetLength;
+
+			if (!Packet::IsPacket(buffer, bufferLength, packetType, packetLength))
+			{
+				return nullptr;
+			}
+
+			if (packetType != Packet::PacketType::BYE)
+			{
+				MS_WARN_DEV("invalid packet type");
+
+				return nullptr;
+			}
+
+			return ByePacket::ParseStrict(buffer, bufferLength, packetLength);
+		}
+
+		ByePacket* ByePacket::Factory(uint8_t* buffer, size_t bufferLength)
+		{
+			MS_TRACE();
+
+			if (bufferLength < Packet::CommonHeaderLength)
+			{
+				MS_THROW_TYPE_ERROR("buffer too small");
+			}
+
+			auto* packet = new ByePacket(buffer, bufferLength);
+
+			packet->InitializeHeader(Packet::PacketType::BYE, Packet::CommonHeaderLength);
+
+			// No need to invoke SetLength() since constructor invoked it with
+			// minimum Packet length.
+
+			return packet;
+		}
+
+		ByePacket* ByePacket::ParseStrict(const uint8_t* buffer, size_t bufferLength, size_t packetLength)
+		{
+			MS_TRACE();
+
+			auto* packet = new ByePacket(const_cast<uint8_t*>(buffer), bufferLength);
+
+			// Must always invoke SetLength() after constructing a Serializable with
+			// not fixed length. It's also required so the getters below operate
+			// against the real packet bounds.
+			packet->SetLength(packetLength);
+
+			// Validate that the announced SSRC/CSRC count fits into the packet.
+			const size_t ssrcsEndOffset = Packet::CommonHeaderLength + (packet->GetCount() * 4);
+
+			if (ssrcsEndOffset > packetLength)
+			{
+				MS_WARN_TAG(rtcp, "SSRC/CSRC count exceeds the packet length");
+
+				delete packet;
+				return nullptr;
+			}
+
+			// Validate that the value of the Reason length field fits into the packet.
+			if (packet->HasReason())
+			{
+				const uint8_t reasonLength = packet->GetReasonLength();
+				// The Reason string starts right after the 1 byte Reason length field.
+				const size_t reasonEndOffset = ssrcsEndOffset + 1 + reasonLength;
+
+				if (reasonEndOffset > packetLength)
+				{
+					MS_WARN_TAG(
+					  rtcp, "Reason length (%" PRIu8 " bytes) exceeds the packet length", reasonLength);
+
+					delete packet;
+					return nullptr;
+				}
+			}
+
+			return packet;
+		}
+
+		/* Instance methods. */
+
+		ByePacket::ByePacket(uint8_t* buffer, size_t bufferLength) : Packet(buffer, bufferLength)
+		{
+			MS_TRACE();
+
+			SetLength(Packet::CommonHeaderLength);
+		}
+
+		ByePacket::~ByePacket()
+		{
+			MS_TRACE();
+		}
+
+		void ByePacket::Dump(int indentation) const
+		{
+			MS_TRACE();
+
+			MS_DUMP_CLEAN(indentation, "<RTCP::ByePacket>");
+			DumpCommon(indentation);
+			MS_DUMP_CLEAN(indentation, "  ssrcs:");
+			for (const uint32_t ssrc : GetSsrcs())
+			{
+				MS_DUMP_CLEAN(indentation, "  - ssrc: %" PRIu32, ssrc);
+			}
+			if (HasReason())
+			{
+				const auto reason = GetReason();
+
+				MS_DUMP_CLEAN(indentation, "  has reason: yes");
+				MS_DUMP_CLEAN(
+				  indentation, "  reason: \"%.*s\"", static_cast<int>(reason.size()), reason.data());
+			}
+			else
+			{
+				MS_DUMP_CLEAN(indentation, "  has reason: no");
+			}
+			MS_DUMP_CLEAN(indentation, "</RTCP::ByePacket>");
+		}
+
+		ByePacket* ByePacket::Clone(uint8_t* buffer, size_t bufferLength) const
+		{
+			MS_TRACE();
+
+			auto* clonedPacket = new ByePacket(buffer, bufferLength);
+
+			CloneInto(clonedPacket);
+			SoftCloneInto(clonedPacket);
+
+			return clonedPacket;
+		}
+
+		std::vector<uint32_t> ByePacket::GetSsrcs() const
+		{
+			MS_TRACE();
+
+			const uint8_t numberOfSsrcs = GetCount();
+			std::vector<uint32_t> ssrcs;
+
+			ssrcs.reserve(numberOfSsrcs);
+
+			for (uint8_t idx{ 0 }; idx < numberOfSsrcs; ++idx)
+			{
+				ssrcs.emplace_back(GetSsrcAt(idx));
+			}
+
+			return ssrcs;
+		}
+
+		void ByePacket::AddSsrc(uint32_t ssrc)
+		{
+			MS_TRACE();
+
+			if (GetCount() == 31)
+			{
+				MS_THROW_ERROR("cannot add more than 31 ssrcs");
+			}
+
+			// NOTE: Must be checked before growing the length below, otherwise
+			// `HasReason()` would be unreliable since the length grows before the
+			// Count field is incremented.
+			const bool hadReason = HasReason();
+
+			// NOTE: This may throw.
+			SetVariableLengthValueLength(GetVariableLengthValueLength() + 4);
+
+			// Must move Reason fields down to make room for the new SSRC.
+			if (hadReason)
+			{
+				std::memmove(
+				  GetReasonLengthPointer() + 4,
+				  GetReasonLengthPointer(),
+				  Utils::Byte::PadTo4Bytes(1u + GetReasonLength()));
+			}
+
+			// Add the new ssrc.
+			Utils::Byte::Set4Bytes(GetSsrcsPointer(), GetCount() * 4, ssrc);
+
+			// Update the counter field.
+			SetCount(GetCount() + 1);
+		}
+
+		void ByePacket::SetReason(const std::string_view& reason)
+		{
+			MS_TRACE();
+
+			if (reason.size() > std::numeric_limits<uint8_t>::max())
+			{
+				MS_THROW_TYPE_ERROR("reason length (%zu bytes) cannot be greater than 255", reason.size());
+			}
+
+			const size_t previousLength      = GetLength();
+			const size_t previousLengthField = GetLengthFieldComputed();
+			// The previous total length of Reason length and Reason fields padded
+			// to 4 bytes.
+			const uint16_t previousReasonFieldsPaddedLength =
+			  HasReason() ? Utils::Byte::PadTo4Bytes(1u + GetReasonLength()) : 0;
+			// The new total length of Reason length and Reason fields padded to
+			// 4 bytes.
+			const uint16_t newReasonFieldsPaddedLength =
+			  !reason.empty() ? Utils::Byte::PadTo4Bytes(1 + reason.size()) : 0;
+			const size_t newLength = size_t{ previousLength } - size_t{ previousReasonFieldsPaddedLength } +
+			                         size_t{ newReasonFieldsPaddedLength };
+
+			try
+			{
+				// Let's call SetLength() on parent with the new computed length.
+				// NOTE: If there is no space in the buffer for it, it will throw.
+				SetLength(newLength);
+
+				// Update length field.
+				// NOTE: This will throw if computed value is too big.
+				SetLengthField(newLength);
+
+				if (!reason.empty())
+				{
+					// Write Reason length field.
+					Utils::Byte::Set1Byte(GetReasonLengthPointer(), 0, reason.size());
+
+					// Write Reason field.
+					std::memmove(GetReasonPointer(), reason.data(), reason.size());
+
+					// Fill padding bytes with zero.
+					FillPadding(newReasonFieldsPaddedLength - 1 - reason.size());
+				}
+			}
+			catch (const MediaSoupError& error)
+			{
+				// Rollback.
+				SetLength(previousLength);
+				SetLengthField(previousLengthField);
+
+				throw;
+			}
+		}
+
+		ByePacket* ByePacket::SoftClone(const uint8_t* buffer) const
+		{
+			MS_TRACE();
+
+			auto* softClonedPacket = new ByePacket(const_cast<uint8_t*>(buffer), GetLength());
+
+			SoftCloneInto(softClonedPacket);
+
+			return softClonedPacket;
+		}
+	} // namespace NEW_RTCP
+} // namespace RTC