mediasoup 3.26.0 → 3.27.0

package/worker/include/RTC/PipeTransport.hpp

@@ -59,10 +59,22 @@ namespace RTC
 		bool SendData(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);
-		void OnRtpDataReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen);
-		void OnRtcpDataReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len);
-		void OnSctpDataReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len);
+		void OnPacketReceived(
+		  RTC::TransportTuple* tuple,
+		  const uint8_t* data,
+		  size_t len,
+		  size_t bufferLen,
+		  int64_t receivedAtUs);
+		void OnRtpDataReceived(
+		  RTC::TransportTuple* tuple,
+		  const uint8_t* data,
+		  size_t len,
+		  size_t bufferLen,
+		  int64_t receivedAtUs);
+		void OnRtcpDataReceived(
+		  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, int64_t receivedAtUs);
+		void OnSctpDataReceived(
+		  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, int64_t receivedAtUs);
 
 		/* Pure virtual methods inherited from RTC::UdpSocket::Listener. */
 	public:
@@ -71,7 +83,8 @@ namespace RTC
 		  const uint8_t* data,
 		  size_t len,
 		  size_t bufferLen,
-		  const struct sockaddr* remoteAddr) override;
+		  const struct sockaddr* remoteAddr,
+		  int64_t receivedAtUs) override;
 
 	private:
 		// Allocated by this.

package/worker/include/RTC/PlainTransport.hpp

@@ -48,10 +48,22 @@ namespace RTC
 		bool SendData(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);
-		void OnRtpDataReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len, size_t bufferLen);
-		void OnRtcpDataReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len);
-		void OnSctpDataReceived(RTC::TransportTuple* tuple, const uint8_t* data, size_t len);
+		void OnPacketReceived(
+		  RTC::TransportTuple* tuple,
+		  const uint8_t* data,
+		  size_t len,
+		  size_t bufferLen,
+		  int64_t receivedAtUs);
+		void OnRtpDataReceived(
+		  RTC::TransportTuple* tuple,
+		  const uint8_t* data,
+		  size_t len,
+		  size_t bufferLen,
+		  int64_t receivedAtUs);
+		void OnRtcpDataReceived(
+		  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, int64_t receivedAtUs);
+		void OnSctpDataReceived(
+		  RTC::TransportTuple* tuple, const uint8_t* data, size_t len, int64_t receivedAtUs);
 		void EmitTuple() const;
 		void EmitRtcpTuple() const;
 
@@ -62,7 +74,8 @@ namespace RTC
 		  const uint8_t* data,
 		  size_t len,
 		  size_t bufferLen,
-		  const struct sockaddr* remoteAddr) override;
+		  const struct sockaddr* remoteAddr,
+		  int64_t receivedAtUs) override;
 
 	private:
 		// Allocated by this.

package/worker/include/RTC/PortManager.hpp

@@ -66,8 +66,8 @@ namespace RTC
 		private:
 			Protocol protocol{ Protocol::UDP };
 			sockaddr_storage bindAddr{};
-			uint16_t minPort{ 0u };
-			uint16_t maxPort{ 0u };
+			uint16_t minPort{ 0 };
+			uint16_t maxPort{ 0 };
 		};
 
 		struct PortRangeKeyHash
@@ -92,8 +92,8 @@ namespace RTC
 			}
 
 			std::vector<bool> ports;
-			uint16_t minPort{ 0u };
-			uint16_t numUsedPorts{ 0u };
+			uint16_t minPort{ 0 };
+			uint16_t numUsedPorts{ 0 };
 		};
 
 	public:

package/worker/include/RTC/Producer.hpp

@@ -33,9 +33,10 @@ namespace RTC
 
 		public:
 			virtual void OnProducerReceiveData(RTC::Producer* producer, size_t len) = 0;
