mediasoup 3.27.0 → 3.28.0

package/worker/src/RTC/BWE/TransportWideCcFeedbackGenerator.cpp

@@ -0,0 +1,377 @@
+#define MS_CLASS "RTC::BWE::TransportWideCcFeedbackGenerator"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/BWE/TransportWideCcFeedbackGenerator.hpp"
+#include "Logger.hpp"
+
+namespace RTC
+{
+	namespace BWE
+	{
+		/* Static. */
+
+		// Shortest and longest a feedback may be waited for (ms), and what is emitted
+		// until there is a measurement to decide with.
+		static constexpr int64_t MinSendIntervalMs{ 50 };
+		static constexpr int64_t MaxSendIntervalMs{ 250 };
+		static constexpr int64_t DefaultSendIntervalMs{ 100 };
+		// What a feedback packet costs regardless of how many packets it reports on
+		// (bytes): IPv4 20, UDP 8, SRTP 10 and an average report of 30.
+		static constexpr int64_t FeedbackPacketOverhead{ 20 + 8 + 10 + 30 };
+		// Share of the bitrate coming in that reporting it back is allowed to cost.
+		static constexpr double FeedbackBitrateFraction{ 0.05 };
+		// Window of the meter of incoming data. It measures what feedback is emitted
+		// for, and a stream falling quiet for a moment must not lengthen the interval,
+		// so it is long enough to only follow the sustained bitrate.
+		static constexpr int64_t IncomingBitrateWindowMs{ 2500 };
+		// How far back the arrival times are kept.
+		static constexpr int64_t PacketArrivalTimestampWindowUs{ 500 * 1000 };
+
+		/* Instance methods. */
+
+		TransportWideCcFeedbackGenerator::TransportWideCcFeedbackGenerator(
+		  Listener* listener, SharedInterface* shared, size_t maxRtcpPacketLen)
+		  : maxRtcpPacketLen(maxRtcpPacketLen),
+		    listener(listener),
+		    shared(shared),
+		    sendPeriodicTimer(shared->CreateTimer(this, "transport-wide-cc-feedback-generator-send")),
+		    incomingDataCounter(shared, /*ignorePaddingOnlyPackets*/ false, IncomingBitrateWindowMs),
+		    sendIntervalMs(DefaultSendIntervalMs)
+		{
+			MS_TRACE();
+
+			ResetFeedbackPacket(0);
+
+			this->sendPeriodicTimer->Start(this->sendIntervalMs, this->sendIntervalMs);
+		}
+
+		void TransportWideCcFeedbackGenerator::IncomingPacket(
+		  int64_t arrivalTimeUs, const RTC::RTP::Packet* packet)
+		{
+			MS_TRACE();
+
+			uint16_t wideSeqNumber{ 0 };
+
+			if (!packet->ReadTransportWideCc01(wideSeqNumber))
+			{
+				return;
+			}
+
+			// NOTE: Done before taking note of this packet, so that what is still
+			// waiting to be reported is told apart from this very arrival.
+			MayDropOldPacketArrivalTimes(wideSeqNumber, arrivalTimeUs);
+
+			// Only take note of the packet the first time it's received.
+			if (!this->mapPacketArrivalTimes.try_emplace(wideSeqNumber, arrivalTimeUs).second)
+			{
+				return;
+			}
+
+			// A packet lower than the one the previous feedback started at may still
+			// arrive, and it may have been reported as lost already, so the next
+			// feedback has to start back there.
+			if (
+			  !this->feedbackWideSeqNumStart.has_value() ||
+			  RTC::SeqManager<uint16_t>::IsSeqLowerThan(
+			    wideSeqNumber, this->feedbackWideSeqNumStart.value()))
+			{
+				this->feedbackWideSeqNumStart = wideSeqNumber;
+			}
+
+			// Sequences below the oldest arrival still kept cannot be reported on any
+			// more, so the next feedback starts no earlier than that one. Without this
+			// they would go out as lost when they have only been forgotten.
+			const uint16_t oldestSequenceNumber = this->mapPacketArrivalTimes.begin()->first;
+
+			if (RTC::SeqManager<uint16_t>::IsSeqLowerThan(this->feedbackWideSeqNumStart.value(), oldestSequenceNumber))
+			{
+				this->feedbackWideSeqNumStart = oldestSequenceNumber;
+			}
+
+			// The feedback reports on whoever sent last.
+			this->feedbackMediaSsrc = packet->GetSsrc();
+
+			this->incomingDataCounter.Update(packet);
+		}
+
+		void TransportWideCcFeedbackGenerator::FillAndSendFeedback()
+		{
+			MS_TRACE();
+
+			if (!this->feedbackWideSeqNumStart.has_value())
+			{
+				return;
+			}
+
+			auto it = this->mapPacketArrivalTimes.lower_bound(this->feedbackWideSeqNumStart.value());
+
+			// Everything known has already been reported, so there is nothing to
+			// build a feedback packet out of.
+			if (it == this->mapPacketArrivalTimes.end())
+			{
+				return;
+			}
+
+			while (it != this->mapPacketArrivalTimes.end())
+			{
+				const uint16_t sequenceNumber = it->first;
+				const int64_t timestampUs     = it->second;
+				// Whether nothing has been added to the current feedback packet yet,
+				// which tells apart a packet that doesn't fit in what is left from one
+				// that doesn't fit in an empty packet either.
+				const bool feedbackPacketIsEmpty = !this->feedbackPacket->IsBaseSet();
+
+				// If the base is not set in this packet let's set it.
+				// NOTE: This may be needed many times during this loop, since the
+				// current feedback packet may be a fresh new one if the previous one was
+				// full (so already sent) or failed to be built.
+				if (feedbackPacketIsEmpty)
+				{
+					const uint16_t oldestReportableSequenceNumber =
+					  sequenceNumber - RTC::RTCP::FeedbackRtpTransportPacket::maxMissingPackets;
+
+					// The base is where the report starts counting from, and every
+					// sequence between it and the first one actually received is reported
+					// as lost. Too long a run of those cannot be encoded, so the base is
+					// moved up rather than letting the packet fail to be built.
+					// NOTE: clang-tidy doesn't understand that this is guaranteed to have
+					// a value: the method returns above when it has none, and nothing
+					// takes it away afterwards, since SendFeedback() only ever assigns
+					// one.
+					// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
+					uint16_t baseSequenceNumber = this->feedbackWideSeqNumStart.value();
+
+					if (RTC::SeqManager<uint16_t>::IsSeqLowerThan(baseSequenceNumber, oldestReportableSequenceNumber))
+					{
+						baseSequenceNumber = oldestReportableSequenceNumber;
+					}
+
+					this->feedbackPacket->SetBase(baseSequenceNumber, timestampUs);
+				}
+
+				const auto result =
+				  this->feedbackPacket->AddPacket(sequenceNumber, timestampUs, this->maxRtcpPacketLen);
+
+				switch (result)
+				{
+					case RTC::RTCP::FeedbackRtpTransportPacket::AddPacketResult::SUCCESS:
+					{
+						// If the feedback packet is full, send it now.
+						if (this->feedbackPacket->IsFull())
+						{
+							MS_DEBUG_DEV("feedback packet is full, sending it now");
+
+							if (SendFeedback())
+							{
+								++this->feedbackPacketCount;
+							}
+
+							ResetFeedbackPacket(this->feedbackPacketCount);
+						}
+
+						++it;
+
+						break;
+					}
+
+					case RTC::RTCP::FeedbackRtpTransportPacket::AddPacketResult::MAX_SIZE_EXCEEDED:
+					{
+						if (SendFeedback())
+						{
+							++this->feedbackPacketCount;
+						}
+
+						ResetFeedbackPacket(this->feedbackPacketCount);
+
+						// NOTE: The iterator is only advanced when the packet had a chance
+						// of fitting. If it didn't fit in a feedback packet that was
+						// already empty it will not fit in the fresh one either, and
+						// retrying it would loop forever.
+						if (feedbackPacketIsEmpty)
+						{
+							++it;
+						}
+
+						break;
+					}
+
+					case RTC::RTCP::FeedbackRtpTransportPacket::AddPacketResult::FATAL:
+					{
+						// This packet cannot be expressed relative to the base and the
+						// reference time of the feedback packet being filled, so what is
+						// already in it goes out and a fresh one is started, whose base
+						// and reference time are taken from this very packet.
+						if (SendFeedback())
+						{
+							++this->feedbackPacketCount;
+						}
+
+						ResetFeedbackPacket(this->feedbackPacketCount);
+
+						// NOTE: Same reasoning as above. If it didn't fit in a feedback
+						// packet that was already empty, a fresh one changes nothing.
+						if (feedbackPacketIsEmpty)
+						{
+							++it;
+						}
+
+						break;
+					}
+				}
+			}
+
+			// The packet may hold nothing, but then SendFeedback() won't send it.
+			if (SendFeedback())
+			{
+				++this->feedbackPacketCount;
+			}
+
+			ResetFeedbackPacket(this->feedbackPacketCount);
+		}
+
+		bool TransportWideCcFeedbackGenerator::SendFeedback()
+		{
+			MS_TRACE();
+
+			this->feedbackPacket->Finish();
+
+			if (!this->feedbackPacket->IsSerializable())
+			{
+				return false;
+			}
+
+			// The report is about whoever has sent last, which this packet could not
+			// be built with: it was started at the end of the previous round, when
+			// that may not have been known yet.
+			this->feedbackPacket->SetMediaSsrc(this->feedbackMediaSsrc);
+
+			const auto latestWideSeqNumber = this->feedbackPacket->GetLatestSequenceNumber();
+
+			this->listener->OnTransportWideCcFeedbackGeneratorSendRtcpPacket(
+			  this, this->feedbackPacket.get());
+
+			this->feedbackWideSeqNumStart = latestWideSeqNumber + 1;
+
+			return true;
+		}
+
+		void TransportWideCcFeedbackGenerator::MayDropOldPacketArrivalTimes(
+		  uint16_t seqNum, int64_t arrivalTimeUs)
+		{
+			MS_TRACE();
+
+			// Ignore the given instant if it's smaller than the window in order to
+			// avoid negative values (should never happen) and return early if the
+			// condition is met.
+			if (arrivalTimeUs < PacketArrivalTimestampWindowUs)
+			{
+				return;
+			}
+
+			if (!this->feedbackWideSeqNumStart.has_value() || this->mapPacketArrivalTimes.empty())
+			{
+				return;
+			}
+
+			const uint16_t feedbackWideSeqNumStart = this->feedbackWideSeqNumStart.value();
+			// Where a feedback that had reported everything known would start from.
+			const uint16_t endSequenceNumber = this->mapPacketArrivalTimes.rbegin()->first + 1;
+
+			// Nothing is forgotten while something already known is still waiting to
+			// be reported, since forgetting it would turn it into a loss.
+			if (RTC::SeqManager<uint16_t>::IsSeqLowerThan(feedbackWideSeqNumStart, endSequenceNumber))
+			{
+				return;
+			}
+
+			const int64_t expiryTimestampUs = arrivalTimeUs - PacketArrivalTimestampWindowUs;
+
+			auto it = this->mapPacketArrivalTimes.begin();
+
+			while (it != this->mapPacketArrivalTimes.end() && it->first != feedbackWideSeqNumStart &&
+			       RTC::SeqManager<uint16_t>::IsSeqLowerThan(it->first, seqNum) &&
+			       it->second <= expiryTimestampUs)
+			{
+				it = this->mapPacketArrivalTimes.erase(it);
+			}
+		}
+
+		void TransportWideCcFeedbackGenerator::ResetFeedbackPacket(uint8_t feedbackPacketCount)
+		{
+			MS_TRACE();
+
+			// NOTE: The media SSRC is left at zero here and filled in when the packet
+			// is about to go out, since who has sent last may still change while this
+			// one is being filled.
+			this->feedbackPacket = std::make_unique<RTC::RTCP::FeedbackRtpTransportPacket>(
+			  /*senderSsrc*/ 0, /*mediaSsrc*/ 0);
+
+			this->feedbackPacket->SetFeedbackPacketCount(feedbackPacketCount);
+		}
+
+		int64_t TransportWideCcFeedbackGenerator::ComputeSendIntervalMs(int64_t incomingBitrate)
+		{
+			MS_TRACE();
+
+			// Bitrate the feedback is allowed to take, which is what decides how long
+			// its fixed cost may be spread over.
+			const double feedbackBitrate = static_cast<double>(incomingBitrate) * FeedbackBitrateFraction;
+			// NOTE: Checked against the bitrate rather than against the resulting
+			// interval, so that a bitrate of zero is not divided by.
+			const double minFeedbackBitrate = (static_cast<double>(FeedbackPacketOverhead) * 8 * 1000) /
+			                                  static_cast<double>(MaxSendIntervalMs);
+
+			if (feedbackBitrate <= minFeedbackBitrate)
+			{
+				return MaxSendIntervalMs;
+			}
+
+			const auto intervalMs = static_cast<int64_t>(
+			  (static_cast<double>(FeedbackPacketOverhead) * 8 * 1000) / feedbackBitrate);
+
+			return std::max(intervalMs, MinSendIntervalMs);
+		}
+
+		void TransportWideCcFeedbackGenerator::MayUpdateSendInterval(int64_t nowMs)
+		{
+			MS_TRACE();
+
+			const auto incomingBitrate = this->incomingDataCounter.GetBitrate(nowMs);
+
+			if (!incomingBitrate.has_value())
+			{
+				return;
+			}
+
+			const int64_t sendIntervalMs = ComputeSendIntervalMs(incomingBitrate.value());
+
+			if (sendIntervalMs == this->sendIntervalMs)
+			{
+				return;
+			}
+
+			MS_DEBUG_DEV(
+			  "send interval changed [old:%" PRIi64 " ms, new:%" PRIi64 " ms, incomingBitrate:%" PRIi64
+			  " bps]",
+			  this->sendIntervalMs,
+			  sendIntervalMs,
+			  incomingBitrate.value());
+
+			this->sendIntervalMs = sendIntervalMs;
+
+			this->sendPeriodicTimer->Restart(this->sendIntervalMs, this->sendIntervalMs);
+		}
+
+		void TransportWideCcFeedbackGenerator::OnTimer(TimerHandleInterface* timer)
+		{
+			MS_TRACE();
+
+			if (timer == this->sendPeriodicTimer.get())
+			{
+				FillAndSendFeedback();
+
+				MayUpdateSendInterval(this->shared->GetTimeMs());
+			}
+		}
+	} // namespace BWE
+} // namespace RTC

