1 /*
2 * Copyright 2004 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 "pc/channel.h"
12
13 #include <algorithm>
14 #include <cstdint>
15 #include <iterator>
16 #include <map>
17 #include <utility>
18
19 #include "absl/algorithm/container.h"
20 #include "absl/strings/string_view.h"
21 #include "api/rtp_parameters.h"
22 #include "api/sequence_checker.h"
23 #include "api/task_queue/queued_task.h"
24 #include "media/base/codec.h"
25 #include "media/base/rid_description.h"
26 #include "media/base/rtp_utils.h"
27 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
28 #include "pc/rtp_media_utils.h"
29 #include "rtc_base/checks.h"
30 #include "rtc_base/copy_on_write_buffer.h"
31 #include "rtc_base/logging.h"
32 #include "rtc_base/network_route.h"
33 #include "rtc_base/strings/string_builder.h"
34 #include "rtc_base/synchronization/mutex.h"
35 #include "rtc_base/task_utils/pending_task_safety_flag.h"
36 #include "rtc_base/task_utils/to_queued_task.h"
37 #include "rtc_base/trace_event.h"
38
39 namespace cricket {
40 namespace {
41
42 using ::rtc::UniqueRandomIdGenerator;
43 using ::webrtc::PendingTaskSafetyFlag;
44 using ::webrtc::SdpType;
45 using ::webrtc::ToQueuedTask;
46
47 struct SendPacketMessageData : public rtc::MessageData {
48 rtc::CopyOnWriteBuffer packet;
49 rtc::PacketOptions options;
50 };
51
52 // Finds a stream based on target's Primary SSRC or RIDs.
53 // This struct is used in BaseChannel::UpdateLocalStreams_w.
54 struct StreamFinder {
StreamFindercricket::__anon8a53d0340111::StreamFinder55 explicit StreamFinder(const StreamParams* target) : target_(target) {
56 RTC_DCHECK(target);
57 }
58
operator ()cricket::__anon8a53d0340111::StreamFinder59 bool operator()(const StreamParams& sp) const {
60 if (target_->has_ssrcs() && sp.has_ssrcs()) {
61 return sp.has_ssrc(target_->first_ssrc());
62 }
63
64 if (!target_->has_rids() && !sp.has_rids()) {
65 return false;
66 }
67
68 const std::vector<RidDescription>& target_rids = target_->rids();
69 const std::vector<RidDescription>& source_rids = sp.rids();
70 if (source_rids.size() != target_rids.size()) {
71 return false;
72 }
73
74 // Check that all RIDs match.
75 return std::equal(source_rids.begin(), source_rids.end(),
76 target_rids.begin(),
77 [](const RidDescription& lhs, const RidDescription& rhs) {
78 return lhs.rid == rhs.rid;
79 });
80 }
81
82 const StreamParams* target_;
83 };
84
85 } // namespace
86
87 enum {
88 MSG_SEND_RTP_PACKET = 1,
89 MSG_SEND_RTCP_PACKET,
90 MSG_READYTOSENDDATA,
91 MSG_DATARECEIVED,
92 MSG_FIRSTPACKETRECEIVED,
93 };
94
SafeSetError(const std::string & message,std::string * error_desc)95 static void SafeSetError(const std::string& message, std::string* error_desc) {
96 if (error_desc) {
97 *error_desc = message;
98 }
99 }
100
101 template <class Codec>
RtpParametersFromMediaDescription(const MediaContentDescriptionImpl<Codec> * desc,const RtpHeaderExtensions & extensions,bool is_stream_active,RtpParameters<Codec> * params)102 void RtpParametersFromMediaDescription(
103 const MediaContentDescriptionImpl<Codec>* desc,
104 const RtpHeaderExtensions& extensions,
105 bool is_stream_active,
106 RtpParameters<Codec>* params) {
107 params->is_stream_active = is_stream_active;
108 params->codecs = desc->codecs();
109 // TODO(bugs.webrtc.org/11513): See if we really need
110 // rtp_header_extensions_set() and remove it if we don't.
111 if (desc->rtp_header_extensions_set()) {
112 params->extensions = extensions;
113 }
114 params->rtcp.reduced_size = desc->rtcp_reduced_size();
115 params->rtcp.remote_estimate = desc->remote_estimate();
116 }
117
118 template <class Codec>
RtpSendParametersFromMediaDescription(const MediaContentDescriptionImpl<Codec> * desc,const RtpHeaderExtensions & extensions,bool is_stream_active,RtpSendParameters<Codec> * send_params)119 void RtpSendParametersFromMediaDescription(
120 const MediaContentDescriptionImpl<Codec>* desc,
121 const RtpHeaderExtensions& extensions,
122 bool is_stream_active,
123 RtpSendParameters<Codec>* send_params) {
124 RtpParametersFromMediaDescription(desc, extensions, is_stream_active,
125 send_params);
126 send_params->max_bandwidth_bps = desc->bandwidth();
127 send_params->extmap_allow_mixed = desc->extmap_allow_mixed();
128 }
129
BaseChannel(rtc::Thread * worker_thread,rtc::Thread * network_thread,rtc::Thread * signaling_thread,std::unique_ptr<MediaChannel> media_channel,const std::string & content_name,bool srtp_required,webrtc::CryptoOptions crypto_options,UniqueRandomIdGenerator * ssrc_generator)130 BaseChannel::BaseChannel(rtc::Thread* worker_thread,
131 rtc::Thread* network_thread,
132 rtc::Thread* signaling_thread,
133 std::unique_ptr<MediaChannel> media_channel,
134 const std::string& content_name,
135 bool srtp_required,
136 webrtc::CryptoOptions crypto_options,
137 UniqueRandomIdGenerator* ssrc_generator)
138 : worker_thread_(worker_thread),
139 network_thread_(network_thread),
140 signaling_thread_(signaling_thread),
141 alive_(PendingTaskSafetyFlag::Create()),
142 content_name_(content_name),
143 srtp_required_(srtp_required),
144 crypto_options_(crypto_options),
145 media_channel_(std::move(media_channel)),
146 ssrc_generator_(ssrc_generator) {
147 RTC_DCHECK_RUN_ON(worker_thread_);
148 RTC_DCHECK(ssrc_generator_);
149 demuxer_criteria_.mid = content_name;
150 RTC_LOG(LS_INFO) << "Created channel: " << ToString();
151 }
152
~BaseChannel()153 BaseChannel::~BaseChannel() {
154 TRACE_EVENT0("webrtc", "BaseChannel::~BaseChannel");
155 RTC_DCHECK_RUN_ON(worker_thread_);
156
157 // Eats any outstanding messages or packets.
158 alive_->SetNotAlive();
159 signaling_thread_->Clear(this);
160 // The media channel is destroyed at the end of the destructor, since it
161 // is a std::unique_ptr. The transport channel (rtp_transport) must outlive
162 // the media channel.
163 }
164
ToString() const165 std::string BaseChannel::ToString() const {
166 rtc::StringBuilder sb;
167 sb << "{mid: " << content_name_;
168 if (media_channel_) {
169 sb << ", media_type: " << MediaTypeToString(media_channel_->media_type());
170 }
171 sb << "}";
172 return sb.Release();
173 }
174
ConnectToRtpTransport()175 bool BaseChannel::ConnectToRtpTransport() {
176 RTC_DCHECK(rtp_transport_);
177 // We don't need to call OnDemuxerCriteriaUpdatePending/Complete because
178 // there's no previous criteria to worry about.
179 bool result = rtp_transport_->RegisterRtpDemuxerSink(demuxer_criteria_, this);
180 if (result) {
181 previous_demuxer_criteria_ = demuxer_criteria_;
182 } else {
183 previous_demuxer_criteria_ = {};
184 RTC_LOG(LS_ERROR) << "Failed to set up demuxing for " << ToString();
185 return false;
186 }
187 rtp_transport_->SignalReadyToSend.connect(
188 this, &BaseChannel::OnTransportReadyToSend);
189 rtp_transport_->SignalNetworkRouteChanged.connect(
190 this, &BaseChannel::OnNetworkRouteChanged);
191 rtp_transport_->SignalWritableState.connect(this,
192 &BaseChannel::OnWritableState);
193 rtp_transport_->SignalSentPacket.connect(this,
194 &BaseChannel::SignalSentPacket_n);
195 return true;
196 }
197
DisconnectFromRtpTransport()198 void BaseChannel::DisconnectFromRtpTransport() {
199 RTC_DCHECK(rtp_transport_);
200 rtp_transport_->UnregisterRtpDemuxerSink(this);
201 rtp_transport_->SignalReadyToSend.disconnect(this);
202 rtp_transport_->SignalNetworkRouteChanged.disconnect(this);
203 rtp_transport_->SignalWritableState.disconnect(this);
204 rtp_transport_->SignalSentPacket.disconnect(this);
205 }
206
Init_w(webrtc::RtpTransportInternal * rtp_transport)207 void BaseChannel::Init_w(webrtc::RtpTransportInternal* rtp_transport) {
208 RTC_DCHECK_RUN_ON(worker_thread());
209
210 network_thread_->Invoke<void>(
211 RTC_FROM_HERE, [this, rtp_transport] { SetRtpTransport(rtp_transport); });
212
213 // Both RTP and RTCP channels should be set, we can call SetInterface on
214 // the media channel and it can set network options.
215 media_channel_->SetInterface(this);
216 }
217
Deinit()218 void BaseChannel::Deinit() {
219 RTC_DCHECK_RUN_ON(worker_thread());
220 media_channel_->SetInterface(/*iface=*/nullptr);
221 // Packets arrive on the network thread, processing packets calls virtual
222 // functions, so need to stop this process in Deinit that is called in
223 // derived classes destructor.
224 network_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
225 RTC_DCHECK_RUN_ON(network_thread());
226 FlushRtcpMessages_n();
227
228 if (rtp_transport_) {
229 DisconnectFromRtpTransport();
230 }
231 // Clear pending read packets/messages.
232 network_thread_->Clear(this);
233 });
234 }
235
SetRtpTransport(webrtc::RtpTransportInternal * rtp_transport)236 bool BaseChannel::SetRtpTransport(webrtc::RtpTransportInternal* rtp_transport) {
237 RTC_DCHECK_RUN_ON(network_thread());
238 if (rtp_transport == rtp_transport_) {
239 return true;
240 }
241
242 if (rtp_transport_) {
243 DisconnectFromRtpTransport();
244 }
245
246 rtp_transport_ = rtp_transport;
247 if (rtp_transport_) {
248 transport_name_ = rtp_transport_->transport_name();
249
250 if (!ConnectToRtpTransport()) {
251 RTC_LOG(LS_ERROR) << "Failed to connect to the new RtpTransport for "
252 << ToString() << ".";
253 return false;
254 }
255 OnTransportReadyToSend(rtp_transport_->IsReadyToSend());
256 UpdateWritableState_n();
257
258 // Set the cached socket options.
259 for (const auto& pair : socket_options_) {
260 rtp_transport_->SetRtpOption(pair.first, pair.second);
261 }
262 if (!rtp_transport_->rtcp_mux_enabled()) {
263 for (const auto& pair : rtcp_socket_options_) {
264 rtp_transport_->SetRtcpOption(pair.first, pair.second);
265 }
266 }
267 }
268 return true;
269 }
270
Enable(bool enable)271 bool BaseChannel::Enable(bool enable) {
272 worker_thread_->Invoke<void>(RTC_FROM_HERE, [this, enable] {
273 RTC_DCHECK_RUN_ON(worker_thread());
274 if (enable) {
275 EnableMedia_w();
276 } else {
277 DisableMedia_w();
278 }
279 });
280 return true;
281 }
282
SetLocalContent(const MediaContentDescription * content,SdpType type,std::string * error_desc)283 bool BaseChannel::SetLocalContent(const MediaContentDescription* content,
284 SdpType type,
285 std::string* error_desc) {
286 TRACE_EVENT0("webrtc", "BaseChannel::SetLocalContent");
287 return InvokeOnWorker<bool>(RTC_FROM_HERE, [this, content, type, error_desc] {
288 RTC_DCHECK_RUN_ON(worker_thread());
289 return SetLocalContent_w(content, type, error_desc);
290 });
291 }
292
SetRemoteContent(const MediaContentDescription * content,SdpType type,std::string * error_desc)293 bool BaseChannel::SetRemoteContent(const MediaContentDescription* content,
294 SdpType type,
295 std::string* error_desc) {
296 TRACE_EVENT0("webrtc", "BaseChannel::SetRemoteContent");
297 return InvokeOnWorker<bool>(RTC_FROM_HERE, [this, content, type, error_desc] {
298 RTC_DCHECK_RUN_ON(worker_thread());
299 return SetRemoteContent_w(content, type, error_desc);
300 });
301 }
302
SetPayloadTypeDemuxingEnabled(bool enabled)303 bool BaseChannel::SetPayloadTypeDemuxingEnabled(bool enabled) {
304 TRACE_EVENT0("webrtc", "BaseChannel::SetPayloadTypeDemuxingEnabled");
305 return InvokeOnWorker<bool>(RTC_FROM_HERE, [this, enabled] {
306 RTC_DCHECK_RUN_ON(worker_thread());
307 return SetPayloadTypeDemuxingEnabled_w(enabled);
308 });
309 }
310
IsReadyToReceiveMedia_w() const311 bool BaseChannel::IsReadyToReceiveMedia_w() const {
312 // Receive data if we are enabled and have local content,
313 return enabled() &&
314 webrtc::RtpTransceiverDirectionHasRecv(local_content_direction_);
315 }
316
IsReadyToSendMedia_w() const317 bool BaseChannel::IsReadyToSendMedia_w() const {
318 // Send outgoing data if we are enabled, have local and remote content,
319 // and we have had some form of connectivity.
320 return enabled() &&
321 webrtc::RtpTransceiverDirectionHasRecv(remote_content_direction_) &&
322 webrtc::RtpTransceiverDirectionHasSend(local_content_direction_) &&
323 was_ever_writable();
324 }
325
SendPacket(rtc::CopyOnWriteBuffer * packet,const rtc::PacketOptions & options)326 bool BaseChannel::SendPacket(rtc::CopyOnWriteBuffer* packet,
327 const rtc::PacketOptions& options) {
328 return SendPacket(false, packet, options);
329 }
330
SendRtcp(rtc::CopyOnWriteBuffer * packet,const rtc::PacketOptions & options)331 bool BaseChannel::SendRtcp(rtc::CopyOnWriteBuffer* packet,
332 const rtc::PacketOptions& options) {
333 return SendPacket(true, packet, options);
334 }
335
SetOption(SocketType type,rtc::Socket::Option opt,int value)336 int BaseChannel::SetOption(SocketType type,
337 rtc::Socket::Option opt,
338 int value) {
339 return network_thread_->Invoke<int>(RTC_FROM_HERE, [this, type, opt, value] {
340 RTC_DCHECK_RUN_ON(network_thread());
341 return SetOption_n(type, opt, value);
342 });
343 }
344
SetOption_n(SocketType type,rtc::Socket::Option opt,int value)345 int BaseChannel::SetOption_n(SocketType type,
346 rtc::Socket::Option opt,
347 int value) {
348 RTC_DCHECK(rtp_transport_);
349 switch (type) {
350 case ST_RTP:
351 socket_options_.push_back(
352 std::pair<rtc::Socket::Option, int>(opt, value));
353 return rtp_transport_->SetRtpOption(opt, value);
354 case ST_RTCP:
355 rtcp_socket_options_.push_back(
356 std::pair<rtc::Socket::Option, int>(opt, value));
357 return rtp_transport_->SetRtcpOption(opt, value);
358 }
359 return -1;
360 }
361
OnWritableState(bool writable)362 void BaseChannel::OnWritableState(bool writable) {
363 RTC_DCHECK_RUN_ON(network_thread());
364 if (writable) {
365 ChannelWritable_n();
366 } else {
367 ChannelNotWritable_n();
368 }
369 }
370
OnNetworkRouteChanged(absl::optional<rtc::NetworkRoute> network_route)371 void BaseChannel::OnNetworkRouteChanged(
372 absl::optional<rtc::NetworkRoute> network_route) {
373 RTC_LOG(LS_INFO) << "Network route changed for " << ToString();
374
375 RTC_DCHECK_RUN_ON(network_thread());
376 rtc::NetworkRoute new_route;
377 if (network_route) {
378 new_route = *(network_route);
379 }
380 // Note: When the RTCP-muxing is not enabled, RTCP transport and RTP transport
381 // use the same transport name and MediaChannel::OnNetworkRouteChanged cannot
382 // work correctly. Intentionally leave it broken to simplify the code and
383 // encourage the users to stop using non-muxing RTCP.
384 media_channel_->OnNetworkRouteChanged(transport_name_, new_route);
385 }
386
SignalFirstPacketReceived()387 sigslot::signal1<ChannelInterface*>& BaseChannel::SignalFirstPacketReceived() {
388 RTC_DCHECK_RUN_ON(signaling_thread_);
389 return SignalFirstPacketReceived_;
390 }
391
SignalSentPacket()392 sigslot::signal1<const rtc::SentPacket&>& BaseChannel::SignalSentPacket() {
393 // TODO(bugs.webrtc.org/11994): Uncomment this check once callers have been
394 // fixed to access this variable from the correct thread.
395 // RTC_DCHECK_RUN_ON(worker_thread_);
396 return SignalSentPacket_;
397 }
398
OnTransportReadyToSend(bool ready)399 void BaseChannel::OnTransportReadyToSend(bool ready) {
400 RTC_DCHECK_RUN_ON(network_thread());
401 media_channel_->OnReadyToSend(ready);
402 }
403
SendPacket(bool rtcp,rtc::CopyOnWriteBuffer * packet,const rtc::PacketOptions & options)404 bool BaseChannel::SendPacket(bool rtcp,
405 rtc::CopyOnWriteBuffer* packet,
406 const rtc::PacketOptions& options) {
407 // Until all the code is migrated to use RtpPacketType instead of bool.
408 RtpPacketType packet_type = rtcp ? RtpPacketType::kRtcp : RtpPacketType::kRtp;
409 // SendPacket gets called from MediaEngine, on a pacer or an encoder thread.
410 // If the thread is not our network thread, we will post to our network
411 // so that the real work happens on our network. This avoids us having to
412 // synchronize access to all the pieces of the send path, including
413 // SRTP and the inner workings of the transport channels.
414 // The only downside is that we can't return a proper failure code if
415 // needed. Since UDP is unreliable anyway, this should be a non-issue.
416 if (!network_thread_->IsCurrent()) {
417 // Avoid a copy by transferring the ownership of the packet data.
418 int message_id = rtcp ? MSG_SEND_RTCP_PACKET : MSG_SEND_RTP_PACKET;
419 SendPacketMessageData* data = new SendPacketMessageData;
420 data->packet = std::move(*packet);
421 data->options = options;
422 network_thread_->Post(RTC_FROM_HERE, this, message_id, data);
423 return true;
424 }
425 RTC_DCHECK_RUN_ON(network_thread());
426
427 TRACE_EVENT0("webrtc", "BaseChannel::SendPacket");
428
429 // Now that we are on the correct thread, ensure we have a place to send this
430 // packet before doing anything. (We might get RTCP packets that we don't
431 // intend to send.) If we've negotiated RTCP mux, send RTCP over the RTP
432 // transport.
433 if (!rtp_transport_ || !rtp_transport_->IsWritable(rtcp)) {
434 return false;
435 }
436
437 // Protect ourselves against crazy data.
438 if (!IsValidRtpPacketSize(packet_type, packet->size())) {
439 RTC_LOG(LS_ERROR) << "Dropping outgoing " << ToString() << " "
440 << RtpPacketTypeToString(packet_type)
441 << " packet: wrong size=" << packet->size();
442 return false;
443 }
444
445 if (!srtp_active()) {
446 if (srtp_required_) {
447 // The audio/video engines may attempt to send RTCP packets as soon as the
448 // streams are created, so don't treat this as an error for RTCP.
449 // See: https://bugs.chromium.org/p/webrtc/issues/detail?id=6809
450 if (rtcp) {
451 return false;
452 }
453 // However, there shouldn't be any RTP packets sent before SRTP is set up
454 // (and SetSend(true) is called).
455 RTC_LOG(LS_ERROR) << "Can't send outgoing RTP packet for " << ToString()
456 << " when SRTP is inactive and crypto is required";
457 RTC_NOTREACHED();
458 return false;
459 }
460
461 std::string packet_type = rtcp ? "RTCP" : "RTP";
462 RTC_DLOG(LS_WARNING) << "Sending an " << packet_type
463 << " packet without encryption for " << ToString()
464 << ".";
465 }
466
467 // Bon voyage.
468 return rtcp ? rtp_transport_->SendRtcpPacket(packet, options, PF_SRTP_BYPASS)
469 : rtp_transport_->SendRtpPacket(packet, options, PF_SRTP_BYPASS);
470 }
471
OnRtpPacket(const webrtc::RtpPacketReceived & parsed_packet)472 void BaseChannel::OnRtpPacket(const webrtc::RtpPacketReceived& parsed_packet) {
473 // Take packet time from the |parsed_packet|.
474 // RtpPacketReceived.arrival_time_ms = (timestamp_us + 500) / 1000;
475 int64_t packet_time_us = -1;
476 if (parsed_packet.arrival_time_ms() > 0) {
477 packet_time_us = parsed_packet.arrival_time_ms() * 1000;
478 }
479
480 if (!has_received_packet_) {
481 has_received_packet_ = true;
482 signaling_thread()->Post(RTC_FROM_HERE, this, MSG_FIRSTPACKETRECEIVED);
483 }
484
485 if (!srtp_active() && srtp_required_) {
486 // Our session description indicates that SRTP is required, but we got a
487 // packet before our SRTP filter is active. This means either that
488 // a) we got SRTP packets before we received the SDES keys, in which case
489 // we can't decrypt it anyway, or
490 // b) we got SRTP packets before DTLS completed on both the RTP and RTCP
491 // transports, so we haven't yet extracted keys, even if DTLS did
492 // complete on the transport that the packets are being sent on. It's
493 // really good practice to wait for both RTP and RTCP to be good to go
494 // before sending media, to prevent weird failure modes, so it's fine
495 // for us to just eat packets here. This is all sidestepped if RTCP mux
496 // is used anyway.
497 RTC_LOG(LS_WARNING) << "Can't process incoming RTP packet when "
498 "SRTP is inactive and crypto is required "
499 << ToString();
500 return;
501 }
502
503 media_channel_->OnPacketReceived(parsed_packet.Buffer(), packet_time_us);
504 }
505
UpdateRtpHeaderExtensionMap(const RtpHeaderExtensions & header_extensions)506 void BaseChannel::UpdateRtpHeaderExtensionMap(
507 const RtpHeaderExtensions& header_extensions) {
508 // Update the header extension map on network thread in case there is data
509 // race.
510 //
511 // NOTE: This doesn't take the BUNDLE case in account meaning the RTP header
512 // extension maps are not merged when BUNDLE is enabled. This is fine because
513 // the ID for MID should be consistent among all the RTP transports.
514 network_thread_->Invoke<void>(RTC_FROM_HERE, [this, &header_extensions] {
515 RTC_DCHECK_RUN_ON(network_thread());
516 rtp_transport_->UpdateRtpHeaderExtensionMap(header_extensions);
517 });
518 }
519
RegisterRtpDemuxerSink_w()520 bool BaseChannel::RegisterRtpDemuxerSink_w() {
521 if (demuxer_criteria_ == previous_demuxer_criteria_) {
522 return true;
523 }
524 media_channel_->OnDemuxerCriteriaUpdatePending();
525 // Copy demuxer criteria, since they're a worker-thread variable
526 // and we want to pass them to the network thread
527 return network_thread_->Invoke<bool>(
528 RTC_FROM_HERE, [this, demuxer_criteria = demuxer_criteria_] {
529 RTC_DCHECK_RUN_ON(network_thread());
530 RTC_DCHECK(rtp_transport_);
531 bool result =
532 rtp_transport_->RegisterRtpDemuxerSink(demuxer_criteria, this);
533 if (result) {
534 previous_demuxer_criteria_ = demuxer_criteria;
535 } else {
536 previous_demuxer_criteria_ = {};
537 }
538 media_channel_->OnDemuxerCriteriaUpdateComplete();
539 return result;
540 });
541 }
542
EnableMedia_w()543 void BaseChannel::EnableMedia_w() {
544 if (enabled_)
545 return;
546
547 RTC_LOG(LS_INFO) << "Channel enabled: " << ToString();
548 enabled_ = true;
549 UpdateMediaSendRecvState_w();
550 }
551
DisableMedia_w()552 void BaseChannel::DisableMedia_w() {
553 if (!enabled_)
554 return;
555
556 RTC_LOG(LS_INFO) << "Channel disabled: " << ToString();
557 enabled_ = false;
558 UpdateMediaSendRecvState_w();
559 }
560
UpdateWritableState_n()561 void BaseChannel::UpdateWritableState_n() {
562 if (rtp_transport_->IsWritable(/*rtcp=*/true) &&
563 rtp_transport_->IsWritable(/*rtcp=*/false)) {
564 ChannelWritable_n();
565 } else {
566 ChannelNotWritable_n();
567 }
568 }
569
ChannelWritable_n()570 void BaseChannel::ChannelWritable_n() {
571 if (writable_) {
572 return;
573 }
574 writable_ = true;
575 RTC_LOG(LS_INFO) << "Channel writable (" << ToString() << ")"
576 << (was_ever_writable_n_ ? "" : " for the first time");
577 // We only have to do this PostTask once, when first transitioning to
578 // writable.
579 if (!was_ever_writable_n_) {
580 worker_thread_->PostTask(ToQueuedTask(alive_, [this] {
581 RTC_DCHECK_RUN_ON(worker_thread());
582 was_ever_writable_ = true;
583 UpdateMediaSendRecvState_w();
584 }));
585 }
586 was_ever_writable_n_ = true;
587 }
588
ChannelNotWritable_n()589 void BaseChannel::ChannelNotWritable_n() {
590 if (!writable_) {
591 return;
592 }
593 writable_ = false;
594 RTC_LOG(LS_INFO) << "Channel not writable (" << ToString() << ")";
595 }
596
AddRecvStream_w(const StreamParams & sp)597 bool BaseChannel::AddRecvStream_w(const StreamParams& sp) {
598 return media_channel()->AddRecvStream(sp);
599 }
600
RemoveRecvStream_w(uint32_t ssrc)601 bool BaseChannel::RemoveRecvStream_w(uint32_t ssrc) {
602 return media_channel()->RemoveRecvStream(ssrc);
603 }
604
ResetUnsignaledRecvStream_w()605 void BaseChannel::ResetUnsignaledRecvStream_w() {
606 media_channel()->ResetUnsignaledRecvStream();
607 }
608
SetPayloadTypeDemuxingEnabled_w(bool enabled)609 bool BaseChannel::SetPayloadTypeDemuxingEnabled_w(bool enabled) {
610 if (enabled == payload_type_demuxing_enabled_) {
611 return true;
612 }
613 payload_type_demuxing_enabled_ = enabled;
614 if (!enabled) {
615 // TODO(crbug.com/11477): This will remove *all* unsignaled streams (those
616 // without an explicitly signaled SSRC), which may include streams that
617 // were matched to this channel by MID or RID. Ideally we'd remove only the
618 // streams that were matched based on payload type alone, but currently
619 // there is no straightforward way to identify those streams.
620 media_channel()->ResetUnsignaledRecvStream();
621 demuxer_criteria_.payload_types.clear();
622 if (!RegisterRtpDemuxerSink_w()) {
623 RTC_LOG(LS_ERROR) << "Failed to disable payload type demuxing for "
624 << ToString();
625 return false;
626 }
627 } else if (!payload_types_.empty()) {
628 demuxer_criteria_.payload_types.insert(payload_types_.begin(),
629 payload_types_.end());
630 if (!RegisterRtpDemuxerSink_w()) {
631 RTC_LOG(LS_ERROR) << "Failed to enable payload type demuxing for "
632 << ToString();
633 return false;
634 }
635 }
636 return true;
637 }
638
UpdateLocalStreams_w(const std::vector<StreamParams> & streams,SdpType type,std::string * error_desc)639 bool BaseChannel::UpdateLocalStreams_w(const std::vector<StreamParams>& streams,
640 SdpType type,
641 std::string* error_desc) {
642 // In the case of RIDs (where SSRCs are not negotiated), this method will
643 // generate an SSRC for each layer in StreamParams. That representation will
644 // be stored internally in |local_streams_|.
645 // In subsequent offers, the same stream can appear in |streams| again
646 // (without the SSRCs), so it should be looked up using RIDs (if available)
647 // and then by primary SSRC.
648 // In both scenarios, it is safe to assume that the media channel will be
649 // created with a StreamParams object with SSRCs. However, it is not safe to
650 // assume that |local_streams_| will always have SSRCs as there are scenarios
651 // in which niether SSRCs or RIDs are negotiated.
652
653 // Check for streams that have been removed.
654 bool ret = true;
655 for (const StreamParams& old_stream : local_streams_) {
656 if (!old_stream.has_ssrcs() ||
657 GetStream(streams, StreamFinder(&old_stream))) {
658 continue;
659 }
660 if (!media_channel()->RemoveSendStream(old_stream.first_ssrc())) {
661 rtc::StringBuilder desc;
662 desc << "Failed to remove send stream with ssrc "
663 << old_stream.first_ssrc() << " from m-section with mid='"
664 << content_name() << "'.";
665 SafeSetError(desc.str(), error_desc);
666 ret = false;
667 }
668 }
669 // Check for new streams.
670 std::vector<StreamParams> all_streams;
671 for (const StreamParams& stream : streams) {
672 StreamParams* existing = GetStream(local_streams_, StreamFinder(&stream));
673 if (existing) {
674 // Parameters cannot change for an existing stream.
675 all_streams.push_back(*existing);
676 continue;
677 }
678
679 all_streams.push_back(stream);
680 StreamParams& new_stream = all_streams.back();
681
682 if (!new_stream.has_ssrcs() && !new_stream.has_rids()) {
683 continue;
684 }
685
686 RTC_DCHECK(new_stream.has_ssrcs() || new_stream.has_rids());
687 if (new_stream.has_ssrcs() && new_stream.has_rids()) {
688 rtc::StringBuilder desc;
689 desc << "Failed to add send stream: " << new_stream.first_ssrc()
690 << " into m-section with mid='" << content_name()
691 << "'. Stream has both SSRCs and RIDs.";
692 SafeSetError(desc.str(), error_desc);
693 ret = false;
694 continue;
695 }
696
697 // At this point we use the legacy simulcast group in StreamParams to
698 // indicate that we want multiple layers to the media channel.
699 if (!new_stream.has_ssrcs()) {
700 // TODO(bugs.webrtc.org/10250): Indicate if flex is desired here.
701 new_stream.GenerateSsrcs(new_stream.rids().size(), /* rtx = */ true,
702 /* flex_fec = */ false, ssrc_generator_);
703 }
704
705 if (media_channel()->AddSendStream(new_stream)) {
706 RTC_LOG(LS_INFO) << "Add send stream ssrc: " << new_stream.ssrcs[0]
707 << " into " << ToString();
708 } else {
709 rtc::StringBuilder desc;
710 desc << "Failed to add send stream ssrc: " << new_stream.first_ssrc()
711 << " into m-section with mid='" << content_name() << "'";
712 SafeSetError(desc.str(), error_desc);
713 ret = false;
714 }
715 }
716 local_streams_ = all_streams;
717 return ret;
718 }
719
UpdateRemoteStreams_w(const std::vector<StreamParams> & streams,SdpType type,std::string * error_desc)720 bool BaseChannel::UpdateRemoteStreams_w(
721 const std::vector<StreamParams>& streams,
722 SdpType type,
723 std::string* error_desc) {
724 // Check for streams that have been removed.
725 bool ret = true;
726 for (const StreamParams& old_stream : remote_streams_) {
727 // If we no longer have an unsignaled stream, we would like to remove
728 // the unsignaled stream params that are cached.
729 if (!old_stream.has_ssrcs() && !HasStreamWithNoSsrcs(streams)) {
730 ResetUnsignaledRecvStream_w();
731 RTC_LOG(LS_INFO) << "Reset unsignaled remote stream for " << ToString()
732 << ".";
733 } else if (old_stream.has_ssrcs() &&
734 !GetStreamBySsrc(streams, old_stream.first_ssrc())) {
735 if (RemoveRecvStream_w(old_stream.first_ssrc())) {
736 RTC_LOG(LS_INFO) << "Remove remote ssrc: " << old_stream.first_ssrc()
737 << " from " << ToString() << ".";
738 } else {
739 rtc::StringBuilder desc;
740 desc << "Failed to remove remote stream with ssrc "
741 << old_stream.first_ssrc() << " from m-section with mid='"
742 << content_name() << "'.";
743 SafeSetError(desc.str(), error_desc);
744 ret = false;
745 }
746 }
747 }
748 demuxer_criteria_.ssrcs.clear();
749 // Check for new streams.
750 for (const StreamParams& new_stream : streams) {
751 // We allow a StreamParams with an empty list of SSRCs, in which case the
752 // MediaChannel will cache the parameters and use them for any unsignaled
753 // stream received later.
754 if ((!new_stream.has_ssrcs() && !HasStreamWithNoSsrcs(remote_streams_)) ||
755 !GetStreamBySsrc(remote_streams_, new_stream.first_ssrc())) {
756 if (AddRecvStream_w(new_stream)) {
757 RTC_LOG(LS_INFO) << "Add remote ssrc: "
758 << (new_stream.has_ssrcs()
759 ? std::to_string(new_stream.first_ssrc())
760 : "unsignaled")
761 << " to " << ToString();
762 } else {
763 rtc::StringBuilder desc;
764 desc << "Failed to add remote stream ssrc: "
765 << (new_stream.has_ssrcs()
766 ? std::to_string(new_stream.first_ssrc())
767 : "unsignaled")
768 << " to " << ToString();
769 SafeSetError(desc.str(), error_desc);
770 ret = false;
771 }
772 }
773 // Update the receiving SSRCs.
774 demuxer_criteria_.ssrcs.insert(new_stream.ssrcs.begin(),
775 new_stream.ssrcs.end());
776 }
777 // Re-register the sink to update the receiving ssrcs.
778 if (!RegisterRtpDemuxerSink_w()) {
779 RTC_LOG(LS_ERROR) << "Failed to set up demuxing for " << ToString();
780 ret = false;
781 }
782 remote_streams_ = streams;
783 return ret;
784 }
785
GetFilteredRtpHeaderExtensions(const RtpHeaderExtensions & extensions)786 RtpHeaderExtensions BaseChannel::GetFilteredRtpHeaderExtensions(
787 const RtpHeaderExtensions& extensions) {
788 if (crypto_options_.srtp.enable_encrypted_rtp_header_extensions) {
789 RtpHeaderExtensions filtered;
790 absl::c_copy_if(extensions, std::back_inserter(filtered),
791 [](const webrtc::RtpExtension& extension) {
792 return !extension.encrypt;
793 });
794 return filtered;
795 }
796
797 return webrtc::RtpExtension::FilterDuplicateNonEncrypted(extensions);
798 }
799
OnMessage(rtc::Message * pmsg)800 void BaseChannel::OnMessage(rtc::Message* pmsg) {
801 TRACE_EVENT0("webrtc", "BaseChannel::OnMessage");
802 switch (pmsg->message_id) {
803 case MSG_SEND_RTP_PACKET:
804 case MSG_SEND_RTCP_PACKET: {
805 RTC_DCHECK_RUN_ON(network_thread());
806 SendPacketMessageData* data =
807 static_cast<SendPacketMessageData*>(pmsg->pdata);
808 bool rtcp = pmsg->message_id == MSG_SEND_RTCP_PACKET;
809 SendPacket(rtcp, &data->packet, data->options);
810 delete data;
811 break;
812 }
813 case MSG_FIRSTPACKETRECEIVED: {
814 RTC_DCHECK_RUN_ON(signaling_thread_);
815 SignalFirstPacketReceived_(this);
816 break;
817 }
818 }
819 }
820
MaybeAddHandledPayloadType(int payload_type)821 void BaseChannel::MaybeAddHandledPayloadType(int payload_type) {
822 if (payload_type_demuxing_enabled_) {
823 demuxer_criteria_.payload_types.insert(static_cast<uint8_t>(payload_type));
824 }
825 // Even if payload type demuxing is currently disabled, we need to remember
826 // the payload types in case it's re-enabled later.
827 payload_types_.insert(static_cast<uint8_t>(payload_type));
828 }
829
ClearHandledPayloadTypes()830 void BaseChannel::ClearHandledPayloadTypes() {
831 demuxer_criteria_.payload_types.clear();
832 payload_types_.clear();
833 }
834
FlushRtcpMessages_n()835 void BaseChannel::FlushRtcpMessages_n() {
836 // Flush all remaining RTCP messages. This should only be called in
837 // destructor.
838 rtc::MessageList rtcp_messages;
839 network_thread_->Clear(this, MSG_SEND_RTCP_PACKET, &rtcp_messages);
840 for (const auto& message : rtcp_messages) {
841 network_thread_->Send(RTC_FROM_HERE, this, MSG_SEND_RTCP_PACKET,
842 message.pdata);
843 }
844 }
845
SignalSentPacket_n(const rtc::SentPacket & sent_packet)846 void BaseChannel::SignalSentPacket_n(const rtc::SentPacket& sent_packet) {
847 worker_thread_->PostTask(ToQueuedTask(alive_, [this, sent_packet] {
848 RTC_DCHECK_RUN_ON(worker_thread());
849 SignalSentPacket()(sent_packet);
850 }));
851 }
852
SetNegotiatedHeaderExtensions_w(const RtpHeaderExtensions & extensions)853 void BaseChannel::SetNegotiatedHeaderExtensions_w(
854 const RtpHeaderExtensions& extensions) {
855 TRACE_EVENT0("webrtc", __func__);
856 webrtc::MutexLock lock(&negotiated_header_extensions_lock_);
857 negotiated_header_extensions_ = extensions;
858 }
859
GetNegotiatedRtpHeaderExtensions() const860 RtpHeaderExtensions BaseChannel::GetNegotiatedRtpHeaderExtensions() const {
861 RTC_DCHECK_RUN_ON(signaling_thread());
862 webrtc::MutexLock lock(&negotiated_header_extensions_lock_);
863 return negotiated_header_extensions_;
864 }
865
VoiceChannel(rtc::Thread * worker_thread,rtc::Thread * network_thread,rtc::Thread * signaling_thread,std::unique_ptr<VoiceMediaChannel> media_channel,const std::string & content_name,bool srtp_required,webrtc::CryptoOptions crypto_options,UniqueRandomIdGenerator * ssrc_generator)866 VoiceChannel::VoiceChannel(rtc::Thread* worker_thread,
867 rtc::Thread* network_thread,
868 rtc::Thread* signaling_thread,
869 std::unique_ptr<VoiceMediaChannel> media_channel,
870 const std::string& content_name,
871 bool srtp_required,
872 webrtc::CryptoOptions crypto_options,
873 UniqueRandomIdGenerator* ssrc_generator)
874 : BaseChannel(worker_thread,
875 network_thread,
876 signaling_thread,
877 std::move(media_channel),
878 content_name,
879 srtp_required,
880 crypto_options,
881 ssrc_generator) {}
882
~VoiceChannel()883 VoiceChannel::~VoiceChannel() {
884 TRACE_EVENT0("webrtc", "VoiceChannel::~VoiceChannel");
885 // this can't be done in the base class, since it calls a virtual
886 DisableMedia_w();
887 Deinit();
888 }
889
UpdateMediaSendRecvState_w()890 void VoiceChannel::UpdateMediaSendRecvState_w() {
891 // Render incoming data if we're the active call, and we have the local
892 // content. We receive data on the default channel and multiplexed streams.
893 RTC_DCHECK_RUN_ON(worker_thread());
894 bool recv = IsReadyToReceiveMedia_w();
895 media_channel()->SetPlayout(recv);
896
897 // Send outgoing data if we're the active call, we have the remote content,
898 // and we have had some form of connectivity.
899 bool send = IsReadyToSendMedia_w();
900 media_channel()->SetSend(send);
901
902 RTC_LOG(LS_INFO) << "Changing voice state, recv=" << recv << " send=" << send
903 << " for " << ToString();
904 }
905
SetLocalContent_w(const MediaContentDescription * content,SdpType type,std::string * error_desc)906 bool VoiceChannel::SetLocalContent_w(const MediaContentDescription* content,
907 SdpType type,
908 std::string* error_desc) {
909 TRACE_EVENT0("webrtc", "VoiceChannel::SetLocalContent_w");
910 RTC_DCHECK_RUN_ON(worker_thread());
911 RTC_LOG(LS_INFO) << "Setting local voice description for " << ToString();
912
913 RTC_DCHECK(content);
914 if (!content) {
915 SafeSetError("Can't find audio content in local description.", error_desc);
916 return false;
917 }
918
919 const AudioContentDescription* audio = content->as_audio();
920
921 if (type == SdpType::kAnswer)
922 SetNegotiatedHeaderExtensions_w(audio->rtp_header_extensions());
923
924 RtpHeaderExtensions rtp_header_extensions =
925 GetFilteredRtpHeaderExtensions(audio->rtp_header_extensions());
926 UpdateRtpHeaderExtensionMap(rtp_header_extensions);
927 media_channel()->SetExtmapAllowMixed(audio->extmap_allow_mixed());
928
929 AudioRecvParameters recv_params = last_recv_params_;
930 RtpParametersFromMediaDescription(
931 audio, rtp_header_extensions,
932 webrtc::RtpTransceiverDirectionHasRecv(audio->direction()), &recv_params);
933 if (!media_channel()->SetRecvParameters(recv_params)) {
934 SafeSetError(
935 "Failed to set local audio description recv parameters for m-section "
936 "with mid='" +
937 content_name() + "'.",
938 error_desc);
939 return false;
940 }
941
942 if (webrtc::RtpTransceiverDirectionHasRecv(audio->direction())) {
943 for (const AudioCodec& codec : audio->codecs()) {
944 MaybeAddHandledPayloadType(codec.id);
945 }
946 // Need to re-register the sink to update the handled payload.
947 if (!RegisterRtpDemuxerSink_w()) {
948 RTC_LOG(LS_ERROR) << "Failed to set up audio demuxing for " << ToString();
949 return false;
950 }
951 }
952
953 last_recv_params_ = recv_params;
954
955 // TODO(pthatcher): Move local streams into AudioSendParameters, and
956 // only give it to the media channel once we have a remote
957 // description too (without a remote description, we won't be able
958 // to send them anyway).
959 if (!UpdateLocalStreams_w(audio->streams(), type, error_desc)) {
960 SafeSetError(
961 "Failed to set local audio description streams for m-section with "
962 "mid='" +
963 content_name() + "'.",
964 error_desc);
965 return false;
966 }
967
968 set_local_content_direction(content->direction());
969 UpdateMediaSendRecvState_w();
970 return true;
971 }
972
SetRemoteContent_w(const MediaContentDescription * content,SdpType type,std::string * error_desc)973 bool VoiceChannel::SetRemoteContent_w(const MediaContentDescription* content,
974 SdpType type,
975 std::string* error_desc) {
976 TRACE_EVENT0("webrtc", "VoiceChannel::SetRemoteContent_w");
977 RTC_DCHECK_RUN_ON(worker_thread());
978 RTC_LOG(LS_INFO) << "Setting remote voice description for " << ToString();
979
980 RTC_DCHECK(content);
981 if (!content) {
982 SafeSetError("Can't find audio content in remote description.", error_desc);
983 return false;
984 }
985
986 const AudioContentDescription* audio = content->as_audio();
987
988 if (type == SdpType::kAnswer)
989 SetNegotiatedHeaderExtensions_w(audio->rtp_header_extensions());
990
991 RtpHeaderExtensions rtp_header_extensions =
992 GetFilteredRtpHeaderExtensions(audio->rtp_header_extensions());
993
994 AudioSendParameters send_params = last_send_params_;
995 RtpSendParametersFromMediaDescription(
996 audio, rtp_header_extensions,
997 webrtc::RtpTransceiverDirectionHasRecv(audio->direction()), &send_params);
998 send_params.mid = content_name();
999
1000 bool parameters_applied = media_channel()->SetSendParameters(send_params);
1001 if (!parameters_applied) {
1002 SafeSetError(
1003 "Failed to set remote audio description send parameters for m-section "
1004 "with mid='" +
1005 content_name() + "'.",
1006 error_desc);
1007 return false;
1008 }
1009 last_send_params_ = send_params;
1010
1011 if (!webrtc::RtpTransceiverDirectionHasSend(content->direction())) {
1012 RTC_DLOG(LS_VERBOSE) << "SetRemoteContent_w: remote side will not send - "
1013 "disable payload type demuxing for "
1014 << ToString();
1015 ClearHandledPayloadTypes();
1016 if (!RegisterRtpDemuxerSink_w()) {
1017 RTC_LOG(LS_ERROR) << "Failed to update audio demuxing for " << ToString();
1018 return false;
1019 }
1020 }
1021
1022 // TODO(pthatcher): Move remote streams into AudioRecvParameters,
1023 // and only give it to the media channel once we have a local
1024 // description too (without a local description, we won't be able to
1025 // recv them anyway).
1026 if (!UpdateRemoteStreams_w(audio->streams(), type, error_desc)) {
1027 SafeSetError(
1028 "Failed to set remote audio description streams for m-section with "
1029 "mid='" +
1030 content_name() + "'.",
1031 error_desc);
1032 return false;
1033 }
1034
1035 set_remote_content_direction(content->direction());
1036 UpdateMediaSendRecvState_w();
1037 return true;
1038 }
1039
VideoChannel(rtc::Thread * worker_thread,rtc::Thread * network_thread,rtc::Thread * signaling_thread,std::unique_ptr<VideoMediaChannel> media_channel,const std::string & content_name,bool srtp_required,webrtc::CryptoOptions crypto_options,UniqueRandomIdGenerator * ssrc_generator)1040 VideoChannel::VideoChannel(rtc::Thread* worker_thread,
1041 rtc::Thread* network_thread,
1042 rtc::Thread* signaling_thread,
1043 std::unique_ptr<VideoMediaChannel> media_channel,
1044 const std::string& content_name,
1045 bool srtp_required,
1046 webrtc::CryptoOptions crypto_options,
1047 UniqueRandomIdGenerator* ssrc_generator)
1048 : BaseChannel(worker_thread,
1049 network_thread,
1050 signaling_thread,
1051 std::move(media_channel),
1052 content_name,
1053 srtp_required,
1054 crypto_options,
1055 ssrc_generator) {}
1056
~VideoChannel()1057 VideoChannel::~VideoChannel() {
1058 TRACE_EVENT0("webrtc", "VideoChannel::~VideoChannel");
1059 // this can't be done in the base class, since it calls a virtual
1060 DisableMedia_w();
1061 Deinit();
1062 }
1063
UpdateMediaSendRecvState_w()1064 void VideoChannel::UpdateMediaSendRecvState_w() {
1065 // Send outgoing data if we're the active call, we have the remote content,
1066 // and we have had some form of connectivity.
1067 RTC_DCHECK_RUN_ON(worker_thread());
1068 bool send = IsReadyToSendMedia_w();
1069 if (!media_channel()->SetSend(send)) {
1070 RTC_LOG(LS_ERROR) << "Failed to SetSend on video channel: " + ToString();
1071 // TODO(gangji): Report error back to server.
1072 }
1073
1074 RTC_LOG(LS_INFO) << "Changing video state, send=" << send << " for "
1075 << ToString();
1076 }
1077
FillBitrateInfo(BandwidthEstimationInfo * bwe_info)1078 void VideoChannel::FillBitrateInfo(BandwidthEstimationInfo* bwe_info) {
1079 VideoMediaChannel* mc = media_channel();
1080 InvokeOnWorker<void>(RTC_FROM_HERE,
1081 [mc, bwe_info] { mc->FillBitrateInfo(bwe_info); });
1082 }
1083
SetLocalContent_w(const MediaContentDescription * content,SdpType type,std::string * error_desc)1084 bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content,
1085 SdpType type,
1086 std::string* error_desc) {
1087 TRACE_EVENT0("webrtc", "VideoChannel::SetLocalContent_w");
1088 RTC_DCHECK_RUN_ON(worker_thread());
1089 RTC_LOG(LS_INFO) << "Setting local video description for " << ToString();
1090
1091 RTC_DCHECK(content);
1092 if (!content) {
1093 SafeSetError("Can't find video content in local description.", error_desc);
1094 return false;
1095 }
1096
1097 const VideoContentDescription* video = content->as_video();
1098
1099 if (type == SdpType::kAnswer)
1100 SetNegotiatedHeaderExtensions_w(video->rtp_header_extensions());
1101
1102 RtpHeaderExtensions rtp_header_extensions =
1103 GetFilteredRtpHeaderExtensions(video->rtp_header_extensions());
1104 UpdateRtpHeaderExtensionMap(rtp_header_extensions);
1105 media_channel()->SetExtmapAllowMixed(video->extmap_allow_mixed());
1106
1107 VideoRecvParameters recv_params = last_recv_params_;
1108 RtpParametersFromMediaDescription(
1109 video, rtp_header_extensions,
1110 webrtc::RtpTransceiverDirectionHasRecv(video->direction()), &recv_params);
1111
1112 VideoSendParameters send_params = last_send_params_;
1113
1114 bool needs_send_params_update = false;
1115 if (type == SdpType::kAnswer || type == SdpType::kPrAnswer) {
1116 for (auto& send_codec : send_params.codecs) {
1117 auto* recv_codec = FindMatchingCodec(recv_params.codecs, send_codec);
1118 if (recv_codec) {
1119 if (!recv_codec->packetization && send_codec.packetization) {
1120 send_codec.packetization.reset();
1121 needs_send_params_update = true;
1122 } else if (recv_codec->packetization != send_codec.packetization) {
1123 SafeSetError(
1124 "Failed to set local answer due to invalid codec packetization "
1125 "specified in m-section with mid='" +
1126 content_name() + "'.",
1127 error_desc);
1128 return false;
1129 }
1130 }
1131 }
1132 }
1133
1134 if (!media_channel()->SetRecvParameters(recv_params)) {
1135 SafeSetError(
1136 "Failed to set local video description recv parameters for m-section "
1137 "with mid='" +
1138 content_name() + "'.",
1139 error_desc);
1140 return false;
1141 }
1142
1143 if (webrtc::RtpTransceiverDirectionHasRecv(video->direction())) {
1144 for (const VideoCodec& codec : video->codecs()) {
1145 MaybeAddHandledPayloadType(codec.id);
1146 }
1147 // Need to re-register the sink to update the handled payload.
1148 if (!RegisterRtpDemuxerSink_w()) {
1149 RTC_LOG(LS_ERROR) << "Failed to set up video demuxing for " << ToString();
1150 return false;
1151 }
1152 }
1153
1154 last_recv_params_ = recv_params;
1155
1156 if (needs_send_params_update) {
1157 if (!media_channel()->SetSendParameters(send_params)) {
1158 SafeSetError("Failed to set send parameters for m-section with mid='" +
1159 content_name() + "'.",
1160 error_desc);
1161 return false;
1162 }
1163 last_send_params_ = send_params;
1164 }
1165
1166 // TODO(pthatcher): Move local streams into VideoSendParameters, and
1167 // only give it to the media channel once we have a remote
1168 // description too (without a remote description, we won't be able
1169 // to send them anyway).
1170 if (!UpdateLocalStreams_w(video->streams(), type, error_desc)) {
1171 SafeSetError(
1172 "Failed to set local video description streams for m-section with "
1173 "mid='" +
1174 content_name() + "'.",
1175 error_desc);
1176 return false;
1177 }
1178
1179 set_local_content_direction(content->direction());
1180 UpdateMediaSendRecvState_w();
1181 return true;
1182 }
1183
SetRemoteContent_w(const MediaContentDescription * content,SdpType type,std::string * error_desc)1184 bool VideoChannel::SetRemoteContent_w(const MediaContentDescription* content,
1185 SdpType type,
1186 std::string* error_desc) {
1187 TRACE_EVENT0("webrtc", "VideoChannel::SetRemoteContent_w");
1188 RTC_DCHECK_RUN_ON(worker_thread());
1189 RTC_LOG(LS_INFO) << "Setting remote video description for " << ToString();
1190
1191 RTC_DCHECK(content);
1192 if (!content) {
1193 SafeSetError("Can't find video content in remote description.", error_desc);
1194 return false;
1195 }
1196
1197 const VideoContentDescription* video = content->as_video();
1198
1199 if (type == SdpType::kAnswer)
1200 SetNegotiatedHeaderExtensions_w(video->rtp_header_extensions());
1201
1202 RtpHeaderExtensions rtp_header_extensions =
1203 GetFilteredRtpHeaderExtensions(video->rtp_header_extensions());
1204
1205 VideoSendParameters send_params = last_send_params_;
1206 RtpSendParametersFromMediaDescription(
1207 video, rtp_header_extensions,
1208 webrtc::RtpTransceiverDirectionHasRecv(video->direction()), &send_params);
1209 if (video->conference_mode()) {
1210 send_params.conference_mode = true;
1211 }
1212 send_params.mid = content_name();
1213
1214 VideoRecvParameters recv_params = last_recv_params_;
1215
1216 bool needs_recv_params_update = false;
1217 if (type == SdpType::kAnswer || type == SdpType::kPrAnswer) {
1218 for (auto& recv_codec : recv_params.codecs) {
1219 auto* send_codec = FindMatchingCodec(send_params.codecs, recv_codec);
1220 if (send_codec) {
1221 if (!send_codec->packetization && recv_codec.packetization) {
1222 recv_codec.packetization.reset();
1223 needs_recv_params_update = true;
1224 } else if (send_codec->packetization != recv_codec.packetization) {
1225 SafeSetError(
1226 "Failed to set remote answer due to invalid codec packetization "
1227 "specifid in m-section with mid='" +
1228 content_name() + "'.",
1229 error_desc);
1230 return false;
1231 }
1232 }
1233 }
1234 }
1235
1236 if (!media_channel()->SetSendParameters(send_params)) {
1237 SafeSetError(
1238 "Failed to set remote video description send parameters for m-section "
1239 "with mid='" +
1240 content_name() + "'.",
1241 error_desc);
1242 return false;
1243 }
1244 last_send_params_ = send_params;
1245
1246 if (needs_recv_params_update) {
1247 if (!media_channel()->SetRecvParameters(recv_params)) {
1248 SafeSetError("Failed to set recv parameters for m-section with mid='" +
1249 content_name() + "'.",
1250 error_desc);
1251 return false;
1252 }
1253 last_recv_params_ = recv_params;
1254 }
1255
1256 if (!webrtc::RtpTransceiverDirectionHasSend(content->direction())) {
1257 RTC_DLOG(LS_VERBOSE) << "SetRemoteContent_w: remote side will not send - "
1258 "disable payload type demuxing for "
1259 << ToString();
1260 ClearHandledPayloadTypes();
1261 if (!RegisterRtpDemuxerSink_w()) {
1262 RTC_LOG(LS_ERROR) << "Failed to update video demuxing for " << ToString();
1263 return false;
1264 }
1265 }
1266
1267 // TODO(pthatcher): Move remote streams into VideoRecvParameters,
1268 // and only give it to the media channel once we have a local
1269 // description too (without a local description, we won't be able to
1270 // recv them anyway).
1271 if (!UpdateRemoteStreams_w(video->streams(), type, error_desc)) {
1272 SafeSetError(
1273 "Failed to set remote video description streams for m-section with "
1274 "mid='" +
1275 content_name() + "'.",
1276 error_desc);
1277 return false;
1278 }
1279 set_remote_content_direction(content->direction());
1280 UpdateMediaSendRecvState_w();
1281 return true;
1282 }
1283
RtpDataChannel(rtc::Thread * worker_thread,rtc::Thread * network_thread,rtc::Thread * signaling_thread,std::unique_ptr<DataMediaChannel> media_channel,const std::string & content_name,bool srtp_required,webrtc::CryptoOptions crypto_options,UniqueRandomIdGenerator * ssrc_generator)1284 RtpDataChannel::RtpDataChannel(rtc::Thread* worker_thread,
1285 rtc::Thread* network_thread,
1286 rtc::Thread* signaling_thread,
1287 std::unique_ptr<DataMediaChannel> media_channel,
1288 const std::string& content_name,
1289 bool srtp_required,
1290 webrtc::CryptoOptions crypto_options,
1291 UniqueRandomIdGenerator* ssrc_generator)
1292 : BaseChannel(worker_thread,
1293 network_thread,
1294 signaling_thread,
1295 std::move(media_channel),
1296 content_name,
1297 srtp_required,
1298 crypto_options,
1299 ssrc_generator) {}
1300
~RtpDataChannel()1301 RtpDataChannel::~RtpDataChannel() {
1302 TRACE_EVENT0("webrtc", "RtpDataChannel::~RtpDataChannel");
1303 // this can't be done in the base class, since it calls a virtual
1304 DisableMedia_w();
1305 Deinit();
1306 }
1307
Init_w(webrtc::RtpTransportInternal * rtp_transport)1308 void RtpDataChannel::Init_w(webrtc::RtpTransportInternal* rtp_transport) {
1309 BaseChannel::Init_w(rtp_transport);
1310 media_channel()->SignalDataReceived.connect(this,
1311 &RtpDataChannel::OnDataReceived);
1312 media_channel()->SignalReadyToSend.connect(
1313 this, &RtpDataChannel::OnDataChannelReadyToSend);
1314 }
1315
SendData(const SendDataParams & params,const rtc::CopyOnWriteBuffer & payload,SendDataResult * result)1316 bool RtpDataChannel::SendData(const SendDataParams& params,
1317 const rtc::CopyOnWriteBuffer& payload,
1318 SendDataResult* result) {
1319 DataMediaChannel* mc = media_channel();
1320 return InvokeOnWorker<bool>(RTC_FROM_HERE, [mc, ¶ms, &payload, result] {
1321 return mc->SendData(params, payload, result);
1322 });
1323 }
1324
CheckDataChannelTypeFromContent(const MediaContentDescription * content,std::string * error_desc)1325 bool RtpDataChannel::CheckDataChannelTypeFromContent(
1326 const MediaContentDescription* content,
1327 std::string* error_desc) {
1328 if (!content->as_rtp_data()) {
1329 if (content->as_sctp()) {
1330 SafeSetError("Data channel type mismatch. Expected RTP, got SCTP.",
1331 error_desc);
1332 } else {
1333 SafeSetError("Data channel is not RTP or SCTP.", error_desc);
1334 }
1335 return false;
1336 }
1337 return true;
1338 }
1339
SetLocalContent_w(const MediaContentDescription * content,SdpType type,std::string * error_desc)1340 bool RtpDataChannel::SetLocalContent_w(const MediaContentDescription* content,
1341 SdpType type,
1342 std::string* error_desc) {
1343 TRACE_EVENT0("webrtc", "RtpDataChannel::SetLocalContent_w");
1344 RTC_DCHECK_RUN_ON(worker_thread());
1345 RTC_LOG(LS_INFO) << "Setting local data description for " << ToString();
1346
1347 RTC_DCHECK(content);
1348 if (!content) {
1349 SafeSetError("Can't find data content in local description.", error_desc);
1350 return false;
1351 }
1352
1353 if (!CheckDataChannelTypeFromContent(content, error_desc)) {
1354 return false;
1355 }
1356 const RtpDataContentDescription* data = content->as_rtp_data();
1357
1358 RtpHeaderExtensions rtp_header_extensions =
1359 GetFilteredRtpHeaderExtensions(data->rtp_header_extensions());
1360
1361 DataRecvParameters recv_params = last_recv_params_;
1362 RtpParametersFromMediaDescription(
1363 data, rtp_header_extensions,
1364 webrtc::RtpTransceiverDirectionHasRecv(data->direction()), &recv_params);
1365 if (!media_channel()->SetRecvParameters(recv_params)) {
1366 SafeSetError(
1367 "Failed to set remote data description recv parameters for m-section "
1368 "with mid='" +
1369 content_name() + "'.",
1370 error_desc);
1371 return false;
1372 }
1373 for (const DataCodec& codec : data->codecs()) {
1374 MaybeAddHandledPayloadType(codec.id);
1375 }
1376 // Need to re-register the sink to update the handled payload.
1377 if (!RegisterRtpDemuxerSink_w()) {
1378 RTC_LOG(LS_ERROR) << "Failed to set up data demuxing for " << ToString();
1379 return false;
1380 }
1381
1382 last_recv_params_ = recv_params;
1383
1384 // TODO(pthatcher): Move local streams into DataSendParameters, and
1385 // only give it to the media channel once we have a remote
1386 // description too (without a remote description, we won't be able
1387 // to send them anyway).
1388 if (!UpdateLocalStreams_w(data->streams(), type, error_desc)) {
1389 SafeSetError(
1390 "Failed to set local data description streams for m-section with "
1391 "mid='" +
1392 content_name() + "'.",
1393 error_desc);
1394 return false;
1395 }
1396
1397 set_local_content_direction(content->direction());
1398 UpdateMediaSendRecvState_w();
1399 return true;
1400 }
1401
SetRemoteContent_w(const MediaContentDescription * content,SdpType type,std::string * error_desc)1402 bool RtpDataChannel::SetRemoteContent_w(const MediaContentDescription* content,
1403 SdpType type,
1404 std::string* error_desc) {
1405 TRACE_EVENT0("webrtc", "RtpDataChannel::SetRemoteContent_w");
1406 RTC_DCHECK_RUN_ON(worker_thread());
1407 RTC_LOG(LS_INFO) << "Setting remote data description for " << ToString();
1408
1409 RTC_DCHECK(content);
1410 if (!content) {
1411 SafeSetError("Can't find data content in remote description.", error_desc);
1412 return false;
1413 }
1414
1415 if (!CheckDataChannelTypeFromContent(content, error_desc)) {
1416 return false;
1417 }
1418
1419 const RtpDataContentDescription* data = content->as_rtp_data();
1420
1421 // If the remote data doesn't have codecs, it must be empty, so ignore it.
1422 if (!data->has_codecs()) {
1423 return true;
1424 }
1425
1426 RtpHeaderExtensions rtp_header_extensions =
1427 GetFilteredRtpHeaderExtensions(data->rtp_header_extensions());
1428
1429 RTC_LOG(LS_INFO) << "Setting remote data description for " << ToString();
1430 DataSendParameters send_params = last_send_params_;
1431 RtpSendParametersFromMediaDescription<DataCodec>(
1432 data, rtp_header_extensions,
1433 webrtc::RtpTransceiverDirectionHasRecv(data->direction()), &send_params);
1434 if (!media_channel()->SetSendParameters(send_params)) {
1435 SafeSetError(
1436 "Failed to set remote data description send parameters for m-section "
1437 "with mid='" +
1438 content_name() + "'.",
1439 error_desc);
1440 return false;
1441 }
1442 last_send_params_ = send_params;
1443
1444 // TODO(pthatcher): Move remote streams into DataRecvParameters,
1445 // and only give it to the media channel once we have a local
1446 // description too (without a local description, we won't be able to
1447 // recv them anyway).
1448 if (!UpdateRemoteStreams_w(data->streams(), type, error_desc)) {
1449 SafeSetError(
1450 "Failed to set remote data description streams for m-section with "
1451 "mid='" +
1452 content_name() + "'.",
1453 error_desc);
1454 return false;
1455 }
1456
1457 set_remote_content_direction(content->direction());
1458 UpdateMediaSendRecvState_w();
1459 return true;
1460 }
1461
UpdateMediaSendRecvState_w()1462 void RtpDataChannel::UpdateMediaSendRecvState_w() {
1463 // Render incoming data if we're the active call, and we have the local
1464 // content. We receive data on the default channel and multiplexed streams.
1465 RTC_DCHECK_RUN_ON(worker_thread());
1466 bool recv = IsReadyToReceiveMedia_w();
1467 if (!media_channel()->SetReceive(recv)) {
1468 RTC_LOG(LS_ERROR) << "Failed to SetReceive on data channel: " << ToString();
1469 }
1470
1471 // Send outgoing data if we're the active call, we have the remote content,
1472 // and we have had some form of connectivity.
1473 bool send = IsReadyToSendMedia_w();
1474 if (!media_channel()->SetSend(send)) {
1475 RTC_LOG(LS_ERROR) << "Failed to SetSend on data channel: " << ToString();
1476 }
1477
1478 // Trigger SignalReadyToSendData asynchronously.
1479 OnDataChannelReadyToSend(send);
1480
1481 RTC_LOG(LS_INFO) << "Changing data state, recv=" << recv << " send=" << send
1482 << " for " << ToString();
1483 }
1484
OnMessage(rtc::Message * pmsg)1485 void RtpDataChannel::OnMessage(rtc::Message* pmsg) {
1486 switch (pmsg->message_id) {
1487 case MSG_READYTOSENDDATA: {
1488 DataChannelReadyToSendMessageData* data =
1489 static_cast<DataChannelReadyToSendMessageData*>(pmsg->pdata);
1490 ready_to_send_data_ = data->data();
1491 SignalReadyToSendData(ready_to_send_data_);
1492 delete data;
1493 break;
1494 }
1495 case MSG_DATARECEIVED: {
1496 DataReceivedMessageData* data =
1497 static_cast<DataReceivedMessageData*>(pmsg->pdata);
1498 SignalDataReceived(data->params, data->payload);
1499 delete data;
1500 break;
1501 }
1502 default:
1503 BaseChannel::OnMessage(pmsg);
1504 break;
1505 }
1506 }
1507
OnDataReceived(const ReceiveDataParams & params,const char * data,size_t len)1508 void RtpDataChannel::OnDataReceived(const ReceiveDataParams& params,
1509 const char* data,
1510 size_t len) {
1511 DataReceivedMessageData* msg = new DataReceivedMessageData(params, data, len);
1512 signaling_thread()->Post(RTC_FROM_HERE, this, MSG_DATARECEIVED, msg);
1513 }
1514
OnDataChannelReadyToSend(bool writable)1515 void RtpDataChannel::OnDataChannelReadyToSend(bool writable) {
1516 // This is usded for congestion control to indicate that the stream is ready
1517 // to send by the MediaChannel, as opposed to OnReadyToSend, which indicates
1518 // that the transport channel is ready.
1519 signaling_thread()->Post(RTC_FROM_HERE, this, MSG_READYTOSENDDATA,
1520 new DataChannelReadyToSendMessageData(writable));
1521 }
1522
1523 } // namespace cricket
1524