mediasoup 3.26.0 → 3.27.1

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
 					{

package/worker/include/RTC/RTP/HeaderExtensionIds.hpp

@@ -12,18 +12,18 @@ namespace RTC
 		struct HeaderExtensionIds
 		{
 			// 0 means no id.
-			uint8_t mid{ 0u };
-			uint8_t rid{ 0u };
-			uint8_t rrid{ 0u };
-			uint8_t absSendTime{ 0u };
-			uint8_t transportWideCc01{ 0u };
-			uint8_t ssrcAudioLevel{ 0u };
-			uint8_t dependencyDescriptor{ 0u };
-			uint8_t videoOrientation{ 0u };
-			uint8_t timeOffset{ 0u };
-			uint8_t absCaptureTime{ 0u };
-			uint8_t playoutDelay{ 0u };
-			uint8_t mediasoupPacketId{ 0u };
+			uint8_t mid{ 0 };
+			uint8_t rid{ 0 };
+			uint8_t rrid{ 0 };
+			uint8_t absSendTime{ 0 };
+			uint8_t transportWideCc01{ 0 };
+			uint8_t ssrcAudioLevel{ 0 };
+			uint8_t dependencyDescriptor{ 0 };
+			uint8_t videoOrientation{ 0 };
+			uint8_t timeOffset{ 0 };
+			uint8_t absCaptureTime{ 0 };
+			uint8_t playoutDelay{ 0 };
+			uint8_t mediasoupPacketId{ 0 };
 		};
 	} // namespace RTP
 } // namespace RTC

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

@@ -527,10 +527,10 @@ namespace RTC
 
 			/**
 			 * @remarks
-			 * - Contrary to `ReadAbsSendTime()` method, given `ms` is internally
-			 *   converted to ABS Send Time.
+			 * - `sentAtUs` is converted internally to the 3 bytes ABS Send Time format,
+			 *   unlike `ReadAbsSendTime()`, which exposes the raw extension value.
 			 */
-			bool UpdateAbsSendTime(uint64_t ms) const;
+			bool UpdateAbsSendTime(int64_t sentAtUs) const;
 
 			bool ReadTransportWideCc01(uint16_t& wideSeqNumber) const;
 
@@ -819,7 +819,7 @@ namespace RTC
 			{
 				if (!this->payloadDescriptorHandler)
 				{
-					return 0u;
+					return 0;
 				}
 
 				return this->payloadDescriptorHandler->GetSpatialLayer();
@@ -832,26 +832,26 @@ namespace RTC
 			{
 				if (!this->payloadDescriptorHandler)
 				{
-					return 0u;
+					return 0;
 				}
 
 				return this->payloadDescriptorHandler->GetTemporalLayer();
 			}
 
 			/**
-			 * Capture time (in ms) of the packet.
+			 * Capture time (in us) of the packet.
 			 */
-			std::optional<uint64_t> GetCaptureMs() const
+			std::optional<int64_t> GetCaptureAtUs() const
 			{
-				return this->captureMs;
+				return this->captureAtUs;
 			}
 
 			/**
-			 * Set the capture time (in ms) of the packet.
+			 * Set the capture time (in us) of the packet.
 			 */
-			void SetCaptureMs(uint64_t captureMs)
+			void SetCaptureAtUs(int64_t captureAtUs)
 			{
-				this->captureMs = captureMs;
+				this->captureAtUs = captureAtUs;
 			}
 
 		private:
@@ -967,7 +967,7 @@ namespace RTC
 			// each entry is the offset (in bytes) from the beginning of the header
 			// extension value to the beginning of the extension.
 			std::array<ssize_t, 14> oneByteExtensions{ -1, -1, -1, -1, -1, -1, -1,
-				                                         -1, -1, -1, -1, -1, -1, -1 };
+			                                           -1, -1, -1, -1, -1, -1, -1 };
 			// Ordered map of Two Bytes Extensions. Key is the id 1 of the extension,
 			// each entry is the offset (in bytes) from the beginning of the header
 			// extension value to the beginning of the extension.
@@ -977,7 +977,7 @@ namespace RTC
 			// Codec related.
 			std::shared_ptr<Codecs::PayloadDescriptorHandler> payloadDescriptorHandler;
 			// Capture time of the packet.
-			std::optional<uint64_t> captureMs;
+			std::optional<int64_t> captureAtUs;
 		};
 	} // namespace RTP
 } // namespace RTC

package/worker/include/RTC/RTP/ProbationGenerator.hpp

@@ -22,7 +22,7 @@ namespace RTC
 			/**
 			 * Codec payload type of the probation RTP stream.
 			 */
-			static const uint8_t PayloadType{ 127u };
+			static const uint8_t PayloadType{ 127 };
 
 		public:
 			explicit ProbationGenerator();

package/worker/include/RTC/RTP/RetransmissionBuffer.hpp

@@ -27,24 +27,24 @@ namespace RTC
 				// Payload descriptor encoder.
 				std::unique_ptr<RTP::Codecs::PayloadDescriptor::Encoder> encoder{ nullptr };
 				// Correct SSRC since original packet may not have the same.
-				uint32_t ssrc{ 0u };
+				uint32_t ssrc{ 0 };
 				// Correct sequence number since original packet may not have the same.
-				uint16_t sequenceNumber{ 0u };
+				uint16_t sequenceNumber{ 0 };
 				// Correct timestamp since original packet may not have the same.
-				uint32_t timestamp{ 0u };
+				uint32_t timestamp{ 0 };
 				// Correct marker bit since original packet may not have the same.
 				bool marker{ false };
 				// Last time this packet was resent.
-				uint64_t resentAtMs{ 0u };
+				int64_t resentAtMs{ 0 };
 				// Number of times this packet was resent.
-				uint8_t sentTimes{ 0u };
+				uint8_t sentTimes{ 0 };
 			};
 
 		private:
 			static Item* FillItem(Item* item, RTP::Packet* packet, const RTP::SharedPacket& sharedPacket);
 
 		public:
-			RetransmissionBuffer(uint16_t maxItems, uint32_t maxRetransmissionDelayMs, uint32_t clockRate);
+			RetransmissionBuffer(uint16_t maxItems, int64_t maxRetransmissionDelayMs, uint32_t clockRate);
 			~RetransmissionBuffer();
 
 			void Dump(int indentation = 0) const;
@@ -67,7 +67,7 @@ namespace RTC
 		private:
 			// Given as argument.
 			uint16_t maxItems;
-			uint32_t maxRetransmissionDelayMs;
+			int64_t maxRetransmissionDelayMs;
 			uint32_t clockRate;
 		};
 	} // namespace RTP