mediasoup 3.27.1 → 3.28.0

package/worker/include/RTC/RateCalculator.hpp

@@ -16,12 +16,25 @@ namespace RTC
 	 * and GetRate() are O(1) amortized.
 	 *
 	 * It is considered that the time source increases monotonically. Timestamps
-	 * going backwards are however tolerated (time comparisons are wrap safe):
-	 * data still within the window is added to the newest item, older data is
-	 * ignored, and nothing is ever expired ahead of time.
+	 * going backwards are however tolerated (time comparisons are wrap safe): no
+	 * data is ever lost nor expired ahead of time, and whatever is given with an
+	 * instant that is not newer than the newest item is added to that item.
 	 */
 	class RateCalculator
 	{
+	private:
+		struct Item
+		{
+			/**
+			 * Sum of the sizes given to Update() within this item.
+			 */
+			uint64_t count{ 0 };
+			/**
+			 * Number of Update() calls accounted for within this item.
+			 */
+			uint64_t samples{ 0 };
+		};
+
 	public:
 		static constexpr int64_t DefaultWindowSizeMs{ 1000 };
 		static constexpr float DefaultBpsScale{ 8000.0f };
@@ -33,11 +46,43 @@ namespace RTC
 		  float scale          = DefaultBpsScale,
 		  uint16_t windowItems = DefaultWindowItems);
 
+		/**
+		 * Accounts for `size` units of data taken at `nowMs`.
+		 *
+		 * @remarks
+		 * - A sample that arrives when the window holds none starts a new measured
+		 *   period, unless the previous sample is recent enough for both to be taken
+		 *   as the same stretch of traffic. That is what keeps a stream which sends
+		 *   less often than the window from restarting its period at every sample and
+		 *   hence never being measured at all.
+		 */
 		void Update(size_t size, int64_t nowMs);
 
-		int64_t GetRate(int64_t nowMs);
-
-		size_t GetBytes() const
+		/**
+		 * Rate of the data within the window ending at `nowMs`, computed over the
+		 * period the data actually spans rather than over the whole window, so that
+		 * a window which has not filled yet is not reported as a fraction of the
+		 * rate it is measuring.
+		 *
+		 * While that period starts at a sample rather than at the edge of the window,
+		 * the data of that sample is left out, since the period does not cover the
+		 * time it took to arrive.
+		 *
+		 * Returns no value when there is nothing to measure, which is any of:
+		 *
+		 * - Not a single sample within the window.
+		 * - A period of a single millisecond, which gives no duration to divide by.
+		 * - A single sample while the window has not filled, since one sample says
+		 *   how much data arrived at an instant but nothing about how fast it is
+		 *   arriving.
+		 *
+		 * Returns zero when there are enough samples to measure but the data they
+		 * add up to rounds down to zero at the configured scale, which takes
+		 * Update() calls of size zero.
+		 */
+		std::optional<int64_t> GetRate(int64_t nowMs);
+
+		uint64_t GetBytes() const
 		{
 			return this->bytes;
 		}
@@ -52,31 +97,56 @@ namespace RTC
 		int64_t windowSizeMs{ DefaultWindowSizeMs };
 		// Item size (in milliseconds). Always >= 1.
 		int64_t itemSizeMs{ 1 };
-		// Precomputed `scale / windowSizeMs`.
-		double rateScale{ 0.0 };
-		// Ring of items, each one holding the count of the data within it. Never
-		// empty, and always long enough to cover the whole window.
-		std::vector<size_t> buffer;
+		// Factor the in-window count is multiplied by before being divided by the
+		// period it spans.
+		double scale{ 0.0 };
+		// How long after a sample the next one still counts as the same stretch of
+		// traffic (in milliseconds). Derived from the window size.
+		int64_t recentSampleMarginMs{ 0 };
+		// Ring of items. Never empty, and always long enough to cover the whole
+		// window.
+		std::vector<Item> buffer;
 		// Index of the newest item. Always < buffer.size().
 		size_t newestItemIndex{ 0 };
 		// Time (in milliseconds) at which the newest item starts.
 		int64_t newestItemStartTimeMs{ 0 };