-			virtual void OnProducerReceiveRtpPacket(RTC::Producer* producer, RTC::RTP::Packet* packet) = 0;
-			virtual void OnProducerPaused(RTC::Producer* producer)  = 0;
-			virtual void OnProducerResumed(RTC::Producer* producer) = 0;
+			virtual void OnProducerReceiveRtpPacket(
+			  RTC::Producer* producer, RTC::RTP::Packet* packet, int64_t receivedAtUs) = 0;
+			virtual void OnProducerPaused(RTC::Producer* producer)                     = 0;
+			virtual void OnProducerResumed(RTC::Producer* producer)                    = 0;
 			virtual void OnProducerNewRtpStream(
 			  RTC::Producer* producer, RTC::RTP::RtpStreamRecv* rtpStream, uint32_t mappedSsrc) = 0;
 			virtual void OnProducerRtpStreamScore(
@@ -45,6 +46,11 @@ namespace RTC
 			  uint8_t previousScore) = 0;
 			virtual void OnProducerRtcpSenderReport(
 			  RTC::Producer* producer, RTC::RTP::RtpStreamRecv* rtpStream, bool first) = 0;
+			virtual void OnProducerSpatialLayerActivityChanged(
+			  RTC::Producer* producer,
+			  RTC::RTP::RtpStreamRecv* rtpStream,
+			  uint8_t spatialLayer,
+			  bool isActive) = 0;
 			virtual void OnProducerRtpPacketReceived(RTC::Producer* producer, RTC::RTP::Packet* packet) = 0;
 			virtual void OnProducerSendRtcpPacket(RTC::Producer* producer, RTC::RTCP::Packet* packet) = 0;
 			/**
@@ -59,15 +65,15 @@ namespace RTC
 			 *
 			 * @returns No value while the capture instant cannot be told yet.
 			 */
-			virtual std::optional<uint64_t> OnProducerNeedLocalCaptureMs(
+			virtual std::optional<int64_t> OnProducerNeedLocalCaptureAtUs(
 			  RTC::Producer* producer, const RTC::RTP::RtpStreamRecv* rtpStream, uint32_t ts) = 0;
 			/**
 			 * Offset between the wall clock of the sender of this Producer and our own
-			 * monotonic one (ms).
+			 * monotonic one (us).
 			 *
 			 * @returns No value while the offset cannot be told yet.
 			 */
-			virtual std::optional<int64_t> OnProducerNeedRemoteClockOffsetMs(const RTC::Producer* producer) = 0;
+			virtual std::optional<int64_t> OnProducerNeedRemoteClockOffsetUs(const RTC::Producer* producer) = 0;
 		};
 
 	private:
@@ -153,10 +159,11 @@ namespace RTC
 		{
 			return std::addressof(this->rtpStreamScores);
 		}
-		ReceiveRtpPacketResult ReceiveRtpPacket(RTC::RTP::Packet* packet);
-		void ReceiveRtcpSenderReport(RTC::RTCP::SenderReport* report);
-		void ReceiveRtcpXrDelaySinceLastRr(RTC::RTCP::DelaySinceLastRr::SsrcInfo* ssrcInfo);
-		bool GetRtcp(RTC::RTCP::CompoundPacket* packet, uint64_t nowMs);
+		ReceiveRtpPacketResult ReceiveRtpPacket(RTC::RTP::Packet* packet, int64_t receivedAtUs);
+		void ReceiveRtcpSenderReport(RTC::RTCP::SenderReport* report, int64_t receivedAtUs);
+		void ReceiveRtcpXrDelaySinceLastRr(
+		  RTC::RTCP::DelaySinceLastRr::SsrcInfo* ssrcInfo, int64_t receivedAtUs);
+		bool GetRtcp(RTC::RTCP::CompoundPacket* packet, int64_t nowUs);
 		void RequestKeyFrame(uint32_t mappedSsrc);
 
 		/* Methods inherited from Channel::ChannelSocket::RequestHandler. */
@@ -198,6 +205,8 @@ namespace RTC
 		void OnRtpStreamScore(RTC::RTP::RtpStream* rtpStream, uint8_t score, uint8_t previousScore) override;
 		void OnRtpStreamSendRtcpPacket(RTC::RTP::RtpStreamRecv* rtpStream, RTC::RTCP::Packet* packet) override;
 		uint8_t OnRtpStreamNeedWorstRemoteFractionLost(RTC::RTP::RtpStreamRecv* rtpStream) override;
