mediasoup 3.26.0 → 3.27.0

package/worker/src/RTC/Transport.cpp

@@ -11,10 +11,12 @@
 #include "RTC/Consumer.hpp"
 #include "RTC/RTCP/FeedbackPs.hpp"
 #include "RTC/RTCP/FeedbackPsAfb.hpp"
+#include "RTC/RTCP/FeedbackPsFir.hpp"
 #include "RTC/RTCP/FeedbackPsRemb.hpp"
 #include "RTC/RTCP/FeedbackRtpNack.hpp"
 #include "RTC/RTCP/FeedbackRtpTransport.hpp"
 #include "RTC/RTCP/XrDelaySinceLastRr.hpp"
+#include "RTC/RTP/ProbationGenerator.hpp"
 #include "RTC/RtpDictionaries.hpp"
 #include "RTC/SCTP/association/Association.hpp"
 #include "RTC/SCTP/public/SctpOptions.hpp"
@@ -23,13 +25,21 @@
 #ifdef MS_RTC_LOGGER_RTP
 #include "RTC/RtcLogger.hpp"
 #endif
+#ifndef MS_USE_BUILTIN_BWE
 #include <libwebrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h> // webrtc::RtpPacketSendInfo
+#endif
 #include <array>
-#include <iterator> // std::ostream_iterator
-#include <map>      // std::multimap
+#include <limits> // std::numeric_limits
+#include <map>    // std::multimap
 
 namespace RTC
 {
+	/* Static. */
+
+	// Bitrate the outgoing target is never taken below (bps), whatever the API
+	// asks for.
+	static constexpr int64_t AbsoluteMinOutgoingBitrate{ 30000 };
+
 	/* Instance methods. */
 
 	Transport::Transport(
@@ -57,7 +67,10 @@ namespace RTC
 		  auto initialAvailableOutgoingBitrate = options->initialAvailableOutgoingBitrate();
 		  initialAvailableOutgoingBitrate.has_value())
 		{
-			this->initialAvailableOutgoingBitrate = initialAvailableOutgoingBitrate.value();
+			// NOTE: The API gives an unsigned 64 bits bitrate, so it is clamped here.
+			this->initialAvailableOutgoingBitrate = static_cast<int64_t>(std::min<uint64_t>(
+			  initialAvailableOutgoingBitrate.value(),
+			  static_cast<uint64_t>(std::numeric_limits<int64_t>::max())));
 		}
 
 		if (options->enableSctp())
@@ -84,7 +97,7 @@ namespace RTC
 		}
 
 		// Create the RTCP timer.
-		this->rtcpTimer = this->shared->CreateTimer(this);
+		this->rtcpTimer = this->shared->CreateTimer(this, "transport-rtcp");
 	}
 
 	Transport::~Transport()
@@ -388,7 +401,7 @@ namespace RTC
 		  this->maxReceiveMessageSize,
 		  sctpParameters,
 		  this->sctpAssociation ? flatbuffers::Optional<FBS::SctpAssociation::SctpState>(sctpState)
-		                        : flatbuffers::nullopt,
+			                      : flatbuffers::nullopt,
 		  sctpNegotiatedCapabilities,
 		  sctpListener,
 		  std::addressof(traceEventTypes));
@@ -399,7 +412,7 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		auto nowMs = this->shared->GetTimeMs();
+		const int64_t nowMs = this->shared->GetTimeMs();
 
 		// Add sctpState.
 		FBS::SctpAssociation::SctpState sctpState{ FBS::SctpAssociation::SctpState::NEW };
@@ -437,64 +450,86 @@ namespace RTC
 			}
 		}
 
