mediasoup 3.9.13 → 3.9.16

package/worker/src/RTC/Codecs/H264_SVC.cpp

@@ -0,0 +1,428 @@
+#define MS_CLASS "RTC::Codecs::H264_SVC"
+
+#include "RTC/Codecs/H264_SVC.hpp"
+#include "Logger.hpp"
+#include "Utils.hpp"
+
+namespace RTC
+{
+	namespace Codecs
+	{
+		/* Class methods. */
+
+		H264_SVC::PayloadDescriptor* H264_SVC::Parse(
+		  const uint8_t* data, size_t len, RTC::RtpPacket::FrameMarking* frameMarking, uint8_t frameMarkingLen)
+		{
+			MS_TRACE();
+
+			if (len < 2)
+				return nullptr;
+
+			std::unique_ptr<PayloadDescriptor> payloadDescriptor(new PayloadDescriptor());
+
+			// Use frame-marking.
+			if (frameMarking)
+			{
+				// Read fields.
+				payloadDescriptor->s       = frameMarking->start;
+				payloadDescriptor->e       = frameMarking->end;
+				payloadDescriptor->i       = frameMarking->independent;
+				payloadDescriptor->d       = frameMarking->discardable;
+				payloadDescriptor->b       = frameMarking->base;
+				payloadDescriptor->tlIndex = frameMarking->tid;
+
+				payloadDescriptor->hasTlIndex = true;
+
+				if (frameMarkingLen >= 2)
+				{
+					payloadDescriptor->hasSlIndex = true;
+					payloadDescriptor->slIndex    = frameMarking->lid >> 4 & 0x07;
+				}
+
+				if (frameMarkingLen == 3)
+				{
+					payloadDescriptor->hasTl0picidx = true;
+					payloadDescriptor->tl0picidx    = frameMarking->tl0picidx;
+				}
+
+				// Detect key frame.
+				if (frameMarking->start && frameMarking->independent)
+					payloadDescriptor->isKeyFrame = true;
+			}
+
+			// NOTE: Unfortunately libwebrtc produces wrong Frame-Marking (without i=1 in
+			// keyframes) when it uses H264 hardware encoder (at least in Mac):
+			//   https://bugs.chromium.org/p/webrtc/issues/detail?id=10746
+			//
+			// As a temporal workaround, always do payload parsing to detect keyframes if
+			// there is no frame-marking or if there is but keyframe was not detected above.
+			if (!frameMarking || !payloadDescriptor->isKeyFrame)
+			{
+				uint8_t nal = *data & 0x1F;
+
+				switch (nal)
+				{
+					// Single NAL unit packet.
+					// IDR (instantaneous decoding picture).
+					case 1:
+					case 5:
+					case 7:
+					case 14:
+					case 20:
+					{
+						payloadDescriptor =
+						  H264_SVC::ParseSingleNalu(data, len, std::move(payloadDescriptor), true);
+
+						if (payloadDescriptor == nullptr)
+							return nullptr;
+
+						break;
+					}
+
+					// Aggreation packet.
+					// STAP-A.
+					case 24:
+					{
+						size_t offset{ 1 };
+
+						len -= 1;
+
+						// Iterate NAL units.
+						while (len >= 3)
+						{
+							auto naluSize = Utils::Byte::Get2Bytes(data, offset);
+
+							payloadDescriptor = H264_SVC::ParseSingleNalu(
+							  (data + offset + sizeof(naluSize)),
+							  (len - sizeof(naluSize)),
+							  std::move(payloadDescriptor),
+							  true);
+							if (payloadDescriptor == nullptr)
+								return nullptr;
+
+							if (payloadDescriptor->isKeyFrame)
+							{
+								break;
+							}
+
+							// Check if there is room for the indicated NAL unit size.
+							if (len < (naluSize + sizeof(naluSize)))
+								break;
+
+							offset += naluSize + sizeof(naluSize);
+							len -= naluSize + sizeof(naluSize);
+						}
+
+						break;
+					}
+
+					// Aggreation packet.
+					// FU-A, FU-B.
+					case 28:
+					case 29:
+					{
+						uint8_t startBit = *(data + 1) & 0x80;
+
+						if (startBit == 128)
+						{
+							payloadDescriptor = H264_SVC::ParseSingleNalu(
+							  (data + 1), (len - 1), std::move(payloadDescriptor), (startBit == 128 ? true : false));
+						}
+						if (payloadDescriptor == nullptr)
+							return nullptr;
+
+						break;
+					}
+				}
+			}
+
+			return payloadDescriptor.release();
+		}
+
+		std::unique_ptr<H264_SVC::PayloadDescriptor> H264_SVC::ParseSingleNalu(
+		  const uint8_t* data,
+		  size_t len,
+		  std::unique_ptr<H264_SVC::PayloadDescriptor> payloadDescriptor,
+		  bool isStartBit)
+		{
+			uint8_t nal = *data & 0x1F;
+
+			switch (nal)
+			{
+				// Single NAL unit packet.
+				// IDR (instantaneous decoding picture).
+				case 5:
+					payloadDescriptor->isKeyFrame = true;
+				case 1:
+				{
+					payloadDescriptor->slIndex = 0;
+					payloadDescriptor->tlIndex = 0;
+
+					payloadDescriptor->hasSlIndex = false;
+					payloadDescriptor->hasTlIndex = false;
+
+					break;
+				}
+				case 14:
+				case 20:
+				{
+					size_t offset{ 1 };
+					uint8_t byte = data[offset];
+
+					payloadDescriptor->idr        = byte >> 6 & 0x01;
+					payloadDescriptor->priorityId = byte & 0x06;
+					payloadDescriptor->isKeyFrame = (isStartBit && payloadDescriptor->idr) ? true : false;
+
+					if (len < ++offset + 1)
+						return nullptr;
+
+					byte                                  = data[offset];
+					payloadDescriptor->noIntLayerPredFlag = byte >> 7 & 0x01;
+					payloadDescriptor->slIndex            = byte >> 4 & 0x03;
+
+					if (len < ++offset + 1)
+						return nullptr;
+
+					byte = data[offset];
+
+					payloadDescriptor->tlIndex = byte >> 5 & 0x03;
+
+					payloadDescriptor->hasSlIndex = payloadDescriptor->slIndex ? true : false;
+					payloadDescriptor->hasTlIndex = payloadDescriptor->tlIndex ? true : false;
+
+					break;
+				}
+				case 7:
+				{
+					payloadDescriptor->isKeyFrame = isStartBit ? true : false;
+
+					break;
+				}
+			}
+			return payloadDescriptor;
+		}
+
+		void H264_SVC::ProcessRtpPacket(RTC::RtpPacket* packet)
+		{
+			MS_TRACE();
+
+			auto* data = packet->GetPayload();
+			auto len   = packet->GetPayloadLength();
+			RtpPacket::FrameMarking* frameMarking{ nullptr };
+			uint8_t frameMarkingLen{ 0 };
+
+			// Read frame-marking.
+			packet->ReadFrameMarking(&frameMarking, frameMarkingLen);
+
+			PayloadDescriptor* payloadDescriptor =
+			  H264_SVC::Parse(data, len, frameMarking, frameMarkingLen);
+
+			if (!payloadDescriptor)
+				return;
+
+			auto* payloadDescriptorHandler = new PayloadDescriptorHandler(payloadDescriptor);
+
+			packet->SetPayloadDescriptorHandler(payloadDescriptorHandler);
+		}
+
+		/* Instance methods. */
+
+		void H264_SVC::PayloadDescriptor::Dump() const
+		{
+			MS_TRACE();
+
+			MS_DUMP("<PayloadDescriptor>");
+			MS_DUMP(
+			  "  s:%" PRIu8 "|e:%" PRIu8 "|i:%" PRIu8 "|d:%" PRIu8 "|b:%" PRIu8,
+			  this->s,
+			  this->e,
+			  this->i,
+			  this->d,
+			  this->b);
+			MS_DUMP("  hasSlIndex           : %s", this->hasSlIndex ? "true" : "false");
+			MS_DUMP("  hasTlIndex           : %s", this->hasTlIndex ? "true" : "false");
+			MS_DUMP("  tl0picidx            : %" PRIu8, this->tl0picidx);
+			MS_DUMP("  noIntLayerPredFlag   : %" PRIu8, this->noIntLayerPredFlag);
+			MS_DUMP("  isKeyFrame           : %s", this->isKeyFrame ? "true" : "false");
+			MS_DUMP("</PayloadDescriptor>");
+		}
+
+		H264_SVC::PayloadDescriptorHandler::PayloadDescriptorHandler(
+		  H264_SVC::PayloadDescriptor* payloadDescriptor)
+		{
+			MS_TRACE();
+
+			this->payloadDescriptor.reset(payloadDescriptor);
+		}
+
+		bool H264_SVC::PayloadDescriptorHandler::Process(
+		  RTC::Codecs::EncodingContext* encodingContext, uint8_t* /*data*/, bool& marker)
+		{
+			MS_TRACE();
+
+			auto* context = static_cast<RTC::Codecs::H264_SVC::EncodingContext*>(encodingContext);
+
+			MS_ASSERT(context->GetTargetSpatialLayer() >= 0, "target spatial layer cannot be -1");
+			MS_ASSERT(context->GetTargetTemporalLayer() >= 0, "target temporal layer cannot be -1");
+
+			auto packetSpatialLayer  = GetSpatialLayer();
+			auto packetTemporalLayer = GetTemporalLayer();
+			auto tmpSpatialLayer     = context->GetCurrentSpatialLayer();
+			auto tmpTemporalLayer    = context->GetCurrentTemporalLayer();
+
+			// If packet spatial or temporal layer is higher than maximum announced
+			// one, drop the packet.
+			// clang-format off
+			if (
+				packetSpatialLayer >= context->GetSpatialLayers() ||
+				packetTemporalLayer >= context->GetTemporalLayers()
+			)
+			// clang-format on
+			{
+				MS_WARN_TAG(
+				  rtp, "too high packet layers %" PRIu8 ":%" PRIu8, packetSpatialLayer, packetTemporalLayer);
+
+				return false;
+			}
+
+			// clang-format off
+			bool isOldPacket = false;
+
+			// Upgrade current spatial layer if needed.
+			if (context->GetTargetSpatialLayer() > context->GetCurrentSpatialLayer())
+			{
+				if (this->payloadDescriptor->isKeyFrame)
+				{
+					MS_DEBUG_DEV(
+					  "upgrading tmpSpatialLayer from %" PRIu16 " to %" PRIu16 " (packet:%" PRIu8 ":%" PRIu8
+					  ")",
+					  context->GetCurrentSpatialLayer(),
+					  context->GetTargetSpatialLayer(),
+					  packetSpatialLayer,
+					  packetTemporalLayer);
+
+					tmpSpatialLayer  = context->GetTargetSpatialLayer();
+					tmpTemporalLayer = 0; // Just in case.
+				}
+			}
+			// Downgrade current spatial layer if needed.
+			else if (context->GetTargetSpatialLayer() < context->GetCurrentSpatialLayer())
+			{
+				// In K-SVC we must wait for a keyframe.
+				if (context->IsKSvc())
+				{
+					if (this->payloadDescriptor->isKeyFrame)
+					// clang-format on
+					{
+						MS_DEBUG_DEV(
+						  "downgrading tmpSpatialLayer from %" PRIu16 " to %" PRIu16 " (packet:%" PRIu8
+						  ":%" PRIu8 ") after keyframe (K-SVC)",
+						  context->GetCurrentSpatialLayer(),
+						  context->GetTargetSpatialLayer(),
+						  packetSpatialLayer,
+						  packetTemporalLayer);
+
+						tmpSpatialLayer  = context->GetTargetSpatialLayer();
+						tmpTemporalLayer = 0; // Just in case.
+					}
+				}
+				// In full SVC we do not need a keyframe.
+				else
+				{
+					// clang-format off
+					if (
+						packetSpatialLayer == context->GetTargetSpatialLayer() &&
+						this->payloadDescriptor->e
+					)
+					// clang-format on
+					{
+						MS_DEBUG_DEV(
+						  "downgrading tmpSpatialLayer from %" PRIu16 " to %" PRIu16 " (packet:%" PRIu8
+						  ":%" PRIu8 ") without keyframe (full SVC)",
+						  context->GetCurrentSpatialLayer(),
+						  context->GetTargetSpatialLayer(),
+						  packetSpatialLayer,
+						  packetTemporalLayer);
+
+						tmpSpatialLayer  = context->GetTargetSpatialLayer();
+						tmpTemporalLayer = 0; // Just in case.
+					}
+				}
+			}
+
+			// Filter spatial layers higher than current one (unless old packet).
+			if (packetSpatialLayer > tmpSpatialLayer && !isOldPacket)
+				return false;
+
+			// Check and handle temporal layer (unless old packet).
+			if (!isOldPacket)
+			{
+				// Upgrade current temporal layer if needed.
+				if (context->GetTargetTemporalLayer() > context->GetCurrentTemporalLayer())
+				{
+					// clang-format off
+					if (
+						packetTemporalLayer >= context->GetCurrentTemporalLayer() + 1 &&
+						this->payloadDescriptor->s
+					)
+					// clang-format on
+					{
+						MS_DEBUG_DEV(
+						  "upgrading tmpTemporalLayer from %" PRIu16 " to %" PRIu8 " (packet:%" PRIu8 ":%" PRIu8
+						  ")",
+						  context->GetCurrentTemporalLayer(),
+						  packetTemporalLayer,
+						  packetSpatialLayer,
+						  packetTemporalLayer);
+
+						tmpTemporalLayer = packetTemporalLayer;
+					}
+				}
+				// Downgrade current temporal layer if needed.
+				else if (context->GetTargetTemporalLayer() < context->GetCurrentTemporalLayer())
+				{
+					// clang-format off
+					if (
+						packetTemporalLayer == context->GetTargetTemporalLayer() &&
+						this->payloadDescriptor->e
+					)
+					// clang-format on
+					{
+						MS_DEBUG_DEV(
+						  "downgrading tmpTemporalLayer from %" PRIu16 " to %" PRIu16 " (packet:%" PRIu8
+						  ":%" PRIu8 ")",
+						  context->GetCurrentTemporalLayer(),
+						  context->GetTargetTemporalLayer(),
+						  packetSpatialLayer,
+						  packetTemporalLayer);
+
+						tmpTemporalLayer = context->GetTargetTemporalLayer();
+					}
+				}
+
+				// Filter temporal layers higher than current one.
+				if (packetTemporalLayer > tmpTemporalLayer)
+					return false;
+			}
+
+			// Set marker bit if needed.
+			if (packetSpatialLayer == tmpSpatialLayer && this->payloadDescriptor->e)
+				marker = true;
+
+			// Update current spatial layer if needed.
+			if (tmpSpatialLayer != context->GetCurrentSpatialLayer())
+				context->SetCurrentSpatialLayer(tmpSpatialLayer);
+
+			// Update current temporal layer if needed.
+			if (tmpTemporalLayer != context->GetCurrentTemporalLayer())
+				context->SetCurrentTemporalLayer(tmpTemporalLayer);
+
+			return true;
+		}
+
+		void H264_SVC::PayloadDescriptorHandler::Restore(uint8_t* /*data*/)
+		{
+			MS_TRACE();
+		}
+	} // namespace Codecs
+} // namespace RTC

