mediasoup 3.11.21 → 3.11.23

package/worker/src/RTC/Producer.cpp

@@ -672,6 +672,8 @@ namespace RTC
 	{
 		MS_TRACE();
 
+		packet->logger.producerId = this->id;
+
 		// Reset current packet.
 		this->currentRtpPacket = nullptr;
 
@@ -684,6 +686,8 @@ namespace RTC
 		{
 			MS_WARN_TAG(rtp, "no stream found for received packet [ssrc:%" PRIu32 "]", packet->GetSsrc());
 
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::RECV_RTP_STREAM_NOT_FOUND);
+
 			return ReceiveRtpPacketResult::DISCARDED;
 		}
 
@@ -705,6 +709,8 @@ namespace RTC
 				if (this->mapSsrcRtpStream.size() > numRtpStreamsBefore)
 					NotifyNewRtpStream(rtpStream);
 
+				packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::RECV_RTP_STREAM_DISCARDED);
+
 				return result;
 			}
 		}
@@ -716,7 +722,11 @@ namespace RTC
 
 			// Process the packet.
 			if (!rtpStream->ReceiveRtxPacket(packet))
+			{
+				packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::RECV_RTP_STREAM_NOT_FOUND);
+
 				return result;
+			}
 		}
 		// Should not happen.
 		else
@@ -1213,8 +1223,11 @@ namespace RTC
 			}
 		}
 
+		// Only perform RTP inactivity check on simulcast.
+		auto useRtpInactivityCheck = this->type == RtpParameters::Type::SIMULCAST;
+
 		// Create a RtpStreamRecv for receiving a media stream.
-		auto* rtpStream = new RTC::RtpStreamRecv(this, params, SendNackDelay);
+		auto* rtpStream = new RTC::RtpStreamRecv(this, params, SendNackDelay, useRtpInactivityCheck);
 
 		// Insert into the maps.
 		this->mapSsrcRtpStream[ssrc]              = rtpStream;

package/worker/src/RTC/Router.cpp