package/worker/src/RTC/BWE/TrendlineEstimator.cpp

@@ -38,11 +38,27 @@ namespace RTC
 
 		/* Instance methods. */
 
-		TrendlineEstimator::TrendlineEstimator(size_t windowSize) : windowSize(windowSize)
+		TrendlineEstimator::TrendlineEstimator() : TrendlineEstimator(TrendlineEstimatorOptions{})
 		{
 			MS_TRACE();
+		}
+
+		TrendlineEstimator::TrendlineEstimator(TrendlineEstimatorOptions options) : options(options)
+		{
+			MS_TRACE();
+
+			MS_ASSERT(
+			  this->options.windowSize >= 2,
+			  "window size must be at least 2 [windowSize:%zu]",
+			  this->options.windowSize);
 
-			MS_ASSERT(windowSize >= 2, "window size must be at least 2 [windowSize:%zu]", windowSize);
+			// NOTE: The slope cap looks at both ends of the window without them
+			// overlapping, and each end needs at least one sample.
+			MS_ASSERT(
+			  !this->options.enableCap ||
+			    (this->options.beginningPackets >= 1 && this->options.endPackets >= 1 &&
+					 this->options.beginningPackets + this->options.endPackets <= this->options.windowSize),
+			  "both ends of the slope cap must fit within the window");
 		}
 
 		void TrendlineEstimator::Update(int64_t sendDeltaUs, int64_t arrivalDeltaUs, int64_t arrivalTimeUs)
