mediasoup 3.27.0 → 3.28.0

package/worker/include/RTC/BWE/TrendlineEstimator.hpp

@@ -26,30 +26,76 @@ namespace RTC
 		 */
 		class TrendlineEstimator
 		{
+		public:
+			/**
+			 * @remarks
+			 * - Every constraint documented below is checked by the constructor and
+			 *   aborts when it doesn't hold. These options are set from C++ alone,
+			 *   never from the network nor from the API, so breaking one of them is a
+			 *   programming error.
+			 */
+			struct TrendlineEstimatorOptions
+			{
+				/**
+				 * Number of samples of the least squares regression window. A shorter
+				 * window reacts sooner at the cost of being noisier.
+				 *
+				 * @remarks
+				 * - It must be at least 2, since a line cannot be fitted to a single
+				 *   point.
+				 */
+				size_t windowSize{ 20 };
+				/**
+				 * Whether the samples of the window are kept sorted by arrival time.
+				 * Feedback should already give them in order, so this is a safety net
+				 * against a source that doesn't.
+				 */
+				bool enableSort{ false };
+				/**
+				 * Whether the slope is capped by the one that the least delayed packets
+				 * of both ends of the window describe, which keeps a burst of delayed
+				 * packets in the middle from being read as a growing queue.
+				 */
+				bool enableCap{ false };
+				/**
+				 * How many packets of the beginning of the window that cap looks at.
+				 *
+				 * @remarks
+				 * - While `enableCap` is set it must be at least 1, and the two ends
+				 *   together must fit in `windowSize`, since the cap looks at both of
+				 *   them without them overlapping.
+				 */
+				size_t beginningPackets{ 7 };
+				/**
+				 * How many packets of the end of the window that cap looks at.
+				 *
+				 * @remarks
+				 * - The same constraints as `beginningPackets`.
+				 */
+				size_t endPackets{ 7 };
+				/**
+				 * Slack added to that cap, so that a slope barely above it is not
+				 * capped.
+				 */
+				double capUncertainty{ 0.0 };
+			};
+
 		private:
 			struct PacketTiming
 			{
 				double arrivalTimeUs;
 				double smoothedDelayUs;
+				/**
+				 * Accumulated delay before it's smoothed, which is what the slope cap
+				 * looks at.
+				 */
+				double rawDelayUs;
 			};
 
 		public:
-			/**
-			 * Number of samples of the least squares regression window used unless
-			 * another one is given.
-			 */
-			static constexpr size_t DefaultWindowSize{ 20 };
+			TrendlineEstimator();
 
-		public:
-			/**
-			 * @param windowSize - Number of samples of the least squares regression
-			 *   window. A shorter window reacts sooner at the cost of being noisier.
-			 *
-			 * @remarks
-			 * - `windowSize` must be at least 2, since a line cannot be fitted to a
-			 *   single point.
-			 */
-			explicit TrendlineEstimator(size_t windowSize = DefaultWindowSize);
+			explicit TrendlineEstimator(TrendlineEstimatorOptions options);
 
 			/**
 			 * Feed the deltas between two consecutive groups of packets.
@@ -77,12 +123,23 @@ namespace RTC
 			 */
 			std::optional<double> GetLinearFitSlope() const;
 
+			/**
+			 * Highest slope that the least delayed samples of both ends of the window
+			 * describe, or no value if they are too close in time to tell.
+			 *
+			 * @remarks
+			 * - A burst of delayed packets in the middle of the window tilts the
+			 *   fitted line even though the queue never grew, and this is what keeps
+			 *   that from being read as overuse.
+			 */
+			std::optional<double> GetSlopeCap() const;
+
 			void Detect(double trend, double sendDeltaUs, int64_t arrivalTimeUs);
 
 			void UpdateThreshold(double modifiedTrend, int64_t arrivalTimeUs);
 
 		private:
-			const size_t windowSize;
+			const TrendlineEstimatorOptions options;
 			int numOfDeltas{ 0 };
 			std::optional<int64_t> firstArrivalTimeUs;
 			double accumulatedDelayUs{ 0 };

package/worker/include/RTC/Consts.hpp

@@ -2,11 +2,39 @@
 #define MS_RTC_CONSTS_HPP
 
 #include "common.hpp"
+#include <string_view>
 
 namespace RTC
 {
 	namespace Consts
 	{
+		/**
+		 * Bytes an IPv4 header takes, without options.
+		 */
+		constexpr size_t Ipv4HeaderSize{ 20 };
+
+		/**
+		 * Bytes an IPv6 header takes, without extension headers.
+		 */
+		constexpr size_t Ipv6HeaderSize{ 40 };
+
+		/**
+		 * Bytes a UDP header takes.
+		 */
+		constexpr size_t UdpHeaderSize{ 8 };
+
+		/**
+		 * Bytes a TCP header takes, without options.
+		 */
+		constexpr size_t TcpHeaderSize{ 20 };
+
+		/**
+		 * Bytes of the length field that frames every packet sent over TCP.
+		 *
+		 * @see https://datatracker.ietf.org/doc/html/rfc4571
+		 */
+		constexpr size_t TcpFramingSize{ 2 };
+
 		/**
 		 * Max MTU size.
 		 */
@@ -39,6 +67,48 @@ namespace RTC
 		 */
 		constexpr uint8_t MidRtpExtensionMaxLength{ 8 };
 
+		/**
+		 * SSRC of the RTP stream the probing packets are sent on.
+		 *
+		 * @remarks
+		 * - The receiver negotiates a stream with this very SSRC, so it cannot be
+		 *   changed without changing the client as well.
+		 */
+		constexpr uint32_t BweProbeRtpSsrc{ 1234 };
+
+		/**
+		 * Codec payload type of the RTP stream the probing packets are sent on.
+		 *
+		 * @remarks
+		 * - The receiver negotiates a stream with this very payload type, so it
+		 *   cannot be changed without changing the client as well.
+		 */
+		constexpr uint8_t BweProbeRtpPayloadType{ 127 };
+
+		/**
+		 * MID of the RTP stream the probing packets are sent on, which is how the
+		 * receiver tells it apart.
+		 *
+		 * @remarks
+		 * - The receiver negotiates a stream with this very MID, so it cannot be
+		 *   changed without changing the client as well.
+		 */
+		constexpr std::string_view BweProbeRtpMid{ "probator" };
+
+		static_assert(
+		  BweProbeRtpMid.size() <= MidRtpExtensionMaxLength,
+		  "the MID of the probing stream does not fit in a MID RTP header extension");
+
+		/**
+		 * Lowest bitrate the bandwidth estimation ever produces (bps), so 5 kbps.
+		 */
+		constexpr int64_t BweMinBitrate{ 5000 };
+
+		/**
+		 * Highest bitrate the bandwidth estimation ever deals in (bps), so 1 Gbps.
+		 */
+		constexpr int64_t BweMaxBitrate{ 1000000000 };
+
 		/**
 		 * Largest safe SCTP packet. Starting from the minimum guaranteed MTU value
 		 * of 1280 for IPv6 (which may not support fragmentation), take off 85

package/worker/include/RTC/DataConsumer.hpp

@@ -4,6 +4,7 @@
 #include "common.hpp"
 #include "Channel/ChannelRequest.hpp"
 #include "Channel/ChannelSocket.hpp"
+#include "handles/SendCallbacks.hpp"
 #include "RTC/SCTP/public/Message.hpp"
 #include "RTC/SctpDictionaries.hpp"
 #include "SharedInterface.hpp"
@@ -14,9 +15,6 @@ namespace RTC
 {
 	class DataConsumer : public Channel::ChannelSocket::RequestHandler
 	{
-	protected:
-		using onQueuedCallback = const std::function<void(bool queued, bool sctpSendBufferFull)>;
-
 	public:
 		class Listener
 		{
@@ -25,7 +23,7 @@ namespace RTC
 
 		public:
 			virtual void OnDataConsumerSendMessage(
-			  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onQueuedCallback* cb) = 0;
+			  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onMessageQueuedCallback cb) = 0;
 			virtual void OnDataConsumerNeedBufferedAmount(
 			  const RTC::DataConsumer* dataConsumer, uint32_t& bufferedAmount) const = 0;
 			virtual void OnDataConsumerNeedBufferedAmountLowThreshold(
@@ -110,7 +108,7 @@ namespace RTC
 		  std::vector<uint16_t>& subchannels,
 		  std::optional<uint16_t> requiredSubchannel,
 		  std::optional<uint16_t> ignoredSubchannel,
-		  const onQueuedCallback* cb = nullptr);
+		  onMessageQueuedCallback cb = {});
 
 		/* Methods inherited from Channel::ChannelSocket::RequestHandler. */
 	public:

package/worker/include/RTC/DirectTransport.hpp

@@ -1,6 +1,7 @@
 #ifndef MS_RTC_DIRECT_TRANSPORT_HPP
 #define MS_RTC_DIRECT_TRANSPORT_HPP
 
+#include "handles/SendCallbacks.hpp"
 #include "RTC/Transport.hpp"
 #include "SharedInterface.hpp"
 
@@ -24,16 +25,14 @@ namespace RTC
 
 	private:
 		bool IsConnected() const override;
-		void SendRtpPacket(
-		  RTC::Consumer* consumer,
-		  RTC::RTP::Packet* packet,
-		  RTC::Transport::onSendCallback* cb = nullptr) override;
+		size_t GetPacketOverhead() const override;
+		void SendRtpPacket(RTC::Consumer* consumer, RTC::RTP::Packet* packet, onSendCallback cb = {}) override;
 		void SendRtcpPacket(RTC::RTCP::Packet* packet) override;
 		void SendRtcpCompoundPacket(RTC::RTCP::CompoundPacket* packet) override;
 		void SendMessage(
 		  RTC::DataConsumer* dataConsumer,
 		  RTC::SCTP::Message message,
-		  onQueuedCallback* cb = nullptr) override;
+		  onMessageQueuedCallback cb = {}) override;
 		bool SendData(const uint8_t* data, size_t len) override;
 		void RecvStreamClosed(uint32_t ssrc) override;
 		void SendStreamClosed(uint32_t ssrc) override;

package/worker/include/RTC/PipeTransport.hpp

@@ -2,6 +2,7 @@
 #define MS_RTC_PIPE_TRANSPORT_HPP
 
 #include "FBS/pipeTransport.h"
+#include "handles/SendCallbacks.hpp"
 #include "RTC/SrtpSession.hpp"
 #include "RTC/Transport.hpp"
 #include "RTC/TransportTuple.hpp"
@@ -45,17 +46,15 @@ namespace RTC
 		{
 			return true;
 		}
+		size_t GetPacketOverhead() const override;
 		bool HasSrtp() const;
-		void SendRtpPacket(
-		  RTC::Consumer* consumer,
-		  RTC::RTP::Packet* packet,
-		  RTC::Transport::onSendCallback* cb = nullptr) override;
+		void SendRtpPacket(RTC::Consumer* consumer, RTC::RTP::Packet* packet, onSendCallback cb = {}) override;
 		void SendRtcpPacket(RTC::RTCP::Packet* packet) override;
 		void SendRtcpCompoundPacket(RTC::RTCP::CompoundPacket* packet) override;
 		void SendMessage(
 		  RTC::DataConsumer* dataConsumer,
 		  RTC::SCTP::Message message,
-		  onQueuedCallback* cb = nullptr) override;
+		  onMessageQueuedCallback cb = {}) override;
 		bool SendData(const uint8_t* data, size_t len) override;
 		void RecvStreamClosed(uint32_t ssrc) override;
 		void SendStreamClosed(uint32_t ssrc) override;

package/worker/include/RTC/PlainTransport.hpp

@@ -2,6 +2,7 @@
 #define MS_RTC_PLAIN_TRANSPORT_HPP
 
 #include "FBS/plainTransport.h"
+#include "handles/SendCallbacks.hpp"
 #include "RTC/SrtpSession.hpp"
 #include "RTC/Transport.hpp"
 #include "RTC/TransportTuple.hpp"
@@ -33,18 +34,16 @@ namespace RTC
 
 	private:
 		bool IsConnected() const override;
+		size_t GetPacketOverhead() const override;
 		bool HasSrtp() const;
 		bool IsSrtpReady() const;
-		void SendRtpPacket(
-		  RTC::Consumer* consumer,
-		  RTC::RTP::Packet* packet,
-		  RTC::Transport::onSendCallback* cb = nullptr) override;
+		void SendRtpPacket(RTC::Consumer* consumer, RTC::RTP::Packet* packet, onSendCallback cb = {}) override;
 		void SendRtcpPacket(RTC::RTCP::Packet* packet) override;
 		void SendRtcpCompoundPacket(RTC::RTCP::CompoundPacket* packet) override;
 		void SendMessage(
 		  RTC::DataConsumer* dataConsumer,
 		  RTC::SCTP::Message message,
-		  onQueuedCallback* cb = nullptr) override;
+		  onMessageQueuedCallback cb = {}) override;
 		bool SendData(const uint8_t* data, size_t len) override;
 		void RecvStreamClosed(uint32_t ssrc) override;
 		void SendStreamClosed(uint32_t ssrc) override;