@@ -706,6 +706,8 @@ namespace RTC
 	{
 		MS_TRACE();
 
+		packet->logger.routerId = this->id;
+
 		auto& consumers = this->mapProducerConsumers.at(producer);
 
 		if (!consumers.empty())

package/worker/src/RTC/RtcLogger.cpp

@@ -0,0 +1,101 @@
+#define MS_CLASS "RTC::RtcLogger"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "RTC/RtcLogger.hpp"
+#include "Logger.hpp"
+
+namespace RTC
+{
+	namespace RtcLogger
+	{
+		// clang-format off
+		absl::flat_hash_map<RtpPacket::DropReason, std::string> RtpPacket::dropReason2String = {
+			{ RtpPacket::DropReason::NONE,                                    "None"                               },
+			{ RtpPacket::DropReason::PRODUCER_NOT_FOUND,                      "ProducerNotFound"                   },
+			{ RtpPacket::DropReason::RECV_RTP_STREAM_NOT_FOUND,               "RecvRtpStreamNotFound"              },
+			{ RtpPacket::DropReason::RECV_RTP_STREAM_DISCARDED,               "RecvRtpStreamDiscarded"             },
+			{ RtpPacket::DropReason::CONSUMER_INACTIVE,                       "ConsumerInactive"                   },
+			{ RtpPacket::DropReason::INVALID_TARGET_LAYER,                    "InvalidTargetLayer"                 },
+			{ RtpPacket::DropReason::UNSUPPORTED_PAYLOAD_TYPE,                "UnsupportedPayloadType"             },
+			{ RtpPacket::DropReason::NOT_A_KEYFRAME,                          "NotAKeyframe"                       },
+			{ RtpPacket::DropReason::SPATIAL_LAYER_MISMATCH,                  "SpatialLayerMismatch"               },
+			{ RtpPacket::DropReason::TOO_HIGH_TIMESTAMP_EXTRA_NEEDED,         "TooHighTimestampExtraNeeded"        },
+			{ RtpPacket::DropReason::PACKET_PREVIOUS_TO_SPATIAL_LAYER_SWITCH, "PacketPreviousToSpatialLayerSwitch" },
+			{ RtpPacket::DropReason::DROPPED_BY_CODEC,                        "DroppedByCodec"                     },
+			{ RtpPacket::DropReason::SEND_RTP_STREAM_DISCARDED,               "SendRtpStreamDiscarded"             },
+		};
+		// clang-format on
+
+		void RtpPacket::Sent()
+		{
+			MS_TRACE();
+
+			this->dropped = false;
+
+			Log();
+			Clear();
+		}
+
+		void RtpPacket::Dropped(DropReason dropReason)
+		{
+			MS_TRACE();
+
+			this->dropped    = true;
+			this->dropReason = dropReason;
+
+			Log();
+			Clear();
+		}
+
+		void RtpPacket::Log() const
+		{
+#ifdef MS_RTC_LOGGER_RTP
+			MS_TRACE();
+
+			std::cout << "{";
+			std::cout << "\"timestamp\": " << this->timestamp;
+
+			if (!this->recvTransportId.empty())
+			{
+				std::cout << ", \"recvTransportId\": \"" << this->recvTransportId << "\"";
+			}
+			if (!this->sendTransportId.empty())
+			{
+				std::cout << ", \"sendTransportId\": \"" << this->sendTransportId << "\"";
+			}
+			if (!this->routerId.empty())
+			{
+				std::cout << ", \"routerId\": \"" << this->routerId << "\"";
+			}
+			if (!this->producerId.empty())
+			{
+				std::cout << ", \"producerId\": \"" << this->producerId << "\"";
+			}
+			if (!this->consumerId.empty())
+			{
+				std::cout << ", \"consumerId\": \"" << this->consumerId << "\"";
+			}
+
+			std::cout << ", \"recvRtpTimestamp\": " << this->recvRtpTimestamp;
+			std::cout << ", \"sendRtpTimestamp\": " << this->sendRtpTimestamp;
+			std::cout << ", \"recvSeqNumber\": " << this->recvSeqNumber;
+			std::cout << ", \"sendSeqNumber\": " << this->sendSeqNumber;
+			std::cout << ", \"dropped\": " << (this->dropped ? "true" : "false");
+			std::cout << ", \"dropReason\": '" << dropReason2String[this->dropReason] << "'";
+			std::cout << "}" << std::endl;
+#endif
+		}
+
+		void RtpPacket::Clear()
+		{
+			MS_TRACE();
+
+			this->sendTransportId = {};
+			this->routerId        = {};
+			this->producerId      = {};
+			this->sendSeqNumber   = { 0 };
+			this->dropped         = { false };
+			this->dropReason      = { DropReason::NONE };
+		}
+	} // namespace RtcLogger
+} // namespace RTC

package/worker/src/RTC/RtpPacket.cpp

@@ -2,6 +2,7 @@
 // #define MS_LOG_DEV_LEVEL 3
 
 #include "RTC/RtpPacket.hpp"
+#include "DepLibUV.hpp"
 #include "Logger.hpp"
 #include <cstring>  // std::memcpy(), std::memmove(), std::memset()
 #include <iterator> // std::ostream_iterator
@@ -139,6 +140,14 @@ namespace RTC
 
 		// Parse RFC 5285 header extension.
 		ParseExtensions();
+
+// Avoid retrieving the time if RTC logger is disabled.
+#ifdef MS_RTC_LOGGER_RTP
+		// Initialize logger.
+		this->logger.timestamp        = DepLibUV::GetTimeMs();
+		this->logger.recvRtpTimestamp = this->GetTimestamp();
+		this->logger.recvSeqNumber    = this->GetSequenceNumber();
+#endif
 	}
 
 	RtpPacket::~RtpPacket()

package/worker/src/RTC/RtpStreamRecv.cpp

@@ -189,8 +189,12 @@ namespace RTC
 	/* Instance methods. */
 
 	RtpStreamRecv::RtpStreamRecv(
-	  RTC::RtpStreamRecv::Listener* listener, RTC::RtpStream::Params& params, unsigned int sendNackDelayMs)
+	  RTC::RtpStreamRecv::Listener* listener,
+	  RTC::RtpStream::Params& params,
+	  unsigned int sendNackDelayMs,
+	  bool useRtpInactivityCheck)
 	  : RTC::RtpStream::RtpStream(listener, params, 10), sendNackDelayMs(sendNackDelayMs),