+#ifdef MS_USE_BUILTIN_BWE
+		// TODO: Take these from the built-in downlink and uplink BWE.
+		const flatbuffers::Optional<uint64_t> availableOutgoingBitrate{ flatbuffers::nullopt };
+		const flatbuffers::Optional<uint64_t> availableIncomingBitrate{ flatbuffers::nullopt };
+		const flatbuffers::Optional<double> rtpPacketLossReceived{ flatbuffers::nullopt };
+		const flatbuffers::Optional<double> rtpPacketLossSent{ flatbuffers::nullopt };
+#else
+		const auto availableOutgoingBitrate =
+		  this->tccClient ? flatbuffers::Optional<uint64_t>(
+		                      static_cast<uint64_t>(this->tccClient->GetAvailableBitrate()))
+			                : flatbuffers::nullopt;
+		const auto availableIncomingBitrate =
+		  this->tccServer ? flatbuffers::Optional<uint64_t>(
+		                      static_cast<uint64_t>(this->tccServer->GetAvailableBitrate()))
+			                : flatbuffers::nullopt;
+		const auto rtpPacketLossReceived =
+		  this->tccServer ? flatbuffers::Optional<double>(this->tccServer->GetPacketLoss())
+			                : flatbuffers::nullopt;
+		const auto rtpPacketLossSent =
+		  this->tccClient ? flatbuffers::Optional<double>(this->tccClient->GetPacketLoss())
+			                : flatbuffers::nullopt;
+#endif
+
 		return FBS::Transport::CreateStatsDirect(
 		  builder,
 		  // transportId.
 		  this->id.c_str(),
 		  // timestamp.
-		  nowMs,
+		  static_cast<uint64_t>(nowMs),
 		  // sctpState.
 		  this->sctpAssociation ? flatbuffers::Optional<FBS::SctpAssociation::SctpState>(sctpState)
-		                        : flatbuffers::nullopt,
+			                      : flatbuffers::nullopt,
 		  // bytesReceived.
 		  this->recvTransmission.GetBytes(),
 		  // recvBitrate.
-		  this->recvTransmission.GetRate(nowMs),
+		  static_cast<uint64_t>(this->recvTransmission.GetRate(nowMs)),
 		  // bytesSent.
 		  this->sendTransmission.GetBytes(),
 		  // sendBitrate.
-		  this->sendTransmission.GetRate(nowMs),
+		  static_cast<uint64_t>(this->sendTransmission.GetRate(nowMs)),
 		  // rtpBytesReceived.
 		  this->recvRtpTransmission.GetBytes(),
 		  // rtpRecvBitrate.
-		  this->recvRtpTransmission.GetBitrate(nowMs),
+		  static_cast<uint64_t>(this->recvRtpTransmission.GetBitrate(nowMs)),
 		  // rtpBytesSent.
 		  this->sendRtpTransmission.GetBytes(),
 		  // rtpSendBitrate.
-		  this->sendRtpTransmission.GetBitrate(nowMs),
+		  static_cast<uint64_t>(this->sendRtpTransmission.GetBitrate(nowMs)),
 		  // rtxBytesReceived.
 		  this->recvRtxTransmission.GetBytes(),
 		  // rtxRecvBitrate.
-		  this->recvRtxTransmission.GetBitrate(nowMs),
+		  static_cast<uint64_t>(this->recvRtxTransmission.GetBitrate(nowMs)),
 		  // rtxBytesSent.
 		  this->sendRtxTransmission.GetBytes(),
 		  // rtxSendBitrate.
-		  this->sendRtxTransmission.GetBitrate(nowMs),
+		  static_cast<uint64_t>(this->sendRtxTransmission.GetBitrate(nowMs)),
 		  // probationBytesSent.
 		  this->sendProbationTransmission.GetBytes(),
 		  // probationSendBitrate.
-		  this->sendProbationTransmission.GetBitrate(nowMs),
+		  static_cast<uint64_t>(this->sendProbationTransmission.GetBitrate(nowMs)),
 		  // availableOutgoingBitrate.
-		  this->tccClient ? flatbuffers::Optional<uint32_t>(this->tccClient->GetAvailableBitrate())
-		                  : flatbuffers::nullopt,
+		  availableOutgoingBitrate,
 		  // availableIncomingBitrate.
-		  this->tccServer ? flatbuffers::Optional<uint32_t>(this->tccServer->GetAvailableBitrate())
-		                  : flatbuffers::nullopt,
+		  availableIncomingBitrate,
 		  // maxIncomingBitrate.
-		  this->maxIncomingBitrate ? flatbuffers::Optional<uint32_t>(this->maxIncomingBitrate)
-		                           : flatbuffers::nullopt,
+		  this->maxIncomingBitrate > 0
+		    ? flatbuffers::Optional<uint64_t>(static_cast<uint64_t>(this->maxIncomingBitrate))
+				: flatbuffers::nullopt,
 		  // maxOutgoingBitrate.
-		  this->maxOutgoingBitrate ? flatbuffers::Optional<uint32_t>(this->maxOutgoingBitrate)
-		                           : flatbuffers::nullopt,
+		  this->maxOutgoingBitrate > 0
+		    ? flatbuffers::Optional<uint64_t>(static_cast<uint64_t>(this->maxOutgoingBitrate))
+				: flatbuffers::nullopt,
 		  // minOutgoingBitrate.
-		  this->minOutgoingBitrate ? flatbuffers::Optional<uint32_t>(this->minOutgoingBitrate)
-		                           : flatbuffers::nullopt,
+		  this->minOutgoingBitrate > 0
+		    ? flatbuffers::Optional<uint64_t>(static_cast<uint64_t>(this->minOutgoingBitrate))
+				: flatbuffers::nullopt,
 		  // rtpPacketLossReceived.
-		  this->tccServer ? flatbuffers::Optional<double>(this->tccServer->GetPacketLoss())
-		                  : flatbuffers::nullopt,
+		  rtpPacketLossReceived,
 		  // rtpPacketLossSent.
-		  this->tccClient ? flatbuffers::Optional<double>(this->tccClient->GetPacketLoss())
-		                  : flatbuffers::nullopt);
+		  rtpPacketLossSent);
 	}
 
 	void Transport::HandleRequest(Channel::ChannelRequest* request)
@@ -507,16 +542,22 @@ namespace RTC
 			{
 				const auto* body = request->data->body_as<FBS::Transport::SetMaxIncomingBitrateRequest>();
 
-				this->maxIncomingBitrate = body->maxIncomingBitrate();
+				// NOTE: The API gives an unsigned 64 bits bitrate, so it is clamped here.
+				this->maxIncomingBitrate = static_cast<int64_t>(std::min<uint64_t>(
+				  body->maxIncomingBitrate(), static_cast<uint64_t>(std::numeric_limits<int64_t>::max())));
 
-				MS_DEBUG_TAG(bwe, "maximum incoming bitrate set to %" PRIu32, this->maxIncomingBitrate);
+				MS_DEBUG_TAG(bwe, "maximum incoming bitrate set to %" PRIi64, this->maxIncomingBitrate);
 
 				request->Accept();
 
+#ifdef MS_USE_BUILTIN_BWE
+				// TODO: Pass maxIncomingBitrate to the built-in uplink BWE.
+#else
 				if (this->tccServer)
 				{
 					this->tccServer->SetMaxIncomingBitrate(this->maxIncomingBitrate);
 				}
+#endif
 
 				break;
 			}
@@ -524,21 +565,27 @@ namespace RTC
 			case Channel::ChannelRequest::Method::TRANSPORT_SET_MAX_OUTGOING_BITRATE:
 			{
 				const auto* body = request->data->body_as<FBS::Transport::SetMaxOutgoingBitrateRequest>();
-				const uint32_t bitrate = body->maxOutgoingBitrate();
 
-				if (bitrate > 0u && bitrate < RTC::TransportCongestionControlMinOutgoingBitrate)
+				// NOTE: The API gives an unsigned 64 bits bitrate, so it is clamped here.
+				const auto bitrate = static_cast<int64_t>(std::min<uint64_t>(
+				  body->maxOutgoingBitrate(), static_cast<uint64_t>(std::numeric_limits<int64_t>::max())));
+
+				if (bitrate > 0 && bitrate < AbsoluteMinOutgoingBitrate)
 				{
 					MS_THROW_TYPE_ERROR(
-					  "bitrate must be >= %" PRIu32 " or 0 (unlimited)",
-					  RTC::TransportCongestionControlMinOutgoingBitrate);
+					  "bitrate must be >= %" PRIi64 " or 0 (unlimited)", AbsoluteMinOutgoingBitrate);
 				}
-				else if (bitrate > 0u && bitrate < this->minOutgoingBitrate)
+				else if (bitrate > 0 && bitrate < this->minOutgoingBitrate)
 				{
 					MS_THROW_TYPE_ERROR(
-					  "bitrate must be >= current min outgoing bitrate (%" PRIu32 ") or 0 (unlimited)",
+					  "bitrate must be >= current min outgoing bitrate (%" PRIi64 ") or 0 (unlimited)",
 					  this->minOutgoingBitrate);
 				}
 
+#ifdef MS_USE_BUILTIN_BWE
+				// TODO: Pass maxOutgoingBitrate to the built-in downlink BWE.
+				this->maxOutgoingBitrate = bitrate;
+#else
 				if (this->tccClient)
 				{
 					// NOTE: This may throw so don't update things before calling this
@@ -546,7 +593,7 @@ namespace RTC
 					this->tccClient->SetMaxOutgoingBitrate(bitrate);
 					this->maxOutgoingBitrate = bitrate;
 
-					MS_DEBUG_TAG(bwe, "maximum outgoing bitrate set to %" PRIu32, this->maxOutgoingBitrate);
+					MS_DEBUG_TAG(bwe, "maximum outgoing bitrate set to %" PRIi64, this->maxOutgoingBitrate);
 
 					ComputeOutgoingDesiredBitrate();
 				}
