blob: 91d8cbf669d644937cd46fbd551d85ae905d7636 [file] [log] [blame]
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001/*
kjellander65c7f672016-02-12 00:05:01 -08002 * Copyright 2004 The WebRTC project authors. All Rights Reserved.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003 *
kjellander65c7f672016-02-12 00:05:01 -08004 * 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.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00009 */
10
jbauch5869f502017-06-29 12:31:36 -070011#include <algorithm>
12#include <iterator>
kwiberg0eb15ed2015-12-17 03:04:15 -080013#include <utility>
14
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020015#include "pc/channel.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000016
Karl Wiberg918f50c2018-07-05 11:40:33 +020017#include "absl/memory/memory.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020018#include "api/call/audio_sink.h"
19#include "media/base/mediaconstants.h"
20#include "media/base/rtputils.h"
Zhi Huang365381f2018-04-13 16:44:34 -070021#include "modules/rtp_rtcp/source/rtp_packet_received.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020022#include "rtc_base/bind.h"
23#include "rtc_base/byteorder.h"
24#include "rtc_base/checks.h"
25#include "rtc_base/copyonwritebuffer.h"
26#include "rtc_base/dscp.h"
27#include "rtc_base/logging.h"
28#include "rtc_base/networkroute.h"
Jonas Olsson366a50c2018-09-06 13:41:30 +020029#include "rtc_base/strings/string_builder.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020030#include "rtc_base/trace_event.h"
Patrik Höglund42805f32018-01-18 19:15:38 +000031// Adding 'nogncheck' to disable the gn include headers check to support modular
32// WebRTC build targets.
33#include "media/engine/webrtcvoiceengine.h" // nogncheck
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020034#include "p2p/base/packettransportinternal.h"
35#include "pc/channelmanager.h"
Steve Anton4e70a722017-11-28 14:57:10 -080036#include "pc/rtpmediautils.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000037
38namespace cricket {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000039using rtc::Bind;
Steve Anton3828c062017-12-06 10:34:51 -080040using webrtc::SdpType;
sergeyu@chromium.org9cf037b2014-02-07 19:03:26 +000041
deadbeef2d110be2016-01-13 12:00:26 -080042namespace {
Danil Chapovalov33b01f22016-05-11 19:55:27 +020043
44struct SendPacketMessageData : public rtc::MessageData {
45 rtc::CopyOnWriteBuffer packet;
46 rtc::PacketOptions options;
47};
48
deadbeef2d110be2016-01-13 12:00:26 -080049} // namespace
50
henrike@webrtc.org28e20752013-07-10 00:45:36 +000051enum {
Steve Anton0807d152018-03-05 11:23:09 -080052 MSG_SEND_RTP_PACKET = 1,
Danil Chapovalov33b01f22016-05-11 19:55:27 +020053 MSG_SEND_RTCP_PACKET,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000054 MSG_READYTOSENDDATA,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000055 MSG_DATARECEIVED,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000056 MSG_FIRSTPACKETRECEIVED,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000057};
58
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +000059static void SafeSetError(const std::string& message, std::string* error_desc) {
60 if (error_desc) {
61 *error_desc = message;
62 }
63}
64
jbaucheec21bd2016-03-20 06:15:43 -070065static bool ValidPacket(bool rtcp, const rtc::CopyOnWriteBuffer* packet) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +000066 // Check the packet size. We could check the header too if needed.
zstein3dcf0e92017-06-01 13:22:42 -070067 return packet && IsValidRtpRtcpPacketSize(rtcp, packet->size());
henrike@webrtc.org28e20752013-07-10 00:45:36 +000068}
69
Peter Thatcherc2ee2c82015-08-07 16:05:34 -070070template <class Codec>
71void RtpParametersFromMediaDescription(
72 const MediaContentDescriptionImpl<Codec>* desc,
jbauch5869f502017-06-29 12:31:36 -070073 const RtpHeaderExtensions& extensions,
Peter Thatcherc2ee2c82015-08-07 16:05:34 -070074 RtpParameters<Codec>* params) {
75 // TODO(pthatcher): Remove this once we're sure no one will give us
Zhi Huang801b8682017-11-15 11:36:43 -080076 // a description without codecs. Currently the ORTC implementation is relying
77 // on this.
Peter Thatcherc2ee2c82015-08-07 16:05:34 -070078 if (desc->has_codecs()) {
79 params->codecs = desc->codecs();
80 }
81 // TODO(pthatcher): See if we really need
82 // rtp_header_extensions_set() and remove it if we don't.
83 if (desc->rtp_header_extensions_set()) {
jbauch5869f502017-06-29 12:31:36 -070084 params->extensions = extensions;
Peter Thatcherc2ee2c82015-08-07 16:05:34 -070085 }
deadbeef13871492015-12-09 12:37:51 -080086 params->rtcp.reduced_size = desc->rtcp_reduced_size();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -070087}
88
nisse05103312016-03-16 02:22:50 -070089template <class Codec>
Peter Thatcherc2ee2c82015-08-07 16:05:34 -070090void RtpSendParametersFromMediaDescription(
91 const MediaContentDescriptionImpl<Codec>* desc,
jbauch5869f502017-06-29 12:31:36 -070092 const RtpHeaderExtensions& extensions,
nisse05103312016-03-16 02:22:50 -070093 RtpSendParameters<Codec>* send_params) {
jbauch5869f502017-06-29 12:31:36 -070094 RtpParametersFromMediaDescription(desc, extensions, send_params);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -070095 send_params->max_bandwidth_bps = desc->bandwidth();
96}
97
Danil Chapovalov33b01f22016-05-11 19:55:27 +020098BaseChannel::BaseChannel(rtc::Thread* worker_thread,
99 rtc::Thread* network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -0800100 rtc::Thread* signaling_thread,
Steve Anton8699a322017-11-06 15:53:33 -0800101 std::unique_ptr<MediaChannel> media_channel,
deadbeefcbecd352015-09-23 11:50:27 -0700102 const std::string& content_name,
Zhi Huange830e682018-03-30 10:48:35 -0700103 bool srtp_required,
Benjamin Wrighta54daf12018-10-11 15:33:17 -0700104 webrtc::CryptoOptions crypto_options)
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200105 : worker_thread_(worker_thread),
106 network_thread_(network_thread),
zhihuangf5b251b2017-01-12 19:37:48 -0800107 signaling_thread_(signaling_thread),
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000108 content_name_(content_name),
deadbeef7af91dd2016-12-13 11:29:11 -0800109 srtp_required_(srtp_required),
Zhi Huange830e682018-03-30 10:48:35 -0700110 crypto_options_(crypto_options),
Zhi Huang1d88d742017-11-15 15:58:49 -0800111 media_channel_(std::move(media_channel)) {
Steve Anton8699a322017-11-06 15:53:33 -0800112 RTC_DCHECK_RUN_ON(worker_thread_);
Zhi Huang365381f2018-04-13 16:44:34 -0700113 demuxer_criteria_.mid = content_name;
Mirko Bonadei675513b2017-11-09 11:09:25 +0100114 RTC_LOG(LS_INFO) << "Created channel for " << content_name;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000115}
116
117BaseChannel::~BaseChannel() {
Peter Boströmca8b4042016-03-08 14:24:13 -0800118 TRACE_EVENT0("webrtc", "BaseChannel::~BaseChannel");
Steve Anton8699a322017-11-06 15:53:33 -0800119 RTC_DCHECK_RUN_ON(worker_thread_);
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200120 // Eats any outstanding messages or packets.
121 worker_thread_->Clear(&invoker_);
122 worker_thread_->Clear(this);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000123 // We must destroy the media channel before the transport channel, otherwise
124 // the media channel may try to send on the dead transport channel. NULLing
125 // is not an effective strategy since the sends will come on another thread.
Steve Anton8699a322017-11-06 15:53:33 -0800126 media_channel_.reset();
Mirko Bonadei675513b2017-11-09 11:09:25 +0100127 RTC_LOG(LS_INFO) << "Destroyed channel: " << content_name_;
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200128}
129
Zhi Huang365381f2018-04-13 16:44:34 -0700130bool BaseChannel::ConnectToRtpTransport() {
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800131 RTC_DCHECK(rtp_transport_);
Zhi Huang365381f2018-04-13 16:44:34 -0700132 if (!RegisterRtpDemuxerSink()) {
133 return false;
134 }
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800135 rtp_transport_->SignalReadyToSend.connect(
136 this, &BaseChannel::OnTransportReadyToSend);
Zhi Huang365381f2018-04-13 16:44:34 -0700137 rtp_transport_->SignalRtcpPacketReceived.connect(
138 this, &BaseChannel::OnRtcpPacketReceived);
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800139 rtp_transport_->SignalNetworkRouteChanged.connect(
140 this, &BaseChannel::OnNetworkRouteChanged);
141 rtp_transport_->SignalWritableState.connect(this,
142 &BaseChannel::OnWritableState);
143 rtp_transport_->SignalSentPacket.connect(this,
144 &BaseChannel::SignalSentPacket_n);
Zhi Huang365381f2018-04-13 16:44:34 -0700145 return true;
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800146}
Danil Chapovalovdae07ba2016-05-14 01:43:50 +0200147
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800148void BaseChannel::DisconnectFromRtpTransport() {
149 RTC_DCHECK(rtp_transport_);
Zhi Huang365381f2018-04-13 16:44:34 -0700150 rtp_transport_->UnregisterRtpDemuxerSink(this);
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800151 rtp_transport_->SignalReadyToSend.disconnect(this);
Zhi Huang365381f2018-04-13 16:44:34 -0700152 rtp_transport_->SignalRtcpPacketReceived.disconnect(this);
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800153 rtp_transport_->SignalNetworkRouteChanged.disconnect(this);
154 rtp_transport_->SignalWritableState.disconnect(this);
155 rtp_transport_->SignalSentPacket.disconnect(this);
Danil Chapovalovdae07ba2016-05-14 01:43:50 +0200156}
157
Anton Sukhanov98a462c2018-10-17 13:15:42 -0700158void BaseChannel::Init_w(webrtc::RtpTransportInternal* rtp_transport,
159 webrtc::MediaTransportInterface* media_transport) {
Zhi Huang2dfc42d2017-12-04 13:38:48 -0800160 RTC_DCHECK_RUN_ON(worker_thread_);
Zhi Huang365381f2018-04-13 16:44:34 -0700161 network_thread_->Invoke<void>(
162 RTC_FROM_HERE, [this, rtp_transport] { SetRtpTransport(rtp_transport); });
Zhi Huang2dfc42d2017-12-04 13:38:48 -0800163
164 // Both RTP and RTCP channels should be set, we can call SetInterface on
165 // the media channel and it can set network options.
Anton Sukhanov98a462c2018-10-17 13:15:42 -0700166 media_channel_->SetInterface(this, media_transport);
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200167}
168
wu@webrtc.org78187522013-10-07 23:32:02 +0000169void BaseChannel::Deinit() {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200170 RTC_DCHECK(worker_thread_->IsCurrent());
Anton Sukhanov98a462c2018-10-17 13:15:42 -0700171 media_channel_->SetInterface(/*iface=*/nullptr,
172 /*media_transport=*/nullptr);
Danil Chapovalovdae07ba2016-05-14 01:43:50 +0200173 // Packets arrive on the network thread, processing packets calls virtual
174 // functions, so need to stop this process in Deinit that is called in
175 // derived classes destructor.
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800176 network_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
Zhi Huang95e7dbb2018-03-29 00:08:03 +0000177 FlushRtcpMessages_n();
Zhi Huang27f3bf52018-03-26 21:37:23 -0700178
Zhi Huange830e682018-03-30 10:48:35 -0700179 if (rtp_transport_) {
180 DisconnectFromRtpTransport();
Zhi Huang95e7dbb2018-03-29 00:08:03 +0000181 }
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800182 // Clear pending read packets/messages.
183 network_thread_->Clear(&invoker_);
184 network_thread_->Clear(this);
185 });
wu@webrtc.org78187522013-10-07 23:32:02 +0000186}
187
Zhi Huang365381f2018-04-13 16:44:34 -0700188bool BaseChannel::SetRtpTransport(webrtc::RtpTransportInternal* rtp_transport) {
189 if (rtp_transport == rtp_transport_) {
190 return true;
191 }
192
Zhi Huang2dfc42d2017-12-04 13:38:48 -0800193 if (!network_thread_->IsCurrent()) {
Zhi Huang365381f2018-04-13 16:44:34 -0700194 return network_thread_->Invoke<bool>(RTC_FROM_HERE, [this, rtp_transport] {
195 return SetRtpTransport(rtp_transport);
Zhi Huang2dfc42d2017-12-04 13:38:48 -0800196 });
197 }
Zhi Huang95e7dbb2018-03-29 00:08:03 +0000198
Zhi Huang2dfc42d2017-12-04 13:38:48 -0800199 if (rtp_transport_) {
200 DisconnectFromRtpTransport();
201 }
Zhi Huange830e682018-03-30 10:48:35 -0700202
Zhi Huang2dfc42d2017-12-04 13:38:48 -0800203 rtp_transport_ = rtp_transport;
Zhi Huange830e682018-03-30 10:48:35 -0700204 if (rtp_transport_) {
205 RTC_DCHECK(rtp_transport_->rtp_packet_transport());
206 transport_name_ = rtp_transport_->rtp_packet_transport()->transport_name();
Zhi Huang2dfc42d2017-12-04 13:38:48 -0800207
Zhi Huang365381f2018-04-13 16:44:34 -0700208 if (!ConnectToRtpTransport()) {
209 RTC_LOG(LS_ERROR) << "Failed to connect to the new RtpTransport.";
210 return false;
211 }
Zhi Huange830e682018-03-30 10:48:35 -0700212 OnTransportReadyToSend(rtp_transport_->IsReadyToSend());
213 UpdateWritableState_n();
Zhi Huang2dfc42d2017-12-04 13:38:48 -0800214
Zhi Huange830e682018-03-30 10:48:35 -0700215 // Set the cached socket options.
216 for (const auto& pair : socket_options_) {
217 rtp_transport_->rtp_packet_transport()->SetOption(pair.first,
218 pair.second);
219 }
220 if (rtp_transport_->rtcp_packet_transport()) {
221 for (const auto& pair : rtcp_socket_options_) {
222 rtp_transport_->rtp_packet_transport()->SetOption(pair.first,
223 pair.second);
224 }
225 }
guoweis46383312015-12-17 16:45:59 -0800226 }
Zhi Huang365381f2018-04-13 16:44:34 -0700227 return true;
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000228}
229
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000230bool BaseChannel::Enable(bool enable) {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700231 worker_thread_->Invoke<void>(
232 RTC_FROM_HERE,
233 Bind(enable ? &BaseChannel::EnableMedia_w : &BaseChannel::DisableMedia_w,
234 this));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000235 return true;
236}
237
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000238bool BaseChannel::AddRecvStream(const StreamParams& sp) {
Zhi Huang365381f2018-04-13 16:44:34 -0700239 demuxer_criteria_.ssrcs.insert(sp.first_ssrc());
240 if (!RegisterRtpDemuxerSink()) {
241 return false;
242 }
stefanf79ade12017-06-02 06:44:03 -0700243 return InvokeOnWorker<bool>(RTC_FROM_HERE,
244 Bind(&BaseChannel::AddRecvStream_w, this, sp));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000245}
246
Peter Boström0c4e06b2015-10-07 12:23:21 +0200247bool BaseChannel::RemoveRecvStream(uint32_t ssrc) {
Zhi Huang365381f2018-04-13 16:44:34 -0700248 demuxer_criteria_.ssrcs.erase(ssrc);
249 if (!RegisterRtpDemuxerSink()) {
250 return false;
251 }
stefanf79ade12017-06-02 06:44:03 -0700252 return InvokeOnWorker<bool>(
253 RTC_FROM_HERE, Bind(&BaseChannel::RemoveRecvStream_w, this, ssrc));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000254}
255
wu@webrtc.orgcadf9042013-08-30 21:24:16 +0000256bool BaseChannel::AddSendStream(const StreamParams& sp) {
stefanf79ade12017-06-02 06:44:03 -0700257 return InvokeOnWorker<bool>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700258 RTC_FROM_HERE, Bind(&MediaChannel::AddSendStream, media_channel(), sp));
wu@webrtc.orgcadf9042013-08-30 21:24:16 +0000259}
260
Peter Boström0c4e06b2015-10-07 12:23:21 +0200261bool BaseChannel::RemoveSendStream(uint32_t ssrc) {
stefanf79ade12017-06-02 06:44:03 -0700262 return InvokeOnWorker<bool>(
263 RTC_FROM_HERE,
264 Bind(&MediaChannel::RemoveSendStream, media_channel(), ssrc));
wu@webrtc.orgcadf9042013-08-30 21:24:16 +0000265}
266
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000267bool BaseChannel::SetLocalContent(const MediaContentDescription* content,
Steve Anton3828c062017-12-06 10:34:51 -0800268 SdpType type,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000269 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +0100270 TRACE_EVENT0("webrtc", "BaseChannel::SetLocalContent");
stefanf79ade12017-06-02 06:44:03 -0700271 return InvokeOnWorker<bool>(
272 RTC_FROM_HERE,
Steve Anton3828c062017-12-06 10:34:51 -0800273 Bind(&BaseChannel::SetLocalContent_w, this, content, type, error_desc));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000274}
275
276bool BaseChannel::SetRemoteContent(const MediaContentDescription* content,
Steve Anton3828c062017-12-06 10:34:51 -0800277 SdpType type,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000278 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +0100279 TRACE_EVENT0("webrtc", "BaseChannel::SetRemoteContent");
stefanf79ade12017-06-02 06:44:03 -0700280 return InvokeOnWorker<bool>(
Steve Anton3828c062017-12-06 10:34:51 -0800281 RTC_FROM_HERE,
282 Bind(&BaseChannel::SetRemoteContent_w, this, content, type, error_desc));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000283}
284
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700285bool BaseChannel::IsReadyToReceiveMedia_w() const {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000286 // Receive data if we are enabled and have local content,
Steve Anton4e70a722017-11-28 14:57:10 -0800287 return enabled() &&
288 webrtc::RtpTransceiverDirectionHasRecv(local_content_direction_);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000289}
290
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700291bool BaseChannel::IsReadyToSendMedia_w() const {
292 // Need to access some state updated on the network thread.
293 return network_thread_->Invoke<bool>(
294 RTC_FROM_HERE, Bind(&BaseChannel::IsReadyToSendMedia_n, this));
295}
296
297bool BaseChannel::IsReadyToSendMedia_n() const {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000298 // Send outgoing data if we are enabled, have local and remote content,
299 // and we have had some form of connectivity.
Steve Anton4e70a722017-11-28 14:57:10 -0800300 return enabled() &&
301 webrtc::RtpTransceiverDirectionHasRecv(remote_content_direction_) &&
302 webrtc::RtpTransceiverDirectionHasSend(local_content_direction_) &&
Zhi Huang365381f2018-04-13 16:44:34 -0700303 was_ever_writable();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000304}
305
jbaucheec21bd2016-03-20 06:15:43 -0700306bool BaseChannel::SendPacket(rtc::CopyOnWriteBuffer* packet,
stefanc1aeaf02015-10-15 07:26:07 -0700307 const rtc::PacketOptions& options) {
308 return SendPacket(false, packet, options);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000309}
310
jbaucheec21bd2016-03-20 06:15:43 -0700311bool BaseChannel::SendRtcp(rtc::CopyOnWriteBuffer* packet,
stefanc1aeaf02015-10-15 07:26:07 -0700312 const rtc::PacketOptions& options) {
313 return SendPacket(true, packet, options);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000314}
315
Yves Gerey665174f2018-06-19 15:03:05 +0200316int BaseChannel::SetOption(SocketType type,
317 rtc::Socket::Option opt,
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000318 int value) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200319 return network_thread_->Invoke<int>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700320 RTC_FROM_HERE, Bind(&BaseChannel::SetOption_n, this, type, opt, value));
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200321}
322
323int BaseChannel::SetOption_n(SocketType type,
324 rtc::Socket::Option opt,
325 int value) {
326 RTC_DCHECK(network_thread_->IsCurrent());
Zhi Huange830e682018-03-30 10:48:35 -0700327 RTC_DCHECK(rtp_transport_);
deadbeef5bd5ca32017-02-10 11:31:50 -0800328 rtc::PacketTransportInternal* transport = nullptr;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000329 switch (type) {
wu@webrtc.org9caf2762013-12-11 18:25:07 +0000330 case ST_RTP:
zsteine8ab5432017-07-12 11:48:11 -0700331 transport = rtp_transport_->rtp_packet_transport();
deadbeefcbecd352015-09-23 11:50:27 -0700332 socket_options_.push_back(
333 std::pair<rtc::Socket::Option, int>(opt, value));
wu@webrtc.org9caf2762013-12-11 18:25:07 +0000334 break;
335 case ST_RTCP:
zsteine8ab5432017-07-12 11:48:11 -0700336 transport = rtp_transport_->rtcp_packet_transport();
deadbeefcbecd352015-09-23 11:50:27 -0700337 rtcp_socket_options_.push_back(
338 std::pair<rtc::Socket::Option, int>(opt, value));
wu@webrtc.org9caf2762013-12-11 18:25:07 +0000339 break;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000340 }
deadbeeff5346592017-01-24 21:51:21 -0800341 return transport ? transport->SetOption(opt, value) : -1;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000342}
343
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800344void BaseChannel::OnWritableState(bool writable) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200345 RTC_DCHECK(network_thread_->IsCurrent());
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800346 if (writable) {
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800347 ChannelWritable_n();
348 } else {
349 ChannelNotWritable_n();
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -0800350 }
351}
352
Zhi Huang942bc2e2017-11-13 13:26:07 -0800353void BaseChannel::OnNetworkRouteChanged(
Danil Chapovalov66cadcc2018-06-19 16:47:43 +0200354 absl::optional<rtc::NetworkRoute> network_route) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200355 RTC_DCHECK(network_thread_->IsCurrent());
Zhi Huang942bc2e2017-11-13 13:26:07 -0800356 rtc::NetworkRoute new_route;
357 if (network_route) {
Zhi Huang942bc2e2017-11-13 13:26:07 -0800358 new_route = *(network_route);
Zhi Huang8c316c12017-11-13 21:13:45 +0000359 }
Zhi Huang942bc2e2017-11-13 13:26:07 -0800360 // Note: When the RTCP-muxing is not enabled, RTCP transport and RTP transport
361 // use the same transport name and MediaChannel::OnNetworkRouteChanged cannot
362 // work correctly. Intentionally leave it broken to simplify the code and
363 // encourage the users to stop using non-muxing RTCP.
Steve Anton8699a322017-11-06 15:53:33 -0800364 invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_, [=] {
Zhi Huang942bc2e2017-11-13 13:26:07 -0800365 media_channel_->OnNetworkRouteChanged(transport_name_, new_route);
Steve Anton8699a322017-11-06 15:53:33 -0800366 });
Honghai Zhangcc411c02016-03-29 17:27:21 -0700367}
368
zstein56162b92017-04-24 16:54:35 -0700369void BaseChannel::OnTransportReadyToSend(bool ready) {
Steve Anton8699a322017-11-06 15:53:33 -0800370 invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_,
371 [=] { media_channel_->OnReadyToSend(ready); });
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000372}
373
stefanc1aeaf02015-10-15 07:26:07 -0700374bool BaseChannel::SendPacket(bool rtcp,
jbaucheec21bd2016-03-20 06:15:43 -0700375 rtc::CopyOnWriteBuffer* packet,
stefanc1aeaf02015-10-15 07:26:07 -0700376 const rtc::PacketOptions& options) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200377 // SendPacket gets called from MediaEngine, on a pacer or an encoder thread.
378 // If the thread is not our network thread, we will post to our network
379 // so that the real work happens on our network. This avoids us having to
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000380 // synchronize access to all the pieces of the send path, including
381 // SRTP and the inner workings of the transport channels.
382 // The only downside is that we can't return a proper failure code if
383 // needed. Since UDP is unreliable anyway, this should be a non-issue.
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200384 if (!network_thread_->IsCurrent()) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000385 // Avoid a copy by transferring the ownership of the packet data.
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200386 int message_id = rtcp ? MSG_SEND_RTCP_PACKET : MSG_SEND_RTP_PACKET;
387 SendPacketMessageData* data = new SendPacketMessageData;
kwiberg0eb15ed2015-12-17 03:04:15 -0800388 data->packet = std::move(*packet);
stefanc1aeaf02015-10-15 07:26:07 -0700389 data->options = options;
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700390 network_thread_->Post(RTC_FROM_HERE, this, message_id, data);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000391 return true;
392 }
Zhi Huange830e682018-03-30 10:48:35 -0700393
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200394 TRACE_EVENT0("webrtc", "BaseChannel::SendPacket");
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000395
396 // Now that we are on the correct thread, ensure we have a place to send this
397 // packet before doing anything. (We might get RTCP packets that we don't
398 // intend to send.) If we've negotiated RTCP mux, send RTCP over the RTP
399 // transport.
Zhi Huange830e682018-03-30 10:48:35 -0700400 if (!rtp_transport_ || !rtp_transport_->IsWritable(rtcp)) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000401 return false;
402 }
403
404 // Protect ourselves against crazy data.
405 if (!ValidPacket(rtcp, packet)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100406 RTC_LOG(LS_ERROR) << "Dropping outgoing " << content_name_ << " "
407 << RtpRtcpStringLiteral(rtcp)
408 << " packet: wrong size=" << packet->size();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000409 return false;
410 }
411
Zhi Huangcf990f52017-09-22 12:12:30 -0700412 if (!srtp_active()) {
413 if (srtp_required_) {
414 // The audio/video engines may attempt to send RTCP packets as soon as the
415 // streams are created, so don't treat this as an error for RTCP.
416 // See: https://bugs.chromium.org/p/webrtc/issues/detail?id=6809
417 if (rtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000418 return false;
419 }
Zhi Huangcf990f52017-09-22 12:12:30 -0700420 // However, there shouldn't be any RTP packets sent before SRTP is set up
421 // (and SetSend(true) is called).
Mirko Bonadei675513b2017-11-09 11:09:25 +0100422 RTC_LOG(LS_ERROR)
423 << "Can't send outgoing RTP packet when SRTP is inactive"
424 << " and crypto is required";
Zhi Huangcf990f52017-09-22 12:12:30 -0700425 RTC_NOTREACHED();
deadbeef8f425f92016-12-01 12:26:27 -0800426 return false;
427 }
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800428
429 std::string packet_type = rtcp ? "RTCP" : "RTP";
430 RTC_LOG(LS_WARNING) << "Sending an " << packet_type
431 << " packet without encryption.";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000432 }
Zhi Huange830e682018-03-30 10:48:35 -0700433
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000434 // Bon voyage.
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800435 return rtcp ? rtp_transport_->SendRtcpPacket(packet, options, PF_SRTP_BYPASS)
436 : rtp_transport_->SendRtpPacket(packet, options, PF_SRTP_BYPASS);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000437}
438
Zhi Huang365381f2018-04-13 16:44:34 -0700439void BaseChannel::OnRtpPacket(const webrtc::RtpPacketReceived& parsed_packet) {
440 // Reconstruct the PacketTime from the |parsed_packet|.
441 // RtpPacketReceived.arrival_time_ms = (PacketTime + 500) / 1000;
442 // Note: The |not_before| field is always 0 here. This field is not currently
443 // used, so it should be fine.
444 int64_t timestamp = -1;
445 if (parsed_packet.arrival_time_ms() > 0) {
446 timestamp = parsed_packet.arrival_time_ms() * 1000;
447 }
448 rtc::PacketTime packet_time(timestamp, /*not_before=*/0);
449
450 OnPacketReceived(/*rtcp=*/false, parsed_packet.Buffer(), packet_time);
451}
452
453void BaseChannel::UpdateRtpHeaderExtensionMap(
454 const RtpHeaderExtensions& header_extensions) {
455 RTC_DCHECK(rtp_transport_);
456 // Update the header extension map on network thread in case there is data
457 // race.
458 // TODO(zhihuang): Add an rtc::ThreadChecker make sure to RtpTransport won't
459 // be accessed from different threads.
460 //
461 // NOTE: This doesn't take the BUNDLE case in account meaning the RTP header
462 // extension maps are not merged when BUNDLE is enabled. This is fine because
463 // the ID for MID should be consistent among all the RTP transports.
464 network_thread_->Invoke<void>(RTC_FROM_HERE, [this, &header_extensions] {
465 rtp_transport_->UpdateRtpHeaderExtensionMap(header_extensions);
466 });
467}
468
469bool BaseChannel::RegisterRtpDemuxerSink() {
470 RTC_DCHECK(rtp_transport_);
471 return network_thread_->Invoke<bool>(RTC_FROM_HERE, [this] {
472 return rtp_transport_->RegisterRtpDemuxerSink(demuxer_criteria_, this);
473 });
474}
475
476void BaseChannel::OnRtcpPacketReceived(rtc::CopyOnWriteBuffer* packet,
477 const rtc::PacketTime& packet_time) {
478 OnPacketReceived(/*rtcp=*/true, *packet, packet_time);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000479}
480
zstein3dcf0e92017-06-01 13:22:42 -0700481void BaseChannel::OnPacketReceived(bool rtcp,
Zhi Huang365381f2018-04-13 16:44:34 -0700482 const rtc::CopyOnWriteBuffer& packet,
zstein3dcf0e92017-06-01 13:22:42 -0700483 const rtc::PacketTime& packet_time) {
honghaiz@google.coma67ca1a2015-01-28 19:48:33 +0000484 if (!has_received_packet_ && !rtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000485 has_received_packet_ = true;
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700486 signaling_thread()->Post(RTC_FROM_HERE, this, MSG_FIRSTPACKETRECEIVED);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000487 }
488
Zhi Huangcf990f52017-09-22 12:12:30 -0700489 if (!srtp_active() && srtp_required_) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000490 // Our session description indicates that SRTP is required, but we got a
491 // packet before our SRTP filter is active. This means either that
492 // a) we got SRTP packets before we received the SDES keys, in which case
493 // we can't decrypt it anyway, or
494 // b) we got SRTP packets before DTLS completed on both the RTP and RTCP
zhihuangb2cdd932017-01-19 16:54:25 -0800495 // transports, so we haven't yet extracted keys, even if DTLS did
496 // complete on the transport that the packets are being sent on. It's
497 // really good practice to wait for both RTP and RTCP to be good to go
498 // before sending media, to prevent weird failure modes, so it's fine
499 // for us to just eat packets here. This is all sidestepped if RTCP mux
500 // is used anyway.
Mirko Bonadei675513b2017-11-09 11:09:25 +0100501 RTC_LOG(LS_WARNING)
502 << "Can't process incoming " << RtpRtcpStringLiteral(rtcp)
503 << " packet when SRTP is inactive and crypto is required";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000504 return;
505 }
506
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200507 invoker_.AsyncInvoke<void>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700508 RTC_FROM_HERE, worker_thread_,
Zhi Huang365381f2018-04-13 16:44:34 -0700509 Bind(&BaseChannel::ProcessPacket, this, rtcp, packet, packet_time));
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200510}
511
zstein3dcf0e92017-06-01 13:22:42 -0700512void BaseChannel::ProcessPacket(bool rtcp,
513 const rtc::CopyOnWriteBuffer& packet,
514 const rtc::PacketTime& packet_time) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200515 RTC_DCHECK(worker_thread_->IsCurrent());
zstein3dcf0e92017-06-01 13:22:42 -0700516
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200517 // Need to copy variable because OnRtcpReceived/OnPacketReceived
518 // requires non-const pointer to buffer. This doesn't memcpy the actual data.
519 rtc::CopyOnWriteBuffer data(packet);
520 if (rtcp) {
521 media_channel_->OnRtcpReceived(&data, packet_time);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000522 } else {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200523 media_channel_->OnPacketReceived(&data, packet_time);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000524 }
525}
526
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000527void BaseChannel::EnableMedia_w() {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700528 RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000529 if (enabled_)
530 return;
531
Mirko Bonadei675513b2017-11-09 11:09:25 +0100532 RTC_LOG(LS_INFO) << "Channel enabled";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000533 enabled_ = true;
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700534 UpdateMediaSendRecvState_w();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000535}
536
537void BaseChannel::DisableMedia_w() {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700538 RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000539 if (!enabled_)
540 return;
541
Mirko Bonadei675513b2017-11-09 11:09:25 +0100542 RTC_LOG(LS_INFO) << "Channel disabled";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000543 enabled_ = false;
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700544 UpdateMediaSendRecvState_w();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000545}
546
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200547void BaseChannel::UpdateWritableState_n() {
Zhi Huange830e682018-03-30 10:48:35 -0700548 if (rtp_transport_->IsWritable(/*rtcp=*/true) &&
549 rtp_transport_->IsWritable(/*rtcp=*/false)) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200550 ChannelWritable_n();
deadbeefcbecd352015-09-23 11:50:27 -0700551 } else {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200552 ChannelNotWritable_n();
deadbeefcbecd352015-09-23 11:50:27 -0700553 }
554}
555
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200556void BaseChannel::ChannelWritable_n() {
557 RTC_DCHECK(network_thread_->IsCurrent());
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -0800558 if (writable_) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000559 return;
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -0800560 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000561
Mirko Bonadei675513b2017-11-09 11:09:25 +0100562 RTC_LOG(LS_INFO) << "Channel writable (" << content_name_ << ")"
563 << (was_ever_writable_ ? "" : " for the first time");
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000564
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000565 was_ever_writable_ = true;
566 writable_ = true;
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700567 UpdateMediaSendRecvState();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000568}
569
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200570void BaseChannel::ChannelNotWritable_n() {
571 RTC_DCHECK(network_thread_->IsCurrent());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000572 if (!writable_)
573 return;
574
Mirko Bonadei675513b2017-11-09 11:09:25 +0100575 RTC_LOG(LS_INFO) << "Channel not writable (" << content_name_ << ")";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000576 writable_ = false;
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700577 UpdateMediaSendRecvState();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000578}
579
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000580bool BaseChannel::AddRecvStream_w(const StreamParams& sp) {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700581 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
pbos482b12e2015-11-16 10:19:58 -0800582 return media_channel()->AddRecvStream(sp);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000583}
584
Peter Boström0c4e06b2015-10-07 12:23:21 +0200585bool BaseChannel::RemoveRecvStream_w(uint32_t ssrc) {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700586 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000587 return media_channel()->RemoveRecvStream(ssrc);
588}
589
590bool BaseChannel::UpdateLocalStreams_w(const std::vector<StreamParams>& streams,
Steve Anton3828c062017-12-06 10:34:51 -0800591 SdpType type,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000592 std::string* error_desc) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000593 // Check for streams that have been removed.
594 bool ret = true;
595 for (StreamParamsVec::const_iterator it = local_streams_.begin();
596 it != local_streams_.end(); ++it) {
Seth Hampson5897a6e2018-04-03 11:16:33 -0700597 if (it->has_ssrcs() && !GetStreamBySsrc(streams, it->first_ssrc())) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000598 if (!media_channel()->RemoveSendStream(it->first_ssrc())) {
Jonas Olsson366a50c2018-09-06 13:41:30 +0200599 rtc::StringBuilder desc;
Yves Gerey665174f2018-06-19 15:03:05 +0200600 desc << "Failed to remove send stream with ssrc " << it->first_ssrc()
601 << ".";
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000602 SafeSetError(desc.str(), error_desc);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000603 ret = false;
604 }
605 }
606 }
607 // Check for new streams.
608 for (StreamParamsVec::const_iterator it = streams.begin();
609 it != streams.end(); ++it) {
Seth Hampson5897a6e2018-04-03 11:16:33 -0700610 if (it->has_ssrcs() && !GetStreamBySsrc(local_streams_, it->first_ssrc())) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000611 if (media_channel()->AddSendStream(*it)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100612 RTC_LOG(LS_INFO) << "Add send stream ssrc: " << it->ssrcs[0];
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000613 } else {
Jonas Olsson366a50c2018-09-06 13:41:30 +0200614 rtc::StringBuilder desc;
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000615 desc << "Failed to add send stream ssrc: " << it->first_ssrc();
616 SafeSetError(desc.str(), error_desc);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000617 ret = false;
618 }
619 }
620 }
621 local_streams_ = streams;
622 return ret;
623}
624
625bool BaseChannel::UpdateRemoteStreams_w(
626 const std::vector<StreamParams>& streams,
Steve Anton3828c062017-12-06 10:34:51 -0800627 SdpType type,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000628 std::string* error_desc) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000629 // Check for streams that have been removed.
630 bool ret = true;
631 for (StreamParamsVec::const_iterator it = remote_streams_.begin();
632 it != remote_streams_.end(); ++it) {
Seth Hampson5897a6e2018-04-03 11:16:33 -0700633 // If we no longer have an unsignaled stream, we would like to remove
634 // the unsignaled stream params that are cached.
635 if ((!it->has_ssrcs() && !HasStreamWithNoSsrcs(streams)) ||
636 !GetStreamBySsrc(streams, it->first_ssrc())) {
Zhi Huang365381f2018-04-13 16:44:34 -0700637 if (RemoveRecvStream_w(it->first_ssrc())) {
638 RTC_LOG(LS_INFO) << "Remove remote ssrc: " << it->first_ssrc();
639 } else {
Jonas Olsson366a50c2018-09-06 13:41:30 +0200640 rtc::StringBuilder desc;
Yves Gerey665174f2018-06-19 15:03:05 +0200641 desc << "Failed to remove remote stream with ssrc " << it->first_ssrc()
642 << ".";
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000643 SafeSetError(desc.str(), error_desc);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000644 ret = false;
645 }
646 }
647 }
Zhi Huang365381f2018-04-13 16:44:34 -0700648 demuxer_criteria_.ssrcs.clear();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000649 // Check for new streams.
650 for (StreamParamsVec::const_iterator it = streams.begin();
Yves Gerey665174f2018-06-19 15:03:05 +0200651 it != streams.end(); ++it) {
Seth Hampson5897a6e2018-04-03 11:16:33 -0700652 // We allow a StreamParams with an empty list of SSRCs, in which case the
653 // MediaChannel will cache the parameters and use them for any unsignaled
654 // stream received later.
655 if ((!it->has_ssrcs() && !HasStreamWithNoSsrcs(remote_streams_)) ||
656 !GetStreamBySsrc(remote_streams_, it->first_ssrc())) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000657 if (AddRecvStream_w(*it)) {
Seth Hampson5897a6e2018-04-03 11:16:33 -0700658 RTC_LOG(LS_INFO) << "Add remote ssrc: " << it->first_ssrc();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000659 } else {
Jonas Olsson366a50c2018-09-06 13:41:30 +0200660 rtc::StringBuilder desc;
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000661 desc << "Failed to add remote stream ssrc: " << it->first_ssrc();
662 SafeSetError(desc.str(), error_desc);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000663 ret = false;
664 }
665 }
Zhi Huang365381f2018-04-13 16:44:34 -0700666 // Update the receiving SSRCs.
667 demuxer_criteria_.ssrcs.insert(it->ssrcs.begin(), it->ssrcs.end());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000668 }
Zhi Huang365381f2018-04-13 16:44:34 -0700669 // Re-register the sink to update the receiving ssrcs.
670 RegisterRtpDemuxerSink();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000671 remote_streams_ = streams;
672 return ret;
673}
674
jbauch5869f502017-06-29 12:31:36 -0700675RtpHeaderExtensions BaseChannel::GetFilteredRtpHeaderExtensions(
676 const RtpHeaderExtensions& extensions) {
Zhi Huange830e682018-03-30 10:48:35 -0700677 RTC_DCHECK(rtp_transport_);
Benjamin Wrighta54daf12018-10-11 15:33:17 -0700678 if (crypto_options_.srtp.enable_encrypted_rtp_header_extensions) {
jbauch5869f502017-06-29 12:31:36 -0700679 RtpHeaderExtensions filtered;
680 auto pred = [](const webrtc::RtpExtension& extension) {
Yves Gerey665174f2018-06-19 15:03:05 +0200681 return !extension.encrypt;
jbauch5869f502017-06-29 12:31:36 -0700682 };
683 std::copy_if(extensions.begin(), extensions.end(),
Yves Gerey665174f2018-06-19 15:03:05 +0200684 std::back_inserter(filtered), pred);
jbauch5869f502017-06-29 12:31:36 -0700685 return filtered;
686 }
687
688 return webrtc::RtpExtension::FilterDuplicateNonEncrypted(extensions);
689}
690
Yves Gerey665174f2018-06-19 15:03:05 +0200691void BaseChannel::OnMessage(rtc::Message* pmsg) {
Peter Boström6f28cf02015-12-07 23:17:15 +0100692 TRACE_EVENT0("webrtc", "BaseChannel::OnMessage");
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000693 switch (pmsg->message_id) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200694 case MSG_SEND_RTP_PACKET:
695 case MSG_SEND_RTCP_PACKET: {
696 RTC_DCHECK(network_thread_->IsCurrent());
697 SendPacketMessageData* data =
698 static_cast<SendPacketMessageData*>(pmsg->pdata);
699 bool rtcp = pmsg->message_id == MSG_SEND_RTCP_PACKET;
700 SendPacket(rtcp, &data->packet, data->options);
701 delete data;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000702 break;
703 }
704 case MSG_FIRSTPACKETRECEIVED: {
705 SignalFirstPacketReceived(this);
706 break;
707 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000708 }
709}
710
zstein3dcf0e92017-06-01 13:22:42 -0700711void BaseChannel::AddHandledPayloadType(int payload_type) {
Zhi Huang365381f2018-04-13 16:44:34 -0700712 demuxer_criteria_.payload_types.insert(static_cast<uint8_t>(payload_type));
zstein3dcf0e92017-06-01 13:22:42 -0700713}
714
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200715void BaseChannel::FlushRtcpMessages_n() {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000716 // Flush all remaining RTCP messages. This should only be called in
717 // destructor.
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200718 RTC_DCHECK(network_thread_->IsCurrent());
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000719 rtc::MessageList rtcp_messages;
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200720 network_thread_->Clear(this, MSG_SEND_RTCP_PACKET, &rtcp_messages);
721 for (const auto& message : rtcp_messages) {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700722 network_thread_->Send(RTC_FROM_HERE, this, MSG_SEND_RTCP_PACKET,
723 message.pdata);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000724 }
725}
726
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800727void BaseChannel::SignalSentPacket_n(const rtc::SentPacket& sent_packet) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200728 RTC_DCHECK(network_thread_->IsCurrent());
729 invoker_.AsyncInvoke<void>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700730 RTC_FROM_HERE, worker_thread_,
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200731 rtc::Bind(&BaseChannel::SignalSentPacket_w, this, sent_packet));
732}
733
734void BaseChannel::SignalSentPacket_w(const rtc::SentPacket& sent_packet) {
735 RTC_DCHECK(worker_thread_->IsCurrent());
736 SignalSentPacket(sent_packet);
737}
738
739VoiceChannel::VoiceChannel(rtc::Thread* worker_thread,
740 rtc::Thread* network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -0800741 rtc::Thread* signaling_thread,
Niels Möllerf120cba2018-01-30 09:33:03 +0100742 // TODO(nisse): Delete unused argument.
743 MediaEngineInterface* /* media_engine */,
Steve Anton8699a322017-11-06 15:53:33 -0800744 std::unique_ptr<VoiceMediaChannel> media_channel,
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000745 const std::string& content_name,
Zhi Huange830e682018-03-30 10:48:35 -0700746 bool srtp_required,
Benjamin Wrighta54daf12018-10-11 15:33:17 -0700747 webrtc::CryptoOptions crypto_options)
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200748 : BaseChannel(worker_thread,
749 network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -0800750 signaling_thread,
Steve Anton8699a322017-11-06 15:53:33 -0800751 std::move(media_channel),
deadbeefcbecd352015-09-23 11:50:27 -0700752 content_name,
Zhi Huange830e682018-03-30 10:48:35 -0700753 srtp_required,
754 crypto_options) {}
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000755
756VoiceChannel::~VoiceChannel() {
Peter Boströmca8b4042016-03-08 14:24:13 -0800757 TRACE_EVENT0("webrtc", "VoiceChannel::~VoiceChannel");
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000758 // this can't be done in the base class, since it calls a virtual
759 DisableMedia_w();
Zhi Huang0ffe03d2018-03-30 13:17:42 -0700760 Deinit();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000761}
762
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700763void BaseChannel::UpdateMediaSendRecvState() {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200764 RTC_DCHECK(network_thread_->IsCurrent());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700765 invoker_.AsyncInvoke<void>(
766 RTC_FROM_HERE, worker_thread_,
767 Bind(&BaseChannel::UpdateMediaSendRecvState_w, this));
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200768}
769
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700770void VoiceChannel::UpdateMediaSendRecvState_w() {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000771 // Render incoming data if we're the active call, and we have the local
772 // content. We receive data on the default channel and multiplexed streams.
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700773 bool recv = IsReadyToReceiveMedia_w();
solenberg5b14b422015-10-01 04:10:31 -0700774 media_channel()->SetPlayout(recv);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000775
776 // Send outgoing data if we're the active call, we have the remote content,
777 // and we have had some form of connectivity.
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700778 bool send = IsReadyToSendMedia_w();
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -0800779 media_channel()->SetSend(send);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000780
Mirko Bonadei675513b2017-11-09 11:09:25 +0100781 RTC_LOG(LS_INFO) << "Changing voice state, recv=" << recv << " send=" << send;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000782}
783
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000784bool VoiceChannel::SetLocalContent_w(const MediaContentDescription* content,
Steve Anton3828c062017-12-06 10:34:51 -0800785 SdpType type,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000786 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +0100787 TRACE_EVENT0("webrtc", "VoiceChannel::SetLocalContent_w");
Steve Antonb1c1de12017-12-21 15:14:30 -0800788 RTC_DCHECK_RUN_ON(worker_thread());
Mirko Bonadei675513b2017-11-09 11:09:25 +0100789 RTC_LOG(LS_INFO) << "Setting local voice description";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000790
Steve Antonb1c1de12017-12-21 15:14:30 -0800791 RTC_DCHECK(content);
792 if (!content) {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000793 SafeSetError("Can't find audio content in local description.", error_desc);
794 return false;
795 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000796
Steve Antonb1c1de12017-12-21 15:14:30 -0800797 const AudioContentDescription* audio = content->as_audio();
798
jbauch5869f502017-06-29 12:31:36 -0700799 RtpHeaderExtensions rtp_header_extensions =
800 GetFilteredRtpHeaderExtensions(audio->rtp_header_extensions());
Zhi Huang365381f2018-04-13 16:44:34 -0700801 UpdateRtpHeaderExtensionMap(rtp_header_extensions);
jbauch5869f502017-06-29 12:31:36 -0700802
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700803 AudioRecvParameters recv_params = last_recv_params_;
jbauch5869f502017-06-29 12:31:36 -0700804 RtpParametersFromMediaDescription(audio, rtp_header_extensions, &recv_params);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700805 if (!media_channel()->SetRecvParameters(recv_params)) {
Peter Thatcherbfab5cb2015-08-20 17:40:24 -0700806 SafeSetError("Failed to set local audio description recv parameters.",
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700807 error_desc);
808 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000809 }
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700810 for (const AudioCodec& codec : audio->codecs()) {
zstein3dcf0e92017-06-01 13:22:42 -0700811 AddHandledPayloadType(codec.id);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700812 }
Zhi Huang365381f2018-04-13 16:44:34 -0700813 // Need to re-register the sink to update the handled payload.
814 if (!RegisterRtpDemuxerSink()) {
815 RTC_LOG(LS_ERROR) << "Failed to set up audio demuxing.";
816 return false;
817 }
818
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700819 last_recv_params_ = recv_params;
820
821 // TODO(pthatcher): Move local streams into AudioSendParameters, and
822 // only give it to the media channel once we have a remote
823 // description too (without a remote description, we won't be able
824 // to send them anyway).
Steve Anton3828c062017-12-06 10:34:51 -0800825 if (!UpdateLocalStreams_w(audio->streams(), type, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700826 SafeSetError("Failed to set local audio description streams.", error_desc);
827 return false;
828 }
829
830 set_local_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700831 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700832 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000833}
834
835bool VoiceChannel::SetRemoteContent_w(const MediaContentDescription* content,
Steve Anton3828c062017-12-06 10:34:51 -0800836 SdpType type,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000837 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +0100838 TRACE_EVENT0("webrtc", "VoiceChannel::SetRemoteContent_w");
Steve Antonb1c1de12017-12-21 15:14:30 -0800839 RTC_DCHECK_RUN_ON(worker_thread());
Mirko Bonadei675513b2017-11-09 11:09:25 +0100840 RTC_LOG(LS_INFO) << "Setting remote voice description";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000841
Steve Antonb1c1de12017-12-21 15:14:30 -0800842 RTC_DCHECK(content);
843 if (!content) {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000844 SafeSetError("Can't find audio content in remote description.", error_desc);
845 return false;
846 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000847
Steve Antonb1c1de12017-12-21 15:14:30 -0800848 const AudioContentDescription* audio = content->as_audio();
849
jbauch5869f502017-06-29 12:31:36 -0700850 RtpHeaderExtensions rtp_header_extensions =
851 GetFilteredRtpHeaderExtensions(audio->rtp_header_extensions());
852
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700853 AudioSendParameters send_params = last_send_params_;
jbauch5869f502017-06-29 12:31:36 -0700854 RtpSendParametersFromMediaDescription(audio, rtp_header_extensions,
Yves Gerey665174f2018-06-19 15:03:05 +0200855 &send_params);
Steve Antonbb50ce52018-03-26 10:24:32 -0700856 send_params.mid = content_name();
skvladdc1c62c2016-03-16 19:07:43 -0700857
858 bool parameters_applied = media_channel()->SetSendParameters(send_params);
859 if (!parameters_applied) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700860 SafeSetError("Failed to set remote audio description send parameters.",
861 error_desc);
862 return false;
863 }
864 last_send_params_ = send_params;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000865
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700866 // TODO(pthatcher): Move remote streams into AudioRecvParameters,
867 // and only give it to the media channel once we have a local
868 // description too (without a local description, we won't be able to
869 // recv them anyway).
Steve Anton3828c062017-12-06 10:34:51 -0800870 if (!UpdateRemoteStreams_w(audio->streams(), type, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700871 SafeSetError("Failed to set remote audio description streams.", error_desc);
872 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000873 }
874
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700875 set_remote_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700876 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700877 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000878}
879
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200880VideoChannel::VideoChannel(rtc::Thread* worker_thread,
881 rtc::Thread* network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -0800882 rtc::Thread* signaling_thread,
Steve Anton8699a322017-11-06 15:53:33 -0800883 std::unique_ptr<VideoMediaChannel> media_channel,
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000884 const std::string& content_name,
Zhi Huange830e682018-03-30 10:48:35 -0700885 bool srtp_required,
Benjamin Wrighta54daf12018-10-11 15:33:17 -0700886 webrtc::CryptoOptions crypto_options)
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200887 : BaseChannel(worker_thread,
888 network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -0800889 signaling_thread,
Steve Anton8699a322017-11-06 15:53:33 -0800890 std::move(media_channel),
deadbeefcbecd352015-09-23 11:50:27 -0700891 content_name,
Zhi Huange830e682018-03-30 10:48:35 -0700892 srtp_required,
893 crypto_options) {}
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000894
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000895VideoChannel::~VideoChannel() {
Peter Boströmca8b4042016-03-08 14:24:13 -0800896 TRACE_EVENT0("webrtc", "VideoChannel::~VideoChannel");
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000897 // this can't be done in the base class, since it calls a virtual
898 DisableMedia_w();
Zhi Huang0ffe03d2018-03-30 13:17:42 -0700899 Deinit();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000900}
901
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700902void VideoChannel::UpdateMediaSendRecvState_w() {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000903 // Send outgoing data if we're the active call, we have the remote content,
904 // and we have had some form of connectivity.
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700905 bool send = IsReadyToSendMedia_w();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000906 if (!media_channel()->SetSend(send)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100907 RTC_LOG(LS_ERROR) << "Failed to SetSend on video channel";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000908 // TODO(gangji): Report error back to server.
909 }
910
Mirko Bonadei675513b2017-11-09 11:09:25 +0100911 RTC_LOG(LS_INFO) << "Changing video state, send=" << send;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000912}
913
stefanf79ade12017-06-02 06:44:03 -0700914void VideoChannel::FillBitrateInfo(BandwidthEstimationInfo* bwe_info) {
915 InvokeOnWorker<void>(RTC_FROM_HERE, Bind(&VideoMediaChannel::FillBitrateInfo,
916 media_channel(), bwe_info));
917}
918
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000919bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content,
Steve Anton3828c062017-12-06 10:34:51 -0800920 SdpType type,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000921 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +0100922 TRACE_EVENT0("webrtc", "VideoChannel::SetLocalContent_w");
Steve Antonb1c1de12017-12-21 15:14:30 -0800923 RTC_DCHECK_RUN_ON(worker_thread());
Mirko Bonadei675513b2017-11-09 11:09:25 +0100924 RTC_LOG(LS_INFO) << "Setting local video description";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000925
Steve Antonb1c1de12017-12-21 15:14:30 -0800926 RTC_DCHECK(content);
927 if (!content) {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000928 SafeSetError("Can't find video content in local description.", error_desc);
929 return false;
930 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000931
Steve Antonb1c1de12017-12-21 15:14:30 -0800932 const VideoContentDescription* video = content->as_video();
933
jbauch5869f502017-06-29 12:31:36 -0700934 RtpHeaderExtensions rtp_header_extensions =
935 GetFilteredRtpHeaderExtensions(video->rtp_header_extensions());
Zhi Huang365381f2018-04-13 16:44:34 -0700936 UpdateRtpHeaderExtensionMap(rtp_header_extensions);
jbauch5869f502017-06-29 12:31:36 -0700937
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700938 VideoRecvParameters recv_params = last_recv_params_;
jbauch5869f502017-06-29 12:31:36 -0700939 RtpParametersFromMediaDescription(video, rtp_header_extensions, &recv_params);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700940 if (!media_channel()->SetRecvParameters(recv_params)) {
941 SafeSetError("Failed to set local video description recv parameters.",
942 error_desc);
943 return false;
944 }
945 for (const VideoCodec& codec : video->codecs()) {
zstein3dcf0e92017-06-01 13:22:42 -0700946 AddHandledPayloadType(codec.id);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700947 }
Zhi Huang365381f2018-04-13 16:44:34 -0700948 // Need to re-register the sink to update the handled payload.
949 if (!RegisterRtpDemuxerSink()) {
950 RTC_LOG(LS_ERROR) << "Failed to set up video demuxing.";
951 return false;
952 }
953
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700954 last_recv_params_ = recv_params;
955
956 // TODO(pthatcher): Move local streams into VideoSendParameters, and
957 // only give it to the media channel once we have a remote
958 // description too (without a remote description, we won't be able
959 // to send them anyway).
Steve Anton3828c062017-12-06 10:34:51 -0800960 if (!UpdateLocalStreams_w(video->streams(), type, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700961 SafeSetError("Failed to set local video description streams.", error_desc);
962 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000963 }
964
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700965 set_local_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700966 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700967 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000968}
969
970bool VideoChannel::SetRemoteContent_w(const MediaContentDescription* content,
Steve Anton3828c062017-12-06 10:34:51 -0800971 SdpType type,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000972 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +0100973 TRACE_EVENT0("webrtc", "VideoChannel::SetRemoteContent_w");
Steve Antonb1c1de12017-12-21 15:14:30 -0800974 RTC_DCHECK_RUN_ON(worker_thread());
Mirko Bonadei675513b2017-11-09 11:09:25 +0100975 RTC_LOG(LS_INFO) << "Setting remote video description";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000976
Steve Antonb1c1de12017-12-21 15:14:30 -0800977 RTC_DCHECK(content);
978 if (!content) {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000979 SafeSetError("Can't find video content in remote description.", error_desc);
980 return false;
981 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000982
Steve Antonb1c1de12017-12-21 15:14:30 -0800983 const VideoContentDescription* video = content->as_video();
984
jbauch5869f502017-06-29 12:31:36 -0700985 RtpHeaderExtensions rtp_header_extensions =
986 GetFilteredRtpHeaderExtensions(video->rtp_header_extensions());
987
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700988 VideoSendParameters send_params = last_send_params_;
jbauch5869f502017-06-29 12:31:36 -0700989 RtpSendParametersFromMediaDescription(video, rtp_header_extensions,
Yves Gerey665174f2018-06-19 15:03:05 +0200990 &send_params);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700991 if (video->conference_mode()) {
nisse4b4dc862016-02-17 05:25:36 -0800992 send_params.conference_mode = true;
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700993 }
Steve Antonbb50ce52018-03-26 10:24:32 -0700994 send_params.mid = content_name();
skvladdc1c62c2016-03-16 19:07:43 -0700995
996 bool parameters_applied = media_channel()->SetSendParameters(send_params);
997
998 if (!parameters_applied) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700999 SafeSetError("Failed to set remote video description send parameters.",
1000 error_desc);
1001 return false;
1002 }
1003 last_send_params_ = send_params;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001004
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001005 // TODO(pthatcher): Move remote streams into VideoRecvParameters,
1006 // and only give it to the media channel once we have a local
1007 // description too (without a local description, we won't be able to
1008 // recv them anyway).
Steve Anton3828c062017-12-06 10:34:51 -08001009 if (!UpdateRemoteStreams_w(video->streams(), type, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001010 SafeSetError("Failed to set remote video description streams.", error_desc);
1011 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001012 }
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001013 set_remote_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001014 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001015 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001016}
1017
deadbeef953c2ce2017-01-09 14:53:41 -08001018RtpDataChannel::RtpDataChannel(rtc::Thread* worker_thread,
1019 rtc::Thread* network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -08001020 rtc::Thread* signaling_thread,
Steve Anton8699a322017-11-06 15:53:33 -08001021 std::unique_ptr<DataMediaChannel> media_channel,
deadbeef953c2ce2017-01-09 14:53:41 -08001022 const std::string& content_name,
Zhi Huange830e682018-03-30 10:48:35 -07001023 bool srtp_required,
Benjamin Wrighta54daf12018-10-11 15:33:17 -07001024 webrtc::CryptoOptions crypto_options)
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001025 : BaseChannel(worker_thread,
1026 network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -08001027 signaling_thread,
Steve Anton8699a322017-11-06 15:53:33 -08001028 std::move(media_channel),
deadbeefcbecd352015-09-23 11:50:27 -07001029 content_name,
Zhi Huange830e682018-03-30 10:48:35 -07001030 srtp_required,
1031 crypto_options) {}
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001032
deadbeef953c2ce2017-01-09 14:53:41 -08001033RtpDataChannel::~RtpDataChannel() {
1034 TRACE_EVENT0("webrtc", "RtpDataChannel::~RtpDataChannel");
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001035 // this can't be done in the base class, since it calls a virtual
1036 DisableMedia_w();
Zhi Huang0ffe03d2018-03-30 13:17:42 -07001037 Deinit();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001038}
1039
Zhi Huang2dfc42d2017-12-04 13:38:48 -08001040void RtpDataChannel::Init_w(webrtc::RtpTransportInternal* rtp_transport) {
Anton Sukhanov98a462c2018-10-17 13:15:42 -07001041 BaseChannel::Init_w(rtp_transport, /*media_transport=*/nullptr);
Zhi Huang2dfc42d2017-12-04 13:38:48 -08001042 media_channel()->SignalDataReceived.connect(this,
1043 &RtpDataChannel::OnDataReceived);
1044 media_channel()->SignalReadyToSend.connect(
1045 this, &RtpDataChannel::OnDataChannelReadyToSend);
1046}
1047
deadbeef953c2ce2017-01-09 14:53:41 -08001048bool RtpDataChannel::SendData(const SendDataParams& params,
1049 const rtc::CopyOnWriteBuffer& payload,
1050 SendDataResult* result) {
stefanf79ade12017-06-02 06:44:03 -07001051 return InvokeOnWorker<bool>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001052 RTC_FROM_HERE, Bind(&DataMediaChannel::SendData, media_channel(), params,
1053 payload, result));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001054}
1055
deadbeef953c2ce2017-01-09 14:53:41 -08001056bool RtpDataChannel::CheckDataChannelTypeFromContent(
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001057 const DataContentDescription* content,
1058 std::string* error_desc) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001059 bool is_sctp = ((content->protocol() == kMediaProtocolSctp) ||
1060 (content->protocol() == kMediaProtocolDtlsSctp));
deadbeef953c2ce2017-01-09 14:53:41 -08001061 // It's been set before, but doesn't match. That's bad.
1062 if (is_sctp) {
1063 SafeSetError("Data channel type mismatch. Expected RTP, got SCTP.",
1064 error_desc);
1065 return false;
1066 }
1067 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001068}
1069
deadbeef953c2ce2017-01-09 14:53:41 -08001070bool RtpDataChannel::SetLocalContent_w(const MediaContentDescription* content,
Steve Anton3828c062017-12-06 10:34:51 -08001071 SdpType type,
deadbeef953c2ce2017-01-09 14:53:41 -08001072 std::string* error_desc) {
1073 TRACE_EVENT0("webrtc", "RtpDataChannel::SetLocalContent_w");
Steve Antonb1c1de12017-12-21 15:14:30 -08001074 RTC_DCHECK_RUN_ON(worker_thread());
Mirko Bonadei675513b2017-11-09 11:09:25 +01001075 RTC_LOG(LS_INFO) << "Setting local data description";
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001076
Steve Antonb1c1de12017-12-21 15:14:30 -08001077 RTC_DCHECK(content);
1078 if (!content) {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001079 SafeSetError("Can't find data content in local description.", error_desc);
1080 return false;
1081 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001082
Steve Antonb1c1de12017-12-21 15:14:30 -08001083 const DataContentDescription* data = content->as_data();
1084
deadbeef953c2ce2017-01-09 14:53:41 -08001085 if (!CheckDataChannelTypeFromContent(data, error_desc)) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001086 return false;
1087 }
1088
jbauch5869f502017-06-29 12:31:36 -07001089 RtpHeaderExtensions rtp_header_extensions =
1090 GetFilteredRtpHeaderExtensions(data->rtp_header_extensions());
1091
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001092 DataRecvParameters recv_params = last_recv_params_;
jbauch5869f502017-06-29 12:31:36 -07001093 RtpParametersFromMediaDescription(data, rtp_header_extensions, &recv_params);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001094 if (!media_channel()->SetRecvParameters(recv_params)) {
1095 SafeSetError("Failed to set remote data description recv parameters.",
1096 error_desc);
1097 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001098 }
deadbeef953c2ce2017-01-09 14:53:41 -08001099 for (const DataCodec& codec : data->codecs()) {
zstein3dcf0e92017-06-01 13:22:42 -07001100 AddHandledPayloadType(codec.id);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001101 }
Zhi Huang365381f2018-04-13 16:44:34 -07001102 // Need to re-register the sink to update the handled payload.
1103 if (!RegisterRtpDemuxerSink()) {
1104 RTC_LOG(LS_ERROR) << "Failed to set up data demuxing.";
1105 return false;
1106 }
1107
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001108 last_recv_params_ = recv_params;
1109
1110 // TODO(pthatcher): Move local streams into DataSendParameters, and
1111 // only give it to the media channel once we have a remote
1112 // description too (without a remote description, we won't be able
1113 // to send them anyway).
Steve Anton3828c062017-12-06 10:34:51 -08001114 if (!UpdateLocalStreams_w(data->streams(), type, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001115 SafeSetError("Failed to set local data description streams.", error_desc);
1116 return false;
1117 }
1118
1119 set_local_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001120 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001121 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001122}
1123
deadbeef953c2ce2017-01-09 14:53:41 -08001124bool RtpDataChannel::SetRemoteContent_w(const MediaContentDescription* content,
Steve Anton3828c062017-12-06 10:34:51 -08001125 SdpType type,
deadbeef953c2ce2017-01-09 14:53:41 -08001126 std::string* error_desc) {
1127 TRACE_EVENT0("webrtc", "RtpDataChannel::SetRemoteContent_w");
Steve Antonb1c1de12017-12-21 15:14:30 -08001128 RTC_DCHECK_RUN_ON(worker_thread());
1129 RTC_LOG(LS_INFO) << "Setting remote data description";
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001130
Steve Antonb1c1de12017-12-21 15:14:30 -08001131 RTC_DCHECK(content);
1132 if (!content) {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001133 SafeSetError("Can't find data content in remote description.", error_desc);
1134 return false;
1135 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001136
Steve Antonb1c1de12017-12-21 15:14:30 -08001137 const DataContentDescription* data = content->as_data();
1138
Zhi Huang801b8682017-11-15 11:36:43 -08001139 // If the remote data doesn't have codecs, it must be empty, so ignore it.
1140 if (!data->has_codecs()) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001141 return true;
1142 }
1143
deadbeef953c2ce2017-01-09 14:53:41 -08001144 if (!CheckDataChannelTypeFromContent(data, error_desc)) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001145 return false;
1146 }
1147
jbauch5869f502017-06-29 12:31:36 -07001148 RtpHeaderExtensions rtp_header_extensions =
1149 GetFilteredRtpHeaderExtensions(data->rtp_header_extensions());
1150
Mirko Bonadei675513b2017-11-09 11:09:25 +01001151 RTC_LOG(LS_INFO) << "Setting remote data description";
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001152 DataSendParameters send_params = last_send_params_;
jbauch5869f502017-06-29 12:31:36 -07001153 RtpSendParametersFromMediaDescription<DataCodec>(data, rtp_header_extensions,
Yves Gerey665174f2018-06-19 15:03:05 +02001154 &send_params);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001155 if (!media_channel()->SetSendParameters(send_params)) {
1156 SafeSetError("Failed to set remote data description send parameters.",
1157 error_desc);
1158 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001159 }
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001160 last_send_params_ = send_params;
1161
1162 // TODO(pthatcher): Move remote streams into DataRecvParameters,
1163 // and only give it to the media channel once we have a local
1164 // description too (without a local description, we won't be able to
1165 // recv them anyway).
Steve Anton3828c062017-12-06 10:34:51 -08001166 if (!UpdateRemoteStreams_w(data->streams(), type, error_desc)) {
Yves Gerey665174f2018-06-19 15:03:05 +02001167 SafeSetError("Failed to set remote data description streams.", error_desc);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001168 return false;
1169 }
1170
1171 set_remote_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001172 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001173 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001174}
1175
deadbeef953c2ce2017-01-09 14:53:41 -08001176void RtpDataChannel::UpdateMediaSendRecvState_w() {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001177 // Render incoming data if we're the active call, and we have the local
1178 // content. We receive data on the default channel and multiplexed streams.
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001179 bool recv = IsReadyToReceiveMedia_w();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001180 if (!media_channel()->SetReceive(recv)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001181 RTC_LOG(LS_ERROR) << "Failed to SetReceive on data channel";
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001182 }
1183
1184 // Send outgoing data if we're the active call, we have the remote content,
1185 // and we have had some form of connectivity.
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001186 bool send = IsReadyToSendMedia_w();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001187 if (!media_channel()->SetSend(send)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001188 RTC_LOG(LS_ERROR) << "Failed to SetSend on data channel";
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001189 }
1190
sergeyu@chromium.org9cf037b2014-02-07 19:03:26 +00001191 // Trigger SignalReadyToSendData asynchronously.
1192 OnDataChannelReadyToSend(send);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001193
Mirko Bonadei675513b2017-11-09 11:09:25 +01001194 RTC_LOG(LS_INFO) << "Changing data state, recv=" << recv << " send=" << send;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001195}
1196
deadbeef953c2ce2017-01-09 14:53:41 -08001197void RtpDataChannel::OnMessage(rtc::Message* pmsg) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001198 switch (pmsg->message_id) {
1199 case MSG_READYTOSENDDATA: {
wu@webrtc.orgd64719d2013-08-01 00:00:07 +00001200 DataChannelReadyToSendMessageData* data =
1201 static_cast<DataChannelReadyToSendMessageData*>(pmsg->pdata);
wu@webrtc.org07a6fbe2013-11-04 18:41:34 +00001202 ready_to_send_data_ = data->data();
1203 SignalReadyToSendData(ready_to_send_data_);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001204 delete data;
1205 break;
1206 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001207 case MSG_DATARECEIVED: {
1208 DataReceivedMessageData* data =
1209 static_cast<DataReceivedMessageData*>(pmsg->pdata);
deadbeef953c2ce2017-01-09 14:53:41 -08001210 SignalDataReceived(data->params, data->payload);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001211 delete data;
1212 break;
1213 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001214 default:
1215 BaseChannel::OnMessage(pmsg);
1216 break;
1217 }
1218}
1219
deadbeef953c2ce2017-01-09 14:53:41 -08001220void RtpDataChannel::OnDataReceived(const ReceiveDataParams& params,
1221 const char* data,
1222 size_t len) {
Yves Gerey665174f2018-06-19 15:03:05 +02001223 DataReceivedMessageData* msg = new DataReceivedMessageData(params, data, len);
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001224 signaling_thread()->Post(RTC_FROM_HERE, this, MSG_DATARECEIVED, msg);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001225}
1226
deadbeef953c2ce2017-01-09 14:53:41 -08001227void RtpDataChannel::OnDataChannelReadyToSend(bool writable) {
wu@webrtc.orgd64719d2013-08-01 00:00:07 +00001228 // This is usded for congestion control to indicate that the stream is ready
1229 // to send by the MediaChannel, as opposed to OnReadyToSend, which indicates
1230 // that the transport channel is ready.
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001231 signaling_thread()->Post(RTC_FROM_HERE, this, MSG_READYTOSENDDATA,
wu@webrtc.orgd64719d2013-08-01 00:00:07 +00001232 new DataChannelReadyToSendMessageData(writable));
1233}
1234
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001235} // namespace cricket