package/worker/src/RTC/DirectTransport.cpp

@@ -20,6 +20,8 @@ namespace RTC
 	DirectTransport::~DirectTransport()
 	{
 		MS_TRACE();
+
+		delete[] this->buffer;
 	}
 
 	void DirectTransport::FillJson(json& jsonObject) const
@@ -102,7 +104,14 @@ namespace RTC
 					return;
 				}
 
-				RTC::RtpPacket* packet = RTC::RtpPacket::Parse(data, len);
+				// If this is the first time to reveive a RTP packet then allocate the receiving buffer now.
+				if (!this->buffer)
+					this->buffer = new uint8_t[RTC::MtuSize + 100];
+
+				// Copy the received packet into this buffer so it can be expanded later.
+				std::memcpy(this->buffer, data, static_cast<size_t>(len));
+
+				RTC::RtpPacket* packet = RTC::RtpPacket::Parse(this->buffer, len);
 
 				if (!packet)
 				{

package/worker/src/RTC/NackGenerator.cpp

@@ -12,15 +12,16 @@ namespace RTC
 {
 	/* Static. */
 
-	constexpr size_t MaxPacketAge{ 10000u };
-	constexpr size_t MaxNackPackets{ 1000u };
-	constexpr uint32_t DefaultRtt{ 100u };
-	constexpr uint8_t MaxNackRetries{ 10u };
-	constexpr uint64_t TimerInterval{ 40u };
+	static constexpr size_t MaxPacketAge{ 10000u };
+	static constexpr size_t MaxNackPackets{ 1000u };
+	static constexpr uint32_t DefaultRtt{ 100u };
+	static constexpr uint8_t MaxNackRetries{ 10u };
+	static constexpr uint64_t TimerInterval{ 40u };
 
 	/* Instance methods. */
 
-	NackGenerator::NackGenerator(Listener* listener) : listener(listener), rtt(DefaultRtt)
+	NackGenerator::NackGenerator(Listener* listener, unsigned int sendNackDelayMs)
+	  : listener(listener), sendNackDelayMs(sendNackDelayMs), rtt(DefaultRtt)
 	{
 		MS_TRACE();
 
@@ -74,9 +75,14 @@ namespace RTC
 				  packet->GetSequenceNumber(),
 				  isRecovered ? "true" : "false");
 
+				auto retries = it->second.retries;
+
 				this->nackList.erase(it);
 
-				return true;
+				if (retries != 0)
+					return true;
+				else
+					return false;
 			}
 
 			// Out of order packet or already handled NACKed packet.
@@ -183,7 +189,13 @@ namespace RTC
 			if (this->recoveredList.find(seq) != this->recoveredList.end())
 				continue;
 
-			this->nackList.emplace(std::make_pair(seq, NackInfo{ seq, seq }));
+			this->nackList.emplace(std::make_pair(
+			  seq,
+			  NackInfo{
+			    DepLibUV::GetTimeMs(),
+			    seq,
+			    seq,
+			  }));
 		}
 	}
 