package/worker/include/RTC/RTCP/FeedbackPsRemb.hpp

@@ -33,8 +33,10 @@ namespace RTC
 		{
 		public:
 			// 'R' 'E' 'M' 'B'.
-			static const uint32_t UniqueIdentifier{ 0x52454D42 };
-			static const size_t UniqueIdentifierSize{ 4 };
+			static constexpr uint32_t UniqueIdentifier{ 0x52454D42 };
+			static constexpr size_t UniqueIdentifierSize{ 4 };
+			// Most SSRCs that fit, since the field that counts them is a single byte.
+			static constexpr size_t MaxNumberOfSsrcs{ 0xFF };
 
 		public:
 			static FeedbackPsRembPacket* Parse(const uint8_t* data, size_t len);
@@ -56,15 +58,12 @@ namespace RTC
 			{
 				this->bitrate = bitrate;
 			}
-			void SetSsrcs(const std::vector<uint32_t>& ssrcs)
-			{
-				this->ssrcs = ssrcs;
-			}
+			void SetSsrcs(const std::vector<uint32_t>& ssrcs);
 			int64_t GetBitrate() const
 			{
 				return this->bitrate;
 			}
-			const std::vector<uint32_t>& GetSsrcs()
+			const std::vector<uint32_t>& GetSsrcs() const
 			{
 				return this->ssrcs;
 			}

package/worker/include/RTC/RTCP/FeedbackRtpTransport.hpp

@@ -3,6 +3,8 @@
 
 #include "common.hpp"
 #include "RTC/RTCP/Feedback.hpp"
+#include "Utils.hpp"
+#include <cstdlib> // std::abs()
 #include <vector>
 
 /* RTP extensions for Transport-wide Congestion Control
@@ -324,7 +326,7 @@ namespace RTC
 				size += this->deltasAndChunksSize;
 
 				// 32 bits padding.
-				size += (-size) & 3;
+				size = Utils::Byte::PadTo4Bytes(size);
 
 				return size;
 			}

package/worker/include/RTC/RTP/Codecs/Tools.hpp

@@ -186,7 +186,7 @@ namespace RTC
 							return true;
 						}
 
-							NO_DEFAULT_GCC();
+							NO_DEFAULT();
 					}
 				}
 

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

@@ -20,7 +20,6 @@ namespace RTC
 			uint8_t ssrcAudioLevel{ 0 };
 			uint8_t dependencyDescriptor{ 0 };
 			uint8_t videoOrientation{ 0 };
-			uint8_t timeOffset{ 0 };
 			uint8_t absCaptureTime{ 0 };
 			uint8_t playoutDelay{ 0 };
 			uint8_t mediasoupPacketId{ 0 };

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

@@ -10,7 +10,7 @@
 #include "RTC/Serializable.hpp"
 #include "Utils.hpp"
 #ifdef MS_RTC_LOGGER_RTP
-#include "RTC/RtcLogger.hpp"
+#include "RTC/RtcLogger/RtpPacket.hpp"
 #endif
 #include <flatbuffers/flatbuffers.h>
 #include <array>
@@ -527,10 +527,11 @@ namespace RTC
 
 			/**
 			 * @remarks
-			 * - `sentAtUs` is converted internally to the 3 bytes ABS Send Time format,
-			 *   unlike `ReadAbsSendTime()`, which exposes the raw extension value.
+			 * - `absSendTime` is the raw 3 bytes unsigned integer the extension
+			 *   carries, the same one `ReadAbsSendTime()` gives back. An instant is
+			 *   turned into it with `Utils::Time::TimeUsToAbsSendTime()`.
 			 */
-			bool UpdateAbsSendTime(int64_t sentAtUs) const;
+			bool UpdateAbsSendTime(uint32_t absSendTime) const;
 
 			bool ReadTransportWideCc01(uint16_t& wideSeqNumber) const;
 
@@ -549,6 +550,17 @@ namespace RTC
 
 			bool ReadAbsCaptureTime(uint64_t& absCaptureTimestamp, int64_t& estimatedCaptureClockOffset) const;
 
+			/**
+			 * @remarks
+			 * - `absCaptureTimestamp` is the raw 8 bytes unsigned integer the extension
+			 *   carries, the same one `ReadAbsCaptureTime()` gives back, which is a
+			 *   capture instant in NTP format. An instant is turned into it with
+			 *   `Utils::Time::TimeUsToNtp()`.
+			 * - The estimated capture clock offset the extension carries when it is 16
+			 *   bytes long is left untouched.
+			 */
+			bool UpdateAbsCaptureTime(uint64_t absCaptureTimestamp) const;
+
 			bool ReadPlayoutDelay(uint16_t& minDelay, uint16_t& maxDelay) const;
 
 			bool ReadMediasoupPacketId(uint32_t& mediasoupPacketId) const;

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

@@ -15,14 +15,6 @@ namespace RTC
 			 * Maximum length of a probation RTP packet.
 			 */
 			static constexpr size_t ProbationPacketMaxLength{ 1400 };
-			/**
-			 * SSRC of the probation RTP stream.
-			 */
-			static const uint32_t Ssrc{ 1234 };
-			/**
-			 * Codec payload type of the probation RTP stream.
-			 */
-			static const uint8_t PayloadType{ 127 };
 
 		public:
 			explicit ProbationGenerator();

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

@@ -259,17 +259,20 @@ namespace RTC
 			// Jitter in RTP timestamp units. As per spec it's kept as floating value
 			// although it's exposed as integer in the stats.
 			float jitter{ 0 };
-			size_t packetsDiscarded{ 0 };
-			size_t packetsRetransmitted{ 0 };
-			size_t packetsRepaired{ 0 };
-			size_t nackCount{ 0 };
-			size_t nackPacketCount{ 0 };
-			size_t pliCount{ 0 };
-			size_t firCount{ 0 };
+			// NOTE: These counters are never reset and nothing bounds them, so they are
+			// as wide as the stats fields they end up in rather than as wide as a
+			// pointer.
+			uint64_t packetsDiscarded{ 0 };
+			uint64_t packetsRetransmitted{ 0 };
+			uint64_t packetsRepaired{ 0 };
+			uint64_t nackCount{ 0 };
+			uint64_t nackPacketCount{ 0 };
+			uint64_t pliCount{ 0 };
+			uint64_t firCount{ 0 };
 			// Packets repaired at last interval for score calculation.
-			size_t repairedPriorScore{ 0 };
+			uint64_t repairedPriorScore{ 0 };
 			// Packets retransmitted at last interval for score calculation.
-			size_t retransmittedPriorScore{ 0 };
+			uint64_t retransmittedPriorScore{ 0 };
 			// Correspondence between wall clock and RTP timeline given by the last Sender
 			// Report.
 			std::optional<RTP::RtpStream::SenderReportMapping> lastSenderReportMapping;

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

@@ -77,9 +77,9 @@ namespace RTC
 
 				int64_t GetLayerBitrate(int64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer);
 
-				size_t GetPacketCount() const;
+				uint64_t GetPacketCount() const;
 
-				size_t GetBytes() const;
+				uint64_t GetBytes() const;
 
 			private:
 				std::vector<std::vector<RTC::RtpDataCounter>> spatialLayerCounters;
@@ -227,6 +227,20 @@ namespace RTC
 			 */
 			std::optional<int64_t> GetRemoteCaptureAtUsFromAbsCaptureTime(uint32_t ts) const;
 
+			/**
+			 * Whether the 'abs-capture-time' RTP header extension has ever been received
+			 * on this stream.
+			 *
+			 * @remarks
+			 * - It is not the same as being able to tell a capture instant from it, which
+			 *   also depends on how far the wanted RTP timestamp falls from the one it
+			 *   referred to.
+			 */
+			bool HasAbsCaptureTime() const
+			{
+				return this->lastAbsCaptureTime.has_value();
+			}
+
 			/**
 			 * Capture instant of the given RTP timestamp, expressed in the remote sender's
 			 * wall clock, interpolated from the last received RTCP Sender Report.
@@ -306,13 +320,17 @@ namespace RTC
 			bool useRtpInactivityCheck{ false };
 			// Others.
 			// Packets expected at last interval.
+			// NOTE: As wide as GetExpectedPackets(), which wraps with the sequence
+			// number, so that the difference against it is taken in its own width.
 			uint32_t expectedPrior{ 0 };
 			// Packets expected at last interval for score calculation.
 			uint32_t expectedPriorScore{ 0 };
 			// Packets received at last interval.
-			uint32_t receivedPrior{ 0 };
+			// NOTE: As wide as the counter it snapshots, which does not wrap, so that
+			// the difference against it stays exact however long the stream runs.
+			uint64_t receivedPrior{ 0 };
 			// Packets received at last interval for score calculation.
-			uint32_t receivedPriorScore{ 0 };
+			uint64_t receivedPriorScore{ 0 };
 			// Timing data of the most recent Sender Report received.
 			std::optional<SenderReportTiming> lastSenderReportTiming;
 			// Most recent `abs-capture-time` RTP header extension received.

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

@@ -109,7 +109,7 @@ namespace RTC
 
 			int64_t GetBitrate(int64_t nowMs) override
 			{
-				return this->transmissionCounter.GetBitrate(nowMs);
+				return this->transmissionCounter.GetBitrate(nowMs).value_or(0);
 			}
 
 			int64_t GetBitrate(int64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) override;
@@ -131,7 +131,9 @@ namespace RTC
 			// Packets lost at last interval for score calculation.
 			int32_t lostPriorScore{ 0 };
 			// Packets sent at last interval for score calculation.
-			uint32_t sentPriorScore{ 0 };
+			// NOTE: As wide as the counter it snapshots, which does not wrap, so that
+			// the difference against it stays exact however long the stream runs.
+			uint64_t sentPriorScore{ 0 };
 			std::string mid;
 			uint16_t rtxSeq{ 0 };
 			RTC::RtpDataCounter transmissionCounter;

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

@@ -96,7 +96,7 @@ namespace RTC
 				return static_cast<float>(this->fractionLost) * 100 / 256;
 			}
 
-			size_t GetPacketsDiscarded() const
+			uint64_t GetPacketsDiscarded() const
 			{
 				return this->packetsDiscarded;
 			}
@@ -131,15 +131,21 @@ namespace RTC
 			uint32_t maxPacketTs{ 0 }; // Highest timestamp seen.
 			int32_t packetsLost{ 0 };
 			uint8_t fractionLost{ 0 };
-			size_t packetsDiscarded{ 0 };
-			size_t packetsCount{ 0 };
+			// NOTE: These counters are never reset and nothing bounds them, so they are
+			// as wide as the stats fields they end up in rather than as wide as a
+			// pointer.
+			uint64_t packetsDiscarded{ 0 };
+			uint64_t packetsCount{ 0 };
 
 		private:
 			// Whether at least a RTP packet has been received.
 			bool started{ false };
 			// Fields for generating Receiver Reports.
+			// NOTE: Each one is as wide as the counter it snapshots, so that the
+			// expected one follows the wrap of the sequence number while the received
+			// one, which does not wrap, stays exact however long the stream runs.
 			uint32_t expectedPrior{ 0 };
-			uint32_t receivedPrior{ 0 };
+			uint64_t receivedPrior{ 0 };
 			// Timing data of the most recent Sender Report received.
 			std::optional<SenderReportTiming> lastSenderReportTiming;
 			int32_t reportedPacketsLost{ 0 };