@@ -554,6 +601,7 @@ namespace RTC
 				{
 					this->maxOutgoingBitrate = bitrate;
 				}
+#endif
 
 				request->Accept();
 
@@ -563,21 +611,27 @@ namespace RTC
 			case Channel::ChannelRequest::Method::TRANSPORT_SET_MIN_OUTGOING_BITRATE:
 			{
 				const auto* body = request->data->body_as<FBS::Transport::SetMinOutgoingBitrateRequest>();
-				const uint32_t bitrate = body->minOutgoingBitrate();
 
-				if (bitrate > 0u && bitrate < RTC::TransportCongestionControlMinOutgoingBitrate)
+				// NOTE: The API gives an unsigned 64 bits bitrate, so it is clamped here.
+				const auto bitrate = static_cast<int64_t>(std::min<uint64_t>(
+				  body->minOutgoingBitrate(), static_cast<uint64_t>(std::numeric_limits<int64_t>::max())));
+
+				if (bitrate > 0 && bitrate < AbsoluteMinOutgoingBitrate)
 				{
 					MS_THROW_TYPE_ERROR(
-					  "bitrate must be >= %" PRIu32 " or 0 (unlimited)",
-					  RTC::TransportCongestionControlMinOutgoingBitrate);
+					  "bitrate must be >= %" PRIi64 " or 0 (unlimited)", AbsoluteMinOutgoingBitrate);
 				}
-				else if (bitrate > 0u && this->maxOutgoingBitrate > 0 && bitrate > this->maxOutgoingBitrate)
+				else if (bitrate > 0 && this->maxOutgoingBitrate > 0 && bitrate > this->maxOutgoingBitrate)
 				{
 					MS_THROW_TYPE_ERROR(
-					  "bitrate must be <= current max outgoing bitrate (%" PRIu32 ") or 0 (unlimited)",
+					  "bitrate must be <= current max outgoing bitrate (%" PRIi64 ") or 0 (unlimited)",
 					  this->maxOutgoingBitrate);
 				}
 
+#ifdef MS_USE_BUILTIN_BWE
+				// TODO: Pass minOutgoingBitrate to the built-in downlink BWE.
+				this->minOutgoingBitrate = bitrate;
+#else
 				if (this->tccClient)
 				{
 					// NOTE: This may throw so don't update things before calling this
@@ -585,7 +639,7 @@ namespace RTC
 					this->tccClient->SetMinOutgoingBitrate(bitrate);
 					this->minOutgoingBitrate = bitrate;
 
-					MS_DEBUG_TAG(bwe, "minimum outgoing bitrate set to %" PRIu32, this->minOutgoingBitrate);
+					MS_DEBUG_TAG(bwe, "minimum outgoing bitrate set to %" PRIi64, this->minOutgoingBitrate);
 
 					ComputeOutgoingDesiredBitrate();
 				}
@@ -593,6 +647,7 @@ namespace RTC
 				{
 					this->minOutgoingBitrate = bitrate;
 				}
+#endif
 
 				request->Accept();
 
@@ -703,6 +758,10 @@ namespace RTC
 
 				request->Accept(FBS::Response::Body::Transport_ProduceResponse, responseOffset);
 
+#ifdef MS_USE_BUILTIN_BWE
+				// TODO: Create the built-in uplink BWE here, choosing transport-cc or
+				// REMB out of the Producer RTP header extensions and RTCP feedback.
+#else
 				// Check if TransportCongestionControlServer or REMB server must be
 				// created.
 				const auto& rtpHeaderExtensionIds = producer->GetRtpHeaderExtensionIds();
@@ -780,6 +839,7 @@ namespace RTC
 						}
 					}
 				}
+#endif
 
 				break;
 			}
@@ -846,6 +906,11 @@ namespace RTC
 
 				request->Accept(FBS::Response::Body::Transport_ConsumeResponse, responseOffset);
 
+#ifdef MS_USE_BUILTIN_BWE
+				// TODO: Create the built-in downlink BWE here, choosing transport-cc or
+				// REMB out of the Consumer RTP header extensions and RTCP feedback, and
+				// tell every Consumer that we manage its bitrate.
+#else
 				// Check if Transport Congestion Control client must be created.
 				const auto& rtpHeaderExtensionIds = consumer->GetRtpHeaderExtensionIds();
 				const auto& codecs                = consumer->GetRtpParameters().codecs;
@@ -925,6 +990,7 @@ namespace RTC
 						  this,
 						  this->shared,
 						  bweType,
+						  AbsoluteMinOutgoingBitrate,
 						  this->initialAvailableOutgoingBitrate,
 						  this->maxOutgoingBitrate,
 						  this->minOutgoingBitrate);
@@ -942,56 +1008,6 @@ namespace RTC
 				{
 					consumer->SetExternallyManagedBitrate();
 				}
-
-#ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
-				// Create SenderBandwidthEstimator if:
-				// - not already created,
-				// - it's a video Consumer, and
-				// - there is transport-wide-cc-01 RTP header extension, and
-				// - there is "transport-cc" in codecs RTCP feedback.
-				//
-				if (
-				  !this->senderBwe && consumer->GetKind() == RTC::Media::Kind::VIDEO &&
-				  rtpHeaderExtensionIds.transportWideCc01 != 0u &&
-				  std::any_of(
-				    codecs.begin(),
-				    codecs.end(),
-				    [](const RTC::RtpCodecParameters& codec)
-				    {
-					    return std::any_of(
-					      codec.rtcpFeedback.begin(),
-					      codec.rtcpFeedback.end(),
-					      [](const RTC::RtcpFeedback& fb)
-					      {
-						      return fb.type == "transport-cc";
-					      });
-				    }))
-				{
-					MS_DEBUG_TAG(bwe, "enabling SenderBandwidthEstimator");
-
-					// Tell all the Consumers that we are gonna manage their bitrate.
-					for (auto& kv : this->mapConsumers)
-					{
-						auto* consumer = kv.second;
-
-						consumer->SetExternallyManagedBitrate();
-					};
-
-					this->senderBwe = std::make_shared<RTC::SenderBandwidthEstimator>(
-					  this, this->shared, this->initialAvailableOutgoingBitrate);
-
-					if (IsConnected())
-					{
-						this->senderBwe->TransportConnected();
-					}
-				}
-
-				// If applicable, tell the new Consumer that we are gonna manage its
-				// bitrate.
-				if (this->senderBwe)
-				{
-					consumer->SetExternallyManagedBitrate();
-				}
 #endif
 
 				if (IsConnected())
