Initial implementation of RtpTransportControllerReceive and related interfaces.

webrtc/call/rtp_transport_controller_receive.h

+/*
+ *  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.

[the sun, 2017/04/18 09:59:00]

It would be nice to use the type system to document this. For instance, the
parsed state of the received RTP packet, could be implemented as a decorator for
the packet data container.

[nisse-webrtc, 2017/04/19 08:35:43]

I think I replied to this earlier... I use const for that purpose, even if it
might be a bit crude. "Decorators" goes beyond my current C++ knowledge...

Eventually, I hope we will need only the "sink" interface with a const packet.

+class RtpPacketSinkInterface {
+ public:
+  virtual void OnRtpPacket(const RtpPacketReceived& packet) = 0;
+  virtual ~RtpPacketSinkInterface() {}
+};
+
+// 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 bool OnRtpPacketReceive(RtpPacketReceived* packet) = 0;
+  virtual ~RtpPacketReceiverInterface() {}
+};
+
+// 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, in particular, feeding information to the congestion
+  // controller.
+
+  // TODO(nisse): It turns out this data is only used for the callback
+  // to the ReceiveSideCongestionController.
+  struct Config {
+    // See draft-holmer-rmcat-transport-wide-cc-extensions for details.
+    bool use_send_side_bwe = false;
+  };
+
+  // The Add* functions return true if registration succeeds, false if
+  // the ssrc is already taken, and the Remove* functions return true
+  // if the stream was found and removed, and false if the stream is
+  // unknown.
+
+  // Registers the receiver responsible for an ssrc.
+  virtual bool 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 bool RemoveReceiver(const RtpPacketReceiverInterface* receiver) = 0;
+
+  // Used to represent auxillary sinks, currently used for FlexFec.

[the sun, 2017/04/18 09:59:00]

I get the feeling that what you're implementing here could be accomplished with
a filter graph? We have at least 3 different varieties of OnRtpPacket(), in
separate interfaces. Can we have less code by having a single abstraction for an
RTP packet consumer? 

[nisse-webrtc, 2017/04/19 08:35:43]

Probably. We just need to move complete parsing further up. pthatcher also
suggested doing parsing and demuxing in separate classes, which might also help
make this clearer.

+  // The responsible receiver must be registered first.
+  virtual bool 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 bool RemoveSink(const RtpPacketSinkInterface* sink) = 0;
+
+#if 0
+  // TODO(nisse): Not yet implemented. We also need something similar to
+  // handle the mid extension.
+  // Incoming packets with unknown ssrcs represent unsignalled
+  // streams. We dispatch on payload type and media type. The receiver
+  // will typically create a new RtpReceiver to pass the packet to. A
+  // true return value from the callback means that we should retry
+  // lookup.
+  virtual bool AddPayload(uint8_t payload_type,
+                          RtpPacketReceiverInterface *receiver) = 0;
+#endif
+  // 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;
+
+  virtual ~RtpTransportControllerReceiveInterface() {}
+
+  // Creates the default implementation.
+  static std::unique_ptr<RtpTransportControllerReceiveInterface> Create(
+      ReceiveSideCongestionController* receive_side_cc,
+      bool enable_receive_side_bwe);
+};
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_CALL_RTP_TRANSPORT_CONTROLLER_RECEIVE_H_