+		// Time (in milliseconds) at which the measured period starts. Unset until the
+		// very first sample, and from then on only ever moved forward by a sample
+		// that finds the window empty after long enough without traffic.
+		// NOTE: Expiration does not move it, so once the data reaches back beyond the
+		// window it names a sample that is already gone. That is on purpose: from
+		// that point on the period is the window itself, which is what the reader
+		// clamps it to.
+		std::optional<int64_t> firstSampleTimeMs;
+		// Count of the sample that starts the measured period, which is left out of
+		// the rate for as long as the period is anchored to it.
+		uint64_t firstSampleCount{ 0 };
+		// Time (in milliseconds) of the latest sample, which together with the window
+		// still holding it is what tells a stream that simply sends less often than
+		// the window apart from one that stopped.
+		std::optional<int64_t> lastSampleTimeMs;
 		// Sum of the count of every item.
-		size_t totalCount{ 0 };
+		uint64_t totalCount{ 0 };
+		// Sum of the samples of every item.
+		uint64_t totalSamples{ 0 };
 		// Total bytes accounted for. Not affected by Reset().
-		size_t bytes{ 0 };
-		// Rate memoized by GetRate(), only valid while both `lastTimeMs` and
-		// `lastTotalCount` below still match. `lastTotalCount` is the one that makes
-		// any Update() changing the rate invalidate this implicitly, so that the hot
-		// path needs no memoization store.
+		// NOTE: Nothing bounds this one, unlike the in-window total above, so it is
+		// as wide as the stats field it ends up in.
+		uint64_t bytes{ 0 };
+		// Rate memoized by GetRate(), only valid while `lastTimeMs`,
+		// `lastTotalCount` and `lastTotalSamples` below all still match.
+		// `lastTotalSamples` is the one that makes any Update() invalidate this
+		// implicitly, so that the hot path needs no memoization store.
 		// NOTE: No "not calculated yet" mark is needed, since the initial and post
-		// Reset() state is a valid entry on its own: a zero rate for a zero count.
-		int64_t lastRate{ 0 };
+		// Reset() state is a valid entry on its own: no rate for no samples.
+		std::optional<int64_t> lastRate;
 		// Time of the latest GetRate() call. Prevents reusing `lastRate` once time
 		// has moved on and there is data pending expiration.
 		int64_t lastTimeMs{ 0 };
 		// Total count at the latest GetRate() call.
-		size_t lastTotalCount{ 0 };
+		uint64_t lastTotalCount{ 0 };
+		// Total samples at the latest GetRate() call.
+		uint64_t lastTotalSamples{ 0 };
 	};
 
 	class RtpDataCounter
@@ -91,17 +161,25 @@ namespace RTC
 	public:
 		void Update(const RTC::RTP::Packet* packet);
 
-		int64_t GetBitrate(int64_t nowMs)
+		/**
+		 * Bitrate (bps) of the RTP traffic within the window ending at `nowMs`,
+		 * measured over the period that traffic actually spans.
+		 *
+		 * @returns No value while there is nothing to measure, which is any of: no
+		 *   packet within the window, a period of a single millisecond, and a single
+		 *   packet while the window has not filled.
+		 */
+		std::optional<int64_t> GetBitrate(int64_t nowMs)
 		{
 			return this->rate.GetRate(nowMs);
 		}
 
-		size_t GetPacketCount() const
+		uint64_t GetPacketCount() const
 		{
 			return this->packets;
 		}
 
-		size_t GetBytes() const
+		uint64_t GetBytes() const
 		{
 			return this->rate.GetBytes();
 		}
@@ -112,7 +190,8 @@ namespace RTC
 		// account.
 		bool ignorePaddingOnlyPackets{ false };
 		RateCalculator rate;
-		size_t packets{ 0 };
+		// Total packets accounted for, which nothing bounds either.
+		uint64_t packets{ 0 };
 	};
 } // namespace RTC
 

package/worker/include/RTC/RemoteCaptureTimeEstimator.hpp

@@ -14,14 +14,19 @@ namespace RTC
 	 * The capture instant is read from one of two sources, and the same one is used
 	 * for every stream of the sender. Mixing them would reintroduce the very inter
 	 * stream skew this is meant to remove, since they do not carry the same residual
-	 * error: `abs-capture-time` is exact while a Sender Report is biased by its own
+	 * error: 'abs-capture-time' is exact while a Sender Report is biased by its own
 	 * one way delay.
 	 *
 	 * The source is chosen from what the Producers of the sender negotiated. The
 	 * first Producer chooses it, and a single Producer that did not negotiate
-	 * `abs-capture-time` moves it to Sender Report for the rest of the life of this
+	 * 'abs-capture-time' moves it to Sender Report for the rest of the life of this
 	 * object, never back.
 	 *
