Replace BundleFilter with RtpDemuxer in RtpTransport.
BundleFilter is replaced by RtpDemuxer in RtpTransport for payload
type-based demuxing. RtpTransport will support MID-based demuxing later.
Each BaseChannel has its own RTP demuxing criteria and when connecting
to the RtpTransport, BaseChannel will register itself as a demuxer sink.
The inheritance model is changed. New inheritance chain:
DtlsSrtpTransport->SrtpTransport->RtpTranpsort
The JsepTransport2 is renamed to JsepTransport.
NOTE:
When RTCP packets are received, Call::DeliverRtcp will be called for
multiple times (webrtc:9035) which is an existing issue. With this CL,
it will become more of a problem and should be fixed.
Bug: webrtc:8587
Change-Id: Ibd880e7b744bd912336a691309950bc18e42cf62
Reviewed-on: https://webrtc-review.googlesource.com/65786
Commit-Queue: Zhi Huang <zhihuang@webrtc.org>
Reviewed-by: Taylor Brandstetter <deadbeef@webrtc.org>
Reviewed-by: Benjamin Wright <benwright@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22867}diff --git a/pc/rtptransport.cc b/pc/rtptransport.cc
index ce6996c..366d6e2 100644
--- a/pc/rtptransport.cc
+++ b/pc/rtptransport.cc
@@ -10,7 +10,10 @@
#include "pc/rtptransport.h"
+#include <utility>
+
#include "media/base/rtputils.h"
+#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "p2p/base/p2pconstants.h"
#include "p2p/base/packettransportinterface.h"
#include "rtc_base/checks.h"
@@ -44,7 +47,7 @@
new_packet_transport->SignalReadPacket.connect(this,
&RtpTransport::OnReadPacket);
new_packet_transport->SignalNetworkRouteChanged.connect(
- this, &RtpTransport::OnNetworkRouteChange);
+ this, &RtpTransport::OnNetworkRouteChanged);
new_packet_transport->SignalWritableState.connect(
this, &RtpTransport::OnWritableState);
new_packet_transport->SignalSentPacket.connect(this,
@@ -80,7 +83,7 @@
new_packet_transport->SignalReadPacket.connect(this,
&RtpTransport::OnReadPacket);
new_packet_transport->SignalNetworkRouteChanged.connect(
- this, &RtpTransport::OnNetworkRouteChange);
+ this, &RtpTransport::OnNetworkRouteChanged);
new_packet_transport->SignalWritableState.connect(
this, &RtpTransport::OnWritableState);
new_packet_transport->SignalSentPacket.connect(this,
@@ -134,6 +137,29 @@
return true;
}
+void RtpTransport::UpdateRtpHeaderExtensionMap(
+ const cricket::RtpHeaderExtensions& header_extensions) {
+ header_extension_map_ = RtpHeaderExtensionMap(header_extensions);
+}
+
+bool RtpTransport::RegisterRtpDemuxerSink(const RtpDemuxerCriteria& criteria,
+ RtpPacketSinkInterface* sink) {
+ rtp_demuxer_.RemoveSink(sink);
+ if (!rtp_demuxer_.AddSink(criteria, sink)) {
+ RTC_LOG(LS_ERROR) << "Failed to register the sink for RTP demuxer.";
+ return false;
+ }
+ return true;
+}
+
+bool RtpTransport::UnregisterRtpDemuxerSink(RtpPacketSinkInterface* sink) {
+ if (!rtp_demuxer_.RemoveSink(sink)) {
+ RTC_LOG(LS_ERROR) << "Failed to unregister the sink for RTP demuxer.";
+ return false;
+ }
+ return true;
+}
+
RTCError RtpTransport::SetParameters(const RtpTransportParameters& parameters) {
if (parameters_.rtcp.mux && !parameters.rtcp.mux) {
LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_STATE,
@@ -160,11 +186,26 @@
return parameters_;
}
+void RtpTransport::DemuxPacket(rtc::CopyOnWriteBuffer* packet,
+ const rtc::PacketTime& time) {
+ webrtc::RtpPacketReceived parsed_packet(&header_extension_map_);
+ if (!parsed_packet.Parse(std::move(*packet))) {
+ RTC_LOG(LS_ERROR)
+ << "Failed to parse the incoming RTP packet before demuxing. Drop it.";
+ return;
+ }
+
+ if (time.timestamp != -1) {
+ parsed_packet.set_arrival_time_ms((time.timestamp + 500) / 1000);
+ }
+ rtp_demuxer_.OnRtpPacket(parsed_packet);
+}
+
RtpTransportAdapter* RtpTransport::GetInternal() {
return nullptr;
}
-bool RtpTransport::IsRtpTransportWritable() {
+bool RtpTransport::IsTransportWritable() {
auto rtcp_packet_transport =
rtcp_mux_enabled_ ? nullptr : rtcp_packet_transport_;
return rtp_packet_transport_ && rtp_packet_transport_->writable() &&
@@ -175,7 +216,7 @@
SetReadyToSend(transport == rtcp_packet_transport_, true);
}
-void RtpTransport::OnNetworkRouteChange(
+void RtpTransport::OnNetworkRouteChanged(
rtc::Optional<rtc::NetworkRoute> network_route) {
SignalNetworkRouteChanged(network_route);
}
@@ -184,7 +225,7 @@
rtc::PacketTransportInternal* packet_transport) {
RTC_DCHECK(packet_transport == rtp_packet_transport_ ||
packet_transport == rtcp_packet_transport_);
- SignalWritableState(IsRtpTransportWritable());
+ SignalWritableState(IsTransportWritable());
}
void RtpTransport::OnSentPacket(rtc::PacketTransportInternal* packet_transport,
@@ -194,6 +235,49 @@
SignalSentPacket(sent_packet);
}
+void RtpTransport::OnRtpPacketReceived(rtc::CopyOnWriteBuffer* packet,
+ const rtc::PacketTime& packet_time) {
+ DemuxPacket(packet, packet_time);
+}
+
+void RtpTransport::OnRtcpPacketReceived(rtc::CopyOnWriteBuffer* packet,
+ const rtc::PacketTime& packet_time) {
+ SignalRtcpPacketReceived(packet, packet_time);
+}
+
+void RtpTransport::OnReadPacket(rtc::PacketTransportInternal* transport,
+ const char* data,
+ size_t len,
+ const rtc::PacketTime& packet_time,
+ int flags) {
+ TRACE_EVENT0("webrtc", "RtpTransport::OnReadPacket");
+
+ // When using RTCP multiplexing we might get RTCP packets on the RTP
+ // transport. We check the RTP payload type to determine if it is RTCP.
+ bool rtcp =
+ transport == rtcp_packet_transport() || cricket::IsRtcpPacket(data, len);
+
+ // Filter out the packet that is neither RTP nor RTCP.
+ if (!rtcp && !cricket::IsRtpPacket(data, len)) {
+ return;
+ }
+
+ rtc::CopyOnWriteBuffer packet(data, len);
+ // Protect ourselves against crazy data.
+ if (!cricket::IsValidRtpRtcpPacketSize(rtcp, packet.size())) {
+ RTC_LOG(LS_ERROR) << "Dropping incoming "
+ << cricket::RtpRtcpStringLiteral(rtcp)
+ << " packet: wrong size=" << packet.size();
+ return;
+ }
+
+ if (rtcp) {
+ OnRtcpPacketReceived(&packet, packet_time);
+ } else {
+ OnRtpPacketReceived(&packet, packet_time);
+ }
+}
+
void RtpTransport::SetReadyToSend(bool rtcp, bool ready) {
if (rtcp) {
rtcp_ready_to_send_ = ready;
@@ -213,52 +297,4 @@
}
}
-// Check the RTP payload type. If 63 < payload type < 96, it's RTCP.
-// For additional details, see http://tools.ietf.org/html/rfc5761.
-bool IsRtcp(const char* data, int len) {
- if (len < 2) {
- return false;
- }
- char pt = data[1] & 0x7F;
- return (63 < pt) && (pt < 96);
-}
-
-void RtpTransport::OnReadPacket(rtc::PacketTransportInternal* transport,
- const char* data,
- size_t len,
- const rtc::PacketTime& packet_time,
- int flags) {
- TRACE_EVENT0("webrtc", "RtpTransport::OnReadPacket");
-
- if (!cricket::IsRtpPacket(data, len) &&
- !IsRtcp(data, static_cast<int>(len))) {
- return;
- }
-
- // When using RTCP multiplexing we might get RTCP packets on the RTP
- // transport. We check the RTP payload type to determine if it is RTCP.
- bool rtcp = transport == rtcp_packet_transport() ||
- IsRtcp(data, static_cast<int>(len));
- rtc::CopyOnWriteBuffer packet(data, len);
-
- if (!WantsPacket(rtcp, &packet)) {
- return;
- }
-
- // This mutates |packet| if it is protected.
- SignalPacketReceived(rtcp, &packet, packet_time);
-}
-
-bool RtpTransport::WantsPacket(bool rtcp,
- const rtc::CopyOnWriteBuffer* packet) {
- // Protect ourselves against crazy data.
- if (!packet || !cricket::IsValidRtpRtcpPacketSize(rtcp, packet->size())) {
- RTC_LOG(LS_ERROR) << "Dropping incoming "
- << cricket::RtpRtcpStringLiteral(rtcp)
- << " packet: wrong size=" << packet->size();
- return false;
- }
- return true;
-}
-
} // namespace webrtc