@@ -226,6 +238,12 @@ namespace RTC
 			NackInfo& nackInfo = it->second;
 			uint16_t seq       = nackInfo.seq;
 
+			if (this->sendNackDelayMs > 0 && nowMs - nackInfo.createdAtMs < this->sendNackDelayMs)
+			{
+				++it;
+				continue;
+			}
+
 			// clang-format off
 			if (
 				filter == NackFilter::SEQ &&
@@ -259,7 +277,7 @@ namespace RTC
 				continue;
 			}
 
-			if (filter == NackFilter::TIME && nowMs - nackInfo.sentAtMs >= this->rtt)
+			if (filter == NackFilter::TIME && (nackInfo.sentAtMs == 0 || nowMs - nackInfo.sentAtMs >= this->rtt))
 			{
 				nackBatch.emplace_back(seq);
 				nackInfo.retries++;

package/worker/src/RTC/PipeConsumer.cpp

@@ -312,6 +312,16 @@ namespace RTC
 
 		packet->AddSdesChunk(sdesChunk);
 
+		auto* dlrr = rtpStream->GetRtcpXrDelaySinceLastRr(nowMs);
+
+		if (dlrr)
+		{
+			auto* report = new RTC::RTCP::DelaySinceLastRr();
+
+			report->AddSsrcInfo(dlrr);
+			packet->AddDelaySinceLastRr(report);
+		}
+
 		this->lastRtcpSentTime = nowMs;
 	}
 