+	 * A sender may negotiate that extension and then never send it, which would
+	 * leave every stream of it without a capture instant forever. So the source also
+	 * falls back to Sender Report when no stream of this sender has carried the
+	 * extension for long enough since its first packet.
+	 *
 	 * A single instance is meant to be shared by all the RTP streams of a given
 	 * CNAME, which is what identifies media coming from a same machine and hence
 	 * from a same wall clock.
@@ -76,17 +81,42 @@ namespace RTC
 		 *
 		 * @param rtpStream - RTP stream the RTP timestamp belongs to.
 		 * @param ts - RTP timestamp whose capture instant is wanted.
+		 * @param nowUs - Current instant, which is also what the fall back to Sender
+		 *   Report is timed against.
 		 *
 		 * @returns No value while the capture instant cannot be told yet.
 		 */
 		std::optional<int64_t> GetLocalCaptureAtUs(
-		  const RTC::RTP::RtpStreamRecv* rtpStream, uint32_t ts) const;
+		  const RTC::RTP::RtpStreamRecv* rtpStream, uint32_t ts, int64_t nowUs);
+
+	private:
+		/**
+		 * Move the source to Sender Report when 'abs-capture-time' was negotiated but
+		 * no stream of this sender has ever carried it, which is told apart from it
+		 * being merely early by how long this sender has been sending.
+		 *
+		 * @param rtpStream - RTP stream whose packet is being looked at.
+		 * @param nowUs - Current instant.
+		 */
+		void MayFallBackToSenderReport(const RTC::RTP::RtpStreamRecv* rtpStream, int64_t nowUs);
 
 	private:
 		// Offset between the wall clock of the sender and our monotonic one.
 		RTC::RemoteClockOffsetEstimator clockOffsetEstimator;
 		// Source the capture instant is read from, for every stream of this sender.
 		std::optional<Source> source;
+		// Instant the first packet of this sender was asked about, or no value until
+		// then. The fall back to Sender Report is measured against it, so it must be
+		// something that exists even when the extension never arrives.
+		//
+		// NOTE: Not every packet is asked about, only the one holding the highest RTP
+		// timestamp of its stream, so this is the first one that got here rather than
+		// the first one that arrived.
+		std::optional<int64_t> firstPacketAtUs;
+		// Whether any stream of this sender has ever carried 'abs-capture-time', which
+		// is what tells a sender that does not send it from a stream whose first
+		// packets carrying it are still on their way.
+		bool absCaptureTimeReceived{ false };
 	};
 } // namespace RTC
 

package/worker/include/RTC/{RtcLogger.hpp → RtcLogger/RtpPacket.hpp}

@@ -1,8 +1,9 @@
-#ifndef MS_RTC_RTC_LOGGER_HPP
-#define MS_RTC_RTC_LOGGER_HPP
+#ifndef MS_RTC_RTC_LOGGER_RTP_PACKET_HPP
+#define MS_RTC_RTC_LOGGER_RTP_PACKET_HPP
 
 #include "common.hpp"
 #include <ankerl/unordered_dense.h>
+#include <string>
 
 namespace RTC
 {
@@ -55,6 +56,7 @@ namespace RTC
 			bool discarded{};
 			DiscardReason discardReason{ DiscardReason::NONE };
 		};
-	}; // namespace RtcLogger
+	} // namespace RtcLogger
 } // namespace RTC
+
 #endif

package/worker/include/RTC/RtcLogger/SendBurst.hpp