@@ -1347,10 +1363,14 @@ namespace RTC
 
 				// This may be the latest active Consumer with BWE. If so we have to stop
 				// probation.
+#ifdef MS_USE_BUILTIN_BWE
+				// TODO: Do it when the built-in downlink BWE is in place.
+#else
 				if (this->tccClient)
 				{
 					ComputeOutgoingDesiredBitrate(/*forceBitrate*/ true);
 				}
+#endif
 
 				break;
 			}
@@ -1468,7 +1488,7 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		switch (notification->event)
+		switch (notification->data->event())
 		{
 			default:
 			{
@@ -1512,8 +1532,11 @@ namespace RTC
 		}
 
 		// Start the RTCP timer.
-		this->rtcpTimer->Start(static_cast<uint64_t>(RTC::RTCP::MaxVideoIntervalMs / 2));
+		this->rtcpTimer->Start(RTC::RTCP::MaxVideoIntervalMs / 2);
 
+#ifdef MS_USE_BUILTIN_BWE
+		// TODO: Tell the built-in downlink and uplink BWE.
+#else
 		// Tell the TransportCongestionControlClient.
 		if (this->tccClient)
 		{
@@ -1525,13 +1548,6 @@ namespace RTC
 		{
 			this->tccServer->TransportConnected();
 		}
-
-#ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
-		// Tell the SenderBandwidthEstimator.
-		if (this->senderBwe)
-		{
-			this->senderBwe->TransportConnected();
-		}
 #endif
 	}
 
@@ -1550,6 +1566,9 @@ namespace RTC
 		// Stop the RTCP timer.
 		this->rtcpTimer->Stop();
 
+#ifdef MS_USE_BUILTIN_BWE
+		// TODO: Tell the built-in downlink and uplink BWE.
+#else
 		// Tell the TransportCongestionControlClient.
 		if (this->tccClient)
 		{
@@ -1561,17 +1580,10 @@ namespace RTC
 		{
 			this->tccServer->TransportDisconnected();
 		}
-
-#ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
-		// Tell the SenderBandwidthEstimator.
-		if (this->senderBwe)
-		{
-			this->senderBwe->TransportDisconnected();
-		}
 #endif
 	}
 
-	void Transport::ReceiveRtpPacket(RTC::RTP::Packet* packet)
+	void Transport::ReceiveRtpPacket(RTC::RTP::Packet* packet, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
@@ -1583,13 +1595,15 @@ namespace RTC
 		// them.
 		packet->AssignExtensionIds(this->recvRtpHeaderExtensionIds);
 
-		auto nowMs = this->shared->GetTimeMs();
-
+#ifdef MS_USE_BUILTIN_BWE
+		// TODO: Feed the built-in uplink BWE.
+#else
 		// Feed the TransportCongestionControlServer.
 		if (this->tccServer)
 		{
-			this->tccServer->IncomingPacket(nowMs, packet);
+			this->tccServer->IncomingPacket(receivedAtUs, packet);
 		}
+#endif
 
 		// Get the associated Producer.
 		RTC::Producer* producer = this->rtpListener.GetProducer(packet);
@@ -1621,7 +1635,7 @@ namespace RTC
 		//   producer->id.c_str());
 
 		// Pass the RTP packet to the corresponding Producer.
-		auto result = producer->ReceiveRtpPacket(packet);
+		auto result = producer->ReceiveRtpPacket(packet, receivedAtUs);
 
 		switch (result)
 		{
@@ -1650,14 +1664,14 @@ namespace RTC
 		delete packet;
 	}
 
-	void Transport::ReceiveRtcpPacket(RTC::RTCP::Packet* packet)
+	void Transport::ReceiveRtcpPacket(RTC::RTCP::Packet* packet, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
 		// Handle each RTCP packet.
 		while (packet)
 		{
-			HandleRtcpPacket(packet);
+			HandleRtcpPacket(packet, receivedAtUs);
 
 			auto* previousPacket = packet;
 
@@ -1667,7 +1681,7 @@ namespace RTC
 		}
 	}
 
-	void Transport::ReceiveSctpData(const uint8_t* data, size_t len)
+	void Transport::ReceiveSctpData(const uint8_t* data, size_t len, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
@@ -1679,7 +1693,7 @@ namespace RTC
 		}
 
 		// Pass it to the SctpAssociation.
-		this->sctpAssociation->ReceiveSctpData(data, len);
+		this->sctpAssociation->ReceiveSctpData(data, len, receivedAtUs);
 	}
 
 	void Transport::SendSctpMessage(
@@ -1708,7 +1722,7 @@ namespace RTC
 			.unordered          = !sctpStreamParameters.ordered,
 			.lifetimeMs         = sctpStreamParameters.ordered
 			                        ? std::nullopt
-			                        : std::optional<uint64_t>(sctpStreamParameters.maxPacketLifeTime),
+			                        : std::optional<int64_t>(sctpStreamParameters.maxPacketLifeTime),
 			.maxRetransmissions = sctpStreamParameters.ordered
 			                        ? std::nullopt
 			                        : std::optional<uint64_t>(sctpStreamParameters.maxRetransmits),
@@ -1933,7 +1947,7 @@ namespace RTC
 		}
 	}
 
-	void Transport::HandleRtcpPacket(RTC::RTCP::Packet* packet)
+	void Transport::HandleRtcpPacket(RTC::RTCP::Packet* packet, int64_t receivedAtUs)
 	{
 		MS_TRACE();
 
@@ -1970,12 +1984,15 @@ namespace RTC
 						continue;
 					}
 
-					consumer->ReceiveRtcpReceiverReport(report);
+					consumer->ReceiveRtcpReceiverReport(report, receivedAtUs);
 				}
 
+#ifdef MS_USE_BUILTIN_BWE
+				// TODO: Feed the Receiver Report to the built-in downlink BWE.
+#else
 				if (this->tccClient && !this->mapConsumers.empty())
 				{
-					float rtt = 0;
+					float rttMs = 0;
 
 					// Retrieve the RTT from the first active consumer.
 					for (auto& kv : this->mapConsumers)
@@ -1984,14 +2001,15 @@ namespace RTC
 
 						if (consumer->IsActive())
 						{
-							rtt = consumer->GetRtt();
+							rttMs = consumer->GetRttMs();
 
 							break;
 						}
 					}
 
-					this->tccClient->ReceiveRtcpReceiverReport(rr, rtt, this->shared->GetTimeMsInt64());
+					this->tccClient->ReceiveRtcpReceiverReport(rr, rttMs, receivedAtUs);
 				}
+#endif
 
 				break;
 			}