+		void OnRtpStreamSpatialLayerActivityChanged(
+		  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t spatialLayer, bool isActive) override;
 
 		/* Pure virtual methods inherited from RTC::KeyFrameRequestManager::Listener. */
 	public:
@@ -229,8 +238,8 @@ namespace RTC
 		bool enableMediasoupPacketIdHeaderExtension{ false };
 		RTC::RTP::Packet* currentRtpPacket{ nullptr };
 		// Timestamp when last RTCP was sent.
-		uint64_t lastRtcpSentTime{ 0u };
-		uint16_t maxRtcpInterval{ 0u };
+		int64_t lastRtcpSentAtUs{ 0 };
+		int64_t maxRtcpIntervalMs{ 0 };
 		// Video orientation.
 		bool videoOrientationDetected{ false };
 		struct VideoOrientation videoOrientation;

package/worker/include/RTC/ProducerStreamManager.hpp

@@ -42,9 +42,9 @@ namespace RTC
 			Type type{ Type::FORWARD };
 
 			// Valid when type == FORWARD:
-			uint32_t tsOffset{ 0u };
+			uint32_t tsOffset{ 0 };
 			bool isSyncPacket{ false };
-			uint16_t syncSeqValue{ 0u };
+			uint16_t syncSeqValue{ 0 };
 			bool shouldSyncEncodingContext{ false };
 			bool spatialLayerSwitched{ false };
 			bool temporalLayerChanged{ false };
@@ -100,16 +100,22 @@ namespace RTC
 		virtual void ProducerRtpStreamScore(
 		  RTC::RTP::RtpStreamRecv* rtpStream, uint8_t score, uint8_t previousScore)           = 0;
 		virtual void ProducerRtcpSenderReport(RTC::RTP::RtpStreamRecv* rtpStream, bool first) = 0;
+		// Only spatial layers within a same RTP stream can start or stop separately,
+		// so just SVC cares about this.
+		virtual void ProducerSpatialLayerActivityChanged(
+		  RTC::RTP::RtpStreamRecv* /*rtpStream*/, uint8_t /*spatialLayer*/, bool /*isActive*/)
+		{
+		}
 
 		void SetExternallyManagedBitrate()
 		{
 			this->externallyManagedBitrate = true;
 		}
 
-		virtual uint32_t IncreaseLayer(
-		  uint32_t bitrate, bool considerLoss, float lossPercentage, uint64_t nowMs) = 0;
-		virtual void ApplyLayers(uint64_t rtpStreamActiveMs)                         = 0;
-		virtual uint32_t GetDesiredBitrate(uint64_t nowMs) const                     = 0;
+		virtual int64_t IncreaseLayer(
+		  int64_t bitrate, bool considerLoss, float lossPercentage, int64_t nowMs) = 0;
+		virtual void ApplyLayers(int64_t rtpStreamActiveMs)                        = 0;
+		virtual int64_t GetDesiredBitrate(int64_t nowMs) const                     = 0;
 
 		virtual RtpPacketProcessResult ProcessRtpPacket(
 		  RTC::RTP::Packet* packet,

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

@@ -60,11 +60,11 @@ namespace RTC
 			{
 				size_t size = Packet::CommonHeaderSize;
 
-				size += ssrcs.size() * 4u;
+				size += ssrcs.size() * 4;
 
 				if (!this->reason.empty())
 				{
-					size += 1u; // Length field.
+					size += 1; // Length field.
 					size += this->reason.length();
 				}
 

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

@@ -52,7 +52,7 @@ namespace RTC
 			{
 				return this->isCorrect;
 			}
-			void SetBitrate(uint64_t bitrate)
+			void SetBitrate(int64_t bitrate)
 			{
 				this->bitrate = bitrate;
 			}
@@ -60,7 +60,7 @@ namespace RTC
 			{
 				this->ssrcs = ssrcs;
 			}
-			uint64_t GetBitrate() const
+			int64_t GetBitrate() const
 			{
 				return this->bitrate;
 			}
@@ -76,13 +76,13 @@ namespace RTC
 			size_t GetSize() const override
 			{
 				// NOLINTNEXTLINE(bugprone-parent-virtual-call)
-				return FeedbackPsPacket::GetSize() + 8 + (4u * this->ssrcs.size());
+				return FeedbackPsPacket::GetSize() + 8 + (4 * this->ssrcs.size());
 			}
 
 		private:
 			std::vector<uint32_t> ssrcs;
 			// Bitrate represented in bps.
-			uint64_t bitrate{ 0 };
+			int64_t bitrate{ 0 };
 			bool isCorrect{ true };
 		};
 	} // namespace RTCP

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

