blob: 3c7207bd84895c6666d0f4ae770b5aeab4c43668 [file] [log] [blame]
Erik Språng09708512018-03-14 14:16:501/*
2 * Copyright (c) 2012 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
Jonas Olssona4d87372019-07-05 17:08:3311#include "call/fake_network_pipe.h"
12
Erik Språng09708512018-03-14 14:16:5013#include <string.h>
Jonas Olssona4d87372019-07-05 17:08:3314
Erik Språng09708512018-03-14 14:16:5015#include <algorithm>
Yves Gerey3e707812018-11-28 15:47:4916#include <queue>
Erik Språng09708512018-03-14 14:16:5017#include <utility>
Yves Gerey3e707812018-11-28 15:47:4918#include <vector>
Erik Språng09708512018-03-14 14:16:5019
Steve Anton10542f22019-01-11 17:11:0020#include "api/media_types.h"
Per Kbc319022023-01-09 20:44:5621#include "api/units/timestamp.h"
22#include "modules/rtp_rtcp/source/rtp_packet_received.h"
Yves Gerey3e707812018-11-28 15:47:4923#include "rtc_base/checks.h"
Erik Språng09708512018-03-14 14:16:5024#include "rtc_base/logging.h"
25#include "system_wrappers/include/clock.h"
26
27namespace webrtc {
28
29namespace {
Sebastian Jansson512bdce2018-04-23 11:15:0430constexpr int64_t kLogIntervalMs = 5000;
Erik Språng09708512018-03-14 14:16:5031} // namespace
32
33NetworkPacket::NetworkPacket(rtc::CopyOnWriteBuffer packet,
34 int64_t send_time,
35 int64_t arrival_time,
Danil Chapovalovb9b146c2018-06-15 10:28:0736 absl::optional<PacketOptions> packet_options,
Erik Språng09708512018-03-14 14:16:5037 bool is_rtcp,
38 MediaType media_type,
Erik Språngeea605d2019-08-12 13:56:5139 absl::optional<int64_t> packet_time_us,
40 Transport* transport)
Erik Språng09708512018-03-14 14:16:5041 : packet_(std::move(packet)),
42 send_time_(send_time),
43 arrival_time_(arrival_time),
44 packet_options_(packet_options),
45 is_rtcp_(is_rtcp),
46 media_type_(media_type),
Erik Språngeea605d2019-08-12 13:56:5147 packet_time_us_(packet_time_us),
48 transport_(transport) {}
Artem Titov537b7fe2018-08-16 09:20:4549
Per Kbc319022023-01-09 20:44:5650NetworkPacket::NetworkPacket(RtpPacketReceived packet_received,
51 MediaType media_type,
52 int64_t send_time,
53 int64_t arrival_time)
54 : packet_(packet_received.Buffer()),
55 send_time_(send_time),
56 arrival_time_(arrival_time),
57 is_rtcp_(false),
58 media_type_(media_type),
59 packet_time_us_(packet_received.arrival_time().us()),
60 packet_received_(std::move(packet_received)),
61 transport_(nullptr) {}
62
Erik Språng09708512018-03-14 14:16:5063NetworkPacket::NetworkPacket(NetworkPacket&& o)
64 : packet_(std::move(o.packet_)),
65 send_time_(o.send_time_),
66 arrival_time_(o.arrival_time_),
67 packet_options_(o.packet_options_),
68 is_rtcp_(o.is_rtcp_),
69 media_type_(o.media_type_),
Erik Språngeea605d2019-08-12 13:56:5170 packet_time_us_(o.packet_time_us_),
Per Kbc319022023-01-09 20:44:5671 packet_received_(std::move(o.packet_received_)),
Erik Språngeea605d2019-08-12 13:56:5172 transport_(o.transport_) {}
Erik Språng09708512018-03-14 14:16:5073
Mirko Bonadeied1dcf92018-07-26 07:15:1174NetworkPacket::~NetworkPacket() = default;
75
Erik Språng09708512018-03-14 14:16:5076NetworkPacket& NetworkPacket::operator=(NetworkPacket&& o) {
77 packet_ = std::move(o.packet_);
78 send_time_ = o.send_time_;
79 arrival_time_ = o.arrival_time_;
80 packet_options_ = o.packet_options_;
81 is_rtcp_ = o.is_rtcp_;
82 media_type_ = o.media_type_;
Niels Möller70082872018-08-07 09:03:1283 packet_time_us_ = o.packet_time_us_;
Per Kbc319022023-01-09 20:44:5684 packet_received_ = o.packet_received_;
Erik Språngeea605d2019-08-12 13:56:5185 transport_ = o.transport_;
Erik Språng09708512018-03-14 14:16:5086
87 return *this;
88}
89
Artem Titovb0050872018-08-16 15:02:2090FakeNetworkPipe::FakeNetworkPipe(
91 Clock* clock,
Artem Titov8ea1e9d2018-10-04 12:46:3192 std::unique_ptr<NetworkBehaviorInterface> network_behavior)
93 : FakeNetworkPipe(clock, std::move(network_behavior), nullptr, 1) {}
Artem Titovb0050872018-08-16 15:02:2094
95FakeNetworkPipe::FakeNetworkPipe(
96 Clock* clock,
Artem Titov8ea1e9d2018-10-04 12:46:3197 std::unique_ptr<NetworkBehaviorInterface> network_behavior,
Artem Titovb0050872018-08-16 15:02:2098 PacketReceiver* receiver)
Artem Titov8ea1e9d2018-10-04 12:46:3199 : FakeNetworkPipe(clock, std::move(network_behavior), receiver, 1) {}
Artem Titovb0050872018-08-16 15:02:20100
101FakeNetworkPipe::FakeNetworkPipe(
102 Clock* clock,
Artem Titov8ea1e9d2018-10-04 12:46:31103 std::unique_ptr<NetworkBehaviorInterface> network_behavior,
Artem Titovb0050872018-08-16 15:02:20104 PacketReceiver* receiver,
105 uint64_t seed)
106 : clock_(clock),
Artem Titov8ea1e9d2018-10-04 12:46:31107 network_behavior_(std::move(network_behavior)),
Artem Titovb0050872018-08-16 15:02:20108 receiver_(receiver),
Artem Titovb0050872018-08-16 15:02:20109 clock_offset_ms_(0),
110 dropped_packets_(0),
111 sent_packets_(0),
112 total_packet_delay_us_(0),
Artem Titovb0050872018-08-16 15:02:20113 last_log_time_us_(clock_->TimeInMicroseconds()) {}
114
Erik Språngeea605d2019-08-12 13:56:51115FakeNetworkPipe::~FakeNetworkPipe() {
Erik Språngeea605d2019-08-12 13:56:51116 RTC_DCHECK(active_transports_.empty());
117}
Erik Språng09708512018-03-14 14:16:50118
119void FakeNetworkPipe::SetReceiver(PacketReceiver* receiver) {
Markus Handell8fe932a2020-07-06 15:41:35120 MutexLock lock(&config_lock_);
Erik Språng09708512018-03-14 14:16:50121 receiver_ = receiver;
122}
123
Erik Språngeea605d2019-08-12 13:56:51124void FakeNetworkPipe::AddActiveTransport(Transport* transport) {
Markus Handell8fe932a2020-07-06 15:41:35125 MutexLock lock(&config_lock_);
Erik Språngeea605d2019-08-12 13:56:51126 active_transports_[transport]++;
127}
128
129void FakeNetworkPipe::RemoveActiveTransport(Transport* transport) {
Markus Handell8fe932a2020-07-06 15:41:35130 MutexLock lock(&config_lock_);
Erik Språngeea605d2019-08-12 13:56:51131 auto it = active_transports_.find(transport);
132 RTC_CHECK(it != active_transports_.end());
133 if (--(it->second) == 0) {
134 active_transports_.erase(it);
135 }
136}
137
Harald Alvestrandd43af912023-08-15 11:41:45138bool FakeNetworkPipe::SendRtp(rtc::ArrayView<const uint8_t> packet,
Erik Språngeea605d2019-08-12 13:56:51139 const PacketOptions& options,
140 Transport* transport) {
141 RTC_DCHECK(transport);
Harald Alvestrandd43af912023-08-15 11:41:45142 EnqueuePacket(rtc::CopyOnWriteBuffer(packet), options, false, transport);
Erik Språngeea605d2019-08-12 13:56:51143 return true;
144}
145
Harald Alvestrandd43af912023-08-15 11:41:45146bool FakeNetworkPipe::SendRtcp(rtc::ArrayView<const uint8_t> packet,
Erik Språngeea605d2019-08-12 13:56:51147 Transport* transport) {
148 RTC_DCHECK(transport);
Harald Alvestrandd43af912023-08-15 11:41:45149 EnqueuePacket(rtc::CopyOnWriteBuffer(packet), absl::nullopt, true, transport);
Erik Språng09708512018-03-14 14:16:50150 return true;
151}
152
Per Kbc319022023-01-09 20:44:56153void FakeNetworkPipe::DeliverRtpPacket(
154 MediaType media_type,
155 RtpPacketReceived packet,
156 OnUndemuxablePacketHandler undemuxable_packet_handler) {
157 MutexLock lock(&process_lock_);
158 int64_t time_now_us = clock_->TimeInMicroseconds();
159 EnqueuePacket(
160 NetworkPacket(std::move(packet), media_type, time_now_us, time_now_us));
161}
162
Per Kcf439a02023-01-05 13:01:39163void FakeNetworkPipe::DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) {
164 EnqueuePacket(std::move(packet), absl::nullopt, true, MediaType::ANY,
165 absl::nullopt);
166}
167
Sebastian Jansson7e85d672018-04-06 07:56:21168void FakeNetworkPipe::SetClockOffset(int64_t offset_ms) {
Markus Handell8fe932a2020-07-06 15:41:35169 MutexLock lock(&config_lock_);
Sebastian Jansson7e85d672018-04-06 07:56:21170 clock_offset_ms_ = offset_ms;
171}
172
Sebastian Jansson7ee2e252018-05-07 12:49:39173FakeNetworkPipe::StoredPacket::StoredPacket(NetworkPacket&& packet)
174 : packet(std::move(packet)) {}
175
176bool FakeNetworkPipe::EnqueuePacket(rtc::CopyOnWriteBuffer packet,
Danil Chapovalovb9b146c2018-06-15 10:28:07177 absl::optional<PacketOptions> options,
Sebastian Jansson7ee2e252018-05-07 12:49:39178 bool is_rtcp,
179 MediaType media_type,
Niels Möller70082872018-08-07 09:03:12180 absl::optional<int64_t> packet_time_us) {
Markus Handell8fe932a2020-07-06 15:41:35181 MutexLock lock(&process_lock_);
Christoffer Rodbro1803bb22018-10-25 10:39:49182 int64_t time_now_us = clock_->TimeInMicroseconds();
Erik Språngeea605d2019-08-12 13:56:51183 return EnqueuePacket(NetworkPacket(std::move(packet), time_now_us,
184 time_now_us, options, is_rtcp, media_type,
185 packet_time_us, nullptr));
186}
187
188bool FakeNetworkPipe::EnqueuePacket(rtc::CopyOnWriteBuffer packet,
189 absl::optional<PacketOptions> options,
190 bool is_rtcp,
191 Transport* transport) {
Markus Handell8fe932a2020-07-06 15:41:35192 MutexLock lock(&process_lock_);
Erik Språngeea605d2019-08-12 13:56:51193 int64_t time_now_us = clock_->TimeInMicroseconds();
194 return EnqueuePacket(NetworkPacket(std::move(packet), time_now_us,
195 time_now_us, options, is_rtcp,
196 MediaType::ANY, absl::nullopt, transport));
197}
198
199bool FakeNetworkPipe::EnqueuePacket(NetworkPacket&& net_packet) {
200 int64_t send_time_us = net_packet.send_time();
201 size_t packet_size = net_packet.data_length();
Sebastian Jansson7ee2e252018-05-07 12:49:39202
203 packets_in_flight_.emplace_back(StoredPacket(std::move(net_packet)));
204 int64_t packet_id = reinterpret_cast<uint64_t>(&packets_in_flight_.back());
Artem Titov8ea1e9d2018-10-04 12:46:31205 bool sent = network_behavior_->EnqueuePacket(
Erik Språngeea605d2019-08-12 13:56:51206 PacketInFlightInfo(packet_size, send_time_us, packet_id));
Sebastian Jansson7ee2e252018-05-07 12:49:39207
208 if (!sent) {
209 packets_in_flight_.pop_back();
210 ++dropped_packets_;
211 }
212 return sent;
213}
214
Erik Språng09708512018-03-14 14:16:50215float FakeNetworkPipe::PercentageLoss() {
Markus Handell8fe932a2020-07-06 15:41:35216 MutexLock lock(&process_lock_);
Erik Språng09708512018-03-14 14:16:50217 if (sent_packets_ == 0)
218 return 0;
219
220 return static_cast<float>(dropped_packets_) /
221 (sent_packets_ + dropped_packets_);
222}
223
224int FakeNetworkPipe::AverageDelay() {
Markus Handell8fe932a2020-07-06 15:41:35225 MutexLock lock(&process_lock_);
Erik Språng09708512018-03-14 14:16:50226 if (sent_packets_ == 0)
227 return 0;
228
Sebastian Jansson512bdce2018-04-23 11:15:04229 return static_cast<int>(total_packet_delay_us_ /
230 (1000 * static_cast<int64_t>(sent_packets_)));
Erik Språng09708512018-03-14 14:16:50231}
232
233size_t FakeNetworkPipe::DroppedPackets() {
Markus Handell8fe932a2020-07-06 15:41:35234 MutexLock lock(&process_lock_);
Erik Språng09708512018-03-14 14:16:50235 return dropped_packets_;
236}
237
238size_t FakeNetworkPipe::SentPackets() {
Markus Handell8fe932a2020-07-06 15:41:35239 MutexLock lock(&process_lock_);
Erik Språng09708512018-03-14 14:16:50240 return sent_packets_;
241}
242
Sebastian Jansson7ee2e252018-05-07 12:49:39243void FakeNetworkPipe::Process() {
Christoffer Rodbro1803bb22018-10-25 10:39:49244 int64_t time_now_us;
Sebastian Jansson7ee2e252018-05-07 12:49:39245 std::queue<NetworkPacket> packets_to_deliver;
246 {
Markus Handell8fe932a2020-07-06 15:41:35247 MutexLock lock(&process_lock_);
Christoffer Rodbro1803bb22018-10-25 10:39:49248 time_now_us = clock_->TimeInMicroseconds();
Sebastian Jansson7ee2e252018-05-07 12:49:39249 if (time_now_us - last_log_time_us_ > kLogIntervalMs * 1000) {
250 int64_t queueing_delay_us = 0;
251 if (!packets_in_flight_.empty())
252 queueing_delay_us =
253 time_now_us - packets_in_flight_.front().packet.send_time();
254
255 RTC_LOG(LS_INFO) << "Network queue: " << queueing_delay_us / 1000
256 << " ms.";
257 last_log_time_us_ = time_now_us;
258 }
259
260 std::vector<PacketDeliveryInfo> delivery_infos =
Artem Titov8ea1e9d2018-10-04 12:46:31261 network_behavior_->DequeueDeliverablePackets(time_now_us);
Sebastian Jansson7ee2e252018-05-07 12:49:39262 for (auto& delivery_info : delivery_infos) {
263 // In the common case where no reordering happens, find will return early
264 // as the first packet will be a match.
265 auto packet_it =
266 std::find_if(packets_in_flight_.begin(), packets_in_flight_.end(),
267 [&delivery_info](StoredPacket& packet_ref) {
268 return reinterpret_cast<uint64_t>(&packet_ref) ==
269 delivery_info.packet_id;
270 });
271 // Check that the packet is in the deque of packets in flight.
272 RTC_CHECK(packet_it != packets_in_flight_.end());
273 // Check that the packet is not already removed.
274 RTC_DCHECK(!packet_it->removed);
275
276 NetworkPacket packet = std::move(packet_it->packet);
277 packet_it->removed = true;
278
279 // Cleanup of removed packets at the beginning of the deque.
280 while (!packets_in_flight_.empty() &&
281 packets_in_flight_.front().removed) {
282 packets_in_flight_.pop_front();
283 }
284
285 if (delivery_info.receive_time_us != PacketDeliveryInfo::kNotReceived) {
286 int64_t added_delay_us =
287 delivery_info.receive_time_us - packet.send_time();
288 packet.IncrementArrivalTime(added_delay_us);
289 packets_to_deliver.emplace(std::move(packet));
Artem Titovea240272021-07-26 10:40:21290 // `time_now_us` might be later than when the packet should have
Sebastian Jansson7ee2e252018-05-07 12:49:39291 // arrived, due to NetworkProcess being called too late. For stats, use
292 // the time it should have been on the link.
293 total_packet_delay_us_ += added_delay_us;
Christoffer Rodbro3284b612018-10-23 14:51:51294 ++sent_packets_;
295 } else {
296 ++dropped_packets_;
Sebastian Jansson7ee2e252018-05-07 12:49:39297 }
Erik Språng09708512018-03-14 14:16:50298 }
Erik Språng09708512018-03-14 14:16:50299 }
300
Markus Handell8fe932a2020-07-06 15:41:35301 MutexLock lock(&config_lock_);
Erik Språng09708512018-03-14 14:16:50302 while (!packets_to_deliver.empty()) {
303 NetworkPacket packet = std::move(packets_to_deliver.front());
304 packets_to_deliver.pop();
Niels Möller70082872018-08-07 09:03:12305 DeliverNetworkPacket(&packet);
Erik Språng09708512018-03-14 14:16:50306 }
Erik Språng09708512018-03-14 14:16:50307}
308
Niels Möller70082872018-08-07 09:03:12309void FakeNetworkPipe::DeliverNetworkPacket(NetworkPacket* packet) {
Erik Språngeea605d2019-08-12 13:56:51310 Transport* transport = packet->transport();
311 if (transport) {
Sebastian Janssona44ab182018-04-06 10:59:14312 RTC_DCHECK(!receiver_);
Erik Språngeea605d2019-08-12 13:56:51313 if (active_transports_.find(transport) == active_transports_.end()) {
314 // Transport has been destroyed, ignore this packet.
315 return;
316 }
Erik Språng09708512018-03-14 14:16:50317 if (packet->is_rtcp()) {
Harald Alvestrand34d82df2023-08-04 12:18:45318 transport->SendRtcp(
319 rtc::MakeArrayView(packet->data(), packet->data_length()));
Erik Språng09708512018-03-14 14:16:50320 } else {
Harald Alvestrand34d82df2023-08-04 12:18:45321 transport->SendRtp(
322 rtc::MakeArrayView(packet->data(), packet->data_length()),
323 packet->packet_options());
Erik Språng09708512018-03-14 14:16:50324 }
Sebastian Jansson09408112018-04-24 12:41:22325 } else if (receiver_) {
Niels Möller70082872018-08-07 09:03:12326 int64_t packet_time_us = packet->packet_time_us().value_or(-1);
327 if (packet_time_us != -1) {
Sebastian Jansson512bdce2018-04-23 11:15:04328 int64_t queue_time_us = packet->arrival_time() - packet->send_time();
329 RTC_CHECK(queue_time_us >= 0);
Niels Möller70082872018-08-07 09:03:12330 packet_time_us += queue_time_us;
331 packet_time_us += (clock_offset_ms_ * 1000);
Erik Språng09708512018-03-14 14:16:50332 }
Per Kbc319022023-01-09 20:44:56333 if (packet->is_rtcp()) {
334 receiver_->DeliverRtcpPacket(std::move(*packet->raw_packet()));
335 } else if (packet->packet_received()) {
336 packet->packet_received()->set_arrival_time(
337 Timestamp::Micros(packet_time_us));
338 receiver_->DeliverRtpPacket(
339 packet->media_type(), *packet->packet_received(),
340 [](const RtpPacketReceived& packet) {
341 RTC_LOG(LS_WARNING)
342 << "Unexpected failed demuxing packet in FakeNetworkPipe, "
343 "Ssrc: "
344 << packet.Ssrc() << " seq : " << packet.SequenceNumber();
345 return false;
346 });
Per Kbc319022023-01-09 20:44:56347 }
Erik Språng09708512018-03-14 14:16:50348 }
349}
350
Sebastian Jansson836fee12019-02-08 15:08:10351absl::optional<int64_t> FakeNetworkPipe::TimeUntilNextProcess() {
Markus Handell8fe932a2020-07-06 15:41:35352 MutexLock lock(&process_lock_);
Sebastian Jansson71822862018-10-30 07:23:27353 absl::optional<int64_t> delivery_us = network_behavior_->NextDeliveryTimeUs();
354 if (delivery_us) {
355 int64_t delay_us = *delivery_us - clock_->TimeInMicroseconds();
356 return std::max<int64_t>((delay_us + 500) / 1000, 0);
357 }
Sebastian Jansson836fee12019-02-08 15:08:10358 return absl::nullopt;
Erik Språng09708512018-03-14 14:16:50359}
360
Sebastian Jansson09408112018-04-24 12:41:22361bool FakeNetworkPipe::HasReceiver() const {
Markus Handell8fe932a2020-07-06 15:41:35362 MutexLock lock(&config_lock_);
Sebastian Jansson09408112018-04-24 12:41:22363 return receiver_ != nullptr;
Erik Språng09708512018-03-14 14:16:50364}
365
Christoffer Rodbro8ef59a42018-03-20 13:34:01366void FakeNetworkPipe::DeliverPacketWithLock(NetworkPacket* packet) {
Markus Handell8fe932a2020-07-06 15:41:35367 MutexLock lock(&config_lock_);
Niels Möller70082872018-08-07 09:03:12368 DeliverNetworkPacket(packet);
Christoffer Rodbro8ef59a42018-03-20 13:34:01369}
370
371void FakeNetworkPipe::ResetStats() {
Markus Handell8fe932a2020-07-06 15:41:35372 MutexLock lock(&process_lock_);
Christoffer Rodbro8ef59a42018-03-20 13:34:01373 dropped_packets_ = 0;
374 sent_packets_ = 0;
Sebastian Jansson512bdce2018-04-23 11:15:04375 total_packet_delay_us_ = 0;
Christoffer Rodbro8ef59a42018-03-20 13:34:01376}
377
Sebastian Jansson512bdce2018-04-23 11:15:04378int64_t FakeNetworkPipe::GetTimeInMicroseconds() const {
379 return clock_->TimeInMicroseconds();
Christoffer Rodbro8ef59a42018-03-20 13:34:01380}
381
Erik Språng09708512018-03-14 14:16:50382} // namespace webrtc