@@ -0,0 +1,88 @@
+#ifndef MS_RTC_RTC_LOGGER_SEND_BURST_HPP
+#define MS_RTC_RTC_LOGGER_SEND_BURST_HPP
+
+#include "common.hpp"
+#include <map>
+#include <string>
+
+namespace RTC
+{
+	namespace RtcLogger
+	{
+		/**
+		 * How many RTP packets a transport sends within a single iteration of the event
+		 * loop.
+		 *
+		 * Nothing spaces those packets out, so a whole iteration's worth of them reaches
+		 * the wire back to back and lands in the first queue of the path as a single
+		 * lump. This gathers how big those lumps are and how much of each one is
+		 * retransmissions, which is what says whether there is anything worth pacing.
+		 */
+		class SendBurst
+		{
+		private:
+			/**
+			 * What all the bursts of a given size added up to.
+			 */
+			struct Counters
+			{
+				/**
+				 * How many of them there were.
+				 */
+				uint64_t count{ 0 };
+				/**
+				 * Retransmissions they carried between all of them, so that the tail of
+				 * the distribution can be attributed.
+				 */
+				uint64_t retransmissions{ 0 };
+				/**
+				 * Probation packets they carried between all of them.
+				 */
+				uint64_t probations{ 0 };
+			};
+
+		public:
+			SendBurst()  = default;
+			~SendBurst() = default;
+
+			/**
+			 * Account for a packet that is about to be sent.
+			 *
+			 * @param loopTimeMs - Time at which the current iteration of the event loop
+			 * began, which is what tells one burst from the next.
+			 */
+			void Sent(uint64_t loopTimeMs, size_t length, bool isRetransmission, bool isProbation);
+
+			/**
+			 * Print what has been gathered so far and start over.
+			 */
+			void Log();
+
+		private:
+			/**
+			 * Add the burst in progress, if there is one, to the distribution.
+			 */
+			void CloseBurst();
+
+			void Clear();
+
+		public:
+			std::string transportId;
+
+		private:
+			// Time of the iteration of the event loop that the burst in progress belongs
+			// to.
+			uint64_t loopTimeMs{ 0 };
+			size_t packets{ 0 };
+			size_t retransmissions{ 0 };
+			size_t probations{ 0 };
+			size_t bytes{ 0 };
+			// Bursts seen, keyed by how many packets each of them carried.
+			std::map<size_t /*packets*/, Counters> bursts;
+			size_t maxPackets{ 0 };
+			size_t maxBytes{ 0 };
+		};
+	} // namespace RtcLogger
+} // namespace RTC
+
+#endif

package/worker/include/RTC/RtpDictionaries.hpp

@@ -123,10 +123,9 @@ namespace RTC
 			SSRC_AUDIO_LEVEL       = 6,
 			DEPENDENCY_DESCRIPTOR  = 7,
 			VIDEO_ORIENTATION      = 8,
-			TIME_OFFSET            = 9,
-			ABS_CAPTURE_TIME       = 10,
-			PLAYOUT_DELAY          = 11,
-			MEDIASOUP_PACKET_ID    = 12
+			ABS_CAPTURE_TIME       = 9,
+			PLAYOUT_DELAY          = 10,
+			MEDIASOUP_PACKET_ID    = 11
 		};
 
 	public:

package/worker/include/RTC/SCTP/association/Association.hpp

@@ -128,7 +128,7 @@ namespace RTC
 						return "SHUTDOWN_ACK_SENT";
 					}
 
-						NO_DEFAULT_GCC();
+						NO_DEFAULT();
 				}
 			}
 

package/worker/include/RTC/SCTP/public/AssociationMetrics.hpp

@@ -2,7 +2,6 @@
 #define MS_RTC_SCTP_ASSOCIATION_METRICS_HPP
 
 #include "common.hpp"
-#include "RTC/SCTP/association/StateCookie.hpp"
 #include "RTC/SCTP/public/SctpTypes.hpp"
 
 namespace RTC

package/worker/include/RTC/SCTP/public/SctpTypes.hpp

@@ -77,7 +77,7 @@ namespace RTC
 						return "SHUTTING_DOWN";
 					}
 
-						NO_DEFAULT_GCC();
+						NO_DEFAULT();
 				}
 			}
 
@@ -179,7 +179,7 @@ namespace RTC
 						return "UNSUPPORTED_OPERATION";
 					}
 
-						NO_DEFAULT_GCC();
+						NO_DEFAULT();
 				}
 			}
 
@@ -219,7 +219,7 @@ namespace RTC
 						return "usrsctp";
 					}
 
-						NO_DEFAULT_GCC();
+						NO_DEFAULT();
 				}
 			}
 
@@ -332,7 +332,7 @@ namespace RTC
 						return "ERROR_SHUTTING_DOWN";
 					}
 
-						NO_DEFAULT_GCC();
+						NO_DEFAULT();
 				}
 			}
 

package/worker/include/RTC/SCTP/rx/DataTracker.hpp

@@ -105,7 +105,7 @@ namespace RTC
 						return "IMMEDIATE";
 					}
 
-						NO_DEFAULT_GCC();
+						NO_DEFAULT();
 				}
 			}
 

package/worker/include/RTC/SCTP/rx/ReassemblyQueue.hpp