@@ -388,6 +398,16 @@ namespace RTC
 		rtpStream->ReceiveRtcpReceiverReport(report);
 	}
 
+	void PipeConsumer::ReceiveRtcpXrReceiverReferenceTime(RTC::RTCP::ReceiverReferenceTime* report)
+	{
+		MS_TRACE();
+
+		for (auto* rtpStream : this->rtpStreams)
+		{
+			rtpStream->ReceiveRtcpXrReceiverReferenceTime(report);
+		}
+	}
+
 	uint32_t PipeConsumer::GetTransmissionRate(uint64_t nowMs)
 	{
 		MS_TRACE();

package/worker/src/RTC/Producer.cpp

@@ -18,6 +18,10 @@
 
 namespace RTC
 {
+	/* Static. */
+
+	static constexpr unsigned int SendNackDelay{ 10u }; // In ms.
+
 	/* Instance methods. */
 
 	Producer::Producer(const std::string& id, RTC::Producer::Listener* listener, json& data)
@@ -1139,7 +1143,7 @@ namespace RTC
 		}
 
 		// Create a RtpStreamRecv for receiving a media stream.
-		auto* rtpStream = new RTC::RtpStreamRecv(this, params);
+		auto* rtpStream = new RTC::RtpStreamRecv(this, params, SendNackDelay);
 
 		// Insert into the maps.
 		this->mapSsrcRtpStream[ssrc]              = rtpStream;

package/worker/src/RTC/RTCP/CompoundPacket.cpp

@@ -145,5 +145,12 @@ namespace RTC
 
 			this->xrPacket.AddReport(report);
 		}