@@ -67,9 +83,21 @@ namespace RTC
 			// the window did, in which case the regression just gets a negative x.
 			const auto elapsedUs = static_cast<double>(arrivalTimeUs - this->firstArrivalTimeUs.value());
 
-			this->delayHist.push_back({ elapsedUs, this->smoothedDelayUs });
+			this->delayHist.push_back({ elapsedUs, this->smoothedDelayUs, this->accumulatedDelayUs });
+
+			// Feedback should already give the groups in order, so this is a safety
+			// net against a source that doesn't.
+			if (this->options.enableSort)
+			{
+				for (size_t idx{ this->delayHist.size() - 1 };
+				     idx > 0 && this->delayHist[idx].arrivalTimeUs < this->delayHist[idx - 1].arrivalTimeUs;
+				     --idx)
+				{
+					std::swap(this->delayHist[idx], this->delayHist[idx - 1]);
+				}
+			}
 
-			if (this->delayHist.size() > this->windowSize)
+			if (this->delayHist.size() > this->options.windowSize)
 			{
 				this->delayHist.pop_front();
 			}
@@ -81,15 +109,84 @@ namespace RTC
 			//   trend < 0      ->  the delay decreases, queues are being emptied.
 			double trend = this->prevTrend;
 
-			if (this->delayHist.size() == this->windowSize)
+			if (this->delayHist.size() == this->options.windowSize)
 			{
 				// Keep the previous trend if the line cannot be fitted.
 				trend = GetLinearFitSlope().value_or(trend);
+
+				if (this->options.enableCap)
+				{
+					const auto cap = GetSlopeCap();
+
+					// The cap only filters out overuse detections, it doesn't turn a
+					// growing queue into an emptying one.
+					if (trend >= 0 && cap.has_value() && trend > cap.value())
+					{
+						trend = cap.value();
+					}
+				}
 			}
 
 			Detect(trend, static_cast<double>(sendDeltaUs), arrivalTimeUs);
 		}
 
