Improved compatibility of RTSP client (channel id)

src/projects/base/common_types.h

@@ -87,6 +87,7 @@ enum class NodeType : int16_t
 {
 	Unknown = 0,
 	Edge = 10,	// Start or End of Nodes
+	Rtsp = 11,
 	Rtp = 100,
 	Rtcp = 101,
 	Srtp = 200,

src/projects/base/ovlibrary/data.h

@@ -47,6 +47,8 @@ namespace ov
 		// Move constructor
 		Data(Data &&data) noexcept;
 
+		virtual ~Data() = default;
+
 		/// Create a new data from this instance. The newly created data is managed by copy-on-write method
 		///
 		/// @return

src/projects/modules/rtp_rtcp/rtp_rtcp.cpp

@@ -6,6 +6,8 @@
 #include "rtcp_receiver.h"
 #include "rtcp_info/fir.h"
 
+#include "modules/rtsp/rtsp_data.h"
+
 #define OV_LOG_TAG "RtpRtcp"
 
 RtpRtcp::RtpRtcp(const std::shared_ptr<RtpRtcpInterface> &observer)
@@ -222,7 +224,6 @@ bool RtpRtcp::OnDataReceivedFromNextNode(NodeType from_node, const std::shared_p
 		return false;
 	}
 
-
 	/* Check if this is a RTP/RTCP packet
 		https://www.rfc-editor.org/rfc/rfc7983.html
 					+----------------+
@@ -246,12 +247,12 @@ bool RtpRtcp::OnDataReceivedFromNextNode(NodeType from_node, const std::shared_p
 		// RTCP
 		if(payload_type >= 192 && payload_type <= 223)
 		{
-			return OnRtcpReceived(data);
+			return OnRtcpReceived(from_node, data);
 		}
 		// RTP
 		else
 		{
-			return OnRtpReceived(data);
+			return OnRtpReceived(from_node, data);
 		}
 	}
 	else
@@ -263,15 +264,29 @@ bool RtpRtcp::OnDataReceivedFromNextNode(NodeType from_node, const std::shared_p
     return true;
 }
 
-bool RtpRtcp::OnRtpReceived(const std::shared_ptr<const ov::Data> &data)
+bool RtpRtcp::OnRtpReceived(NodeType from_node, const std::shared_ptr<const ov::Data> &data)
 {
 	auto packet = std::make_shared<RtpPacket>(data);
 	logtd("%s", packet->Dump().CStr());
 
-	auto track_it = _tracks.find(packet->Ssrc());
+	uint32_t track_id = packet->Ssrc();
+	if(from_node == NodeType::Rtsp)
+	{
+		auto rtsp_data = std::dynamic_pointer_cast<const RtspData>(data);
+		if(rtsp_data == nullptr)
+		{
+			logte("Could not convert to RtspData");
+			return false;
+		}
+
+		// RTSP Node uses channelID as trackID
+		track_id = rtsp_data->GetChannelId();
+	}
+
+	auto track_it = _tracks.find(track_id);
 	if(track_it == _tracks.end())
 	{
-		logte("Could not find track info for ssrc %u", packet->Ssrc());
+		logte("Could not find track info for track ID %u", track_id);
 		return false;
 	}
 	auto track = track_it->second;
@@ -324,7 +339,7 @@ bool RtpRtcp::OnRtpReceived(const std::shared_ptr<const ov::Data> &data)
 
 	if(jitter_buffer_type == 1)
 	{
-		auto buffer_it = _rtp_frame_jitter_buffers.find(packet->Ssrc());
+		auto buffer_it = _rtp_frame_jitter_buffers.find(track_id);
 		if(buffer_it == _rtp_frame_jitter_buffers.end())
 		{
 			// can not happen
@@ -362,12 +377,12 @@ bool RtpRtcp::OnRtpReceived(const std::shared_ptr<const ov::Data> &data)
 				rtp_packets.push_back(packet);
 			}
 
-			_observer->OnRtpFrameReceived(rtp_packets);
+			_observer->OnRtpFrameReceived(track_id, rtp_packets);
 		}
 	}
 	else if(jitter_buffer_type == 2)
 	{
-		auto buffer_it = _rtp_minimal_jitter_buffers.find(packet->Ssrc());
+		auto buffer_it = _rtp_minimal_jitter_buffers.find(track_id);
 		if(buffer_it == _rtp_minimal_jitter_buffers.end())
 		{
 			// can not happen
@@ -384,7 +399,7 @@ bool RtpRtcp::OnRtpReceived(const std::shared_ptr<const ov::Data> &data)
 		{
 			std::vector<std::shared_ptr<RtpPacket>> rtp_packets;
 			rtp_packets.push_back(pop_packet);
-			_observer->OnRtpFrameReceived(rtp_packets);
+			_observer->OnRtpFrameReceived(track_id, rtp_packets);
 		}
 	}
 	else
@@ -395,7 +410,7 @@ bool RtpRtcp::OnRtpReceived(const std::shared_ptr<const ov::Data> &data)
 	return true;
 }
 
-bool RtpRtcp::OnRtcpReceived(const std::shared_ptr<const ov::Data> &data)
+bool RtpRtcp::OnRtcpReceived(NodeType from_node, const std::shared_ptr<const ov::Data> &data)
 {
 	logtd("Get RTCP Packet - length(%d)", data->GetLength());
 	// Parse RTCP Packet
@@ -405,6 +420,20 @@ bool RtpRtcp::OnRtcpReceived(const std::shared_ptr<const ov::Data> &data)
 		return false;
 	}
 
+	uint32_t track_id = 0;
+	if(from_node == NodeType::Rtsp)
+	{
+		auto rtsp_data = std::dynamic_pointer_cast<const RtspData>(data);
+		if(rtsp_data == nullptr)
+		{
+			logte("Could not convert to RtspData");
+			return false;
+		}
+
+		// RTSP Node uses channelID as trackID
+		track_id = rtsp_data->GetChannelId();
+	}
+
 	while(receiver.HasAvailableRtcpInfo())
 	{
 		auto info = receiver.PopRtcpInfo();
@@ -422,7 +451,7 @@ bool RtpRtcp::OnRtcpReceived(const std::shared_ptr<const ov::Data> &data)
 
 		if(_observer != nullptr)
 		{
-			_observer->OnRtcpReceived(info);
+			_observer->OnRtcpReceived(track_id, info);
 		}
 	}
 

src/projects/modules/rtp_rtcp/rtp_rtcp.h

@@ -17,8 +17,8 @@
 class RtpRtcpInterface : public ov::EnableSharedFromThis<RtpRtcpInterface>
 {
 public:
-	virtual void OnRtpFrameReceived(const std::vector<std::shared_ptr<RtpPacket>> &rtp_packets) = 0;
-	virtual void OnRtcpReceived(const std::shared_ptr<RtcpInfo> &rtcp_info) = 0;
+	virtual void OnRtpFrameReceived(uint32_t track_id, const std::vector<std::shared_ptr<RtpPacket>> &rtp_packets) = 0;
+	virtual void OnRtcpReceived(uint32_t track_id, const std::shared_ptr<RtcpInfo> &rtcp_info) = 0;
 };
 
 class RtpRtcp : public ov::Node
@@ -46,8 +46,8 @@ class RtpRtcp : public ov::Node
 	bool OnDataReceivedFromNextNode(NodeType from_node, const std::shared_ptr<const ov::Data> &data) override;
 
 private:
-	bool OnRtpReceived(const std::shared_ptr<const ov::Data> &data);
-	bool OnRtcpReceived(const std::shared_ptr<const ov::Data> &data);
+	bool OnRtpReceived(NodeType from_node, const std::shared_ptr<const ov::Data> &data);
+	bool OnRtcpReceived(NodeType from_node, const std::shared_ptr<const ov::Data> &data);
 
 	std::shared_ptr<RtpFrameJitterBuffer> GetJitterBuffer(uint8_t payload_type);
 

src/projects/modules/rtsp/rtsp_data.cpp

@@ -50,23 +50,19 @@ int RtspData::ParseInternal(const std::shared_ptr<const ov::Data> &data)
 		return 0;
 	}
 
-	_data = std::make_shared<ov::Data>(&ptr[4], data_length);
+	Clear();
+	Append(&ptr[4], data_length);
 
 	return RTSP_INTERLEAVED_DATA_HEADER_LEN + data_length;;
 }
 
 RtspData::RtspData(uint8_t channel_id, const std::shared_ptr<ov::Data> &data)
+	: RtspData(data->GetData(), data->GetLength())
 {
 	_channel_id = channel_id;
-	_data = data;
 }
 
-uint8_t RtspData::GetChannelId()
+uint8_t RtspData::GetChannelId() const
 {
 	return _channel_id;
-}
-
-std::shared_ptr<ov::Data> RtspData::GetData()
-{
-	return _data;
 }

src/projects/modules/rtsp/rtsp_data.h

@@ -12,9 +12,11 @@
 
 // $ + ID + Length = 4
 #define RTSP_INTERLEAVED_DATA_HEADER_LEN	4	
-class RtspData
+class RtspData : public ov::Data
 {
 public:
+	using ov::Data::Data;
+
 	// If success, returns RtspData and parsed data length
 	// If not enough data, returns nullptr and 0
 	// If fail, returns nullptr and -1
@@ -25,12 +27,10 @@ class RtspData
 	RtspData(){}
 	RtspData(uint8_t channel_id, const std::shared_ptr<ov::Data> &data);
 
-	uint8_t GetChannelId();
-	std::shared_ptr<ov::Data> GetData();
+	uint8_t GetChannelId() const;
 
 private:
 	int ParseInternal(const std::shared_ptr<const ov::Data> &data);
 
 	uint8_t _channel_id;
-	std::shared_ptr<ov::Data>	_data;
 };