+
+		void CompoundPacket::AddDelaySinceLastRr(DelaySinceLastRr* report)
+		{
+			MS_TRACE();
+
+			this->xrPacket.AddReport(report);
+		}
 	} // namespace RTCP
 } // namespace RTC

package/worker/src/RTC/RtpDictionaries/RtpCodecMimeType.cpp

@@ -36,6 +36,7 @@ namespace RTC
 		{ "vp8",             RtpCodecMimeType::Subtype::VP8             },
 		{ "vp9",             RtpCodecMimeType::Subtype::VP9             },
 		{ "h264",            RtpCodecMimeType::Subtype::H264            },
+		{ "h264-svc",        RtpCodecMimeType::Subtype::H264_SVC        },
 		{ "x-h264uc",        RtpCodecMimeType::Subtype::X_H264UC        },
 		{ "h265",            RtpCodecMimeType::Subtype::H265            },
 		// Complementary codecs:
@@ -63,6 +64,7 @@ namespace RTC
 		{ RtpCodecMimeType::Subtype::VP8,             "VP8"             },
 		{ RtpCodecMimeType::Subtype::VP9,             "VP9"             },
 		{ RtpCodecMimeType::Subtype::H264,            "H264"            },
+		{ RtpCodecMimeType::Subtype::H264_SVC,        "H264-SVC"        },
 		{ RtpCodecMimeType::Subtype::X_H264UC,        "X-H264UC"        },
 		{ RtpCodecMimeType::Subtype::H265,            "H265"            },
 		// Complementary codecs:

