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 | |
11 #include <map> | |
12 #include <utility> | |
13 #include <vector> | |
14 | |
15 #include "webrtc/call/rtp_transport_controller_receive.h" | |
16 #include "webrtc/modules/congestion_controller/include/receive_side_congestion_c ontroller.h" | |
17 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h" | |
18 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h" | |
19 | |
20 namespace webrtc { | |
21 namespace { | |
22 | |
23 class RtpTransportControllerReceive | |
24 : public RtpTransportControllerReceiveInterface { | |
25 public: | |
26 RtpTransportControllerReceive( | |
27 ReceiveSideCongestionController* receive_side_cc, | |
28 bool enable_receive_side_bwe); | |
29 | |
30 ~RtpTransportControllerReceive() override; | |
31 | |
32 // ImplementRtpTransportControllerReceiveInterface | |
33 void AddReceiver(uint32_t ssrc, | |
34 const Config& config, | |
35 RtpPacketReceiverInterface* receiver) override; | |
36 void RemoveReceiver(const RtpPacketReceiverInterface* receiver) override; | |
37 | |
38 void AddSink(uint32_t ssrc, RtpPacketSinkInterface* sink) override; | |
39 void RemoveSink(const RtpPacketSinkInterface* sink) override; | |
40 | |
41 #if 0 | |
danilchap
2017/04/25 09:33:40
remove
nisse-webrtc
2017/04/25 11:22:50
Done.
| |
42 void RegisterPayload(uint8_t payload_type, MediaType media_type, | |
43 RtpPacketReceiverInterface *receiver) override; | |
44 #endif | |
45 PacketReceiver::DeliveryStatus OnRtpPacket( | |
46 int64_t arrival_time_ms, | |
47 rtc::ArrayView<const uint8_t> packet) override; | |
48 | |
49 private: | |
50 struct Stream { | |
51 Config config; | |
52 RtpPacketReceiverInterface* receiver; | |
53 std::vector<RtpPacketSinkInterface*> auxillary_sinks; | |
54 | |
55 Stream(Config config, RtpPacketReceiverInterface* receiver) | |
56 : config(config), receiver(receiver) {} | |
57 }; | |
58 | |
59 Stream* LookupStream(uint32_t ssrc); | |
60 | |
61 // Indexed by ssrc. | |
62 std::map<uint32_t, Stream> streams_; | |
63 ReceiveSideCongestionController* const receive_side_cc_; | |
64 const bool enable_receive_side_bwe_; | |
65 }; | |
66 | |
67 RtpTransportControllerReceive::RtpTransportControllerReceive( | |
68 ReceiveSideCongestionController* receive_side_cc, | |
69 bool enable_receive_side_bwe) | |
70 : receive_side_cc_(receive_side_cc), | |
71 enable_receive_side_bwe_(enable_receive_side_bwe) {} | |
72 | |
73 RtpTransportControllerReceive::~RtpTransportControllerReceive() { | |
74 RTC_DCHECK(streams_.empty()); | |
75 } | |
76 | |
77 RtpTransportControllerReceive::Stream* | |
78 RtpTransportControllerReceive::LookupStream(uint32_t ssrc) { | |
79 const auto it = streams_.find(ssrc); | |
80 return (it != streams_.end()) ? &it->second : nullptr; | |
81 } | |
82 | |
83 void RtpTransportControllerReceive::AddReceiver( | |
84 uint32_t ssrc, | |
85 const Config& config, | |
86 RtpPacketReceiverInterface* receiver) { | |
87 bool inserted = streams_.emplace(ssrc, Stream(config, receiver)).second; | |
88 RTC_DCHECK(inserted); | |
89 } | |
90 | |
91 void RtpTransportControllerReceive::RemoveReceiver( | |
92 const RtpPacketReceiverInterface* receiver) { | |
93 for (auto it = streams_.begin(); it != streams_.end();) { | |
94 if (it->second.receiver == receiver) { | |
95 receive_side_cc_ | |
96 ->GetRemoteBitrateEstimator(it->second.config.use_send_side_bwe) | |
97 ->RemoveStream(it->first); | |
98 it = streams_.erase(it); | |
99 } else { | |
100 ++it; | |
101 } | |
102 } | |
103 } | |
104 | |
105 void RtpTransportControllerReceive::AddSink(uint32_t ssrc, | |
106 RtpPacketSinkInterface* sink) { | |
107 Stream* stream = LookupStream(ssrc); | |
108 // Can't DCHECK this, since flexfec tests create flexfec streams | |
109 // without creating the streams they are protecting. | |
110 if (!stream) | |
111 return; | |
112 | |
113 stream->auxillary_sinks.push_back(sink); | |
114 } | |
115 | |
116 void RtpTransportControllerReceive::RemoveSink( | |
117 const RtpPacketSinkInterface* sink) { | |
118 for (auto& it : streams_) { | |
119 auto sinks_end = it.second.auxillary_sinks.end(); | |
120 auto sinks_it = | |
121 std::remove(it.second.auxillary_sinks.begin(), sinks_end, sink); | |
122 it.second.auxillary_sinks.erase(sinks_it, sinks_end); | |
123 } | |
124 } | |
125 | |
126 PacketReceiver::DeliveryStatus RtpTransportControllerReceive::OnRtpPacket( | |
127 int64_t arrival_time_ms, | |
128 rtc::ArrayView<const uint8_t> raw_packet) { | |
129 RtpPacketReceived parsed_packet; | |
130 if (!parsed_packet.Parse(raw_packet)) | |
131 return PacketReceiver::DELIVERY_PACKET_ERROR; | |
132 parsed_packet.set_arrival_time_ms(arrival_time_ms); | |
133 | |
134 Stream* stream = LookupStream(parsed_packet.Ssrc()); | |
135 if (!stream) { | |
136 return PacketReceiver::DELIVERY_UNKNOWN_SSRC; | |
137 } | |
138 if (!stream->receiver->OnRtpPacketReceive(&parsed_packet)) | |
danilchap
2017/04/25 09:33:40
here you do not have {} around one-line if, previo
nisse-webrtc
2017/04/25 11:22:50
Added braces for all the ifs.
| |
139 return PacketReceiver::DELIVERY_PACKET_ERROR; | |
140 for (auto* it : stream->auxillary_sinks) { | |
141 it->OnRtpPacket(parsed_packet); | |
142 } | |
143 if (receive_side_cc_) { | |
144 if (!stream->config.use_send_side_bwe && | |
145 parsed_packet.HasExtension<TransportSequenceNumber>()) { | |
146 // Inconsistent configuration of send side BWE. Do nothing. | |
147 // TODO(nisse): Without this check, we may produce RTCP feedback | |
148 // packets even when not negotiated. But it would be cleaner to | |
149 // move the check down to RTCPSender::SendFeedbackPacket, which | |
150 // would also help the PacketRouter to select an appropriate rtp | |
151 // module in the case that some, but not all, have RTCP feedback | |
152 // enabled. | |
153 return PacketReceiver::DELIVERY_OK; | |
154 } | |
155 // Receive side bwe is not used for audio. | |
156 if (enable_receive_side_bwe_ || | |
157 (stream->config.use_send_side_bwe && | |
158 parsed_packet.HasExtension<TransportSequenceNumber>())) { | |
159 RTPHeader header; | |
160 parsed_packet.GetHeader(&header); | |
161 | |
162 receive_side_cc_->OnReceivedPacket( | |
163 parsed_packet.arrival_time_ms(), | |
164 parsed_packet.payload_size() + parsed_packet.padding_size(), header); | |
165 } | |
166 } | |
167 return PacketReceiver::DELIVERY_OK; | |
168 } | |
169 | |
170 } // namespace | |
171 | |
172 // static | |
173 std::unique_ptr<RtpTransportControllerReceiveInterface> | |
174 RtpTransportControllerReceiveInterface::Create( | |
175 ReceiveSideCongestionController* receive_side_cc, | |
176 bool enable_receive_side_bwe) { | |
177 return std::unique_ptr<RtpTransportControllerReceiveInterface>( | |
danilchap
2017/04/25 09:33:40
may be start using MakeUnique helper:
#include "w
nisse-webrtc
2017/04/25 11:22:50
Done.
| |
178 new RtpTransportControllerReceive(receive_side_cc, | |
179 enable_receive_side_bwe)); | |
180 } | |
181 | |
182 } // namespace webrtc | |
OLD | NEW |