+	    useRtpInactivityCheck(useRtpInactivityCheck),
 	    transmissionCounter(
 	      params.spatialLayers, params.temporalLayers, this->params.useDtx ? 6000 : 2500)
 	{
@@ -201,18 +205,16 @@ namespace RTC
 			this->nackGenerator.reset(new RTC::NackGenerator(this, this->sendNackDelayMs));
 		}
 
-		// Run the RTP inactivity periodic timer (use a different timeout if DTX is
-		// enabled).
-		this->inactivityCheckPeriodicTimer = new Timer(this);
-		this->inactive                     = false;
+		this->inactive = false;
 
-		if (!this->params.useDtx)
+		if (this->useRtpInactivityCheck)
 		{
-			this->inactivityCheckPeriodicTimer->Start(InactivityCheckInterval);
-		}
-		else
-		{
-			this->inactivityCheckPeriodicTimer->Start(InactivityCheckIntervalWithDtx);
+			// Run the RTP inactivity periodic timer (use a different timeout if DTX is
+			// enabled).
+			this->inactivityCheckPeriodicTimer = new Timer(this);
+
+			this->inactivityCheckPeriodicTimer->Start(
+			  this->params.useDtx ? InactivityCheckIntervalWithDtx : InactivityCheckInterval);
 		}
 	}
 
@@ -222,6 +224,7 @@ namespace RTC
 
 		// Close the RTP inactivity check periodic timer.
 		delete this->inactivityCheckPeriodicTimer;
+		this->inactivityCheckPeriodicTimer = nullptr;
 	}
 
 	void RtpStreamRecv::FillJsonStats(json& jsonObject)

package/worker/src/RTC/SeqManager.cpp

@@ -58,14 +58,11 @@ namespace RTC
 		// Mark as dropped if 'input' is higher than anyone already processed.
 		if (SeqManager<T, N>::IsSeqHigherThan(input, this->maxInput))
 		{
+			this->maxInput = input;
 			this->dropped.insert(input);
-		}
-	}
 
-	template<typename T, uint8_t N>
-	void SeqManager<T, N>::Offset(T offset)
-	{
-		this->base = (this->base + offset) & MaxValue;
+			ClearDropped();
+		}
 	}
 
 	template<typename T, uint8_t N>
@@ -73,44 +70,52 @@ namespace RTC
 	{
 		auto base = this->base;
 
-		// There are dropped inputs. Synchronize.
-		if (!this->dropped.empty())
+		// No dropped inputs to consider.
+		if (this->dropped.empty())
+		{
+			goto done;
+		}
+		// Dropped inputs present, cleanup and update base.
+		else
 		{
-			// Check whether this input was dropped.
-			if (this->dropped.find(input) != this->dropped.end())
+			// Set 'maxInput' here if needed before calling ClearDropped().
+			if (this->started && IsSeqHigherThan(input, this->maxInput))
 			{
-				MS_DEBUG_DEV("trying to send a dropped input");
-
-				return false;
+				this->maxInput = input;
 			}
 
-			// Dropped entries count that must be considered for the output.
-			size_t count{ 0 };
+			ClearDropped();
+
+			base = this->base;
+		}
 
-			/*
-			 * Consider values lower than input and those higher that input
-			 * which belong to a previous cycle.
-			 */
-			for (const auto& value : this->dropped)
+		// No dropped inputs to consider after cleanup.
+		if (this->dropped.empty())
+		{
+			goto done;
+		}
+		// This input was dropped.
+		else if (this->dropped.find(input) != this->dropped.end())
+		{
+			MS_DEBUG_DEV("trying to send a dropped input");
+
+			return false;
+		}
+		// There are dropped inputs, calculate 'base' for this input.
+		else
+		{
+			// Get the first dropped input which is higher than or equal 'input'.
+			auto it = this->dropped.lower_bound(input);
+
+			// There are dropped inputs lower than 'input'.
+			if (it != this->dropped.begin())
 			{
-				// clang-format off
-				if
-				(
-					IsSeqLowerThan(value, input) ||
-					(
-					 (value > input && (value - input > MaxValue / 3)) ||
-					 (value < input && (input - value > MaxValue / 3))
-					)
-				)
-				// clang-format on
-				{
-					count++;
-				}
+				auto count = std::distance(this->dropped.begin(), it);
+				base       = (this->base - count) & MaxValue;
 			}
-
-			base = (this->base - count) & MaxValue;
 		}
 
+	done:
 		output = (input + base) & MaxValue;
 
 		if (!this->started)
@@ -122,23 +127,19 @@ namespace RTC
 		}
 		else
 		{
-			// New input is higher than the maximum seen. But less than acceptable units higher.
-			// Keep it as the maximum seen. See Drop().
+			// New input is higher than the maximum seen.
 			if (IsSeqHigherThan(input, this->maxInput))
 			{
 				this->maxInput = input;
 			}
 
-			// New output is higher than the maximum seen. But less than acceptable units higher.
-			// Keep it as the maximum seen. See Sync().
+			// New output is higher than the maximum seen.
 			if (IsSeqHigherThan(output, this->maxOutput))
 			{
 				this->maxOutput = output;
 			}
 		}
 