+		std::optional<double> TrendlineEstimator::GetSlopeCap() const
+		{
+			MS_TRACE();
+
+			// NOTE: Both counts come from the options this was built with, never from
+			// anything received, so a window they don't fit in is a programming error.
+			MS_ASSERT(
+			  this->options.beginningPackets >= 1 && this->options.beginningPackets < this->delayHist.size(),
+			  "beginning packets don't fit in the window [beginningPackets:%zu, window:%zu]",
+			  this->options.beginningPackets,
+			  this->delayHist.size());
+			MS_ASSERT(
+			  this->options.endPackets >= 1 && this->options.endPackets < this->delayHist.size(),
+			  "end packets don't fit in the window [endPackets:%zu, window:%zu]",
+			  this->options.endPackets,
+			  this->delayHist.size());
+			MS_ASSERT(
+			  this->options.beginningPackets + this->options.endPackets <= this->delayHist.size(),
+			  "beginning and end packets overlap [beginningPackets:%zu, endPackets:%zu, window:%zu]",
+			  this->options.beginningPackets,
+			  this->options.endPackets,
+			  this->delayHist.size());
+
+			// The least delayed sample of the beginning of the window.
+			PacketTiming early = this->delayHist[0];
+
+			for (size_t idx{ 1 }; idx < this->options.beginningPackets; ++idx)
+			{
+				if (this->delayHist[idx].rawDelayUs < early.rawDelayUs)
+				{
+					early = this->delayHist[idx];
+				}
+			}
+
+			const size_t lateStart = this->delayHist.size() - this->options.endPackets;
+
+			// The least delayed sample of the end of the window.
+			PacketTiming late = this->delayHist[lateStart];
+
+			for (size_t idx{ lateStart + 1 }; idx < this->delayHist.size(); ++idx)
+			{
+				if (this->delayHist[idx].rawDelayUs < late.rawDelayUs)
+				{
+					late = this->delayHist[idx];
+				}
+			}
+
+			// Too close in time for a slope between them to say anything.
+			if (late.arrivalTimeUs - early.arrivalTimeUs < 1000)
+			{
+				return std::nullopt;
+			}
+
+			return ((late.rawDelayUs - early.rawDelayUs) / (late.arrivalTimeUs - early.arrivalTimeUs)) +
+			       this->options.capUncertainty;
+		}
+
 		std::optional<double> TrendlineEstimator::GetLinearFitSlope() const
 		{
 			MS_TRACE();

package/worker/src/RTC/Consumer.cpp

@@ -11,7 +11,7 @@
 #include "RTC/SvcProducerStreamManager.hpp"
 #include "Utils.hpp"
 #ifdef MS_RTC_LOGGER_RTP
-#include "RTC/RtcLogger.hpp"
+#include "RTC/RtcLogger/RtpPacket.hpp"
 #endif
 #include <limits> // std::numeric_limits
 
@@ -717,9 +717,11 @@ namespace RTC
 				  newPreferredLayers.temporal,
 				  this->id.c_str());
 