@@ -2085,11 +2103,16 @@ namespace RTC
 						{
 							auto* remb = static_cast<RTC::RTCP::FeedbackPsRembPacket*>(afb);
 
+#ifdef MS_USE_BUILTIN_BWE
+							// TODO: Pass the REMB bitrate to the built-in downlink BWE.
+							(void)remb;
+#else
 							// Pass it to the TCC client.
 							if (this->tccClient && this->tccClient->GetBweType() == RTC::BweType::REMB)
 							{
 								this->tccClient->ReceiveEstimatedBitrate(remb->GetBitrate());
 							}
+#endif
 
 							break;
 						}
@@ -2132,7 +2155,7 @@ namespace RTC
 				if (
 				  !consumer && feedback->GetMessageType() != RTC::RTCP::FeedbackRtp::MessageType::TCC &&
 				  (feedback->GetMediaSsrc() != RTC::RTP::ProbationGenerator::Ssrc ||
-				   !GetConsumerByRtxSsrc(feedback->GetMediaSsrc())))
+					 !GetConsumerByRtxSsrc(feedback->GetMediaSsrc())))
 				{
 					MS_DEBUG_TAG(
 					  rtcp,
@@ -2171,17 +2194,14 @@ namespace RTC
 					{
 						auto* feedback = static_cast<RTC::RTCP::FeedbackRtpTransportPacket*>(packet);
 
+#ifdef MS_USE_BUILTIN_BWE
+						// TODO: Feed the transport-cc feedback to the built-in downlink BWE.
+						(void)feedback;
+#else
 						if (this->tccClient)
 						{
 							this->tccClient->ReceiveRtcpTransportFeedback(feedback);
 						}
-
-#ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
-						// Pass it to the SenderBandwidthEstimator client.
-						if (this->senderBwe)
-						{
-							this->senderBwe->ReceiveRtcpTransportFeedback(feedback);
-						}
 #endif
 
 						break;
@@ -2222,7 +2242,7 @@ namespace RTC
 						continue;
 					}
 
-					producer->ReceiveRtcpSenderReport(report);
+					producer->ReceiveRtcpSenderReport(report, receivedAtUs);
 				}
 
 				break;
@@ -2283,7 +2303,7 @@ namespace RTC
 									continue;
 								}
 
-								producer->ReceiveRtcpXrDelaySinceLastRr(ssrcInfo);
+								producer->ReceiveRtcpXrDelaySinceLastRr(ssrcInfo, receivedAtUs);
 							}
 
 							break;
@@ -2297,7 +2317,7 @@ namespace RTC
 							{
 								auto* consumer = kv.second;
 
-								consumer->ReceiveRtcpXrReceiverReferenceTime(rrt);
+								consumer->ReceiveRtcpXrReceiverReferenceTime(rrt, receivedAtUs);
 							}
 
 							break;
@@ -2320,7 +2340,7 @@ namespace RTC
 		}
 	}
 
-	void Transport::SendRtcp(uint64_t nowMs)
+	void Transport::SendRtcp(int64_t nowUs)
 	{
 		MS_TRACE();
 
@@ -2329,7 +2349,7 @@ namespace RTC
 		for (auto& kv : this->mapConsumers)
 		{
 			auto* consumer = kv.second;
-			auto rtcpAdded = consumer->GetRtcp(packet.get(), nowMs);
+			auto rtcpAdded = consumer->GetRtcp(packet.get(), nowUs);
 
 			// RTCP data couldn't be added because the Compound packet is full.
 			// Send the RTCP compound packet and request for RTCP again.
@@ -2341,14 +2361,14 @@ namespace RTC
 				packet.reset(new RTC::RTCP::CompoundPacket());
 
 				// Retrieve the RTCP again.
-				consumer->GetRtcp(packet.get(), nowMs);
+				consumer->GetRtcp(packet.get(), nowUs);
 			}
 		}
 
 		for (auto& kv : this->mapProducers)
 		{
 			auto* producer = kv.second;
-			auto rtcpAdded = producer->GetRtcp(packet.get(), nowMs);
+			auto rtcpAdded = producer->GetRtcp(packet.get(), nowUs);
 
 			// RTCP data couldn't be added because the Compound packet is full.
 			// Send the RTCP compound packet and request for RTCP again.
@@ -2360,7 +2380,7 @@ namespace RTC
 				packet.reset(new RTC::RTCP::CompoundPacket());
 
 				// Retrieve the RTCP again.
-				producer->GetRtcp(packet.get(), nowMs);
+				producer->GetRtcp(packet.get(), nowUs);
 			}
 		}
 
@@ -2375,6 +2395,9 @@ namespace RTC
 	{
 		MS_TRACE();
 
+#ifdef MS_USE_BUILTIN_BWE
+		// TODO: Distribute the bitrate the built-in downlink BWE reports.
+#else
 		MS_ASSERT(this->tccClient, "no TransportCongestionClient");
 
 		std::multimap<uint8_t, RTC::Consumer*> multimapPriorityConsumer;
@@ -2397,18 +2420,18 @@ namespace RTC
 			return;
 		}
 
-		bool baseAllocation       = true;
-		uint32_t availableBitrate = this->tccClient->GetAvailableBitrate();
+		bool baseAllocation      = true;
+		int64_t availableBitrate = this->tccClient->GetAvailableBitrate();
 
 		this->tccClient->RescheduleNextAvailableBitrateEvent();
 
-		MS_DEBUG_DEV("before layer-by-layer iterations [availableBitrate:%" PRIu32 "]", availableBitrate);
+		MS_DEBUG_DEV("before layer-by-layer iterations [availableBitrate:%" PRIi64 "]", availableBitrate);
 
 		// Redistribute the available bitrate by allowing Consumers to increase
 		// layer by layer. Initially try to spread the bitrate across all
 		// consumers. Then allocate the excess bitrate to Consumers starting
 		// with the highest priorty.