-		ClearDropped();
-
 		return true;
 	}
 
@@ -155,7 +156,7 @@ namespace RTC
 	}
 
 	/*
-	 * Delete droped inputs greater than maxInput that belong to a previous
+	 * Delete droped inputs greater than maxInput, which belong to a previous
 	 * cycle.
 	 */
 	template<typename T, uint8_t N>
@@ -167,37 +168,19 @@ namespace RTC
 			return;
 		}
 
-		const size_t threshold           = (this->maxInput + MaxValue / 3) & MaxValue;
 		const size_t previousDroppedSize = this->dropped.size();
-		const auto it1                   = this->dropped.upper_bound(this->maxInput);
-		const auto it2                   = this->dropped.lower_bound(threshold);
 
-		// There is no dropped value greater than this->maxInput.
-		if (it1 == this->dropped.end())
-		{
-			return;
-		}
-
-		// There is a single value in the range.
-		if (it1 == it2)
-		{
-			this->dropped.erase(it1);
-		}
-		// There are many values in the range.
-		else
+		for (auto it = this->dropped.begin(); it != this->dropped.end();)
 		{
-			// Measure the distance of it1 and it2 to the beggining of dropped.
-			auto distanceIt1 = std::distance(this->dropped.begin(), it1);
-			auto distanceIt2 = std::distance(this->dropped.begin(), it2);
+			auto value = *it;
 
-			// it2 goes out of range, only it1 is within the range.
-			if (distanceIt2 < distanceIt1)
+			if (isSeqHigherThan(value, this->maxInput))
 			{
-				this->dropped.erase(it1);
+				it = this->dropped.erase(it);
 			}
 			else
 			{
-				this->dropped.erase(it1, it2);
+				break;
 			}
 		}
 

package/worker/src/RTC/SimpleConsumer.cpp

@@ -265,8 +265,14 @@ namespace RTC
 	{
 		MS_TRACE();
 
+		packet->logger.consumerId = this->id;
+
 		if (!IsActive())
+		{
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::CONSUMER_INACTIVE);
+
 			return;
+		}
 
 		auto payloadType = packet->GetPayloadType();
 
@@ -276,6 +282,8 @@ namespace RTC
 		{
 			MS_DEBUG_DEV("payload type not supported [payloadType:%" PRIu8 "]", payloadType);
 
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::UNSUPPORTED_PAYLOAD_TYPE);
+
 			return;
 		}
 
@@ -292,13 +300,19 @@ namespace RTC
 
 			this->rtpSeqManager.Drop(packet->GetSequenceNumber());
 
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::DROPPED_BY_CODEC);
+
 			return;
 		}
 
 		// If we need to sync, support key frames and this is not a key frame, ignore
 		// the packet.
 		if (this->syncRequired && this->keyFrameSupported && !packet->IsKeyFrame())
+		{
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::NOT_A_KEYFRAME);
+
 			return;
+		}
 
 		// Whether this is the first packet after re-sync.
 		const bool isSyncPacket = this->syncRequired;
@@ -327,6 +341,9 @@ namespace RTC
 		packet->SetSsrc(this->rtpParameters.encodings[0].ssrc);
 		packet->SetSequenceNumber(seq);
 