@@ -52,11 +52,11 @@ namespace RTC
 			{
 				this->ssrc = ssrc;
 			}
-			uint64_t GetBitrate() const
+			int64_t GetBitrate() const
 			{
 				return this->bitrate;
 			}
-			void SetBitrate(uint64_t bitrate)
+			void SetBitrate(int64_t bitrate)
 			{
 				this->bitrate = bitrate;
 			}
@@ -80,7 +80,7 @@ namespace RTC
 
 		private:
 			uint32_t ssrc{ 0 };
-			uint64_t bitrate{ 0 };
+			int64_t bitrate{ 0 };
 			uint16_t overhead{ 0 };
 		};
 

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

@@ -42,21 +42,25 @@ namespace RTC
 		class FeedbackRtpTransportPacket : public FeedbackRtpPacket
 		{
 		public:
-			static constexpr int64_t BaseTimeTick   = 64;
-			static constexpr int64_t TimeWrapPeriod = BaseTimeTick * (1ll << 24);
+			// Receive deltas are expressed in multiples of this.
+			static constexpr int64_t DeltaTickUs = 250;
+			// The reference time is expressed in multiples of this.
+			static constexpr int64_t BaseTimeTickUs = DeltaTickUs * (1 << 8);
+			// Period after which the reference time wraps around.
+			static constexpr int64_t TimeWrapPeriodUs = BaseTimeTickUs * (1ll << 24);
 
 		public:
-			struct PacketResult
+			struct PacketStatus
 			{
-				PacketResult(uint16_t sequenceNumber, bool received)
+				PacketStatus(uint16_t sequenceNumber, bool received)
 				  : sequenceNumber(sequenceNumber), received(received)
 				{
 				}
 
 				uint16_t sequenceNumber;   // Wide sequence number.
-				int16_t delta{ 0 };        // Delta.
+				int16_t delta{ 0 };        // Delta in DeltaTickUs units.
 				bool received{ false };    // Packet received or not.
-				int64_t receivedAtMs{ 0 }; // Received time (ms) in remote timestamp reference.
+				int64_t receivedAtUs{ 0 }; // Received time (us) in remote timestamp reference.
 			};
 
 		public:
@@ -100,8 +104,8 @@ namespace RTC
 				virtual void Dump(int indentation = 0) const                                     = 0;
 				virtual uint16_t GetCount() const                                                = 0;
 				virtual uint16_t GetReceivedStatusCount() const                                  = 0;
-				virtual void FillResults(
-				  std::vector<struct PacketResult>& packetResults, uint16_t& currentSequenceNumber) const = 0;
+				virtual void FillStatuses(
+				  std::vector<struct PacketStatus>& packetStatuses, uint16_t& currentSequenceNumber) const = 0;
 				virtual size_t Serialize(uint8_t* buffer) = 0;
 			};
 
@@ -127,14 +131,14 @@ namespace RTC
 					return this->count;
 				}
 				uint16_t GetReceivedStatusCount() const override;
-				void FillResults(
-				  std::vector<struct PacketResult>& packetResults,
+				void FillStatuses(
+				  std::vector<struct PacketStatus>& packetStatuses,
 				  uint16_t& currentSequenceNumber) const override;
 				size_t Serialize(uint8_t* buffer) override;
 
 			private:
 				Status status{ Status::None };
-				uint16_t count{ 0u };
+				uint16_t count{ 0 };
 			};
 
 		private:
