Add nack request resend

Author: kaizhi-singtown

include/rtc/rtcpnackrequester.hpp

@@ -21,21 +21,26 @@ namespace rtc {
 
 class RTC_CPP_EXPORT RtcpNackRequester final : public MediaHandler {
 public:
+	RtcpNackRequester(SSRC ssrc, size_t jitterSize = 5, size_t nackResendIntervalMs = 10,
+	                  size_t nackResendTimesMax = 10);
 	SSRC ssrc;
-	size_t jitterSize;
-	size_t nackWaitMs;
-
-	RtcpNackRequester(SSRC ssrc, size_t jitterSize = 5, size_t nackWaitMs = 50);
 	void incoming(message_vector &messages, const message_callback &send) override;
 
 private:
-	uint16_t expectSequence = 0;
-	std::chrono::steady_clock::time_point nackWaitUntil;
+	size_t jitterSize;
+	size_t nackResendIntervalMs;
+	size_t nackResendTimesMax;
+
+	bool initialized = false;
+	uint16_t expectedSeq;
+	size_t nackResendTimes = 0;
+	std::chrono::steady_clock::time_point nextNackTime = std::chrono::steady_clock::now();
 
-	std::unordered_map<uint16_t, message_ptr> receivePackets;
-	std::set<uint16_t> lostSequenceNumbers;
+	std::map<uint16_t, message_ptr> jitterBuffer;
 
-	message_ptr nackMesssage(uint16_t sequence);
+	auto isSeqNewerOrEqual(uint16_t seq1, uint16_t seq2) -> bool;
+	void clearBuffer();
+	auto nackMessage(uint16_t sequence) -> message_ptr;
 };
 
 } // namespace rtc

src/rtcpnackrequester.cpp

@@ -14,9 +14,10 @@
 #include "impl/internals.hpp"
 
 namespace rtc {
-
-RtcpNackRequester::RtcpNackRequester(SSRC ssrc, size_t jitterSize, size_t nackWaitMs)
-    : ssrc(ssrc), jitterSize(jitterSize), nackWaitMs(nackWaitMs) {}
+RtcpNackRequester::RtcpNackRequester(SSRC ssrc, size_t jitterSize, size_t nackResendIntervalMs,
+                                     size_t nackResendTimesMax)
+    : ssrc(ssrc), jitterSize(jitterSize), nackResendIntervalMs(nackResendIntervalMs),
+      nackResendTimesMax(nackResendTimesMax) {}
 
 void RtcpNackRequester::incoming(message_vector &messages, const message_callback &send) {
 	message_vector result;
@@ -33,45 +34,61 @@ void RtcpNackRequester::incoming(message_vector &messages, const message_callbac
 
 		auto rtp = reinterpret_cast<RtpHeader *>(message->data());
 		uint16_t seqNo = rtp->seqNumber();
-		lostSequenceNumbers.erase(seqNo);
 
-		if (expectSequence == 0) {
-			expectSequence = seqNo;
+		if (!initialized) {
+			expectedSeq = seqNo;
+			initialized = true;
 		}
-		if ((int16_t)(seqNo - expectSequence) >= 0) {
-			receivePackets[seqNo] = message;
+		if (isSeqNewerOrEqual(seqNo, expectedSeq)) {
+			jitterBuffer[seqNo] = message;
 		}
 	}
 
-	while (receivePackets.size() > jitterSize) {
-		bool alreadyReceived = receivePackets.count(expectSequence) > 0;
+	while (jitterBuffer.size() > 0) {
+		bool alreadyReceived = jitterBuffer.count(expectedSeq) > 0;
 		if (alreadyReceived) {
-			auto packet = receivePackets[expectSequence];
+			auto packet = jitterBuffer[expectedSeq];
 			result.push_back(packet);
-			receivePackets.erase(expectSequence);
-			expectSequence++;
+			jitterBuffer.erase(expectedSeq);
+			expectedSeq++;
+			nackResendTimes = 0;
 			continue;
 		} else {
-			bool alreadySentNack = lostSequenceNumbers.count(expectSequence) > 0;
+			if (jitterBuffer.size() < jitterSize) {
+				break;
+			}
+			if (nackResendTimes >= nackResendTimesMax) {
+				PLOG_VERBOSE << "Skip NACK for lost packet: " << expectedSeq;
+				clearBuffer();
+				break;
+			}
+
 			auto now = std::chrono::steady_clock::now();
-			if (alreadySentNack) {
-				if (now >= nackWaitUntil) {
-					PLOG_VERBOSE << "Skip NACK for lost packet: " << expectSequence;
-					expectSequence++;
-				}
-			} else {
-				PLOG_VERBOSE << "Sending NACK for lost packet: " << expectSequence;
-				lostSequenceNumbers.insert(expectSequence);
-				nackWaitUntil = now + std::chrono::milliseconds(nackWaitMs);
-				send(nackMesssage(expectSequence));
+			if (now > nextNackTime) {
+				PLOG_VERBOSE << "Sending NACK for lost packet: " << expectedSeq;
+				nextNackTime = now + std::chrono::milliseconds(nackResendIntervalMs);
+				send(nackMessage(expectedSeq));
+				nackResendTimes++;
 			}
+
 			break;
 		}
 	}
 	messages.swap(result);
 }
 
-message_ptr RtcpNackRequester::nackMesssage(uint16_t sequence) {
+auto RtcpNackRequester::isSeqNewerOrEqual(uint16_t seq1, uint16_t seq2) -> bool {
+	return (int16_t)(seq1 - seq2) >= 0;
+}
+
+void RtcpNackRequester::clearBuffer() {
+	initialized = false;
+	jitterBuffer.clear();
+	nackResendTimes = 0;
+	nextNackTime = std::chrono::steady_clock::now();
+}
+
+auto RtcpNackRequester::nackMessage(uint16_t sequence) -> message_ptr {
 	unsigned int fciCount = 0;
 	uint16_t fciPID = 0;