+		packet->logger.sendRtpTimestamp = packet->GetTimestamp();
+		packet->logger.sendSeqNumber    = seq;
+
 		if (isSyncPacket)
 		{
 			MS_DEBUG_TAG(

package/worker/src/RTC/SimulcastConsumer.cpp

@@ -664,11 +664,21 @@ namespace RTC
 	{
 		MS_TRACE();
 
+		packet->logger.consumerId = this->id;
+
 		if (!IsActive())
+		{
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::CONSUMER_INACTIVE);
+
 			return;
+		}
 
 		if (this->targetTemporalLayer == -1)
+		{
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::INVALID_TARGET_LAYER);
+
 			return;
+		}
 
 		auto payloadType = packet->GetPayloadType();
 
@@ -678,6 +688,8 @@ namespace RTC
 		{
 			MS_DEBUG_DEV("payload type not supported [payloadType:%" PRIu8 "]", payloadType);
 
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::UNSUPPORTED_PAYLOAD_TYPE);
+
 			return;
 		}
 
@@ -690,7 +702,11 @@ namespace RTC
 		{
 			// Ignore if not a key frame.
 			if (!packet->IsKeyFrame())
+			{
+				packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::NOT_A_KEYFRAME);
+
 				return;
+			}
 
 			shouldSwitchCurrentSpatialLayer = true;
 
@@ -702,12 +718,18 @@ namespace RTC
 		// drop it.
 		else if (spatialLayer != this->currentSpatialLayer)
 		{
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::SPATIAL_LAYER_MISMATCH);
+
 			return;
 		}
 
 		// If we need to sync and this is not a key frame, ignore the packet.
 		if (this->syncRequired && !packet->IsKeyFrame())
+		{
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::NOT_A_KEYFRAME);
+
 			return;
+		}
 
 		// Whether this is the first packet after re-sync.
 		const bool isSyncPacket = this->syncRequired;
@@ -814,6 +836,8 @@ namespace RTC
 					this->syncRequired       = false;
 					this->spatialLayerToSync = -1;
 
+					packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::TOO_HIGH_TIMESTAMP_EXTRA_NEEDED);
+
 					return;
 				}
 
@@ -854,6 +878,9 @@ namespace RTC
 			if (SeqManager<uint16_t>::IsSeqLowerThan(
 			      packet->GetSequenceNumber(), this->snReferenceSpatialLayer))
 			{
+				packet->logger.Dropped(
+				  RtcLogger::RtpPacket::DropReason::PACKET_PREVIOUS_TO_SPATIAL_LAYER_SWITCH);
+
 				return;
 			}
 			else if (SeqManager<uint16_t>::IsSeqHigherThan(
@@ -898,6 +925,8 @@ namespace RTC
 			{
 				this->rtpSeqManager.Drop(packet->GetSequenceNumber());
 
+				packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::DROPPED_BY_CODEC);
+
 				return;
 			}
 
@@ -921,6 +950,9 @@ namespace RTC
 		packet->SetSequenceNumber(seq);
 		packet->SetTimestamp(timestamp);
 
+		packet->logger.sendRtpTimestamp = timestamp;
+		packet->logger.sendSeqNumber    = seq;
+
 		if (isSyncPacket)
 		{
 			MS_DEBUG_TAG(
@@ -959,6 +991,8 @@ namespace RTC
 			  origSsrc,
 			  origSeq,
 			  origTimestamp);
+
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::SEND_RTP_STREAM_DISCARDED);
 		}
 
 		// Restore packet fields.

package/worker/src/RTC/SvcConsumer.cpp

@@ -593,8 +593,14 @@ namespace RTC
 	{
 		MS_TRACE();
 
+		packet->logger.consumerId = this->id;
+
 		if (!IsActive())
+		{
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::CONSUMER_INACTIVE);
+
 			return;
+		}
 
 		// clang-format off
 		if (
@@ -603,6 +609,8 @@ namespace RTC
 		)
 		// clang-format on
 		{
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::INVALID_TARGET_LAYER);
+
 			return;
 		}
 
@@ -614,12 +622,18 @@ namespace RTC
 		{
 			MS_DEBUG_DEV("payload type not supported [payloadType:%" PRIu8 "]", payloadType);
 
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::UNSUPPORTED_PAYLOAD_TYPE);
+
 			return;
 		}
 
 		// If we need to sync and this is not a key frame, ignore the packet.
 		if (this->syncRequired && !packet->IsKeyFrame())