-		while (availableBitrate > 0u)
+		while (availableBitrate > 0)
 		{
 			auto previousAvailableBitrate = availableBitrate;
 
@@ -2421,17 +2444,15 @@ namespace RTC
 				// NOLINTNEXTLINE(bugprone-too-small-loop-variable)
 				for (uint8_t i{ 1u }; i <= (baseAllocation ? 1u : priority); ++i)
 				{
-					uint32_t usedBitrate{ 0u };
-					const bool considerLoss = (bweType == RTC::BweType::REMB);
-
-					usedBitrate = consumer->IncreaseLayer(availableBitrate, considerLoss);
+					const bool considerLoss   = (bweType == RTC::BweType::REMB);
+					const int64_t usedBitrate = consumer->IncreaseLayer(availableBitrate, considerLoss);
 
 					MS_ASSERT(usedBitrate <= availableBitrate, "Consumer used more layer bitrate than given");
 
 					availableBitrate -= usedBitrate;
 
-					// Exit the loop fast if used bitrate is 0.
-					if (usedBitrate == 0u)
+					// Exit the loop fast if no bitrate was used.
+					if (usedBitrate <= 0)
 					{
 						break;
 					}
@@ -2447,7 +2468,7 @@ namespace RTC
 			baseAllocation = false;
 		}
 
-		MS_DEBUG_DEV("after layer-by-layer iterations [availableBitrate:%" PRIu32 "]", availableBitrate);
+		MS_DEBUG_DEV("after layer-by-layer iterations [availableBitrate:%" PRIi64 "]", availableBitrate);
 
 		// Finally instruct Consumers to apply their computed layers.
 		for (auto it = multimapPriorityConsumer.rbegin(); it != multimapPriorityConsumer.rend(); ++it)
@@ -2456,15 +2477,20 @@ namespace RTC
 
 			consumer->ApplyLayers();
 		}
+#endif
 	}
 
 	void Transport::ComputeOutgoingDesiredBitrate(bool forceBitrate)
 	{
 		MS_TRACE();
 
+#ifdef MS_USE_BUILTIN_BWE
+		// TODO: Give the total desired bitrate to the built-in downlink BWE.
+		(void)forceBitrate;
+#else
 		MS_ASSERT(this->tccClient, "no TransportCongestionClient");
 
-		uint32_t totalDesiredBitrate{ 0u };
+		int64_t totalDesiredBitrate{ 0 };
 
 		for (auto& kv : this->mapConsumers)
 		{
@@ -2474,9 +2500,10 @@ namespace RTC
 			totalDesiredBitrate += desiredBitrate;
 		}
 
-		MS_DEBUG_DEV("total desired bitrate: %" PRIu32, totalDesiredBitrate);
+		MS_DEBUG_DEV("total desired bitrate: %" PRIi64, totalDesiredBitrate);
 
 		this->tccClient->SetDesiredBitrate(totalDesiredBitrate, forceBitrate);
+#endif
 	}
 
 	inline void Transport::EmitTraceEventProbationType(RTC::RTP::Packet* /*packet*/) const
@@ -2492,7 +2519,7 @@ namespace RTC
 		auto notification = FBS::Transport::CreateTraceNotification(
 		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
 		  FBS::Transport::TraceEventType::PROBATION,
-		  this->shared->GetTimeMs(),
+		  static_cast<uint64_t>(this->shared->GetTimeMs()),
 		  FBS::Common::TraceDirection::DIRECTION_OUT);
 
 		this->shared->GetChannelNotifier()->Emit(
@@ -2502,6 +2529,7 @@ namespace RTC
 		  notification);
 	}
 
+#ifndef MS_USE_BUILTIN_BWE
 	inline void Transport::EmitTraceEventBweType(
 	  RTC::TransportCongestionControlClient::Bitrates& bitrates) const
 	{
@@ -2517,18 +2545,18 @@ namespace RTC
 		  this->tccClient->GetBweType() == RTC::BweType::TRANSPORT_CC
 		    ? FBS::Transport::BweType::TRANSPORT_CC
 		    : FBS::Transport::BweType::REMB,
-		  bitrates.desiredBitrate,
-		  bitrates.effectiveDesiredBitrate,
-		  bitrates.minBitrate,
-		  bitrates.maxBitrate,
-		  bitrates.startBitrate,
-		  bitrates.maxPaddingBitrate,
-		  bitrates.availableBitrate);
+		  static_cast<uint64_t>(bitrates.desiredBitrate),
+		  static_cast<uint64_t>(bitrates.effectiveDesiredBitrate),
+		  static_cast<uint64_t>(bitrates.minBitrate),
+		  static_cast<uint64_t>(bitrates.maxBitrate),
+		  static_cast<uint64_t>(bitrates.startBitrate),
+		  static_cast<uint64_t>(bitrates.maxPaddingBitrate),
+		  static_cast<uint64_t>(bitrates.availableBitrate));
 
 		auto notification = FBS::Transport::CreateTraceNotification(
 		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
 		  FBS::Transport::TraceEventType::BWE,
-		  this->shared->GetTimeMs(),
+		  static_cast<uint64_t>(this->shared->GetTimeMs()),
 		  FBS::Common::TraceDirection::DIRECTION_OUT,
 		  FBS::Transport::TraceInfo::BweTraceInfo,
 		  traceInfo.Union());
@@ -2539,6 +2567,7 @@ namespace RTC
 		  FBS::Notification::Body::Transport_TraceNotification,
 		  notification);
 	}
+#endif
 
 	void Transport::OnProducerPaused(RTC::Producer* producer)
 	{
@@ -2589,6 +2618,15 @@ namespace RTC
 		this->listener->OnTransportProducerRtcpSenderReport(this, producer, rtpStream, first);
 	}
 
+	void Transport::OnProducerSpatialLayerActivityChanged(
+	  RTC::Producer* producer, RTC::RTP::RtpStreamRecv* rtpStream, uint8_t spatialLayer, bool isActive)
+	{
+		MS_TRACE();
+
+		this->listener->OnTransportProducerSpatialLayerActivityChanged(
+		  this, producer, rtpStream, spatialLayer, isActive);
+	}
+
 	void Transport::OnProducerRtpPacketReceived(RTC::Producer* producer, RTC::RTP::Packet* packet)
 	{
 		MS_TRACE();
@@ -2610,7 +2648,7 @@ namespace RTC
 		return this->listener->OnTransportNeedWorstRemoteFractionLost(this, producer, mappedSsrc);
 	}
 