-				preferredTemporalLayer     = newPreferredLayers.temporal;
+				preferredTemporalLayer     = static_cast<uint8_t>(newPreferredLayers.temporal);
 				auto preferredLayersOffset = FBS::Consumer::CreateConsumerLayers(
-				  request->GetBufferBuilder(), newPreferredLayers.spatial, preferredTemporalLayer);
+				  request->GetBufferBuilder(),
+				  static_cast<uint8_t>(newPreferredLayers.spatial),
+				  preferredTemporalLayer);
 				auto responseOffset = FBS::Consumer::CreateSetPreferredLayersResponse(
 				  request->GetBufferBuilder(), preferredLayersOffset);
 
@@ -1823,8 +1825,8 @@ namespace RTC
 		{
 			layersOffset = FBS::Consumer::CreateConsumerLayers(
 			  this->shared->GetChannelNotifier()->GetBufferBuilder(),
-			  this->producerStreamManager->GetCurrentSpatialLayer(),
-			  this->producerStreamManager->GetCurrentTemporalLayer());
+			  static_cast<uint8_t>(this->producerStreamManager->GetCurrentSpatialLayer()),
+			  static_cast<uint8_t>(this->producerStreamManager->GetCurrentTemporalLayer()));
 		}
 
 		auto notificationOffset = FBS::Consumer::CreateLayersChangeNotification(

package/worker/src/RTC/DataConsumer.cpp

@@ -284,8 +284,8 @@ namespace RTC
 				// NOTE: Capturing `this` and `request` (by reference) is safe here because the
 				// callback is always invoked synchronously within this same call stack (never
 				// deferred).
-				const auto* cb = new onQueuedCallback(
-				  [this, &request](bool queued, bool sctpSendBufferFull)
+				onMessageQueuedCallback cb(
+				  [this, &request](bool queued, bool isSendBufferFull)
 				  {
 					  if (queued)
 					  {
@@ -300,7 +300,7 @@ namespace RTC
 					  }
 					  else
 					  {
-						  request->Error(sctpSendBufferFull ? "sctpsendbufferfull" : "message send failed");
+						  request->Error(isSendBufferFull ? "sctpsendbufferfull" : "message send failed");
 					  }
 				  });
 
@@ -313,7 +313,7 @@ namespace RTC
 				// move the message and pass its ownership to the SCTP stack.
 				RTC::SCTP::Message message(streamId, body->ppid(), std::vector<uint8_t>(data, data + len));
 
-				SendMessage(std::move(message), emptySubchannels, std::nullopt, std::nullopt, cb);
+				SendMessage(std::move(message), emptySubchannels, std::nullopt, std::nullopt, std::move(cb));
 
 				break;
 			}
@@ -545,7 +545,7 @@ namespace RTC
 	  std::vector<uint16_t>& subchannels,
 	  std::optional<uint16_t> requiredSubchannel,
 	  std::optional<uint16_t> ignoredSubchannel,
-	  const onQueuedCallback* cb)
+	  onMessageQueuedCallback cb)
 	{
 		MS_TRACE();
 
@@ -553,8 +553,7 @@ namespace RTC
 		{
 			if (cb)
 			{
-				(*cb)(false, false);
-				delete cb;
+				cb(false, /*isSendBufferFull*/ false);
 			}
 
 			return false;
@@ -604,8 +603,7 @@ namespace RTC
 
 			if (cb)
 			{
-				(*cb)(false, false);
-				delete cb;
+				cb(false, /*isSendBufferFull*/ false);
 			}
 
 			return false;
@@ -614,7 +612,7 @@ namespace RTC
 		this->messagesSent++;
 		this->bytesSent += messageLen;
 
-		this->listener->OnDataConsumerSendMessage(this, std::move(message), cb);
+		this->listener->OnDataConsumerSendMessage(this, std::move(message), std::move(cb));
 
 		return true;
 	}

package/worker/src/RTC/DirectTransport.cpp

@@ -145,8 +145,17 @@ namespace RTC
 		return true;
 	}
 