package/worker/src/RTC/RtpStreamRecv.cpp

@@ -182,15 +182,16 @@ namespace RTC
 
 	/* Instance methods. */
 
-	RtpStreamRecv::RtpStreamRecv(RTC::RtpStreamRecv::Listener* listener, RTC::RtpStream::Params& params)
-	  : RTC::RtpStream::RtpStream(listener, params, 10),
+	RtpStreamRecv::RtpStreamRecv(
+	  RTC::RtpStreamRecv::Listener* listener, RTC::RtpStream::Params& params, unsigned int sendNackDelayMs)
+	  : RTC::RtpStream::RtpStream(listener, params, 10), sendNackDelayMs(sendNackDelayMs),
 	    transmissionCounter(
 	      params.spatialLayers, params.temporalLayers, this->params.useDtx ? 6000 : 2500)
 	{
 		MS_TRACE();
 
 		if (this->params.useNack)
-			this->nackGenerator.reset(new RTC::NackGenerator(this));
+			this->nackGenerator.reset(new RTC::NackGenerator(this, this->sendNackDelayMs));
 
 		// Run the RTP inactivity periodic timer (use a different timeout if DTX is
 		// enabled).

package/worker/src/RTC/RtpStreamSend.cpp

@@ -186,6 +186,15 @@ namespace RTC
 		UpdateScore(report);
 	}
 
+	void RtpStreamSend::ReceiveRtcpXrReceiverReferenceTime(RTC::RTCP::ReceiverReferenceTime* report)
+	{
+		MS_TRACE();
+
+		this->lastRrReceivedMs = DepLibUV::GetTimeMs();
+		this->lastRrTimestamp  = report->GetNtpSec() << 16;
+		this->lastRrTimestamp += report->GetNtpFrac() >> 16;
+	}
+
 	RTC::RTCP::SenderReport* RtpStreamSend::GetRtcpSenderReport(uint64_t nowMs)
 	{
 		MS_TRACE();
@@ -214,6 +223,29 @@ namespace RTC
 		return report;
 	}
 
+	RTC::RTCP::DelaySinceLastRr::SsrcInfo* RtpStreamSend::GetRtcpXrDelaySinceLastRr(uint64_t nowMs)
+	{
+		MS_TRACE();
+
+		if (this->lastRrReceivedMs == 0u)
+			return nullptr;
+
+		// Get delay in milliseconds.
+		auto delayMs = static_cast<uint32_t>(nowMs - this->lastRrReceivedMs);
+		// Express delay in units of 1/65536 seconds.
+		uint32_t dlrr = (delayMs / 1000) << 16;
+
+		dlrr |= uint32_t{ (delayMs % 1000) * 65536 / 1000 };
+
+		auto* ssrcInfo = new RTC::RTCP::DelaySinceLastRr::SsrcInfo();
+
+		ssrcInfo->SetSsrc(GetSsrc());
+		ssrcInfo->SetDelaySinceLastReceiverReport(dlrr);
+		ssrcInfo->SetLastReceiverReport(this->lastRrTimestamp);
+
+		return ssrcInfo;
+	}
+
 	RTC::RTCP::SdesChunk* RtpStreamSend::GetRtcpSdesChunk()
 	{
 		MS_TRACE();