@@ -57,7 +57,7 @@ namespace RTC
 			 * SCTP association should restrict incoming data to avoid filling up the
 			 * queue.
 			 */
-			static constexpr float HighWatermarkLimit{ 0.9 };
+			static constexpr double HighWatermarkLimit{ 0.9 };
 
 		private:
 			struct DeferredResetStreams

package/worker/include/RTC/SctpDictionaries.hpp

@@ -18,8 +18,8 @@ namespace RTC
 	public:
 		uint16_t streamId{ 0 };
 		bool ordered{ true };
-		uint16_t maxPacketLifeTime{ 0 };
-		uint16_t maxRetransmits{ 0 };
+		std::optional<uint16_t> maxPacketLifeTime;
+		std::optional<uint16_t> maxRetransmits;
 	};
 } // namespace RTC
 

package/worker/include/RTC/TcpConnection.hpp

@@ -2,6 +2,7 @@
 #define MS_RTC_TCP_CONNECTION_HPP
 
 #include "common.hpp"
+#include "handles/SendCallbacks.hpp"
 #include "handles/TcpConnectionHandle.hpp"
 #include "SharedInterface.hpp"
 
@@ -29,7 +30,7 @@ namespace RTC
 		~TcpConnection() override;
 
 	public:
-		void Send(const uint8_t* data, size_t len, ::TcpConnectionHandle::onSendCallback* cb);
+		void Send(const uint8_t* data, size_t len, onSendCallback cb);
 
 		/* Pure virtual methods inherited from ::TcpConnectionHandle. */
 	public:

package/worker/include/RTC/Transport.hpp

@@ -6,6 +6,7 @@
 #include "Channel/ChannelRequest.hpp"
 #include "Channel/ChannelSocket.hpp"
 #include "FBS/transport.h"
+#include "handles/SendCallbacks.hpp"
 #include "handles/TimerHandleInterface.hpp"
 #include "RTC/Consumer.hpp"
 #include "RTC/DataConsumer.hpp"
@@ -28,6 +29,9 @@
 #include "RTC/TransportCongestionControlServer.hpp"
 #endif
 #include "SharedInterface.hpp"
+#ifdef MS_RTC_LOGGER_SEND_BURST
+#include "RTC/RtcLogger/SendBurst.hpp"
+#endif
 #include <ankerl/unordered_dense.h>
 #include <string>
 #include <vector>
@@ -47,10 +51,6 @@ namespace RTC
 	                  public Channel::ChannelSocket::NotificationHandler,
 	                  public TimerHandleInterface::Listener
 	{
-	protected:
-		using onSendCallback   = const std::function<void(bool sent)>;
-		using onQueuedCallback = const std::function<void(bool queued, bool sctpSendBufferFull)>;
-
 	public:
 		class Listener
 		{
@@ -202,7 +202,9 @@ namespace RTC
 		virtual void ReceiveRtcpPacket(RTC::RTCP::Packet* packet, int64_t receivedAtUs) final;
 		virtual void ReceiveSctpData(const uint8_t* data, size_t len, int64_t receivedAtUs) final;
 		virtual void SendSctpMessage(
-		  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onQueuedCallback* cb = nullptr) final;
+		  RTC::DataConsumer* dataConsumer,
+		  RTC::SCTP::Message message,
+		  onMessageQueuedCallback cb = {}) final;
 
 	private:
 		virtual RTC::Producer* AssertAndGetProducerById(
@@ -228,14 +230,20 @@ namespace RTC
 		{
 			return false;
 		}
+		/**
+		 * Bytes that every packet sent through this transport carries on top of its
+		 * own length once it's on the network, or zero while no path has been
+		 * chosen yet.
+		 */
+		virtual size_t GetPacketOverhead() const = 0;
 		virtual void SendRtpPacket(
-		  RTC::Consumer* consumer, RTC::RTP::Packet* packet, const onSendCallback* cb = nullptr) = 0;
+		  RTC::Consumer* consumer, RTC::RTP::Packet* packet, onSendCallback cb = {}) = 0;
 		virtual void HandleRtcpPacket(RTC::RTCP::Packet* packet, int64_t receivedAtUs) final;
 		virtual void SendRtcp(int64_t nowUs) final;
 		virtual void SendRtcpPacket(RTC::RTCP::Packet* packet)                 = 0;
 		virtual void SendRtcpCompoundPacket(RTC::RTCP::CompoundPacket* packet) = 0;
 		virtual void SendMessage(
-		  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onQueuedCallback* cb = nullptr) = 0;
+		  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onMessageQueuedCallback cb = {}) = 0;
 		virtual bool SendData(const uint8_t* data, size_t len) = 0;
 		virtual void RecvStreamClosed(uint32_t ssrc)           = 0;
 		virtual void SendStreamClosed(uint32_t ssrc)           = 0;