-	std::optional<uint64_t> Transport::OnProducerNeedLocalCaptureMs(
+	std::optional<int64_t> Transport::OnProducerNeedLocalCaptureAtUs(
 	  RTC::Producer* producer, const RTC::RTP::RtpStreamRecv* rtpStream, uint32_t ts)
 	{
 		MS_TRACE();
@@ -2625,10 +2663,10 @@ namespace RTC
 
 		const auto& remoteCaptureTimeEstimator = it->second;
 
-		return remoteCaptureTimeEstimator.GetLocalCaptureMs(rtpStream, ts);
+		return remoteCaptureTimeEstimator.GetLocalCaptureAtUs(rtpStream, ts);
 	}
 
-	std::optional<int64_t> Transport::OnProducerNeedRemoteClockOffsetMs(const RTC::Producer* producer)
+	std::optional<int64_t> Transport::OnProducerNeedRemoteClockOffsetUs(const RTC::Producer* producer)
 	{
 		MS_TRACE();
 
@@ -2641,9 +2679,9 @@ namespace RTC
 		}
 
 		const auto& remoteCaptureTimeEstimator = it->second;
-		const auto clockOffsetMs               = remoteCaptureTimeEstimator.GetClockOffsetMs();
+		const auto clockOffsetUs               = remoteCaptureTimeEstimator.GetClockOffsetUs();
 
-		if (!clockOffsetMs.has_value())
+		if (!clockOffsetUs.has_value())
 		{
 			return std::nullopt;
 		}
@@ -2651,9 +2689,9 @@ namespace RTC
 		// NOTE: The estimator gives the offset against our own monotonic clock, while what
 		// a receiver reconstructs out of the Sender Reports we send is the clock we
 		// announce, so the distance to the NTP epoch has to be taken into account. Both
-		// terms are huge and their sum is small, so they are added as milliseconds before
+		// terms are huge and their sum is small, so they are added as microseconds before
 		// anything scales them up.
-		return clockOffsetMs.value() + static_cast<int64_t>(this->shared->GetNtpOffsetMs());
+		return clockOffsetUs.value() + this->shared->GetNtpOffsetUs();
 	}
 
 	void Transport::OnConsumerSendRtpPacket(RTC::Consumer* consumer, RTC::RTP::Packet* packet)
@@ -2666,8 +2704,13 @@ namespace RTC
 #endif
 
 		// Update abs-send-time if present.
-		packet->UpdateAbsSendTime(this->shared->GetTimeMs());
+		packet->UpdateAbsSendTime(this->shared->GetTimeUs());
 
+#ifdef MS_USE_BUILTIN_BWE
+		// TODO: Write the transport wide sequence number the built-in downlink BWE
+		// hands out and register the send in it.
+		SendRtpPacket(consumer, packet);
+#else
 		// Update transport wide sequence number if present.
 		if (
 		  this->tccClient && this->tccClient->GetBweType() == RTC::BweType::TRANSPORT_CC &&
@@ -2696,38 +2739,6 @@ namespace RTC
 
 			auto* shared = this->shared;
 
-#ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
-			std::weak_ptr<RTC::SenderBandwidthEstimator> senderBweWeakPtr(this->senderBwe);
-			RTC::SenderBandwidthEstimator::SentInfo sentInfo;
-
-			sentInfo.wideSeq     = this->transportWideCcSeq;
-			sentInfo.size        = packet->GetLength();
-			sentInfo.sendingAtMs = this->shared->GetTimeMs();
-
-			const auto* cb = new onSendCallback(
-			  [tccClientWeakPtr, shared, packetInfo, senderBweWeakPtr, sentInfo](bool sent) mutable
-			  {
-				  if (sent)
-				  {
-					  auto tccClient = tccClientWeakPtr.lock();
-
-					  if (tccClient)
-					  {
-						  tccClient->PacketSent(packetInfo, shared->GetTimeMsInt64());
-					  }
-
-					  auto senderBwe = senderBweWeakPtr.lock();
-
-					  if (senderBwe)
-					  {
-						  sentInfo.sentAtMs = shared->GetTimeMs();
-						  senderBwe->RtpPacketSent(sentInfo);
-					  }
-				  }
-			  });
-
-			SendRtpPacket(consumer, packet, cb);
-#else
 			const auto* cb = new onSendCallback(
 			  [tccClientWeakPtr, shared, packetInfo](bool sent)
 			  {
@@ -2737,18 +2748,18 @@ namespace RTC
 
 					  if (tccClient)
 					  {
-						  tccClient->PacketSent(packetInfo, shared->GetTimeMsInt64());
+						  tccClient->PacketSent(packetInfo, shared->GetTimeUs());
 					  }
 				  }
 			  });
 
 			SendRtpPacket(consumer, packet, cb);
-#endif
 		}
 		else
 		{
 			SendRtpPacket(consumer, packet);
 		}
+#endif
 
 		this->sendRtpTransmission.Update(packet);
 	}
@@ -2758,8 +2769,13 @@ namespace RTC
 		MS_TRACE();
 
 		// Update abs-send-time if present.
-		packet->UpdateAbsSendTime(this->shared->GetTimeMs());
+		packet->UpdateAbsSendTime(this->shared->GetTimeUs());
 
+#ifdef MS_USE_BUILTIN_BWE
+		// TODO: Write the transport wide sequence number the built-in downlink BWE
+		// hands out and register the send in it.
+		SendRtpPacket(consumer, packet);
+#else
 		// Update transport wide sequence number if present.
 		if (
 		  this->tccClient && this->tccClient->GetBweType() == RTC::BweType::TRANSPORT_CC &&
@@ -2783,38 +2799,6 @@ namespace RTC
 
 			auto* shared = this->shared;
 
-#ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
-			std::weak_ptr<RTC::SenderBandwidthEstimator> senderBweWeakPtr = this->senderBwe;
-			RTC::SenderBandwidthEstimator::SentInfo sentInfo;
-
-			sentInfo.wideSeq     = this->transportWideCcSeq;
-			sentInfo.size        = packet->GetLength();
-			sentInfo.sendingAtMs = this->shared->GetTimeMs();
-
-			const auto* cb = new onSendCallback(
-			  [tccClientWeakPtr, shared, packetInfo, senderBweWeakPtr, sentInfo](bool sent) mutable
-			  {
-				  if (sent)
-				  {
-					  auto tccClient = tccClientWeakPtr.lock();
-
-					  if (tccClient)
-					  {
-						  tccClient->PacketSent(packetInfo, shared->GetTimeMsInt64());
-					  }
-
-					  auto senderBwe = senderBweWeakPtr.lock();
-
-					  if (senderBwe)
-					  {
-						  sentInfo.sentAtMs = shared->GetTimeMs();
-						  senderBwe->RtpPacketSent(sentInfo);
-					  }
-				  }
-			  });
-
-			SendRtpPacket(consumer, packet, cb);
-#else
 			const auto* cb = new onSendCallback(
 			  [tccClientWeakPtr, shared, packetInfo](bool sent)
 			  {
@@ -2824,18 +2808,18 @@ namespace RTC
 
 					  if (tccClient)
 					  {
-						  tccClient->PacketSent(packetInfo, shared->GetTimeMsInt64());
+						  tccClient->PacketSent(packetInfo, shared->GetTimeUs());
 					  }
 				  }
 			  });
 
 			SendRtpPacket(consumer, packet, cb);
-#endif
 		}
 		else
 		{
 			SendRtpPacket(consumer, packet);
 		}
+#endif
 
 		this->sendRtxTransmission.Update(packet);
 	}
