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 "webrtc/base/array_view.h"
+
+// For MediaType and DeliveryStatus.
+// TODO(nisse): This file ought to not depend on call. We could move
+// MediaType definition here, and perhaps rename it to transport_id in
+// the process, since its main purpose is to disambiguate ssrc
+// collisions between transports.
+#include "webrtc/call/call.h"
+
+namespace webrtc {
+
+class RtpPacketReceived;
+
+// This class represents a receiver of already parsed RTP packets.
+class RtpPacketSinkInterface {
+ public:
+  virtual void OnRtpPacket(const RtpPacketReceived& packet) = 0;
+  virtual ~RtpPacketSinkInterface() {}
+};
+
+// TODO(nisse): This additional interface may be a bit confusing, it's

[danilchap, 2017/03/16 11:25:18]

there are use cases (mid & rid) where extensions have to be identified before
receiver can be chosen.
Likely they will need to be identified twice: 1st with transport-wide extensions
map, then, if individual receiver has it's own map, with receiver's extensions
map.

+// 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;

[Taylor Brandstetter, 2017/03/17 19:45:22]

OnRtpPacketReceived instead of OnRtpPacketReceive?

+  virtual ~RtpPacketReceiverInterface() {}
+};
+
+class RtpPacketObserverInterface;

[danilchap, 2017/03/16 11:25:18]

May be more concrete examples of receivers and observers give better explanation
why there are several interfaces.
Personally I think 3 is 1 too many, 2 should be enough:
Receiver/Sink reserve single ssrc and process all packets addressed to it. That
packet doesn't have to come from a network, it might be restored rtx, red or fec
packet.
audio/video streams, rtx, flexfec will implement this interface.
packet goes to 1 receiver.

Observers watch all packets from the network, regardless of ssrc. But they are
not interested in recreated packets.
Congestion controller and flexfec (with own ssrc filtering) should implement
this interface.
packet goes through all observers.

(flexfec will likely implement both interfaces: it need to watch all protected
streams/ssrcs and it is responsible for own stream/ssrc.)

+
+// This class represents the RTP receive parsing and demuxing. 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
+  // RtpPacketObserverInterface callback. Since we have no interest in
+  // the details, make it a void* pointer or use a template parameter
+  // for the type?
+  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. The |media_type|
+  // identifies the incoming transport, since we may use separate
+  // transport for audio and video, with independent ssrc spaces.
+  virtual bool AddReceiver(uint32_t ssrc,
+                           MediaType media_type,
+                           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 responsible receiver must be registered first.
+  virtual bool AddSink(uint32_t ssrc,
+                       MediaType media_type,
+                       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, MediaType media_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(
+      MediaType media_type,
+      int64_t arrival_time_ms,
+      rtc::ArrayView<const uint8_t> packet) = 0;
+
+  virtual ~RtpTransportControllerReceiveInterface() {}
+
+  // Creates the default implementation.

[Taylor Brandstetter, 2017/03/17 19:45:22]

Add comment for what |observer| is meant for?

+  static std::unique_ptr<RtpTransportControllerReceiveInterface> Create(
+      RtpPacketObserverInterface* observer);
+};
+
+// Callback invoked for all processed RTP packets, used for feeding
+// the congestion controller (which is more tightly coupled to the
+// send side).
+class RtpPacketObserverInterface {

[Taylor Brandstetter, 2017/03/17 19:45:22]

The distinction between "RtpPacketObserver", "RtpPacketReceiver" and
"RtpPacketSink" seems likely to confuse people. Could they be named more
descriptively so the differences are more obvious?

+ public:
+  virtual void OnRtpPacket(
+      // TODO(nisse): Add media type / transport id to the RtpParsedPacket.
+      MediaType media_type,
+      const RtpTransportControllerReceiveInterface::Config config,
+      const RtpPacketReceived& packet) = 0;
+  virtual ~RtpPacketObserverInterface() {}
+};
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_CALL_RTP_TRANSPORT_CONTROLLER_RECEIVE_H_