+		{
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::NOT_A_KEYFRAME);
+
 			return;
+		}
 
 		// Whether this is the first packet after re-sync.
 		const bool isSyncPacket = this->syncRequired;
@@ -646,6 +660,8 @@ namespace RTC
 		{
 			this->rtpSeqManager.Drop(packet->GetSequenceNumber());
 
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::DROPPED_BY_CODEC);
+
 			return;
 		}
 
@@ -673,6 +689,9 @@ namespace RTC
 		packet->SetSsrc(this->rtpParameters.encodings[0].ssrc);
 		packet->SetSequenceNumber(seq);
 
+		packet->logger.sendRtpTimestamp = packet->GetTimestamp();
+		packet->logger.sendSeqNumber    = seq;
+
 		if (marker)
 		{
 			packet->SetMarker(true);

package/worker/src/RTC/Transport.cpp

@@ -1692,6 +1692,8 @@ namespace RTC
 	{
 		MS_TRACE();
 
+		packet->logger.recvTransportId = this->id;
+
 		// Apply the Transport RTP header extension ids so the RTP listener can use them.
 		packet->SetMidExtensionId(this->recvRtpHeaderExtensionIds.mid);
 		packet->SetRidExtensionId(this->recvRtpHeaderExtensionIds.rid);
@@ -1712,6 +1714,8 @@ namespace RTC
 
 		if (!producer)
 		{
+			packet->logger.Dropped(RtcLogger::RtpPacket::DropReason::PRODUCER_NOT_FOUND);
+
 			MS_WARN_TAG(
 			  rtp,
 			  "no suitable Producer for received RTP packet [ssrc:%" PRIu32 ", payloadType:%" PRIu8 "]",
@@ -2663,6 +2667,9 @@ namespace RTC
 	{
 		MS_TRACE();
 
+		packet->logger.sendTransportId = this->id;
+		packet->logger.Sent();
+
 		// Update abs-send-time if present.
 		packet->UpdateAbsSendTime(DepLibUV::GetTimeMs());
 

package/worker/test/src/RTC/TestRtpStreamRecv.cpp

@@ -11,6 +11,7 @@ using namespace RTC;
 // 17: 16 bit mask + the initial sequence number.
 static constexpr size_t MaxRequestedPackets{ 17 };
 static constexpr unsigned int SendNackDelay{ 0u }; // In ms.
+static const bool UseRtpInactivityCheck{ false };
 
 SCENARIO("receive RTP packets and trigger NACK", "[rtp][rtpstream]")
 {
@@ -141,7 +142,7 @@ SCENARIO("receive RTP packets and trigger NACK", "[rtp][rtpstream]")
 	SECTION("NACK one packet")
 	{
 		RtpStreamRecvListener listener;
-		RtpStreamRecv rtpStream(&listener, params, SendNackDelay);
+		RtpStreamRecv rtpStream(&listener, params, SendNackDelay, UseRtpInactivityCheck);
 
 		packet->SetSequenceNumber(1);
 		rtpStream.ReceivePacket(packet);
@@ -170,7 +171,7 @@ SCENARIO("receive RTP packets and trigger NACK", "[rtp][rtpstream]")
 	SECTION("wrapping sequence numbers")
 	{
 		RtpStreamRecvListener listener;
-		RtpStreamRecv rtpStream(&listener, params, SendNackDelay);
+		RtpStreamRecv rtpStream(&listener, params, SendNackDelay, UseRtpInactivityCheck);
 
 		packet->SetSequenceNumber(0xfffe);
 		rtpStream.ReceivePacket(packet);
@@ -190,7 +191,7 @@ SCENARIO("receive RTP packets and trigger NACK", "[rtp][rtpstream]")
 	SECTION("require key frame")
 	{
 		RtpStreamRecvListener listener;
-		RtpStreamRecv rtpStream(&listener, params, SendNackDelay);
+		RtpStreamRecv rtpStream(&listener, params, SendNackDelay, UseRtpInactivityCheck);
 
 		packet->SetSequenceNumber(1);
 		rtpStream.ReceivePacket(packet);