@@ -2858,7 +2842,9 @@ namespace RTC
 	{
 		MS_TRACE();
 
+#ifndef MS_USE_BUILTIN_BWE
 		MS_ASSERT(this->tccClient, "no TransportCongestionClient");
+#endif
 
 		DistributeAvailableOutgoingBitrate();
 		ComputeOutgoingDesiredBitrate();
@@ -2868,7 +2854,9 @@ namespace RTC
 	{
 		MS_TRACE();
 
+#ifndef MS_USE_BUILTIN_BWE
 		MS_ASSERT(this->tccClient, "no TransportCongestionClient");
+#endif
 
 		DistributeAvailableOutgoingBitrate();
 
@@ -2908,10 +2896,14 @@ namespace RTC
 		delete consumer;
 
 		// This may be the latest active Consumer with BWE. If so we have to stop probation.
+#ifdef MS_USE_BUILTIN_BWE
+		// TODO: Do it when the built-in downlink BWE is in place.
+#else
 		if (this->tccClient)
 		{
 			ComputeOutgoingDesiredBitrate(/*forceBitrate*/ true);
 		}
+#endif
 	}
 
 	void Transport::OnDataProducerMessageReceived(
@@ -3391,13 +3383,14 @@ namespace RTC
 		return IsConnected() && (!this->mapDataProducers.empty() || !this->mapDataConsumers.empty());
 	}
 
+#ifndef MS_USE_BUILTIN_BWE
 	void Transport::OnTransportCongestionControlClientBitrates(
 	  RTC::TransportCongestionControlClient* /*tccClient*/,
 	  RTC::TransportCongestionControlClient::Bitrates& bitrates)
 	{
 		MS_TRACE();
 
-		MS_DEBUG_DEV("outgoing available bitrate:%" PRIu32, bitrates.availableBitrate);
+		MS_DEBUG_DEV("outgoing available bitrate:%" PRIi64, bitrates.availableBitrate);
 
 		DistributeAvailableOutgoingBitrate();
 		ComputeOutgoingDesiredBitrate();
@@ -3414,7 +3407,7 @@ namespace RTC
 		MS_TRACE();
 
 		// Update abs-send-time if present.
-		packet->UpdateAbsSendTime(this->shared->GetTimeMs());
+		packet->UpdateAbsSendTime(this->shared->GetTimeUs());
 
 		// Update transport wide sequence number if present.
 		if (
@@ -3442,39 +3435,6 @@ namespace RTC
 
 			auto* shared = this->shared;
 
-#ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
-			std::weak_ptr<RTC::SenderBandwidthEstimator> senderBweWeakPtr = this->senderBwe;
-			RTC::SenderBandwidthEstimator::SentInfo sentInfo;
-
-			sentInfo.wideSeq     = this->transportWideCcSeq;
-			sentInfo.size        = packet->GetLength();
-			sentInfo.isProbation = true;
-			sentInfo.sendingAtMs = this->shared->GetTimeMs();
-
-			const auto* cb = new onSendCallback(
-			  [tccClientWeakPtr, shared, packetInfo, senderBweWeakPtr, sentInfo](bool sent) mutable
-			  {
-				  if (sent)
-				  {
-					  auto tccClient = tccClientWeakPtr.lock();
-
-					  if (tccClient)
-					  {
-						  tccClient->PacketSent(packetInfo, shared->GetTimeMsInt64());
-					  }
-
-					  auto senderBwe = senderBweWeakPtr.lock();
-
-					  if (senderBwe)
-					  {
-						  sentInfo.sentAtMs = shared->GetTimeMs();
-						  senderBwe->RtpPacketSent(sentInfo);
-					  }
-				  }
-			  });
-
-			SendRtpPacket(nullptr, packet, cb);
-#else
 			const auto* cb = new onSendCallback(
 			  [tccClientWeakPtr, shared, packetInfo](bool sent)
 			  {
@@ -3484,13 +3444,12 @@ namespace RTC
 
 					  if (tccClient)
 					  {
-						  tccClient->PacketSent(packetInfo, shared->GetTimeMsInt64());
+						  tccClient->PacketSent(packetInfo, shared->GetTimeUs());
 					  }
 				  }
 			  });
 
 			SendRtpPacket(nullptr, packet, cb);
-#endif
 		}
 		else
 		{
@@ -3503,7 +3462,7 @@ namespace RTC
 		this->sendProbationTransmission.Update(packet);
 
 		MS_DEBUG_DEV(
-		  "probation sent [seq:%" PRIu16 ", wideSeq:%" PRIu16 ", size:%zu, bitrate:%" PRIu32 "]",
+		  "probation sent [seq:%" PRIu16 ", wideSeq:%" PRIu16 ", size:%zu, bitrate:%" PRIi64 "]",
 		  packet->GetSequenceNumber(),
 		  this->transportWideCcSeq,
 		  packet->GetLength(),
@@ -3519,24 +3478,6 @@ namespace RTC
 
 		SendRtcpPacket(packet);
 	}
-
-#ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
-	void Transport::OnSenderBandwidthEstimatorAvailableBitrate(
-	  RTC::SenderBandwidthEstimator* /*senderBwe*/,
-	  uint32_t availableBitrate,
-	  uint32_t previousAvailableBitrate)
-	{
-		MS_TRACE();
-
-		MS_DEBUG_DEV(
-		  "outgoing available bitrate [now:%" PRIu32 ", before:%" PRIu32 "]",
-		  availableBitrate,
-		  previousAvailableBitrate);
-
-		// TODO: Uncomment once just SenderBandwidthEstimator is used.
-		// DistributeAvailableOutgoingBitrate();
-		// ComputeOutgoingDesiredBitrate();
-	}
 #endif
 
 	void Transport::OnTimer(TimerHandleInterface* timer)
@@ -3546,19 +3487,18 @@ namespace RTC
 		// RTCP timer.
 		if (timer == this->rtcpTimer)
 		{
-			auto interval        = static_cast<uint64_t>(RTC::RTCP::MaxVideoIntervalMs);
-			const uint64_t nowMs = this->shared->GetTimeMs();
+			auto intervalMs = static_cast<int64_t>(RTC::RTCP::MaxVideoIntervalMs);
 
-			SendRtcp(nowMs);
+			SendRtcp(this->shared->GetTimeUs());
 
 			/*
 			 * The interval between RTCP packets is varied randomly over the range
 			 * [1.0, 1.5] times the calculated interval to avoid unintended
 			 * synchronization of all participants.
 			 */
-			interval *= static_cast<float>(Utils::Crypto::GetRandomUInt<uint16_t>(10, 15)) / 10;
+			intervalMs *= static_cast<float>(Utils::Crypto::GetRandomUInt<uint16_t>(10, 15)) / 10;
 
-			this->rtcpTimer->Start(interval);
+			this->rtcpTimer->Start(intervalMs);
 		}
 	}
 } // namespace RTC