mediasoup 3.10.3 → 3.10.4

package/node/lib/EnhancedEventEmitter.d.ts

@@ -15,7 +15,7 @@ export declare class EnhancedEventEmitter<E extends Events = Events> extends Eve
     once<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
     prependOnceListener<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
     removeListener<K extends keyof E & string>(eventName: K, listener: (...args: E[K]) => void): this;
-    removeAllListeners<K extends keyof E & string>(eventName: K): this;
+    removeAllListeners<K extends keyof E & string>(eventName?: K): this;
     listenerCount<K extends keyof E & string>(eventName: K): number;
     listeners<K extends keyof E & string>(eventName: K): Function[];
     rawListeners<K extends keyof E & string>(eventName: K): Function[];

package/node/lib/EnhancedEventEmitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EnhancedEventEmitter.d.ts","sourceRoot":"","sources":["../src/EnhancedEventEmitter.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAKtC,aAAK,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAA;AAEnC,qBAAa,oBAAoB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,YAAY;;IAQhF,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO;IAKtE;;OAEG;IACH,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO;IAkB1E,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAC5B,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAC/B,IAAI;IAOP,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAC7B,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAC/B,IAAI;IAOP,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EACrC,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAC/B,IAAI;IAOP,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EACzC,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAC/B,IAAI;IAOP,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAC9B,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAC/B,IAAI;IAOP,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAC7C,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAC/B,IAAI;IAOP,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EACxC,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAC/B,IAAI;IAOP,kBAAkB,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,CAAC,GAAG,IAAI;IAOlE,aAAa,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,CAAC,GAAG,MAAM;IAK/D,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,CAAC,GAAG,QAAQ,EAAE;IAK/D,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,CAAC,GAAG,QAAQ,EAAE;CAIlE"}
+{"version":3,"file":"EnhancedEventEmitter.d.ts","sourceRoot":"","sources":["../src/EnhancedEventEmitter.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAKtC,aAAK,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAA;AAEnC,qBAAa,oBAAoB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,YAAY;;IAQhF,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO;IAKtE;;OAEG;IACH,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO;IAkB1E,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAC5B,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAC/B,IAAI;IAOP,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAC7B,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAC/B,IAAI;IAOP,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EACrC,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAC/B,IAAI;IAOP,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EACzC,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAC/B,IAAI;IAOP,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAC9B,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAC/B,IAAI;IAOP,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAC7C,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAC/B,IAAI;IAOP,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EACxC,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,GAC/B,IAAI;IAOP,kBAAkB,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,SAAS,CAAC,EAAE,CAAC,GAAG,IAAI;IAOnE,aAAa,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,CAAC,GAAG,MAAM;IAK/D,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,CAAC,GAAG,QAAQ,EAAE;IAK/D,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,CAAC,GAAG,QAAQ,EAAE;CAIlE"}

package/node/lib/Worker.js

@@ -81,7 +81,7 @@ class Worker extends EnhancedEventEmitter_1.EnhancedEventEmitter {
         // options
         {
             env: {
-                MEDIASOUP_VERSION: '3.10.3',
+                MEDIASOUP_VERSION: '3.10.4',
                 // Let the worker process inherit all environment variables, useful
                 // if a custom and not in the path GCC is used so the user can set
                 // LD_LIBRARY_PATH environment variable for runtime.

package/node/lib/index.d.ts

@@ -9,7 +9,7 @@ export { types };
 /**
  * Expose mediasoup version.
  */
-export declare const version = "3.10.3";
+export declare const version = "3.10.4";
 /**
  * Expose parseScalabilityMode() function.
  */

package/node/lib/index.js

@@ -11,7 +11,7 @@ exports.types = types;
 /**
  * Expose mediasoup version.
  */
-exports.version = '3.10.3';
+exports.version = '3.10.4';
 /**
  * Expose parseScalabilityMode() function.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mediasoup",
-  "version": "3.10.3",
+  "version": "3.10.4",
   "description": "Cutting Edge WebRTC Video Conferencing",
   "contributors": [
     "Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -78,10 +78,10 @@
   "devDependencies": {
     "@types/debug": "^4.1.7",
     "@types/uuid": "^8.3.4",
-    "@typescript-eslint/eslint-plugin": "^5.30.5",
-    "@typescript-eslint/parser": "^5.30.5",
-    "eslint": "^8.19.0",
-    "eslint-plugin-jest": "^26.5.3",
+    "@typescript-eslint/eslint-plugin": "^5.30.6",
+    "@typescript-eslint/parser": "^5.30.6",
+    "eslint": "^8.20.0",
+    "eslint-plugin-jest": "^26.6.0",
     "jest": "^27.5.1",
     "jest-tobetype": "^1.2.3",
     "open-cli": "^7.0.1",

package/worker/include/RTC/Consumer.hpp

@@ -142,8 +142,8 @@ namespace RTC
 		virtual uint32_t IncreaseLayer(uint32_t bitrate, bool considerLoss) = 0;
 		virtual void ApplyLayers()                                          = 0;
 		virtual uint32_t GetDesiredBitrate() const                          = 0;
-		virtual void SendRtpPacket(std::shared_ptr<RTC::RtpPacket> packet)  = 0;
-		virtual std::vector<RTC::RtpStreamSend*> GetRtpStreams()            = 0;
+		virtual void SendRtpPacket(RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket) = 0;
+		virtual std::vector<RTC::RtpStreamSend*> GetRtpStreams() = 0;
 		virtual void GetRtcp(
 		  RTC::RTCP::CompoundPacket* packet, RTC::RtpStreamSend* rtpStream, uint64_t nowMs) = 0;
 		virtual void NeedWorstRemoteFractionLost(uint32_t mappedSsrc, uint8_t& worstRemoteFractionLost) = 0;

package/worker/include/RTC/PipeConsumer.hpp

@@ -30,7 +30,7 @@ namespace RTC
 		uint32_t IncreaseLayer(uint32_t bitrate, bool considerLoss) override;
 		void ApplyLayers() override;
 		uint32_t GetDesiredBitrate() const override;
-		void SendRtpPacket(std::shared_ptr<RTC::RtpPacket> packet) override;
+		void SendRtpPacket(RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket) override;
 		void GetRtcp(RTC::RTCP::CompoundPacket* packet, RTC::RtpStreamSend* rtpStream, uint64_t nowMs) override;
 		std::vector<RTC::RtpStreamSend*> GetRtpStreams() override
 		{

package/worker/include/RTC/RtpStreamSend.hpp

@@ -71,7 +71,7 @@ namespace RTC
 
 		void FillJsonStats(json& jsonObject) override;
 		void SetRtx(uint8_t payloadType, uint32_t ssrc) override;
-		bool ReceivePacket(std::shared_ptr<RTC::RtpPacket> packet);
+		bool ReceivePacket(RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket);
 		void ReceiveNack(RTC::RTCP::FeedbackRtpNackPacket* nackPacket);
 		void ReceiveKeyFrameRequest(RTC::RTCP::FeedbackPs::MessageType messageType);
 		void ReceiveRtcpReceiverReport(RTC::RTCP::ReceiverReport* report);
@@ -90,7 +90,7 @@ namespace RTC
 		uint32_t GetLayerBitrate(uint64_t nowMs, uint8_t spatialLayer, uint8_t temporalLayer) override;
 
 	private:
-		void StorePacket(std::shared_ptr<RTC::RtpPacket> packet);
+		void StorePacket(RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket);
 		void ClearOldPackets(const RtpPacket* packet);
 		void ClearBuffer();
 		void FillRetransmissionContainer(uint16_t seq, uint16_t bitmask);

package/worker/include/RTC/SimpleConsumer.hpp

@@ -40,7 +40,7 @@ namespace RTC
 		uint32_t IncreaseLayer(uint32_t bitrate, bool considerLoss) override;
 		void ApplyLayers() override;
 		uint32_t GetDesiredBitrate() const override;
-		void SendRtpPacket(std::shared_ptr<RTC::RtpPacket> packet) override;
+		void SendRtpPacket(RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket) override;
 		std::vector<RTC::RtpStreamSend*> GetRtpStreams() override
 		{
 			return this->rtpStreams;

package/worker/include/RTC/SimulcastConsumer.hpp

@@ -56,7 +56,7 @@ namespace RTC
 		uint32_t IncreaseLayer(uint32_t bitrate, bool considerLoss) override;
 		void ApplyLayers() override;
 		uint32_t GetDesiredBitrate() const override;
-		void SendRtpPacket(std::shared_ptr<RTC::RtpPacket> packet) override;
+		void SendRtpPacket(RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket) override;
 		void GetRtcp(RTC::RTCP::CompoundPacket* packet, RTC::RtpStreamSend* rtpStream, uint64_t nowMs) override;
 		std::vector<RTC::RtpStreamSend*> GetRtpStreams() override
 		{

package/worker/include/RTC/SvcConsumer.hpp

@@ -51,7 +51,7 @@ namespace RTC
 		uint32_t IncreaseLayer(uint32_t bitrate, bool considerLoss) override;
 		void ApplyLayers() override;
 		uint32_t GetDesiredBitrate() const override;
-		void SendRtpPacket(std::shared_ptr<RTC::RtpPacket> packet) override;
+		void SendRtpPacket(RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket) override;
 		void GetRtcp(RTC::RTCP::CompoundPacket* packet, RTC::RtpStreamSend* rtpStream, uint64_t nowMs) override;
 		std::vector<RTC::RtpStreamSend*> GetRtpStreams() override
 		{

package/worker/src/RTC/DtlsTransport.cpp

@@ -980,28 +980,25 @@ namespace RTC
 	{
 		MS_TRACE();
 
+		MS_ASSERT(this->ssl, "this->ssl is not set");
 		MS_ASSERT(
 		  this->state == DtlsState::CONNECTING || this->state == DtlsState::CONNECTED,
 		  "invalid DTLS state");
 
-		int64_t ret;
 		uv_timeval_t dtlsTimeout{ 0, 0 };
 		uint64_t timeoutMs;
 
-		// NOTE: No DTLSv_1_2_get_timeout() or DTLS_get_timeout() in OpenSSL 1.1.0-dev.
-		ret = DTLSv1_get_timeout(this->ssl, static_cast<void*>(&dtlsTimeout)); // NOLINT
-
-		if (ret == 0)
-		{
-			OnTimer(this->timer);
-
-			return true;
-		}
+		// DTLSv1_get_timeout queries the next DTLS handshake timeout. If there is
+		// a timeout in progress, it sets *out to the time remaining and returns
+		// one. Otherwise, it returns zero.
+		DTLSv1_get_timeout(this->ssl, static_cast<void*>(&dtlsTimeout)); // NOLINT
 
 		timeoutMs = (dtlsTimeout.tv_sec * static_cast<uint64_t>(1000)) + (dtlsTimeout.tv_usec / 1000);
 
 		if (timeoutMs == 0)
 		{
+			MS_DEBUG_DEV("timeout is 0, calling OnTimer() callback directly");
+
 			OnTimer(this->timer);
 
 			return true;
@@ -1424,11 +1421,21 @@ namespace RTC
 			return;
 		}
 
+		// DTLSv1_handle_timeout is called when a DTLS handshake timeout expires.
+		// If no timeout had expired, it returns 0. Otherwise, it retransmits the
+		// previous flight of handshake messages and returns 1. If too many timeouts
+		// had expired without progress or an error occurs, it returns -1.
 		auto ret = DTLSv1_handle_timeout(this->ssl);
 
-		// -1 means that too many timeouts had expired without progress or an
-		// error occurs.
-		if (ret == -1)
+		if (ret == 1)
+		{
+			// If required, send DTLS data.
+			SendPendingOutgoingDtlsData();
+
+			// Set the DTLS timer again.
+			SetTimeout();
+		}
+		else if (ret == -1)
 		{
 			MS_WARN_TAG(dtls, "DTLSv1_handle_timeout() failed");
 
@@ -1438,13 +1445,5 @@ namespace RTC
 			this->state = DtlsState::FAILED;
 			this->listener->OnDtlsTransportFailed(this);
 		}
-		else
-		{
-			// If required, send DTLS data.
-			SendPendingOutgoingDtlsData();
-
-			// Set the DTLS timer again.
-			SetTimeout();
-		}
 	}
 } // namespace RTC

package/worker/src/RTC/PipeConsumer.cpp

@@ -184,7 +184,7 @@ namespace RTC
 		return 0u;
 	}
 
-	void PipeConsumer::SendRtpPacket(std::shared_ptr<RTC::RtpPacket> packet)
+	void PipeConsumer::SendRtpPacket(RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket)
 	{
 		MS_TRACE();
 
@@ -253,13 +253,13 @@ namespace RTC
 		}
 
 		// Process the packet.
-		if (rtpStream->ReceivePacket(packet))
+		if (rtpStream->ReceivePacket(packet, sharedPacket))
 		{
 			// Send the packet.
-			this->listener->OnConsumerSendRtpPacket(this, packet.get());
+			this->listener->OnConsumerSendRtpPacket(this, packet);
 
 			// May emit 'trace' event.
-			EmitTraceEventRtpAndKeyFrameTypes(packet.get());
+			EmitTraceEventRtpAndKeyFrameTypes(packet);
 		}
 		else
 		{

package/worker/src/RTC/Router.cpp

@@ -798,9 +798,10 @@ namespace RTC
 
 		if (!consumers.empty())
 		{
-			// Clone the packet so it holds its own buffer, usable for future
-			// retransmissions.
-			std::shared_ptr<RTC::RtpPacket> sharedPacket(packet->Clone());
+			// Cloned ref-counted packet that RtpStreamSend will store for as long as
+			// needed avoiding multiple allocations unless absolutely necessary.
+			// Clone only happens if needed.
+			std::shared_ptr<RTC::RtpPacket> sharedPacket;
 
 			for (auto* consumer : consumers)
 			{
@@ -810,7 +811,7 @@ namespace RTC
 				if (!mid.empty())
 					packet->UpdateMid(mid);
 
-				consumer->SendRtpPacket(sharedPacket);
+				consumer->SendRtpPacket(packet, sharedPacket);
 			}
 		}
 

package/worker/src/RTC/RtpStreamSend.cpp

@@ -194,20 +194,20 @@ namespace RTC
 		this->rtxSeq = Utils::Crypto::GetRandomUInt(0u, 0xFFFF);
 	}
 
-	bool RtpStreamSend::ReceivePacket(std::shared_ptr<RTC::RtpPacket> packet)
+	bool RtpStreamSend::ReceivePacket(RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket)
 	{
 		MS_TRACE();
 
 		// Call the parent method.
-		if (!RtpStream::ReceiveStreamPacket(packet.get()))
+		if (!RtpStream::ReceiveStreamPacket(packet))
 			return false;
 
 		// If NACK is enabled, store the packet into the buffer.
 		if (this->params.useNack)
-			StorePacket(packet);
+			StorePacket(packet, sharedPacket);
 
 		// Increase transmission counter.
-		this->transmissionCounter.Update(packet.get());
+		this->transmissionCounter.Update(packet);
 
 		return true;
 	}
@@ -433,7 +433,7 @@ namespace RTC
 		MS_ABORT("invalid method call");
 	}
 
-	void RtpStreamSend::StorePacket(std::shared_ptr<RTC::RtpPacket> packet)
+	void RtpStreamSend::StorePacket(RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket)
 	{
 		MS_TRACE();
 
@@ -452,7 +452,7 @@ namespace RTC
 			return;
 		}
 
-		this->ClearOldPackets(packet.get());
+		this->ClearOldPackets(packet);
 
 		auto seq          = packet->GetSequenceNumber();
 		auto* storageItem = this->storageItemBuffer.Get(seq);
@@ -476,8 +476,14 @@ namespace RTC
 			this->storageItemBuffer.Insert(seq, storageItem);
 		}
 
+		// Only clone once and only if necessary.
+		if (!sharedPacket.get())
+		{
+			sharedPacket.reset(packet->Clone());
+		}
+
 		// Store original packet and some extra info into the storage item.
-		storageItem->packet         = packet;
+		storageItem->packet         = sharedPacket;
 		storageItem->ssrc           = packet->GetSsrc();
 		storageItem->sequenceNumber = packet->GetSequenceNumber();
 		storageItem->timestamp      = packet->GetTimestamp();

package/worker/src/RTC/SimpleConsumer.cpp

@@ -249,7 +249,7 @@ namespace RTC
 		return desiredBitrate;
 	}
 
-	void SimpleConsumer::SendRtpPacket(std::shared_ptr<RTC::RtpPacket> packet)
+	void SimpleConsumer::SendRtpPacket(RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket)
 	{
 		MS_TRACE();
 
@@ -328,13 +328,13 @@ namespace RTC
 		}
 
 		// Process the packet.
-		if (this->rtpStream->ReceivePacket(packet))
+		if (this->rtpStream->ReceivePacket(packet, sharedPacket))
 		{
 			// Send the packet.
-			this->listener->OnConsumerSendRtpPacket(this, packet.get());
+			this->listener->OnConsumerSendRtpPacket(this, packet);
 
 			// May emit 'trace' event.
-			EmitTraceEventRtpAndKeyFrameTypes(packet.get());
+			EmitTraceEventRtpAndKeyFrameTypes(packet);
 		}
 		else
 		{

package/worker/src/RTC/SimulcastConsumer.cpp

@@ -640,7 +640,8 @@ namespace RTC
 		return desiredBitrate;
 	}
 
-	void SimulcastConsumer::SendRtpPacket(std::shared_ptr<RTC::RtpPacket> packet)
+	void SimulcastConsumer::SendRtpPacket(
+	  RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket)
 	{
 		MS_TRACE();
 
@@ -912,16 +913,16 @@ namespace RTC
 		}
 
 		// Process the packet.
-		if (this->rtpStream->ReceivePacket(packet))
+		if (this->rtpStream->ReceivePacket(packet, sharedPacket))
 		{
 			if (this->rtpSeqManager.GetMaxOutput() == packet->GetSequenceNumber())
 				this->lastSentPacketHasMarker = packet->HasMarker();
 
 			// Send the packet.
-			this->listener->OnConsumerSendRtpPacket(this, packet.get());
+			this->listener->OnConsumerSendRtpPacket(this, packet);
 
 			// May emit 'trace' event.
-			EmitTraceEventRtpAndKeyFrameTypes(packet.get());
+			EmitTraceEventRtpAndKeyFrameTypes(packet);
 		}
 		else
 		{

package/worker/src/RTC/SvcConsumer.cpp

@@ -532,7 +532,7 @@ namespace RTC
 		return desiredBitrate;
 	}
 
-	void SvcConsumer::SendRtpPacket(std::shared_ptr<RTC::RtpPacket> packet)
+	void SvcConsumer::SendRtpPacket(RTC::RtpPacket* packet, std::shared_ptr<RTC::RtpPacket>& sharedPacket)
 	{
 		MS_TRACE();
 
@@ -633,13 +633,13 @@ namespace RTC
 		}
 
 		// Process the packet.
-		if (this->rtpStream->ReceivePacket(packet))
+		if (this->rtpStream->ReceivePacket(packet, sharedPacket))
 		{
 			// Send the packet.
-			this->listener->OnConsumerSendRtpPacket(this, packet.get());
+			this->listener->OnConsumerSendRtpPacket(this, packet);
 
 			// May emit 'trace' event.
-			EmitTraceEventRtpAndKeyFrameTypes(packet.get());
+			EmitTraceEventRtpAndKeyFrameTypes(packet);
 		}
 		else
 		{

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

@@ -6,24 +6,29 @@
 #include <catch2/catch.hpp>
 #include <vector>
 
+// #define PERFORMANCE_TEST 1
+
 using namespace RTC;
 
-static std::shared_ptr<RtpPacket> CreateRtpPacket(uint8_t* buffer, uint16_t seq, uint32_t timestamp)
+static RtpPacket* CreateRtpPacket(uint8_t* buffer, uint16_t seq, uint32_t timestamp)
 {
 	auto* packet = RtpPacket::Parse(buffer, 1500);
 
 	packet->SetSequenceNumber(seq);
 	packet->SetTimestamp(timestamp);
 
-	std::shared_ptr<RtpPacket> shared(packet);
-
-	return shared;
+	return packet;
 }
 
-static void SendRtpPacket(RtpStreamSend* stream, std::shared_ptr<RtpPacket> packet, uint32_t ssrc)
+static void SendRtpPacket(std::vector<std::pair<RtpStreamSend*, uint32_t>> streams, RtpPacket* packet)
 {
-	packet->SetSsrc(ssrc);
-	stream->ReceivePacket(packet);
+	std::shared_ptr<RtpPacket> sharedPacket;
+
+	for (auto& stream : streams)
+	{
+		packet->SetSsrc(stream.second);
+		stream.first->ReceivePacket(packet, sharedPacket);
+	}
 }
 
 static void CheckRtxPacket(RtpPacket* packet, uint16_t seq, uint32_t timestamp)
@@ -88,21 +93,22 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 
 		RtpStream::Params params;
 
-		params.ssrc      = 1111;
-		params.clockRate = 90000;
-		params.useNack   = true;
+		params.ssrc          = 1111;
+		params.clockRate     = 90000;
+		params.useNack       = true;
+		params.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		std::string mid;
 		RtpStreamSend* stream = new RtpStreamSend(&testRtpStreamListener, params, mid);
 
 		// Receive all the packets (some of them not in order and/or duplicated).
-		SendRtpPacket(stream, packet1, params.ssrc);
-		SendRtpPacket(stream, packet3, params.ssrc);
-		SendRtpPacket(stream, packet2, params.ssrc);
-		SendRtpPacket(stream, packet3, params.ssrc);
-		SendRtpPacket(stream, packet4, params.ssrc);
-		SendRtpPacket(stream, packet5, params.ssrc);
-		SendRtpPacket(stream, packet5, params.ssrc);
+		SendRtpPacket({ { stream, params.ssrc } }, packet1);
+		SendRtpPacket({ { stream, params.ssrc } }, packet3);
+		SendRtpPacket({ { stream, params.ssrc } }, packet2);
+		SendRtpPacket({ { stream, params.ssrc } }, packet3);
+		SendRtpPacket({ { stream, params.ssrc } }, packet4);
+		SendRtpPacket({ { stream, params.ssrc } }, packet5);
+		SendRtpPacket({ { stream, params.ssrc } }, packet5);
 
 		// Create a NACK item that request for all the packets.
 		RTCP::FeedbackRtpNackPacket nackPacket(0, params.ssrc);
@@ -134,6 +140,112 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 		delete stream;
 	}
 
+	SECTION("receive NACK and get zero retransmitted packets if useNack is not set")
+	{
+		// packet1 [pt:123, seq:21006, timestamp:1533790901]
+		auto packet1 = CreateRtpPacket(rtpBuffer1, 21006, 1533790901);
+		// packet2 [pt:123, seq:21007, timestamp:1533790901]
+		auto packet2 = CreateRtpPacket(rtpBuffer2, 21007, 1533790901);
+		// packet3 [pt:123, seq:21008, timestamp:1533793871]
+		auto packet3 = CreateRtpPacket(rtpBuffer3, 21008, 1533793871);
+		// packet4 [pt:123, seq:21009, timestamp:1533793871]
+		auto packet4 = CreateRtpPacket(rtpBuffer4, 21009, 1533793871);
+		// packet5 [pt:123, seq:21010, timestamp:1533796931]
+		auto packet5 = CreateRtpPacket(rtpBuffer5, 21010, 1533796931);
+
+		// Create a RtpStreamSend instance.
+		TestRtpStreamListener testRtpStreamListener;
+
+		RtpStream::Params params;
+
+		params.ssrc          = 1111;
+		params.clockRate     = 90000;
+		params.useNack       = false;
+		params.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
+
+		std::string mid;
+		RtpStreamSend* stream = new RtpStreamSend(&testRtpStreamListener, params, mid);
+
+		// Receive all the packets (some of them not in order and/or duplicated).
+		SendRtpPacket({ { stream, params.ssrc } }, packet1);
+		SendRtpPacket({ { stream, params.ssrc } }, packet3);
+		SendRtpPacket({ { stream, params.ssrc } }, packet2);
+		SendRtpPacket({ { stream, params.ssrc } }, packet3);
+		SendRtpPacket({ { stream, params.ssrc } }, packet4);
+		SendRtpPacket({ { stream, params.ssrc } }, packet5);
+		SendRtpPacket({ { stream, params.ssrc } }, packet5);
+
+		// Create a NACK item that request for all the packets.
+		RTCP::FeedbackRtpNackPacket nackPacket(0, params.ssrc);
+		auto* nackItem = new RTCP::FeedbackRtpNackItem(21006, 0b0000000000001111);
+
+		nackPacket.AddItem(nackItem);
+
+		REQUIRE(nackItem->GetPacketId() == 21006);
+		REQUIRE(nackItem->GetLostPacketBitmask() == 0b0000000000001111);
+
+		stream->ReceiveNack(&nackPacket);
+
+		REQUIRE(testRtpStreamListener.retransmittedPackets.size() == 0);
+
+		testRtpStreamListener.retransmittedPackets.clear();
+
+		delete stream;
+	}
+
+	SECTION("receive NACK and get zero retransmitted packets for audio")
+	{
+		// packet1 [pt:123, seq:21006, timestamp:1533790901]
+		auto packet1 = CreateRtpPacket(rtpBuffer1, 21006, 1533790901);
+		// packet2 [pt:123, seq:21007, timestamp:1533790901]
+		auto packet2 = CreateRtpPacket(rtpBuffer2, 21007, 1533790901);
+		// packet3 [pt:123, seq:21008, timestamp:1533793871]
+		auto packet3 = CreateRtpPacket(rtpBuffer3, 21008, 1533793871);
+		// packet4 [pt:123, seq:21009, timestamp:1533793871]
+		auto packet4 = CreateRtpPacket(rtpBuffer4, 21009, 1533793871);
+		// packet5 [pt:123, seq:21010, timestamp:1533796931]
+		auto packet5 = CreateRtpPacket(rtpBuffer5, 21010, 1533796931);
+
+		// Create a RtpStreamSend instance.
+		TestRtpStreamListener testRtpStreamListener;
+
+		RtpStream::Params params;
+
+		params.ssrc          = 1111;
+		params.clockRate     = 90000;
+		params.useNack       = false;
+		params.mimeType.type = RTC::RtpCodecMimeType::Type::AUDIO;
+
+		std::string mid;
+		RtpStreamSend* stream = new RtpStreamSend(&testRtpStreamListener, params, mid);
+
+		// Receive all the packets (some of them not in order and/or duplicated).
+		SendRtpPacket({ { stream, params.ssrc } }, packet1);
+		SendRtpPacket({ { stream, params.ssrc } }, packet3);
+		SendRtpPacket({ { stream, params.ssrc } }, packet2);
+		SendRtpPacket({ { stream, params.ssrc } }, packet3);
+		SendRtpPacket({ { stream, params.ssrc } }, packet4);
+		SendRtpPacket({ { stream, params.ssrc } }, packet5);
+		SendRtpPacket({ { stream, params.ssrc } }, packet5);
+
+		// Create a NACK item that request for all the packets.
+		RTCP::FeedbackRtpNackPacket nackPacket(0, params.ssrc);
+		auto* nackItem = new RTCP::FeedbackRtpNackItem(21006, 0b0000000000001111);
+
+		nackPacket.AddItem(nackItem);
+
+		REQUIRE(nackItem->GetPacketId() == 21006);
+		REQUIRE(nackItem->GetLostPacketBitmask() == 0b0000000000001111);
+
+		stream->ReceiveNack(&nackPacket);
+
+		REQUIRE(testRtpStreamListener.retransmittedPackets.size() == 0);
+
+		testRtpStreamListener.retransmittedPackets.clear();
+
+		delete stream;
+	}
+
 	SECTION("receive NACK in different RtpStreamSend instances and get retransmitted packets")
 	{
 		// packet1 [pt:123, seq:21006, timestamp:1533790901]
@@ -147,27 +259,26 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 
 		RtpStream::Params params1;
 
-		params1.ssrc      = 1111;
-		params1.clockRate = 90000;
-		params1.useNack   = true;
+		params1.ssrc          = 1111;
+		params1.clockRate     = 90000;
+		params1.useNack       = true;
+		params1.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		std::string mid;
 		RtpStreamSend* stream1 = new RtpStreamSend(&testRtpStreamListener1, params1, mid);
 
 		RtpStream::Params params2;
 
-		params2.ssrc      = 2222;
-		params2.clockRate = 90000;
-		params2.useNack   = true;
+		params2.ssrc          = 2222;
+		params2.clockRate     = 90000;
+		params2.useNack       = true;
+		params2.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		RtpStreamSend* stream2 = new RtpStreamSend(&testRtpStreamListener2, params2, mid);
 
 		// Receive all the packets in both streams.
-		SendRtpPacket(stream1, packet1, params1.ssrc);
-		SendRtpPacket(stream2, packet1, params2.ssrc);
-
-		SendRtpPacket(stream1, packet2, params1.ssrc);
-		SendRtpPacket(stream2, packet2, params2.ssrc);
+		SendRtpPacket({ { stream1, params1.ssrc }, { stream2, params2.ssrc } }, packet1);
+		SendRtpPacket({ { stream1, params1.ssrc }, { stream2, params2.ssrc } }, packet2);
 
 		// Create a NACK item that request for all the packets.
 		RTCP::FeedbackRtpNackPacket nackPacket(0, params1.ssrc);
@@ -223,16 +334,17 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 
 		RtpStream::Params params1;
 
-		params1.ssrc      = 1111;
-		params1.clockRate = clockRate;
-		params1.useNack   = true;
+		params1.ssrc          = 1111;
+		params1.clockRate     = clockRate;
+		params1.useNack       = true;
+		params1.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		std::string mid;
-		RtpStreamSend* stream1 = new RtpStreamSend(&testRtpStreamListener1, params1, mid);
+		RtpStreamSend* stream = new RtpStreamSend(&testRtpStreamListener1, params1, mid);
 
 		// Receive all the packets.
-		SendRtpPacket(stream1, packet1, params1.ssrc);
-		SendRtpPacket(stream1, packet2, params1.ssrc);
+		SendRtpPacket({ { stream, params1.ssrc } }, packet1);
+		SendRtpPacket({ { stream, params1.ssrc } }, packet2);
 
 		// Create a NACK item that request for all the packets.
 		RTCP::FeedbackRtpNackPacket nackPacket(0, params1.ssrc);
@@ -244,7 +356,7 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 		REQUIRE(nackItem->GetLostPacketBitmask() == 0b0000000000000001);
 
 		// Process the NACK packet on stream1.
-		stream1->ReceiveNack(&nackPacket);
+		stream->ReceiveNack(&nackPacket);
 
 		REQUIRE(testRtpStreamListener1.retransmittedPackets.size() == 2);
 
@@ -256,7 +368,7 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 		CheckRtxPacket(rtxPacket1, packet1->GetSequenceNumber(), packet1->GetTimestamp());
 		CheckRtxPacket(rtxPacket2, packet2->GetSequenceNumber(), packet2->GetTimestamp());
 
-		delete stream1;
+		delete stream;
 	}
 
 	SECTION("packets don't get retransmitted if MaxRetransmissionDelay is exceeded")
@@ -274,16 +386,17 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 
 		RtpStream::Params params1;
 
-		params1.ssrc      = 1111;
-		params1.clockRate = clockRate;
-		params1.useNack   = true;
+		params1.ssrc          = 1111;
+		params1.clockRate     = clockRate;
+		params1.useNack       = true;
+		params1.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		std::string mid;
-		RtpStreamSend* stream1 = new RtpStreamSend(&testRtpStreamListener1, params1, mid);
+		RtpStreamSend* stream = new RtpStreamSend(&testRtpStreamListener1, params1, mid);
 
 		// Receive all the packets.
-		SendRtpPacket(stream1, packet1, params1.ssrc);
-		SendRtpPacket(stream1, packet2, params1.ssrc);
+		SendRtpPacket({ { stream, params1.ssrc } }, packet1);
+		SendRtpPacket({ { stream, params1.ssrc } }, packet2);
 
 		// Create a NACK item that request for all the packets.
 		RTCP::FeedbackRtpNackPacket nackPacket(0, params1.ssrc);
@@ -295,7 +408,7 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 		REQUIRE(nackItem->GetLostPacketBitmask() == 0b0000000000000001);
 
 		// Process the NACK packet on stream1.
-		stream1->ReceiveNack(&nackPacket);
+		stream->ReceiveNack(&nackPacket);
 
 		REQUIRE(testRtpStreamListener1.retransmittedPackets.size() == 1);
 
@@ -305,6 +418,65 @@ SCENARIO("NACK and RTP packets retransmission", "[rtp][rtcp][nack]")
 
 		CheckRtxPacket(rtxPacket2, packet2->GetSequenceNumber(), packet2->GetTimestamp());
 
-		delete stream1;
+		delete stream;
+	}
+
+#ifdef PERFORMANCE_TEST
+	SECTION("Performance")
+	{
+		// Create a RtpStreamSend instance.
+		TestRtpStreamListener testRtpStreamListener;
+
+		RtpStream::Params params;
+
+		params.ssrc          = 1111;
+		params.clockRate     = 90000;
+		params.useNack       = true;
+		params.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
+
+		std::string mid;
+		RtpStreamSend* stream = new RtpStreamSend(&testRtpStreamListener, params, mid);
+
+		size_t iterations = 10000000;
+
+		auto start = std::chrono::system_clock::now();
+
+		for (size_t i = 0; i < iterations; i++)
+		{
+			// Create packet.
+			auto* packet = RtpPacket::Parse(rtpBuffer1, 1500);
+			packet->SetSsrc(1111);
+
+			std::shared_ptr<RtpPacket> sharedPacket(packet);
+
+			stream->ReceivePacket(packet, sharedPacket);
+		}
+
+		std::chrono::duration<double> dur = std::chrono::system_clock::now() - start;
+		std::cout << "nullptr && initialized shared_ptr: \t" << dur.count() << " seconds" << std::endl;
+
+		delete stream;
+
+		params.mimeType.type = RTC::RtpCodecMimeType::Type::AUDIO;
+		stream               = new RtpStreamSend(&testRtpStreamListener, params, mid);
+
+		start = std::chrono::system_clock::now();
+
+		for (size_t i = 0; i < iterations; i++)
+		{
+			std::shared_ptr<RtpPacket> sharedPacket;
+
+			// Create packet.
+			auto* packet = RtpPacket::Parse(rtpBuffer1, 1500);
+			packet->SetSsrc(1111);
+
+			stream->ReceivePacket(packet, sharedPacket);
+		}
+
+		dur = std::chrono::system_clock::now() - start;
+		std::cout << "raw && empty shared_ptr duration: \t" << dur.count() << " seconds" << std::endl;
+
+		delete stream;
 	}
+#endif
 }