@@ -155,8 +159,8 @@ namespace RTC
 					return this->statuses.size();
 				}
 				uint16_t GetReceivedStatusCount() const override;
-				void FillResults(
-				  std::vector<struct PacketResult>& packetResults,
+				void FillStatuses(
+				  std::vector<struct PacketStatus>& packetStatuses,
 				  uint16_t& currentSequenceNumber) const override;
 				size_t Serialize(uint8_t* buffer) override;
 
@@ -182,8 +186,8 @@ namespace RTC
 					return this->statuses.size();
 				}
 				uint16_t GetReceivedStatusCount() const override;
-				void FillResults(
-				  std::vector<struct PacketResult>& packetResults,
+				void FillStatuses(
+				  std::vector<struct PacketStatus>& packetStatuses,
 				  uint16_t& currentSequenceNumber) const override;
 				size_t Serialize(uint8_t* buffer) override;
 
@@ -200,6 +204,17 @@ namespace RTC
 		public:
 			static FeedbackRtpTransportPacket* Parse(const uint8_t* data, size_t len);
 
+		private:
+			/**
+			 * Turn a number of whole base time ticks elapsed into the reference time
+			 * that stands for it.
+			 *
+			 * @remarks
+			 * - The reference time is a 24 bits signed integer, so it's kept sign
+			 *   extended, which is how parsing it back gives it.
+			 */
+			static int32_t TicksToReferenceTime(int64_t baseTimeTicks);
+
 		private:
 			static const ankerl::unordered_dense::map<Status, std::string> Status2String;
 
@@ -216,8 +231,8 @@ namespace RTC
 			{
 				return this->baseSet;
 			}
-			void SetBase(uint16_t sequenceNumber, uint64_t timestamp);
-			AddPacketResult AddPacket(uint16_t sequenceNumber, uint64_t timestamp, size_t maxRtcpPacketLen);
+			void SetBase(uint16_t sequenceNumber, int64_t timestampUs);
+			AddPacketResult AddPacket(uint16_t sequenceNumber, int64_t timestampUs, size_t maxRtcpPacketLen);
 			// Just for locally generated packets.
 			void Finish();
 			bool IsFull() const
@@ -247,27 +262,27 @@ namespace RTC
 			{
 				return this->referenceTime;
 			}
-			// NOTE: We only use this for testing purpose.
-			void SetReferenceTime(int64_t referenceTime)
-			{
-				this->referenceTime = (referenceTime % TimeWrapPeriod) / BaseTimeTick;
-			}
-			int64_t GetReferenceTimestamp() const // Reference time in ms.
+			/**
+			 * @remarks
+			 * - Only used for testing purposes.
+			 */
+			void SetReferenceTimeUs(int64_t referenceTimeUs);
+			int64_t GetReferenceTimestampUs() const // Reference time in us.
 			{
-				return TimeWrapPeriod + (static_cast<int64_t>(this->referenceTime) * BaseTimeTick);
+				return TimeWrapPeriodUs + (static_cast<int64_t>(this->referenceTime) * BaseTimeTickUs);
 			}
-			int64_t GetBaseDelta(const int64_t previousTimestampMs) const
+			int64_t GetBaseDeltaUs(const int64_t previousTimestampUs) const
 			{
-				int64_t delta = GetReferenceTimestamp() - previousTimestampMs;
+				int64_t delta = GetReferenceTimestampUs() - previousTimestampUs;
 
 				// Compensate for wrap around.
-				if (std::abs(delta - TimeWrapPeriod) < std::abs(delta))
+				if (std::abs(delta - TimeWrapPeriodUs) < std::abs(delta))
 				{
-					delta -= TimeWrapPeriod;
+					delta -= TimeWrapPeriodUs;
 				}
-				else if (std::abs(delta + TimeWrapPeriod) < std::abs(delta))
+				else if (std::abs(delta + TimeWrapPeriodUs) < std::abs(delta))
 				{
-					delta += TimeWrapPeriod;
+					delta += TimeWrapPeriodUs;
 				}
 
 				return delta;
@@ -284,11 +299,11 @@ namespace RTC
 			{
 				return this->latestSequenceNumber;
 			}
-			uint64_t GetLatestTimestamp() const // Just for locally generated packets.
+			int64_t GetLatestTimestampUs() const // Just for locally generated packets.
 			{
-				return this->latestTimestamp;
+				return this->latestTimestampUs;
 			}
-			std::vector<struct PacketResult> GetPacketResults() const;
+			std::vector<struct PacketStatus> GetPacketStatuses() const;
 			uint8_t GetPacketFractionLost() const;
 
 			/* Pure virtual methods inherited from Packet. */
@@ -324,20 +339,20 @@ namespace RTC
 		private:
 			// Whether baseSequenceNumber has been set.
 			bool baseSet{ false };
-			uint16_t baseSequenceNumber{ 0u };
+			uint16_t baseSequenceNumber{ 0 };
 			// 24 bits signed integer.
 			int32_t referenceTime{ 0 };
 			// Just for locally generated packets.
-			uint16_t latestSequenceNumber{ 0u };
+			uint16_t latestSequenceNumber{ 0 };
 			// Just for locally generated packets.
-			uint64_t latestTimestamp{ 0u };
-			uint16_t packetStatusCount{ 0u };
-			uint8_t feedbackPacketCount{ 0u };
+			int64_t latestTimestampUs{ 0 };
+			uint16_t packetStatusCount{ 0 };
+			uint8_t feedbackPacketCount{ 0 };
 			std::vector<Chunk*> chunks;
 			std::vector<int16_t> deltas;
 			// Just for locally generated packets.
 			Context context;
-			size_t deltasAndChunksSize{ 0u };
+			size_t deltasAndChunksSize{ 0 };
 			size_t size{ 0 };
 			bool isCorrect{ true };
 		};

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

@@ -20,8 +20,8 @@ namespace RTC
 		// capture system but an estimation that moves. Refreshing it for audio less often
 		// than for video would make receivers combine measurements taken at different
 		// instants, and that difference is lip sync error.
-		constexpr uint16_t MaxAudioIntervalMs{ 1000 };
-		constexpr uint16_t MaxVideoIntervalMs{ 1000 };
+		constexpr int64_t MaxAudioIntervalMs{ 1000 };
+		constexpr int64_t MaxVideoIntervalMs{ 1000 };
 
 		enum class Type : uint8_t
 		{
@@ -118,7 +118,7 @@ namespace RTC
 			}
 			virtual size_t GetCount() const
 			{
-				return 0u;
+				return 0;
 			}
 			virtual size_t GetSize() const = 0;
 

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

@@ -113,7 +113,7 @@ namespace RTC
 
 		private:
 			Header* header{ nullptr };
-			uint8_t raw[HeaderSize]{ 0u };
+			uint8_t raw[HeaderSize]{ 0 };
 		};
 
 		class ReceiverReportPacket : public Packet
