blob: 29bf947eeeec9476186856e0761559accf51c54f [file] [log] [blame]
Steve Anton6e634bf2017-11-13 10:44:53 -08001/*
2 * Copyright 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
Steve Anton10542f22019-01-11 09:11:00 -080011#include "pc/rtp_transceiver.h"
Steve Anton6e634bf2017-11-13 10:44:53 -080012
Harald Alvestrandc24a2182022-02-23 13:44:59 +000013#include <algorithm>
Harald Alvestrand5761e7b2021-01-29 14:45:08 +000014#include <iterator>
Steve Anton6e634bf2017-11-13 10:44:53 -080015#include <string>
Markus Handell0357b3e2020-03-16 13:40:51 +010016#include <utility>
Markus Handell5932fe12020-12-17 22:19:40 +010017#include <vector>
Steve Anton6e634bf2017-11-13 10:44:53 -080018
Steve Anton64b626b2019-01-28 17:25:26 -080019#include "absl/algorithm/container.h"
Markus Handell0357b3e2020-03-16 13:40:51 +010020#include "api/rtp_parameters.h"
Artem Titovd15a5752021-02-10 14:31:24 +010021#include "api/sequence_checker.h"
Harald Alvestrand5761e7b2021-01-29 14:45:08 +000022#include "media/base/codec.h"
23#include "media/base/media_constants.h"
Florent Castelli2d9d82e2019-04-23 19:25:51 +020024#include "pc/channel_manager.h"
Steve Anton10542f22019-01-11 09:11:00 -080025#include "pc/rtp_media_utils.h"
Markus Handell5932fe12020-12-17 22:19:40 +010026#include "pc/session_description.h"
Yves Gerey3e707812018-11-28 16:47:49 +010027#include "rtc_base/checks.h"
Harald Alvestrandc24a2182022-02-23 13:44:59 +000028#include "rtc_base/location.h"
Yves Gerey3e707812018-11-28 16:47:49 +010029#include "rtc_base/logging.h"
Tommi99c8a802021-04-27 15:00:00 +020030#include "rtc_base/task_utils/to_queued_task.h"
Harald Alvestrand5761e7b2021-01-29 14:45:08 +000031#include "rtc_base/thread.h"
Steve Antondcc3c022017-12-22 16:02:54 -080032
Steve Anton6e634bf2017-11-13 10:44:53 -080033namespace webrtc {
Johannes Kron3e983682020-03-29 22:17:00 +020034namespace {
35template <class T>
36RTCError VerifyCodecPreferences(const std::vector<RtpCodecCapability>& codecs,
37 const std::vector<T>& send_codecs,
38 const std::vector<T>& recv_codecs) {
39 // If the intersection between codecs and
40 // RTCRtpSender.getCapabilities(kind).codecs or the intersection between
41 // codecs and RTCRtpReceiver.getCapabilities(kind).codecs only contains RTX,
42 // RED or FEC codecs or is an empty set, throw InvalidModificationError.
43 // This ensures that we always have something to offer, regardless of
44 // transceiver.direction.
45
46 if (!absl::c_any_of(codecs, [&recv_codecs](const RtpCodecCapability& codec) {
47 return codec.name != cricket::kRtxCodecName &&
48 codec.name != cricket::kRedCodecName &&
49 codec.name != cricket::kFlexfecCodecName &&
50 absl::c_any_of(recv_codecs, [&codec](const T& recv_codec) {
51 return recv_codec.MatchesCapability(codec);
52 });
53 })) {
54 return RTCError(RTCErrorType::INVALID_MODIFICATION,
55 "Invalid codec preferences: Missing codec from recv "
56 "codec capabilities.");
57 }
58
59 if (!absl::c_any_of(codecs, [&send_codecs](const RtpCodecCapability& codec) {
60 return codec.name != cricket::kRtxCodecName &&
61 codec.name != cricket::kRedCodecName &&
62 codec.name != cricket::kFlexfecCodecName &&
63 absl::c_any_of(send_codecs, [&codec](const T& send_codec) {
64 return send_codec.MatchesCapability(codec);
65 });
66 })) {
67 return RTCError(RTCErrorType::INVALID_MODIFICATION,
68 "Invalid codec preferences: Missing codec from send "
69 "codec capabilities.");
70 }
71
72 // Let codecCapabilities be the union of
73 // RTCRtpSender.getCapabilities(kind).codecs and
74 // RTCRtpReceiver.getCapabilities(kind).codecs. For each codec in codecs, If
75 // codec is not in codecCapabilities, throw InvalidModificationError.
76 for (const auto& codec_preference : codecs) {
77 bool is_recv_codec =
78 absl::c_any_of(recv_codecs, [&codec_preference](const T& codec) {
79 return codec.MatchesCapability(codec_preference);
80 });
81
82 bool is_send_codec =
83 absl::c_any_of(send_codecs, [&codec_preference](const T& codec) {
84 return codec.MatchesCapability(codec_preference);
85 });
86
87 if (!is_recv_codec && !is_send_codec) {
88 return RTCError(
89 RTCErrorType::INVALID_MODIFICATION,
90 std::string("Invalid codec preferences: invalid codec with name \"") +
91 codec_preference.name + "\".");
92 }
93 }
94
95 // Check we have a real codec (not just rtx, red or fec)
96 if (absl::c_all_of(codecs, [](const RtpCodecCapability& codec) {
97 return codec.name == cricket::kRtxCodecName ||
98 codec.name == cricket::kRedCodecName ||
99 codec.name == cricket::kUlpfecCodecName;
100 })) {
101 return RTCError(RTCErrorType::INVALID_MODIFICATION,
102 "Invalid codec preferences: codec list must have a non "
103 "RTX, RED or FEC entry.");
104 }
105
106 return RTCError::OK();
107}
108
Harald Alvestrand6060df52020-08-11 09:54:02 +0200109TaskQueueBase* GetCurrentTaskQueueOrThread() {
110 TaskQueueBase* current = TaskQueueBase::Current();
111 if (!current)
112 current = rtc::ThreadManager::Instance()->CurrentThread();
113 return current;
114}
115
Johannes Kron3e983682020-03-29 22:17:00 +0200116} // namespace
Steve Anton6e634bf2017-11-13 10:44:53 -0800117
Tommi99c8a802021-04-27 15:00:00 +0200118RtpTransceiver::RtpTransceiver(
119 cricket::MediaType media_type,
120 cricket::ChannelManager* channel_manager /* = nullptr*/)
Harald Alvestrand6060df52020-08-11 09:54:02 +0200121 : thread_(GetCurrentTaskQueueOrThread()),
122 unified_plan_(false),
Tommi99c8a802021-04-27 15:00:00 +0200123 media_type_(media_type),
124 channel_manager_(channel_manager) {
Steve Anton6e634bf2017-11-13 10:44:53 -0800125 RTC_DCHECK(media_type == cricket::MEDIA_TYPE_AUDIO ||
126 media_type == cricket::MEDIA_TYPE_VIDEO);
Tommi99c8a802021-04-27 15:00:00 +0200127 RTC_DCHECK(channel_manager_);
Steve Anton6e634bf2017-11-13 10:44:53 -0800128}
129
Steve Anton79e79602017-11-20 10:25:56 -0800130RtpTransceiver::RtpTransceiver(
131 rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender,
132 rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
Florent Castelli2d9d82e2019-04-23 19:25:51 +0200133 receiver,
Markus Handell0357b3e2020-03-16 13:40:51 +0100134 cricket::ChannelManager* channel_manager,
Harald Alvestrand280054f2020-11-10 13:12:53 +0000135 std::vector<RtpHeaderExtensionCapability> header_extensions_offered,
136 std::function<void()> on_negotiation_needed)
Harald Alvestrand6060df52020-08-11 09:54:02 +0200137 : thread_(GetCurrentTaskQueueOrThread()),
138 unified_plan_(true),
Florent Castelli2d9d82e2019-04-23 19:25:51 +0200139 media_type_(sender->media_type()),
Markus Handell0357b3e2020-03-16 13:40:51 +0100140 channel_manager_(channel_manager),
Harald Alvestrand280054f2020-11-10 13:12:53 +0000141 header_extensions_to_offer_(std::move(header_extensions_offered)),
142 on_negotiation_needed_(std::move(on_negotiation_needed)) {
Steve Anton79e79602017-11-20 10:25:56 -0800143 RTC_DCHECK(media_type_ == cricket::MEDIA_TYPE_AUDIO ||
144 media_type_ == cricket::MEDIA_TYPE_VIDEO);
145 RTC_DCHECK_EQ(sender->media_type(), receiver->media_type());
Tommi99c8a802021-04-27 15:00:00 +0200146 RTC_DCHECK(channel_manager_);
Steve Anton79e79602017-11-20 10:25:56 -0800147 senders_.push_back(sender);
148 receivers_.push_back(receiver);
149}
150
Steve Anton6e634bf2017-11-13 10:44:53 -0800151RtpTransceiver::~RtpTransceiver() {
Tommi99c8a802021-04-27 15:00:00 +0200152 // TODO(tommi): On Android, when running PeerConnectionClientTest (e.g.
153 // PeerConnectionClientTest#testCameraSwitch), the instance doesn't get
154 // deleted on `thread_`. See if we can fix that.
Harald Alvestrand85466662021-04-19 21:21:36 +0000155 if (!stopped_) {
156 RTC_DCHECK_RUN_ON(thread_);
157 StopInternal();
158 }
Tomas Gunnarsson16de2162022-01-26 10:21:57 +0100159
160 RTC_CHECK(!channel_) << "Missing call to SetChannel(nullptr)?";
Steve Anton6e634bf2017-11-13 10:44:53 -0800161}
162
Tomas Gunnarsson4f8a58c2022-01-19 11:36:23 +0100163void RtpTransceiver::SetChannel(
164 cricket::ChannelInterface* channel,
165 std::function<RtpTransportInternal*(const std::string&)> transport_lookup) {
Tommi99c8a802021-04-27 15:00:00 +0200166 RTC_DCHECK_RUN_ON(thread_);
Amit Hilbuchdd9390c2018-11-13 16:26:05 -0800167 // Cannot set a non-null channel on a stopped transceiver.
Tomas Gunnarsson16de2162022-01-26 10:21:57 +0100168 if ((stopped_ && channel) || channel == channel_) {
Amit Hilbuchdd9390c2018-11-13 16:26:05 -0800169 return;
170 }
171
Tommi99c8a802021-04-27 15:00:00 +0200172 RTC_DCHECK(channel || channel_);
Tomas Gunnarsson4f8a58c2022-01-19 11:36:23 +0100173 RTC_DCHECK(!channel || transport_lookup) << "lookup function not supplied";
Tommi99c8a802021-04-27 15:00:00 +0200174
Tommife041642021-04-07 10:08:28 +0200175 RTC_LOG_THREAD_BLOCK_COUNT();
176
Tommi99c8a802021-04-27 15:00:00 +0200177 if (channel_) {
178 signaling_thread_safety_->SetNotAlive();
179 signaling_thread_safety_ = nullptr;
180 }
181
Steve Anton6e634bf2017-11-13 10:44:53 -0800182 if (channel) {
183 RTC_DCHECK_EQ(media_type(), channel->media_type());
Tommi99c8a802021-04-27 15:00:00 +0200184 signaling_thread_safety_ = PendingTaskSafetyFlag::Create();
Steve Anton6e634bf2017-11-13 10:44:53 -0800185 }
Steve Anton60776752018-01-10 11:51:34 -0800186
Tomas Gunnarsson16de2162022-01-26 10:21:57 +0100187 cricket::ChannelInterface* channel_to_delete = nullptr;
188
Tommi99c8a802021-04-27 15:00:00 +0200189 // An alternative to this, could be to require SetChannel to be called
190 // on the network thread. The channel object operates for the most part
191 // on the network thread, as part of its initialization being on the network
192 // thread is required, so setting a channel object as part of the construction
193 // (without thread hopping) might be the more efficient thing to do than
194 // how SetChannel works today.
195 // Similarly, if the channel() accessor is limited to the network thread, that
196 // helps with keeping the channel implementation requirements being met and
197 // avoids synchronization for accessing the pointer or network related state.
198 channel_manager_->network_thread()->Invoke<void>(RTC_FROM_HERE, [&]() {
199 if (channel_) {
200 channel_->SetFirstPacketReceivedCallback(nullptr);
Tomas Gunnarsson4f8a58c2022-01-19 11:36:23 +0100201 channel_->SetRtpTransport(nullptr);
Tomas Gunnarsson16de2162022-01-26 10:21:57 +0100202 channel_to_delete = channel_;
Tommi99c8a802021-04-27 15:00:00 +0200203 }
Steve Anton60776752018-01-10 11:51:34 -0800204
Tommi99c8a802021-04-27 15:00:00 +0200205 channel_ = channel;
Steve Anton60776752018-01-10 11:51:34 -0800206
Tommi99c8a802021-04-27 15:00:00 +0200207 if (channel_) {
Tomas Gunnarsson5411b172022-01-24 08:45:26 +0100208 channel_->SetRtpTransport(transport_lookup(channel_->mid()));
Tommi99c8a802021-04-27 15:00:00 +0200209 channel_->SetFirstPacketReceivedCallback(
210 [thread = thread_, flag = signaling_thread_safety_, this]() mutable {
211 thread->PostTask(ToQueuedTask(
212 std::move(flag), [this]() { OnFirstPacketReceived(); }));
213 });
214 }
215 });
Steve Anton60776752018-01-10 11:51:34 -0800216
Tommi99c8a802021-04-27 15:00:00 +0200217 RTC_DCHECK_BLOCK_COUNT_NO_MORE_THAN(1);
Tommife041642021-04-07 10:08:28 +0200218
Tommi6589def2022-02-17 23:36:47 +0100219 if (channel_to_delete || !senders_.empty() || !receivers_.empty()) {
220 channel_manager_->worker_thread()->Invoke<void>(RTC_FROM_HERE, [&]() {
221 auto* media_channel = channel_ ? channel_->media_channel() : nullptr;
222 for (const auto& sender : senders_) {
223 sender->internal()->SetMediaChannel(media_channel);
224 }
225
226 for (const auto& receiver : receivers_) {
227 receiver->internal()->SetMediaChannel(media_channel);
228 }
229
230 // Destroy the channel, if we had one, now _after_ updating the receivers
231 // who might have had references to the previous channel.
232 if (channel_to_delete) {
233 channel_manager_->DestroyChannel(channel_to_delete);
234 }
235 });
Tomas Gunnarsson16de2162022-01-26 10:21:57 +0100236 }
Tommi6589def2022-02-17 23:36:47 +0100237
238 RTC_DCHECK_BLOCK_COUNT_NO_MORE_THAN(2);
Steve Anton6e634bf2017-11-13 10:44:53 -0800239}
240
241void RtpTransceiver::AddSender(
242 rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>> sender) {
Tommi99c8a802021-04-27 15:00:00 +0200243 RTC_DCHECK_RUN_ON(thread_);
Amit Hilbuchdd9390c2018-11-13 16:26:05 -0800244 RTC_DCHECK(!stopped_);
Steve Anton6e634bf2017-11-13 10:44:53 -0800245 RTC_DCHECK(!unified_plan_);
246 RTC_DCHECK(sender);
Steve Anton69470252018-02-09 11:43:08 -0800247 RTC_DCHECK_EQ(media_type(), sender->media_type());
Steve Anton64b626b2019-01-28 17:25:26 -0800248 RTC_DCHECK(!absl::c_linear_search(senders_, sender));
Steve Anton6e634bf2017-11-13 10:44:53 -0800249 senders_.push_back(sender);
250}
251
252bool RtpTransceiver::RemoveSender(RtpSenderInterface* sender) {
253 RTC_DCHECK(!unified_plan_);
254 if (sender) {
255 RTC_DCHECK_EQ(media_type(), sender->media_type());
256 }
Steve Anton64b626b2019-01-28 17:25:26 -0800257 auto it = absl::c_find(senders_, sender);
Steve Anton6e634bf2017-11-13 10:44:53 -0800258 if (it == senders_.end()) {
259 return false;
260 }
261 (*it)->internal()->Stop();
262 senders_.erase(it);
263 return true;
264}
265
266void RtpTransceiver::AddReceiver(
267 rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
268 receiver) {
Tommi99c8a802021-04-27 15:00:00 +0200269 RTC_DCHECK_RUN_ON(thread_);
Amit Hilbuchdd9390c2018-11-13 16:26:05 -0800270 RTC_DCHECK(!stopped_);
Steve Anton6e634bf2017-11-13 10:44:53 -0800271 RTC_DCHECK(!unified_plan_);
272 RTC_DCHECK(receiver);
Steve Anton69470252018-02-09 11:43:08 -0800273 RTC_DCHECK_EQ(media_type(), receiver->media_type());
Steve Anton64b626b2019-01-28 17:25:26 -0800274 RTC_DCHECK(!absl::c_linear_search(receivers_, receiver));
Steve Anton6e634bf2017-11-13 10:44:53 -0800275 receivers_.push_back(receiver);
276}
277
278bool RtpTransceiver::RemoveReceiver(RtpReceiverInterface* receiver) {
Tommi6589def2022-02-17 23:36:47 +0100279 RTC_DCHECK_RUN_ON(thread_);
Steve Anton6e634bf2017-11-13 10:44:53 -0800280 RTC_DCHECK(!unified_plan_);
281 if (receiver) {
282 RTC_DCHECK_EQ(media_type(), receiver->media_type());
283 }
Steve Anton64b626b2019-01-28 17:25:26 -0800284 auto it = absl::c_find(receivers_, receiver);
Steve Anton6e634bf2017-11-13 10:44:53 -0800285 if (it == receivers_.end()) {
286 return false;
287 }
Tommi6589def2022-02-17 23:36:47 +0100288
Steve Anton6e634bf2017-11-13 10:44:53 -0800289 (*it)->internal()->Stop();
Tommi6589def2022-02-17 23:36:47 +0100290 channel_manager_->worker_thread()->Invoke<void>(RTC_FROM_HERE, [&]() {
291 // `Stop()` will clear the receiver's pointer to the media channel.
292 (*it)->internal()->SetMediaChannel(nullptr);
293 });
294
Steve Anton6e634bf2017-11-13 10:44:53 -0800295 receivers_.erase(it);
296 return true;
297}
298
Steve Antonf9381f02017-12-14 10:23:57 -0800299rtc::scoped_refptr<RtpSenderInternal> RtpTransceiver::sender_internal() const {
300 RTC_DCHECK(unified_plan_);
301 RTC_CHECK_EQ(1u, senders_.size());
Niels Möllere7cc8832022-01-04 15:20:03 +0100302 return rtc::scoped_refptr<RtpSenderInternal>(senders_[0]->internal());
Steve Antonf9381f02017-12-14 10:23:57 -0800303}
304
305rtc::scoped_refptr<RtpReceiverInternal> RtpTransceiver::receiver_internal()
306 const {
307 RTC_DCHECK(unified_plan_);
308 RTC_CHECK_EQ(1u, receivers_.size());
Niels Möllere7cc8832022-01-04 15:20:03 +0100309 return rtc::scoped_refptr<RtpReceiverInternal>(receivers_[0]->internal());
Steve Antonf9381f02017-12-14 10:23:57 -0800310}
311
Steve Anton69470252018-02-09 11:43:08 -0800312cricket::MediaType RtpTransceiver::media_type() const {
313 return media_type_;
314}
315
Danil Chapovalov66cadcc2018-06-19 16:47:43 +0200316absl::optional<std::string> RtpTransceiver::mid() const {
Steve Anton6e634bf2017-11-13 10:44:53 -0800317 return mid_;
318}
319
Tommi99c8a802021-04-27 15:00:00 +0200320void RtpTransceiver::OnFirstPacketReceived() {
Mirko Bonadei739baf02019-01-27 17:29:42 +0100321 for (const auto& receiver : receivers_) {
Steve Anton60776752018-01-10 11:51:34 -0800322 receiver->internal()->NotifyFirstPacketReceived();
323 }
324}
325
Steve Anton6e634bf2017-11-13 10:44:53 -0800326rtc::scoped_refptr<RtpSenderInterface> RtpTransceiver::sender() const {
327 RTC_DCHECK(unified_plan_);
328 RTC_CHECK_EQ(1u, senders_.size());
329 return senders_[0];
330}
331
332rtc::scoped_refptr<RtpReceiverInterface> RtpTransceiver::receiver() const {
333 RTC_DCHECK(unified_plan_);
334 RTC_CHECK_EQ(1u, receivers_.size());
335 return receivers_[0];
336}
337
Steve Antondcc3c022017-12-22 16:02:54 -0800338void RtpTransceiver::set_current_direction(RtpTransceiverDirection direction) {
Steve Anton3d954a62018-04-02 11:27:23 -0700339 RTC_LOG(LS_INFO) << "Changing transceiver (MID=" << mid_.value_or("<not set>")
340 << ") current direction from "
341 << (current_direction_ ? RtpTransceiverDirectionToString(
342 *current_direction_)
343 : "<not set>")
344 << " to " << RtpTransceiverDirectionToString(direction)
345 << ".";
Steve Antondcc3c022017-12-22 16:02:54 -0800346 current_direction_ = direction;
347 if (RtpTransceiverDirectionHasSend(*current_direction_)) {
348 has_ever_been_used_to_send_ = true;
349 }
350}
351
Steve Anton0f5400a2018-07-17 14:25:36 -0700352void RtpTransceiver::set_fired_direction(RtpTransceiverDirection direction) {
353 fired_direction_ = direction;
354}
355
Steve Anton6e634bf2017-11-13 10:44:53 -0800356bool RtpTransceiver::stopped() const {
Tommi99c8a802021-04-27 15:00:00 +0200357 RTC_DCHECK_RUN_ON(thread_);
Steve Anton6e634bf2017-11-13 10:44:53 -0800358 return stopped_;
359}
360
Harald Alvestrand6060df52020-08-11 09:54:02 +0200361bool RtpTransceiver::stopping() const {
362 RTC_DCHECK_RUN_ON(thread_);
363 return stopping_;
364}
365
Steve Anton6e634bf2017-11-13 10:44:53 -0800366RtpTransceiverDirection RtpTransceiver::direction() const {
Harald Alvestrand6060df52020-08-11 09:54:02 +0200367 if (unified_plan_ && stopping())
368 return webrtc::RtpTransceiverDirection::kStopped;
369
Steve Anton6e634bf2017-11-13 10:44:53 -0800370 return direction_;
371}
372
Harald Alvestrand6060df52020-08-11 09:54:02 +0200373RTCError RtpTransceiver::SetDirectionWithError(
374 RtpTransceiverDirection new_direction) {
375 if (unified_plan_ && stopping()) {
376 LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_STATE,
377 "Cannot set direction on a stopping transceiver.");
Steve Anton52d86772018-02-20 15:48:12 -0800378 }
Harald Alvestrand6060df52020-08-11 09:54:02 +0200379 if (new_direction == direction_)
380 return RTCError::OK();
381
382 if (new_direction == RtpTransceiverDirection::kStopped) {
383 LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER,
384 "The set direction 'stopped' is invalid.");
Steve Anton52d86772018-02-20 15:48:12 -0800385 }
Harald Alvestrand6060df52020-08-11 09:54:02 +0200386
Steve Anton52d86772018-02-20 15:48:12 -0800387 direction_ = new_direction;
Harald Alvestrand280054f2020-11-10 13:12:53 +0000388 on_negotiation_needed_();
Harald Alvestrand6060df52020-08-11 09:54:02 +0200389
390 return RTCError::OK();
Steve Anton6e634bf2017-11-13 10:44:53 -0800391}
392
Danil Chapovalov66cadcc2018-06-19 16:47:43 +0200393absl::optional<RtpTransceiverDirection> RtpTransceiver::current_direction()
Steve Anton6e634bf2017-11-13 10:44:53 -0800394 const {
Harald Alvestrandc75c4282020-08-26 12:17:54 +0000395 if (unified_plan_ && stopped())
Harald Alvestrand6060df52020-08-11 09:54:02 +0200396 return webrtc::RtpTransceiverDirection::kStopped;
397
Steve Anton6e634bf2017-11-13 10:44:53 -0800398 return current_direction_;
399}
400
Steve Anton0f5400a2018-07-17 14:25:36 -0700401absl::optional<RtpTransceiverDirection> RtpTransceiver::fired_direction()
402 const {
403 return fired_direction_;
404}
405
Harald Alvestrand6060df52020-08-11 09:54:02 +0200406void RtpTransceiver::StopSendingAndReceiving() {
407 // 1. Let sender be transceiver.[[Sender]].
408 // 2. Let receiver be transceiver.[[Receiver]].
409 //
410 // 3. Stop sending media with sender.
411 //
Tommi6589def2022-02-17 23:36:47 +0100412 RTC_DCHECK_RUN_ON(thread_);
413
Harald Alvestrand6060df52020-08-11 09:54:02 +0200414 // 4. Send an RTCP BYE for each RTP stream that was being sent by sender, as
415 // specified in [RFC3550].
Harald Alvestrand6060df52020-08-11 09:54:02 +0200416 for (const auto& sender : senders_)
Steve Anton6e634bf2017-11-13 10:44:53 -0800417 sender->internal()->Stop();
Harald Alvestrand6060df52020-08-11 09:54:02 +0200418
Tommi6589def2022-02-17 23:36:47 +0100419 // Signal to receiver sources that we're stopping.
Harald Alvestrand6060df52020-08-11 09:54:02 +0200420 for (const auto& receiver : receivers_)
Tommi6589def2022-02-17 23:36:47 +0100421 receiver->internal()->Stop();
422
423 channel_manager_->worker_thread()->Invoke<void>(RTC_FROM_HERE, [&]() {
424 // 5 Stop receiving media with receiver.
425 for (const auto& receiver : receivers_)
426 receiver->internal()->SetMediaChannel(nullptr);
427 });
Harald Alvestrand6060df52020-08-11 09:54:02 +0200428
429 stopping_ = true;
430 direction_ = webrtc::RtpTransceiverDirection::kInactive;
431}
432
433RTCError RtpTransceiver::StopStandard() {
434 RTC_DCHECK_RUN_ON(thread_);
Harald Alvestrandc75c4282020-08-26 12:17:54 +0000435 // If we're on Plan B, do what Stop() used to do there.
436 if (!unified_plan_) {
437 StopInternal();
438 return RTCError::OK();
439 }
Harald Alvestrand6060df52020-08-11 09:54:02 +0200440 // 1. Let transceiver be the RTCRtpTransceiver object on which the method is
441 // invoked.
442 //
443 // 2. Let connection be the RTCPeerConnection object associated with
444 // transceiver.
445 //
446 // 3. If connection.[[IsClosed]] is true, throw an InvalidStateError.
447 if (is_pc_closed_) {
448 LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_STATE,
449 "PeerConnection is closed.");
Harald Alvestranda88c9772020-08-10 18:06:09 +0000450 }
Harald Alvestrand6060df52020-08-11 09:54:02 +0200451
452 // 4. If transceiver.[[Stopping]] is true, abort these steps.
453 if (stopping_)
454 return RTCError::OK();
455
456 // 5. Stop sending and receiving given transceiver, and update the
457 // negotiation-needed flag for connection.
458 StopSendingAndReceiving();
Harald Alvestrand280054f2020-11-10 13:12:53 +0000459 on_negotiation_needed_();
Harald Alvestrand6060df52020-08-11 09:54:02 +0200460
461 return RTCError::OK();
462}
463
464void RtpTransceiver::StopInternal() {
Harald Alvestrand85466662021-04-19 21:21:36 +0000465 RTC_DCHECK_RUN_ON(thread_);
Harald Alvestrandc75c4282020-08-26 12:17:54 +0000466 StopTransceiverProcedure();
467}
468
469void RtpTransceiver::StopTransceiverProcedure() {
Harald Alvestrand6060df52020-08-11 09:54:02 +0200470 RTC_DCHECK_RUN_ON(thread_);
Harald Alvestrandc75c4282020-08-26 12:17:54 +0000471 // As specified in the "Stop the RTCRtpTransceiver" procedure
Harald Alvestrand6060df52020-08-11 09:54:02 +0200472 // 1. If transceiver.[[Stopping]] is false, stop sending and receiving given
473 // transceiver.
474 if (!stopping_)
475 StopSendingAndReceiving();
476
477 // 2. Set transceiver.[[Stopped]] to true.
Steve Anton6e634bf2017-11-13 10:44:53 -0800478 stopped_ = true;
Harald Alvestrand6060df52020-08-11 09:54:02 +0200479
480 // Signal the updated change to the senders.
481 for (const auto& sender : senders_)
482 sender->internal()->SetTransceiverAsStopped();
483
484 // 3. Set transceiver.[[Receptive]] to false.
485 // 4. Set transceiver.[[CurrentDirection]] to null.
Danil Chapovalov66cadcc2018-06-19 16:47:43 +0200486 current_direction_ = absl::nullopt;
Steve Anton6e634bf2017-11-13 10:44:53 -0800487}
488
Florent Castelli2d9d82e2019-04-23 19:25:51 +0200489RTCError RtpTransceiver::SetCodecPreferences(
490 rtc::ArrayView<RtpCodecCapability> codec_capabilities) {
491 RTC_DCHECK(unified_plan_);
492
493 // 3. If codecs is an empty list, set transceiver's [[PreferredCodecs]] slot
494 // to codecs and abort these steps.
495 if (codec_capabilities.empty()) {
496 codec_preferences_.clear();
497 return RTCError::OK();
498 }
499
500 // 4. Remove any duplicate values in codecs.
501 std::vector<RtpCodecCapability> codecs;
502 absl::c_remove_copy_if(codec_capabilities, std::back_inserter(codecs),
503 [&codecs](const RtpCodecCapability& codec) {
504 return absl::c_linear_search(codecs, codec);
505 });
506
Johannes Kron3e983682020-03-29 22:17:00 +0200507 // 6. to 8.
508 RTCError result;
Florent Castelli2d9d82e2019-04-23 19:25:51 +0200509 if (media_type_ == cricket::MEDIA_TYPE_AUDIO) {
Florent Castelli2d9d82e2019-04-23 19:25:51 +0200510 std::vector<cricket::AudioCodec> recv_codecs, send_codecs;
511 channel_manager_->GetSupportedAudioReceiveCodecs(&recv_codecs);
512 channel_manager_->GetSupportedAudioSendCodecs(&send_codecs);
513
Johannes Kron3e983682020-03-29 22:17:00 +0200514 result = VerifyCodecPreferences(codecs, send_codecs, recv_codecs);
Florent Castelli2d9d82e2019-04-23 19:25:51 +0200515 } else if (media_type_ == cricket::MEDIA_TYPE_VIDEO) {
Johannes Kron3e983682020-03-29 22:17:00 +0200516 std::vector<cricket::VideoCodec> recv_codecs, send_codecs;
517 channel_manager_->GetSupportedVideoReceiveCodecs(&recv_codecs);
518 channel_manager_->GetSupportedVideoSendCodecs(&send_codecs);
Florent Castelli2d9d82e2019-04-23 19:25:51 +0200519
Johannes Kron3e983682020-03-29 22:17:00 +0200520 result = VerifyCodecPreferences(codecs, send_codecs, recv_codecs);
Florent Castelli2d9d82e2019-04-23 19:25:51 +0200521 }
522
Johannes Kron3e983682020-03-29 22:17:00 +0200523 if (result.ok()) {
524 codec_preferences_ = codecs;
Florent Castelli2d9d82e2019-04-23 19:25:51 +0200525 }
526
Johannes Kron3e983682020-03-29 22:17:00 +0200527 return result;
Steve Anton6e634bf2017-11-13 10:44:53 -0800528}
529
Markus Handell0357b3e2020-03-16 13:40:51 +0100530std::vector<RtpHeaderExtensionCapability>
531RtpTransceiver::HeaderExtensionsToOffer() const {
Markus Handell755c65d2020-06-24 01:06:10 +0200532 return header_extensions_to_offer_;
533}
534
Markus Handell5932fe12020-12-17 22:19:40 +0100535std::vector<RtpHeaderExtensionCapability>
536RtpTransceiver::HeaderExtensionsNegotiated() const {
Tommicc7a3682021-05-04 14:59:38 +0200537 RTC_DCHECK_RUN_ON(thread_);
Markus Handell5932fe12020-12-17 22:19:40 +0100538 std::vector<RtpHeaderExtensionCapability> result;
Tommicc7a3682021-05-04 14:59:38 +0200539 for (const auto& ext : negotiated_header_extensions_) {
Markus Handell5932fe12020-12-17 22:19:40 +0100540 result.emplace_back(ext.uri, ext.id, RtpTransceiverDirection::kSendRecv);
541 }
542 return result;
543}
544
Markus Handell755c65d2020-06-24 01:06:10 +0200545RTCError RtpTransceiver::SetOfferedRtpHeaderExtensions(
546 rtc::ArrayView<const RtpHeaderExtensionCapability>
547 header_extensions_to_offer) {
548 for (const auto& entry : header_extensions_to_offer) {
549 // Handle unsupported requests for mandatory extensions as per
550 // https://w3c.github.io/webrtc-extensions/#rtcrtptransceiver-interface.
551 // Note:
552 // - We do not handle setOfferedRtpHeaderExtensions algorithm step 2.1,
553 // this has to be checked on a higher level. We naturally error out
554 // in the handling of Step 2.2 if an unset URI is encountered.
555
556 // Step 2.2.
557 // Handle unknown extensions.
558 auto it = std::find_if(
559 header_extensions_to_offer_.begin(), header_extensions_to_offer_.end(),
560 [&entry](const auto& offered) { return entry.uri == offered.uri; });
561 if (it == header_extensions_to_offer_.end()) {
Markus Handellc17bca72021-01-14 17:08:01 +0100562 return RTCError(RTCErrorType::UNSUPPORTED_PARAMETER,
Markus Handell755c65d2020-06-24 01:06:10 +0200563 "Attempted to modify an unoffered extension.");
564 }
565
566 // Step 2.4-2.5.
567 // - Use of the transceiver interface indicates unified plan is in effect,
568 // hence the MID extension needs to be enabled.
569 // - Also handle the mandatory video orientation extensions.
570 if ((entry.uri == RtpExtension::kMidUri ||
571 entry.uri == RtpExtension::kVideoRotationUri) &&
572 entry.direction != RtpTransceiverDirection::kSendRecv) {
573 return RTCError(RTCErrorType::INVALID_MODIFICATION,
574 "Attempted to stop a mandatory extension.");
575 }
576 }
577
578 // Apply mutation after error checking.
579 for (const auto& entry : header_extensions_to_offer) {
580 auto it = std::find_if(
581 header_extensions_to_offer_.begin(), header_extensions_to_offer_.end(),
582 [&entry](const auto& offered) { return entry.uri == offered.uri; });
583 it->direction = entry.direction;
584 }
585
586 return RTCError::OK();
Markus Handell0357b3e2020-03-16 13:40:51 +0100587}
588
Tommicc7a3682021-05-04 14:59:38 +0200589void RtpTransceiver::OnNegotiationUpdate(
590 SdpType sdp_type,
591 const cricket::MediaContentDescription* content) {
592 RTC_DCHECK_RUN_ON(thread_);
593 RTC_DCHECK(content);
594 if (sdp_type == SdpType::kAnswer)
595 negotiated_header_extensions_ = content->rtp_header_extensions();
596}
597
Harald Alvestrand6060df52020-08-11 09:54:02 +0200598void RtpTransceiver::SetPeerConnectionClosed() {
599 is_pc_closed_ = true;
600}
601
Steve Anton6e634bf2017-11-13 10:44:53 -0800602} // namespace webrtc