@@ -308,7 +316,7 @@ namespace RTC
 		/* Pure virtual methods inherited from RTC::DataConsumer::Listener. */
 	public:
 		void OnDataConsumerSendMessage(
-		  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onQueuedCallback* cb) override;
+		  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onMessageQueuedCallback cb) override;
 		void OnDataConsumerNeedBufferedAmount(
 		  const RTC::DataConsumer* dataConsumer, uint32_t& bufferedAmount) const override;
 		void OnDataConsumerNeedBufferedAmountLowThreshold(
@@ -412,6 +420,13 @@ namespace RTC
 		size_t maxSendMessageSize{ 0 };
 		size_t maxReceiveMessageSize{ 0 };
 		struct TraceEventTypes traceEventTypes;
+
+#ifdef MS_RTC_LOGGER_SEND_BURST
+	private:
+		RTC::RtcLogger::SendBurst sendBurstLogger;
+		// Allocated by this.
+		TimerHandleInterface* sendBurstLoggerTimer{ nullptr };
+#endif
 	};
 } // namespace RTC
 

package/worker/include/RTC/TransportTuple.hpp

@@ -3,6 +3,8 @@
 
 #include "common.hpp"
 #include "FBS/transport.h"
+#include "handles/SendCallbacks.hpp"
+#include "RTC/Consts.hpp"
 #include "RTC/TcpConnection.hpp"
 #include "RTC/UdpSocket.hpp"
 #include "Utils.hpp"
@@ -13,9 +15,6 @@ namespace RTC
 {
 	class TransportTuple
 	{
-	protected:
-		using onSendCallback = const std::function<void(bool sent)>;
-
 	public:
 		enum class Protocol : uint8_t
 		{
@@ -139,15 +138,15 @@ namespace RTC
 			this->localAnnouncedAddress = localAnnouncedAddress;
 		}
 
-		void Send(const uint8_t* data, size_t len, RTC::TransportTuple::onSendCallback* cb = nullptr)
+		void Send(const uint8_t* data, size_t len, onSendCallback cb = {})
 		{
 			if (this->protocol == Protocol::UDP)
 			{
-				this->udpSocket->Send(data, len, this->udpRemoteAddr, cb);
+				this->udpSocket->Send(data, len, this->udpRemoteAddr, std::move(cb));
 			}
 			else
 			{
-				this->tcpConnection->Send(data, len, cb);
+				this->tcpConnection->Send(data, len, std::move(cb));
 			}
 		}
 
@@ -156,6 +155,62 @@ namespace RTC
 			return this->protocol;
 		}
 
+		/**
+		 * Bytes that every packet sent through this tuple carries on top of its own
+		 * length, which is what the network sees but nothing in here counts.
+		 *
+		 * @remarks
+		 * - It only contemplates IPv4 and IPv6 for the network layer and UDP and
+		 *   TCP for the transport one, both without options, plus the length field
+		 *   that frames a packet sent over TCP. Anything below that, such as the
+		 *   Ethernet frame or a tunnel, is not counted.
+		 */
+		size_t GetPacketOverhead() const
+		{
+			size_t overhead{ 0 };
+
+			switch (GetLocalAddress()->sa_family)
+			{
+				case AF_INET:
+				{
+					overhead += RTC::Consts::Ipv4HeaderSize;
+
+					break;
+				}
+
+				case AF_INET6:
+				{
+					overhead += RTC::Consts::Ipv6HeaderSize;
+
+					break;
+				}
+
+				default:
+				{
+					break;
+				}
+			}
+
+			switch (this->protocol)
+			{
+				case Protocol::UDP:
+				{
+					overhead += RTC::Consts::UdpHeaderSize;
+
+					break;
+				}
+
+				case Protocol::TCP:
+				{
+					overhead += RTC::Consts::TcpHeaderSize + RTC::Consts::TcpFramingSize;
+
+					break;
+				}
+			}
+
+			return overhead;
+		}
+
 		const struct sockaddr* GetLocalAddress() const
 		{
 			if (this->protocol == Protocol::UDP)