OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright (c) 2017 The WebRTC project authors. All Rights Reserved. |
| 3 * |
| 4 * Use of this source code is governed by a BSD-style license |
| 5 * that can be found in the LICENSE file in the root of the source |
| 6 * tree. An additional intellectual property rights grant can be found |
| 7 * in the file PATENTS. All contributing project authors may |
| 8 * be found in the AUTHORS file in the root of the source tree. |
| 9 */ |
| 10 #ifndef WEBRTC_CALL_RTP_TRANSPORT_CONTROLLER_RECEIVE_H_ |
| 11 #define WEBRTC_CALL_RTP_TRANSPORT_CONTROLLER_RECEIVE_H_ |
| 12 |
| 13 #include <memory> |
| 14 |
| 15 #include "webrtc/base/array_view.h" |
| 16 |
| 17 // For DeliveryStatus. |
| 18 // TODO(nisse): This file ought to not depend on call. |
| 19 #include "webrtc/call/call.h" |
| 20 |
| 21 namespace webrtc { |
| 22 |
| 23 class ReceiveSideCongestionController; |
| 24 class RtpPacketReceived; |
| 25 |
| 26 // This class represents a receiver of already parsed RTP packets. |
| 27 class RtpPacketSinkInterface { |
| 28 public: |
| 29 virtual ~RtpPacketSinkInterface() {} |
| 30 virtual void OnRtpPacket(const RtpPacketReceived& packet) = 0; |
| 31 }; |
| 32 |
| 33 // TODO(nisse): This additional interface may be a bit confusing, it's |
| 34 // needed because RTP extensions are currently associated with each |
| 35 // stream. We should be able to identify extensions earlier, since the |
| 36 // mapping is the same for all streams on the same transport. Then we |
| 37 // can delete this class, replacing it with RtpPacketSinkInterface. |
| 38 // There's also the subtlety that the per-transport negotiation may |
| 39 // differ from the extensions expected for a particular stream, and we |
| 40 // may have code that breaks if we identify extension which is not |
| 41 // consistent with the configuration of the stream. |
| 42 |
| 43 // This class represents a receiver of RTP packets, which has the |
| 44 // additional responsibility of identifying extension headers. I.e., |
| 45 // the caller of OnRtpPacketReceive is expected to have called |
| 46 // packet->Parse, but not packet->IdentifyExtensions. |
| 47 class RtpPacketReceiverInterface { |
| 48 public: |
| 49 virtual ~RtpPacketReceiverInterface() {} |
| 50 virtual bool OnRtpPacketReceive(RtpPacketReceived* packet) = 0; |
| 51 }; |
| 52 |
| 53 // This class represents the RTP receive parsing and demuxing, for a |
| 54 // single transport. It isn't thread aware, leaving responsibility of |
| 55 // multithreading issues to the user of this class. TODO(nisse): Add |
| 56 // RTCP processing, we should aim to terminate RTCP and not leave any |
| 57 // RTCP processing to individual receive streams. TODO(nisse): Extract |
| 58 // parsing and demuxing logic into separate classes. A demuxer should |
| 59 // handle only a single transport. |
| 60 class RtpTransportControllerReceiveInterface { |
| 61 public: |
| 62 // Configuration needed for media-independent processing of received |
| 63 // packets. |
| 64 struct Config { |
| 65 // Send side bandwidth estimation is defined in |
| 66 // draft-holmer-rmcat-transport-wide-cc-extensions. When invoking |
| 67 // the ReceiveSideCongestionController, we need to know if |
| 68 // send-side bwe is configured or not. |
| 69 bool use_send_side_bwe = false; |
| 70 }; |
| 71 |
| 72 // Creates the default implementation. |
| 73 static std::unique_ptr<RtpTransportControllerReceiveInterface> Create( |
| 74 ReceiveSideCongestionController* receive_side_cc, |
| 75 bool enable_receive_side_bwe); |
| 76 |
| 77 virtual ~RtpTransportControllerReceiveInterface() {} |
| 78 |
| 79 // Registers the receiver responsible for an ssrc. |
| 80 virtual void AddReceiver(uint32_t ssrc, |
| 81 const Config& config, |
| 82 RtpPacketReceiverInterface* receiver) = 0; |
| 83 // TODO(nisse): It's unclear what info is conveniently available at |
| 84 // remove time. For now, we take only the |receiver| pointer and |
| 85 // iterate over the mapping. |
| 86 virtual void RemoveReceiver(const RtpPacketReceiverInterface* receiver) = 0; |
| 87 |
| 88 // Used to represent auxillary sinks, currently used for FlexFec. |
| 89 // The responsible receiver must be registered first. |
| 90 virtual void AddSink(uint32_t ssrc, RtpPacketSinkInterface* sink) = 0; |
| 91 // TODO(nisse): It's unclear what info is conveniently available at |
| 92 // remove time. For now, we take only the |receiver| pointer and |
| 93 // iterate over the mapping. |
| 94 virtual void RemoveSink(const RtpPacketSinkInterface* sink) = 0; |
| 95 |
| 96 // Process raw incoming RTP packets. |
| 97 // TODO(nisse): DeliveryStatus is needed for the current handling of |
| 98 // unsignalled ssrcs. Change return type to bool or void, once we do |
| 99 // that via AddPayload instead. |
| 100 virtual PacketReceiver::DeliveryStatus OnRtpPacket( |
| 101 int64_t arrival_time_ms, |
| 102 rtc::ArrayView<const uint8_t> packet) = 0; |
| 103 }; |
| 104 |
| 105 } // namespace webrtc |
| 106 |
| 107 #endif // WEBRTC_CALL_RTP_TRANSPORT_CONTROLLER_RECEIVE_H_ |
OLD | NEW |