+	inline size_t DirectTransport::GetPacketOverhead() const
+	{
+		MS_TRACE();
+
+		// Nothing sent through this reaches a socket, so there is no network to
+		// carry anything on top of the packet.
+		return 0;
+	}
+
 	void DirectTransport::SendRtpPacket(
-	  RTC::Consumer* consumer, RTC::RTP::Packet* packet, const RTC::Transport::onSendCallback* cb)
+	  RTC::Consumer* consumer, RTC::RTP::Packet* packet, onSendCallback cb)
 	{
 		MS_TRACE();
 
@@ -156,8 +165,7 @@ namespace RTC
 
 			if (cb)
 			{
-				(*cb)(false);
-				delete cb;
+				cb(false);
 			}
 
 			return;
@@ -177,8 +185,7 @@ namespace RTC
 
 		if (cb)
 		{
-			(*cb)(true);
-			delete cb;
+			cb(true);
 		}
 
 		// Increase send transmission.
@@ -226,7 +233,7 @@ namespace RTC
 	}
 
 	void DirectTransport::SendMessage(
-	  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onQueuedCallback* cb)
+	  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onMessageQueuedCallback cb)
 	{
 		MS_TRACE();
 
@@ -245,8 +252,7 @@ namespace RTC
 
 		if (cb)
 		{
-			(*cb)(true, false);
-			delete cb;
+			cb(true, /*isSendBufferFull*/ false);
 		}
 
 		// Increase send transmission.