@@ -193,7 +193,7 @@ namespace RTC
 				// A serialized packet can contain a maximum of 31 reports.
 				// If number of reports exceeds 31 then the required number of packets
 				// will be serialized which will take the size calculated below.
-				size_t size = (Packet::CommonHeaderSize + 4u /* this->ssrc */) *
+				size_t size = (Packet::CommonHeaderSize + 4 /* this->ssrc */) *
 				              ((this->GetCount() / maxReportsPerPacket) + 1);
 				size += ReceiverReport::HeaderSize * this->GetCount();
 
@@ -202,7 +202,7 @@ namespace RTC
 
 		private:
 			// SSRC of packet sender.
-			uint32_t ssrc{ 0u };
+			uint32_t ssrc{ 0 };
 			std::vector<ReceiverReport*> reports;
 		};
 	} // namespace RTCP

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

@@ -122,7 +122,7 @@ namespace RTC
 			size_t Serialize(uint8_t* buffer);
 			size_t GetSize() const
 			{
-				size_t size = 4u /*ssrc*/;
+				size_t size = 4 /*ssrc*/;
 
 				for (auto* item : this->items)
 				{
@@ -158,7 +158,7 @@ namespace RTC
 			}
 
 		private:
-			uint32_t ssrc{ 0u };
+			uint32_t ssrc{ 0 };
 			std::vector<SdesItem*> items;
 		};
 

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

