Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(459)

Unified Diff: webrtc/call/rtp_transport_controller_receive.h

Issue 2709723003: Initial implementation of RtpTransportControllerReceive and related interfaces.
Patch Set: Rename foo_audio --> audio_foo. Created 3 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « webrtc/call/flexfec_receive_stream_impl.cc ('k') | webrtc/call/rtp_transport_controller_receive.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: webrtc/call/rtp_transport_controller_receive.h
diff --git a/webrtc/call/rtp_transport_controller_receive.h b/webrtc/call/rtp_transport_controller_receive.h
new file mode 100644
index 0000000000000000000000000000000000000000..70a2f400e874c69134d4ef56cb408a7a8920778a
--- /dev/null
+++ b/webrtc/call/rtp_transport_controller_receive.h
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+#ifndef WEBRTC_CALL_RTP_TRANSPORT_CONTROLLER_RECEIVE_H_
+#define WEBRTC_CALL_RTP_TRANSPORT_CONTROLLER_RECEIVE_H_
+
+#include <memory>
+
+#include "webrtc/base/array_view.h"
+
+// For DeliveryStatus.
+// TODO(nisse): This file ought to not depend on call.
+#include "webrtc/call/call.h"
+
+namespace webrtc {
+
+class ReceiveSideCongestionController;
+class RtpPacketReceived;
+
+// This class represents a receiver of already parsed RTP packets.
+class RtpPacketSinkInterface {
+ public:
+ virtual ~RtpPacketSinkInterface() {}
+ virtual void OnRtpPacket(const RtpPacketReceived& packet) = 0;
+};
+
+// TODO(nisse): This additional interface may be a bit confusing, it's
+// needed because RTP extensions are currently associated with each
+// stream. We should be able to identify extensions earlier, since the
+// mapping is the same for all streams on the same transport. Then we
+// can delete this class, replacing it with RtpPacketSinkInterface.
+// There's also the subtlety that the per-transport negotiation may
+// differ from the extensions expected for a particular stream, and we
+// may have code that breaks if we identify extension which is not
+// consistent with the configuration of the stream.
+
+// This class represents a receiver of RTP packets, which has the
+// additional responsibility of identifying extension headers. I.e.,
+// the caller of OnRtpPacketReceive is expected to have called
+// packet->Parse, but not packet->IdentifyExtensions.
+class RtpPacketReceiverInterface {
+ public:
+ virtual ~RtpPacketReceiverInterface() {}
+ virtual bool OnRtpPacketReceive(RtpPacketReceived* packet) = 0;
+};
+
+// This class represents the RTP receive parsing and demuxing, for a
+// single transport. It isn't thread aware, leaving responsibility of
+// multithreading issues to the user of this class. TODO(nisse): Add
+// RTCP processing, we should aim to terminate RTCP and not leave any
+// RTCP processing to individual receive streams. TODO(nisse): Extract
+// parsing and demuxing logic into separate classes. A demuxer should
+// handle only a single transport.
+class RtpTransportControllerReceiveInterface {
+ public:
+ // Configuration needed for media-independent processing of received
+ // packets.
+ struct Config {
+ // Send side bandwidth estimation is defined in
+ // draft-holmer-rmcat-transport-wide-cc-extensions. When invoking
+ // the ReceiveSideCongestionController, we need to know if
+ // send-side bwe is configured or not.
+ bool use_send_side_bwe = false;
+ };
+
+ // Creates the default implementation.
+ static std::unique_ptr<RtpTransportControllerReceiveInterface> Create(
+ ReceiveSideCongestionController* receive_side_cc,
+ bool enable_receive_side_bwe);
+
+ virtual ~RtpTransportControllerReceiveInterface() {}
+
+ // Registers the receiver responsible for an ssrc.
+ virtual void AddReceiver(uint32_t ssrc,
+ const Config& config,
+ RtpPacketReceiverInterface* receiver) = 0;
+ // TODO(nisse): It's unclear what info is conveniently available at
+ // remove time. For now, we take only the |receiver| pointer and
+ // iterate over the mapping.
+ virtual void RemoveReceiver(const RtpPacketReceiverInterface* receiver) = 0;
+
+ // Used to represent auxillary sinks, currently used for FlexFec.
+ // The responsible receiver must be registered first.
+ virtual void AddSink(uint32_t ssrc, RtpPacketSinkInterface* sink) = 0;
+ // TODO(nisse): It's unclear what info is conveniently available at
+ // remove time. For now, we take only the |receiver| pointer and
+ // iterate over the mapping.
+ virtual void RemoveSink(const RtpPacketSinkInterface* sink) = 0;
+
+ // Process raw incoming RTP packets.
+ // TODO(nisse): DeliveryStatus is needed for the current handling of
+ // unsignalled ssrcs. Change return type to bool or void, once we do
+ // that via AddPayload instead.
+ virtual PacketReceiver::DeliveryStatus OnRtpPacket(
+ int64_t arrival_time_ms,
+ rtc::ArrayView<const uint8_t> packet) = 0;
+};
+
+} // namespace webrtc
+
+#endif // WEBRTC_CALL_RTP_TRANSPORT_CONTROLLER_RECEIVE_H_
« no previous file with comments | « webrtc/call/flexfec_receive_stream_impl.cc ('k') | webrtc/call/rtp_transport_controller_receive.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698