@@ -143,7 +143,7 @@ namespace RTC
 			}
 			size_t GetSize() const override
 			{
-				size_t size = Packet::CommonHeaderSize + 4u /*ssrc*/;
+				size_t size = Packet::CommonHeaderSize + 4 /*ssrc*/;
 
 				for (auto* report : this->reports)
 				{
@@ -154,7 +154,7 @@ namespace RTC
 			}
 
 		private:
-			uint32_t ssrc{ 0u };
+			uint32_t ssrc{ 0 };
 			std::vector<ExtendedReportBlock*> reports;
 		};
 	} // namespace RTCP

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

@@ -151,7 +151,7 @@ namespace RTC
 			size_t Serialize(uint8_t* buffer) override;
 			size_t GetSize() const override
 			{
-				size_t size{ 4u }; // Common header.
+				size_t size{ 4 }; // Common header.
 
 				for (auto* ssrcInfo : this->ssrcInfos)
 				{

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

@@ -84,7 +84,7 @@ namespace RTC
 					}
 					uint8_t GetSpatialLayer() const override
 					{
-						return 0u;
+						return 0;
 					}
 					uint8_t GetTemporalLayer() const override
 					{

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

@@ -80,11 +80,11 @@ namespace RTC
 					}
 					uint8_t GetSpatialLayer() const override
 					{
-						return 0u;
+						return 0;
 					}
 					uint8_t GetTemporalLayer() const override
 					{
-						return 0u;
+						return 0;
 					}
 					bool IsKeyFrame() const override
 					{

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

@@ -29,7 +29,7 @@ namespace RTC
 
 			class PictureIdList
 			{
-				static constexpr uint16_t MaxCurrentLayerPictureIdNum{ 1000u };
+				static constexpr uint16_t MaxCurrentLayerPictureIdNum{ 1000 };
 
 			public:
 				explicit PictureIdList() = default;
@@ -93,8 +93,8 @@ namespace RTC
 			public:
 				struct Params
 				{
-					uint8_t spatialLayers{ 1u };
-					uint8_t temporalLayers{ 1u };
+					uint8_t spatialLayers{ 1 };
+					uint8_t temporalLayers{ 1 };
 					bool ksvc{ false };
 				};
 

package/worker/include/RTC/RTP/Codecs/VP8.hpp

@@ -158,11 +158,11 @@ namespace RTC
 					void Restore(RTP::Packet* packet) override;
 					uint8_t GetSpatialLayer() const override
 					{
-						return 0u;
+						return 0;
 					}
 					uint8_t GetTemporalLayer() const override
 					{
-						return this->payloadDescriptor->hasTlIndex ? this->payloadDescriptor->tlIndex : 0u;
+						return this->payloadDescriptor->hasTlIndex ? this->payloadDescriptor->tlIndex : 0;
 					}
 					bool IsKeyFrame() const override
 					{

package/worker/include/RTC/RTP/Codecs/VP9.hpp

@@ -141,11 +141,11 @@ namespace RTC
 					}
 					uint8_t GetSpatialLayer() const override
 					{
-						return this->payloadDescriptor->hasSlIndex ? this->payloadDescriptor->slIndex : 0u;
+						return this->payloadDescriptor->hasSlIndex ? this->payloadDescriptor->slIndex : 0;
 					}
 					uint8_t GetTemporalLayer() const override
 					{
-						return this->payloadDescriptor->hasTlIndex ? this->payloadDescriptor->tlIndex : 0u;
+						return this->payloadDescriptor->hasTlIndex ? this->payloadDescriptor->tlIndex : 0;
 					}
 					bool IsKeyFrame() const override
 					{