blob: 563464833644feb19770888d9ff3e9ad5a9dfaa2 [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
kwiberg0eb15ed2015-12-17 03:04:15 -080011#include <utility>
12
kjellander@webrtc.org9b8df252016-02-12 06:47:59 +010013#include "webrtc/pc/channel.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000014
kjellandera69d9732016-08-31 07:33:05 -070015#include "webrtc/api/call/audio_sink.h"
buildbot@webrtc.org65b98d12014-08-07 22:09:08 +000016#include "webrtc/base/bind.h"
buildbot@webrtc.org65b98d12014-08-07 22:09:08 +000017#include "webrtc/base/byteorder.h"
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -070018#include "webrtc/base/checks.h"
jbaucheec21bd2016-03-20 06:15:43 -070019#include "webrtc/base/copyonwritebuffer.h"
buildbot@webrtc.org65b98d12014-08-07 22:09:08 +000020#include "webrtc/base/dscp.h"
21#include "webrtc/base/logging.h"
Honghai Zhangcc411c02016-03-29 17:27:21 -070022#include "webrtc/base/networkroute.h"
Peter Boström6f28cf02015-12-07 23:17:15 +010023#include "webrtc/base/trace_event.h"
kjellanderf4752772016-03-02 05:42:30 -080024#include "webrtc/media/base/mediaconstants.h"
kjellandera96e2d72016-02-04 23:52:28 -080025#include "webrtc/media/base/rtputils.h"
deadbeef5bd5ca32017-02-10 11:31:50 -080026#include "webrtc/p2p/base/packettransportinternal.h"
kjellander@webrtc.org9b8df252016-02-12 06:47:59 +010027#include "webrtc/pc/channelmanager.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000028
29namespace cricket {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000030using rtc::Bind;
sergeyu@chromium.org9cf037b2014-02-07 19:03:26 +000031
deadbeef2d110be2016-01-13 12:00:26 -080032namespace {
kwiberg31022942016-03-11 14:18:21 -080033// See comment below for why we need to use a pointer to a unique_ptr.
deadbeef2d110be2016-01-13 12:00:26 -080034bool SetRawAudioSink_w(VoiceMediaChannel* channel,
35 uint32_t ssrc,
kwiberg31022942016-03-11 14:18:21 -080036 std::unique_ptr<webrtc::AudioSinkInterface>* sink) {
37 channel->SetRawAudioSink(ssrc, std::move(*sink));
deadbeef2d110be2016-01-13 12:00:26 -080038 return true;
39}
Danil Chapovalov33b01f22016-05-11 19:55:27 +020040
41struct SendPacketMessageData : public rtc::MessageData {
42 rtc::CopyOnWriteBuffer packet;
43 rtc::PacketOptions options;
44};
45
isheriff6f8d6862016-05-26 11:24:55 -070046#if defined(ENABLE_EXTERNAL_AUTH)
47// Returns the named header extension if found among all extensions,
48// nullptr otherwise.
49const webrtc::RtpExtension* FindHeaderExtension(
50 const std::vector<webrtc::RtpExtension>& extensions,
51 const std::string& uri) {
52 for (const auto& extension : extensions) {
53 if (extension.uri == uri)
54 return &extension;
55 }
56 return nullptr;
57}
58#endif
59
deadbeef2d110be2016-01-13 12:00:26 -080060} // namespace
61
henrike@webrtc.org28e20752013-07-10 00:45:36 +000062enum {
sergeyu@chromium.org9cf037b2014-02-07 19:03:26 +000063 MSG_EARLYMEDIATIMEOUT = 1,
Danil Chapovalov33b01f22016-05-11 19:55:27 +020064 MSG_SEND_RTP_PACKET,
65 MSG_SEND_RTCP_PACKET,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000066 MSG_CHANNEL_ERROR,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000067 MSG_READYTOSENDDATA,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000068 MSG_DATARECEIVED,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000069 MSG_FIRSTPACKETRECEIVED,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000070};
71
72// Value specified in RFC 5764.
73static const char kDtlsSrtpExporterLabel[] = "EXTRACTOR-dtls_srtp";
74
75static const int kAgcMinus10db = -10;
76
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +000077static void SafeSetError(const std::string& message, std::string* error_desc) {
78 if (error_desc) {
79 *error_desc = message;
80 }
81}
82
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000083struct VoiceChannelErrorMessageData : public rtc::MessageData {
Peter Boström0c4e06b2015-10-07 12:23:21 +020084 VoiceChannelErrorMessageData(uint32_t in_ssrc,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000085 VoiceMediaChannel::Error in_error)
Peter Boström0c4e06b2015-10-07 12:23:21 +020086 : ssrc(in_ssrc), error(in_error) {}
87 uint32_t ssrc;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000088 VoiceMediaChannel::Error error;
89};
90
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000091struct VideoChannelErrorMessageData : public rtc::MessageData {
Peter Boström0c4e06b2015-10-07 12:23:21 +020092 VideoChannelErrorMessageData(uint32_t in_ssrc,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000093 VideoMediaChannel::Error in_error)
Peter Boström0c4e06b2015-10-07 12:23:21 +020094 : ssrc(in_ssrc), error(in_error) {}
95 uint32_t ssrc;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000096 VideoMediaChannel::Error error;
97};
98
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000099struct DataChannelErrorMessageData : public rtc::MessageData {
Peter Boström0c4e06b2015-10-07 12:23:21 +0200100 DataChannelErrorMessageData(uint32_t in_ssrc,
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000101 DataMediaChannel::Error in_error)
Peter Boström0c4e06b2015-10-07 12:23:21 +0200102 : ssrc(in_ssrc), error(in_error) {}
103 uint32_t ssrc;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000104 DataMediaChannel::Error error;
105};
106
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000107static const char* PacketType(bool rtcp) {
108 return (!rtcp) ? "RTP" : "RTCP";
109}
110
jbaucheec21bd2016-03-20 06:15:43 -0700111static bool ValidPacket(bool rtcp, const rtc::CopyOnWriteBuffer* packet) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000112 // Check the packet size. We could check the header too if needed.
113 return (packet &&
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +0000114 packet->size() >= (!rtcp ? kMinRtpPacketLen : kMinRtcpPacketLen) &&
115 packet->size() <= kMaxRtpPacketLen);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000116}
117
118static bool IsReceiveContentDirection(MediaContentDirection direction) {
119 return direction == MD_SENDRECV || direction == MD_RECVONLY;
120}
121
122static bool IsSendContentDirection(MediaContentDirection direction) {
123 return direction == MD_SENDRECV || direction == MD_SENDONLY;
124}
125
126static const MediaContentDescription* GetContentDescription(
127 const ContentInfo* cinfo) {
128 if (cinfo == NULL)
129 return NULL;
130 return static_cast<const MediaContentDescription*>(cinfo->description);
131}
132
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700133template <class Codec>
134void RtpParametersFromMediaDescription(
135 const MediaContentDescriptionImpl<Codec>* desc,
136 RtpParameters<Codec>* params) {
137 // TODO(pthatcher): Remove this once we're sure no one will give us
138 // a description without codecs (currently a CA_UPDATE with just
139 // streams can).
140 if (desc->has_codecs()) {
141 params->codecs = desc->codecs();
142 }
143 // TODO(pthatcher): See if we really need
144 // rtp_header_extensions_set() and remove it if we don't.
145 if (desc->rtp_header_extensions_set()) {
146 params->extensions = desc->rtp_header_extensions();
147 }
deadbeef13871492015-12-09 12:37:51 -0800148 params->rtcp.reduced_size = desc->rtcp_reduced_size();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700149}
150
nisse05103312016-03-16 02:22:50 -0700151template <class Codec>
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700152void RtpSendParametersFromMediaDescription(
153 const MediaContentDescriptionImpl<Codec>* desc,
nisse05103312016-03-16 02:22:50 -0700154 RtpSendParameters<Codec>* send_params) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700155 RtpParametersFromMediaDescription(desc, send_params);
156 send_params->max_bandwidth_bps = desc->bandwidth();
157}
158
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200159BaseChannel::BaseChannel(rtc::Thread* worker_thread,
160 rtc::Thread* network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -0800161 rtc::Thread* signaling_thread,
deadbeefcbecd352015-09-23 11:50:27 -0700162 MediaChannel* media_channel,
deadbeefcbecd352015-09-23 11:50:27 -0700163 const std::string& content_name,
deadbeefac22f702017-01-12 21:59:29 -0800164 bool rtcp_mux_required,
deadbeef7af91dd2016-12-13 11:29:11 -0800165 bool srtp_required)
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200166 : worker_thread_(worker_thread),
167 network_thread_(network_thread),
zhihuangf5b251b2017-01-12 19:37:48 -0800168 signaling_thread_(signaling_thread),
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000169 content_name_(content_name),
zsteind48dbda2017-04-04 19:45:57 -0700170 rtp_transport_(rtcp_mux_required),
deadbeef7af91dd2016-12-13 11:29:11 -0800171 srtp_required_(srtp_required),
michaelt79e05882016-11-08 02:50:09 -0800172 media_channel_(media_channel),
173 selected_candidate_pair_(nullptr) {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700174 RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
jbauchdfcab722017-03-06 00:14:10 -0800175#if defined(ENABLE_EXTERNAL_AUTH)
176 srtp_filter_.EnableExternalAuth();
177#endif
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000178 LOG(LS_INFO) << "Created channel for " << content_name;
179}
180
181BaseChannel::~BaseChannel() {
Peter Boströmca8b4042016-03-08 14:24:13 -0800182 TRACE_EVENT0("webrtc", "BaseChannel::~BaseChannel");
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700183 RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
wu@webrtc.org78187522013-10-07 23:32:02 +0000184 Deinit();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000185 StopConnectionMonitor();
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200186 // Eats any outstanding messages or packets.
187 worker_thread_->Clear(&invoker_);
188 worker_thread_->Clear(this);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000189 // We must destroy the media channel before the transport channel, otherwise
190 // the media channel may try to send on the dead transport channel. NULLing
191 // is not an effective strategy since the sends will come on another thread.
192 delete media_channel_;
zhihuangf5b251b2017-01-12 19:37:48 -0800193 LOG(LS_INFO) << "Destroyed channel: " << content_name_;
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200194}
195
Danil Chapovalovdae07ba2016-05-14 01:43:50 +0200196void BaseChannel::DisconnectTransportChannels_n() {
197 // Send any outstanding RTCP packets.
198 FlushRtcpMessages_n();
199
200 // Stop signals from transport channels, but keep them alive because
201 // media_channel may use them from a different thread.
zhihuangb2cdd932017-01-19 16:54:25 -0800202 if (rtp_dtls_transport_) {
deadbeeff5346592017-01-24 21:51:21 -0800203 DisconnectFromDtlsTransport(rtp_dtls_transport_);
zsteind48dbda2017-04-04 19:45:57 -0700204 } else if (rtp_transport_.rtp_packet_transport()) {
205 DisconnectFromPacketTransport(rtp_transport_.rtp_packet_transport());
Danil Chapovalovdae07ba2016-05-14 01:43:50 +0200206 }
zhihuangb2cdd932017-01-19 16:54:25 -0800207 if (rtcp_dtls_transport_) {
deadbeeff5346592017-01-24 21:51:21 -0800208 DisconnectFromDtlsTransport(rtcp_dtls_transport_);
zsteind48dbda2017-04-04 19:45:57 -0700209 } else if (rtp_transport_.rtcp_packet_transport()) {
210 DisconnectFromPacketTransport(rtp_transport_.rtcp_packet_transport());
Danil Chapovalovdae07ba2016-05-14 01:43:50 +0200211 }
212
213 // Clear pending read packets/messages.
214 network_thread_->Clear(&invoker_);
215 network_thread_->Clear(this);
216}
217
zhihuangb2cdd932017-01-19 16:54:25 -0800218bool BaseChannel::Init_w(DtlsTransportInternal* rtp_dtls_transport,
deadbeeff5346592017-01-24 21:51:21 -0800219 DtlsTransportInternal* rtcp_dtls_transport,
deadbeef5bd5ca32017-02-10 11:31:50 -0800220 rtc::PacketTransportInternal* rtp_packet_transport,
221 rtc::PacketTransportInternal* rtcp_packet_transport) {
skvlad6c87a672016-05-17 17:49:52 -0700222 if (!network_thread_->Invoke<bool>(
zhihuangb2cdd932017-01-19 16:54:25 -0800223 RTC_FROM_HERE, Bind(&BaseChannel::InitNetwork_n, this,
deadbeeff5346592017-01-24 21:51:21 -0800224 rtp_dtls_transport, rtcp_dtls_transport,
225 rtp_packet_transport, rtcp_packet_transport))) {
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000226 return false;
227 }
deadbeeff5346592017-01-24 21:51:21 -0800228 // Both RTP and RTCP channels should be set, we can call SetInterface on
229 // the media channel and it can set network options.
230 RTC_DCHECK_RUN_ON(worker_thread_);
wu@webrtc.orgde305012013-10-31 15:40:38 +0000231 media_channel_->SetInterface(this);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000232 return true;
233}
234
deadbeeff5346592017-01-24 21:51:21 -0800235bool BaseChannel::InitNetwork_n(
236 DtlsTransportInternal* rtp_dtls_transport,
237 DtlsTransportInternal* rtcp_dtls_transport,
deadbeef5bd5ca32017-02-10 11:31:50 -0800238 rtc::PacketTransportInternal* rtp_packet_transport,
239 rtc::PacketTransportInternal* rtcp_packet_transport) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200240 RTC_DCHECK(network_thread_->IsCurrent());
deadbeeff5346592017-01-24 21:51:21 -0800241 SetTransports_n(rtp_dtls_transport, rtcp_dtls_transport, rtp_packet_transport,
242 rtcp_packet_transport);
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200243
deadbeeff5346592017-01-24 21:51:21 -0800244 if (rtp_dtls_transport_ &&
245 !SetDtlsSrtpCryptoSuites_n(rtp_dtls_transport_, false)) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200246 return false;
247 }
zhihuangb2cdd932017-01-19 16:54:25 -0800248 if (rtcp_dtls_transport_ &&
249 !SetDtlsSrtpCryptoSuites_n(rtcp_dtls_transport_, true)) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200250 return false;
251 }
zsteind48dbda2017-04-04 19:45:57 -0700252 if (rtp_transport_.rtcp_mux_required()) {
deadbeefac22f702017-01-12 21:59:29 -0800253 rtcp_mux_filter_.SetActive();
254 }
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200255 return true;
256}
257
wu@webrtc.org78187522013-10-07 23:32:02 +0000258void BaseChannel::Deinit() {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200259 RTC_DCHECK(worker_thread_->IsCurrent());
wu@webrtc.org78187522013-10-07 23:32:02 +0000260 media_channel_->SetInterface(NULL);
Danil Chapovalovdae07ba2016-05-14 01:43:50 +0200261 // Packets arrive on the network thread, processing packets calls virtual
262 // functions, so need to stop this process in Deinit that is called in
263 // derived classes destructor.
264 network_thread_->Invoke<void>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700265 RTC_FROM_HERE, Bind(&BaseChannel::DisconnectTransportChannels_n, this));
wu@webrtc.org78187522013-10-07 23:32:02 +0000266}
267
zhihuangb2cdd932017-01-19 16:54:25 -0800268void BaseChannel::SetTransports(DtlsTransportInternal* rtp_dtls_transport,
269 DtlsTransportInternal* rtcp_dtls_transport) {
deadbeeff5346592017-01-24 21:51:21 -0800270 network_thread_->Invoke<void>(
271 RTC_FROM_HERE,
272 Bind(&BaseChannel::SetTransports_n, this, rtp_dtls_transport,
273 rtcp_dtls_transport, rtp_dtls_transport, rtcp_dtls_transport));
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000274}
275
deadbeeff5346592017-01-24 21:51:21 -0800276void BaseChannel::SetTransports(
deadbeef5bd5ca32017-02-10 11:31:50 -0800277 rtc::PacketTransportInternal* rtp_packet_transport,
278 rtc::PacketTransportInternal* rtcp_packet_transport) {
deadbeeff5346592017-01-24 21:51:21 -0800279 network_thread_->Invoke<void>(
280 RTC_FROM_HERE, Bind(&BaseChannel::SetTransports_n, this, nullptr, nullptr,
281 rtp_packet_transport, rtcp_packet_transport));
282}
zhihuangf5b251b2017-01-12 19:37:48 -0800283
deadbeeff5346592017-01-24 21:51:21 -0800284void BaseChannel::SetTransports_n(
285 DtlsTransportInternal* rtp_dtls_transport,
286 DtlsTransportInternal* rtcp_dtls_transport,
deadbeef5bd5ca32017-02-10 11:31:50 -0800287 rtc::PacketTransportInternal* rtp_packet_transport,
288 rtc::PacketTransportInternal* rtcp_packet_transport) {
deadbeeff5346592017-01-24 21:51:21 -0800289 RTC_DCHECK(network_thread_->IsCurrent());
290 // Validate some assertions about the input.
291 RTC_DCHECK(rtp_packet_transport);
292 RTC_DCHECK_EQ(NeedsRtcpTransport(), rtcp_packet_transport != nullptr);
293 if (rtp_dtls_transport || rtcp_dtls_transport) {
294 // DTLS/non-DTLS pointers should be to the same object.
295 RTC_DCHECK(rtp_dtls_transport == rtp_packet_transport);
296 RTC_DCHECK(rtcp_dtls_transport == rtcp_packet_transport);
297 // Can't go from non-DTLS to DTLS.
zsteind48dbda2017-04-04 19:45:57 -0700298 RTC_DCHECK(!rtp_transport_.rtp_packet_transport() || rtp_dtls_transport_);
deadbeeff5346592017-01-24 21:51:21 -0800299 } else {
300 // Can't go from DTLS to non-DTLS.
301 RTC_DCHECK(!rtp_dtls_transport_);
302 }
303 // Transport names should be the same.
zhihuangb2cdd932017-01-19 16:54:25 -0800304 if (rtp_dtls_transport && rtcp_dtls_transport) {
305 RTC_DCHECK(rtp_dtls_transport->transport_name() ==
306 rtcp_dtls_transport->transport_name());
zhihuangb2cdd932017-01-19 16:54:25 -0800307 }
deadbeeff5346592017-01-24 21:51:21 -0800308 std::string debug_name;
309 if (rtp_dtls_transport) {
310 transport_name_ = rtp_dtls_transport->transport_name();
311 debug_name = transport_name_;
312 } else {
313 debug_name = rtp_packet_transport->debug_name();
314 }
zsteind48dbda2017-04-04 19:45:57 -0700315 if (rtp_packet_transport == rtp_transport_.rtp_packet_transport()) {
deadbeeff5346592017-01-24 21:51:21 -0800316 // Nothing to do if transport isn't changing.
deadbeefbad5dad2017-01-17 18:32:35 -0800317 return;
deadbeefcbecd352015-09-23 11:50:27 -0700318 }
319
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -0800320 // When using DTLS-SRTP, we must reset the SrtpFilter every time the transport
321 // changes and wait until the DTLS handshake is complete to set the newly
322 // negotiated parameters.
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200323 if (ShouldSetupDtlsSrtp_n()) {
guoweis46383312015-12-17 16:45:59 -0800324 // Set |writable_| to false such that UpdateWritableState_w can set up
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700325 // DTLS-SRTP when |writable_| becomes true again.
guoweis46383312015-12-17 16:45:59 -0800326 writable_ = false;
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -0800327 srtp_filter_.ResetParams();
328 }
329
deadbeefac22f702017-01-12 21:59:29 -0800330 // If this BaseChannel doesn't require RTCP mux and we haven't fully
331 // negotiated RTCP mux, we need an RTCP transport.
deadbeeff5346592017-01-24 21:51:21 -0800332 if (rtcp_packet_transport) {
zhihuangf5b251b2017-01-12 19:37:48 -0800333 LOG(LS_INFO) << "Setting RTCP Transport for " << content_name() << " on "
deadbeeff5346592017-01-24 21:51:21 -0800334 << debug_name << " transport " << rtcp_packet_transport;
335 SetTransport_n(true, rtcp_dtls_transport, rtcp_packet_transport);
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000336 }
337
deadbeeff5346592017-01-24 21:51:21 -0800338 LOG(LS_INFO) << "Setting RTP Transport for " << content_name() << " on "
339 << debug_name << " transport " << rtp_packet_transport;
340 SetTransport_n(false, rtp_dtls_transport, rtp_packet_transport);
guoweis46383312015-12-17 16:45:59 -0800341
deadbeefcbecd352015-09-23 11:50:27 -0700342 // Update aggregate writable/ready-to-send state between RTP and RTCP upon
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700343 // setting new transport channels.
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200344 UpdateWritableState_n();
deadbeef062ce9f2016-08-26 21:42:15 -0700345 // We can only update ready-to-send after updating writability.
346 //
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700347 // On setting a new channel, assume it's ready to send if it's writable,
348 // because we have no way of knowing otherwise (the channel doesn't give us
349 // "was last send successful?").
350 //
351 // This won't always be accurate (the last SendPacket call from another
352 // BaseChannel could have resulted in an error), but even so, we'll just
353 // encounter the error again and update "ready to send" accordingly.
deadbeef062ce9f2016-08-26 21:42:15 -0700354 SetTransportChannelReadyToSend(
zsteind48dbda2017-04-04 19:45:57 -0700355 false, rtp_packet_transport && rtp_packet_transport->writable());
zhihuangb2cdd932017-01-19 16:54:25 -0800356 SetTransportChannelReadyToSend(
zsteind48dbda2017-04-04 19:45:57 -0700357 true, rtcp_packet_transport && rtcp_packet_transport->writable());
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000358}
359
deadbeeff5346592017-01-24 21:51:21 -0800360void BaseChannel::SetTransport_n(
361 bool rtcp,
362 DtlsTransportInternal* new_dtls_transport,
deadbeef5bd5ca32017-02-10 11:31:50 -0800363 rtc::PacketTransportInternal* new_packet_transport) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200364 RTC_DCHECK(network_thread_->IsCurrent());
deadbeeff5346592017-01-24 21:51:21 -0800365 DtlsTransportInternal*& old_dtls_transport =
zhihuangb2cdd932017-01-19 16:54:25 -0800366 rtcp ? rtcp_dtls_transport_ : rtp_dtls_transport_;
zsteind48dbda2017-04-04 19:45:57 -0700367 rtc::PacketTransportInternal* old_packet_transport =
368 rtcp ? rtp_transport_.rtcp_packet_transport()
369 : rtp_transport_.rtp_packet_transport();
zhihuangb2cdd932017-01-19 16:54:25 -0800370
deadbeeff5346592017-01-24 21:51:21 -0800371 if (!old_packet_transport && !new_packet_transport) {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700372 // Nothing to do.
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000373 return;
374 }
zhihuangb2cdd932017-01-19 16:54:25 -0800375
deadbeeff5346592017-01-24 21:51:21 -0800376 RTC_DCHECK(old_packet_transport != new_packet_transport);
377 if (old_dtls_transport) {
378 DisconnectFromDtlsTransport(old_dtls_transport);
379 } else if (old_packet_transport) {
380 DisconnectFromPacketTransport(old_packet_transport);
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000381 }
382
zsteind48dbda2017-04-04 19:45:57 -0700383 if (rtcp) {
384 rtp_transport_.set_rtcp_packet_transport(new_packet_transport);
385 } else {
386 rtp_transport_.set_rtp_packet_transport(new_packet_transport);
387 }
deadbeeff5346592017-01-24 21:51:21 -0800388 old_dtls_transport = new_dtls_transport;
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000389
deadbeeff5346592017-01-24 21:51:21 -0800390 // If there's no new transport, we're done after disconnecting from old one.
391 if (!new_packet_transport) {
392 return;
393 }
394
395 if (rtcp && new_dtls_transport) {
396 RTC_CHECK(!(ShouldSetupDtlsSrtp_n() && srtp_filter_.IsActive()))
397 << "Setting RTCP for DTLS/SRTP after SrtpFilter is active "
398 << "should never happen.";
399 }
400 if (new_dtls_transport) {
401 ConnectToDtlsTransport(new_dtls_transport);
402 } else {
403 ConnectToPacketTransport(new_packet_transport);
404 }
405 auto& socket_options = rtcp ? rtcp_socket_options_ : socket_options_;
406 for (const auto& pair : socket_options) {
407 new_packet_transport->SetOption(pair.first, pair.second);
guoweis46383312015-12-17 16:45:59 -0800408 }
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000409}
410
deadbeeff5346592017-01-24 21:51:21 -0800411void BaseChannel::ConnectToDtlsTransport(DtlsTransportInternal* transport) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200412 RTC_DCHECK(network_thread_->IsCurrent());
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000413
zhihuangb2cdd932017-01-19 16:54:25 -0800414 transport->SignalWritableState.connect(this, &BaseChannel::OnWritableState);
415 transport->SignalReadPacket.connect(this, &BaseChannel::OnPacketRead);
416 transport->SignalReadyToSend.connect(this, &BaseChannel::OnReadyToSend);
417 transport->SignalDtlsState.connect(this, &BaseChannel::OnDtlsState);
418 transport->SignalSentPacket.connect(this, &BaseChannel::SignalSentPacket_n);
419 transport->ice_transport()->SignalSelectedCandidatePairChanged.connect(
Honghai Zhangcc411c02016-03-29 17:27:21 -0700420 this, &BaseChannel::OnSelectedCandidatePairChanged);
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000421}
422
deadbeeff5346592017-01-24 21:51:21 -0800423void BaseChannel::DisconnectFromDtlsTransport(
424 DtlsTransportInternal* transport) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200425 RTC_DCHECK(network_thread_->IsCurrent());
zhihuangb2cdd932017-01-19 16:54:25 -0800426 OnSelectedCandidatePairChanged(transport->ice_transport(), nullptr, -1,
427 false);
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000428
zhihuangb2cdd932017-01-19 16:54:25 -0800429 transport->SignalWritableState.disconnect(this);
430 transport->SignalReadPacket.disconnect(this);
431 transport->SignalReadyToSend.disconnect(this);
432 transport->SignalDtlsState.disconnect(this);
433 transport->SignalSentPacket.disconnect(this);
434 transport->ice_transport()->SignalSelectedCandidatePairChanged.disconnect(
435 this);
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000436}
437
deadbeeff5346592017-01-24 21:51:21 -0800438void BaseChannel::ConnectToPacketTransport(
deadbeef5bd5ca32017-02-10 11:31:50 -0800439 rtc::PacketTransportInternal* transport) {
deadbeeff5346592017-01-24 21:51:21 -0800440 RTC_DCHECK_RUN_ON(network_thread_);
441 transport->SignalWritableState.connect(this, &BaseChannel::OnWritableState);
442 transport->SignalReadPacket.connect(this, &BaseChannel::OnPacketRead);
443 transport->SignalReadyToSend.connect(this, &BaseChannel::OnReadyToSend);
444 transport->SignalSentPacket.connect(this, &BaseChannel::SignalSentPacket_n);
445}
446
447void BaseChannel::DisconnectFromPacketTransport(
deadbeef5bd5ca32017-02-10 11:31:50 -0800448 rtc::PacketTransportInternal* transport) {
deadbeeff5346592017-01-24 21:51:21 -0800449 RTC_DCHECK_RUN_ON(network_thread_);
450 transport->SignalWritableState.disconnect(this);
451 transport->SignalReadPacket.disconnect(this);
452 transport->SignalReadyToSend.disconnect(this);
453 transport->SignalSentPacket.disconnect(this);
454}
455
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000456bool BaseChannel::Enable(bool enable) {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700457 worker_thread_->Invoke<void>(
458 RTC_FROM_HERE,
459 Bind(enable ? &BaseChannel::EnableMedia_w : &BaseChannel::DisableMedia_w,
460 this));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000461 return true;
462}
463
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000464bool BaseChannel::AddRecvStream(const StreamParams& sp) {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700465 return InvokeOnWorker(RTC_FROM_HERE,
466 Bind(&BaseChannel::AddRecvStream_w, this, sp));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000467}
468
Peter Boström0c4e06b2015-10-07 12:23:21 +0200469bool BaseChannel::RemoveRecvStream(uint32_t ssrc) {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700470 return InvokeOnWorker(RTC_FROM_HERE,
471 Bind(&BaseChannel::RemoveRecvStream_w, this, ssrc));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000472}
473
wu@webrtc.orgcadf9042013-08-30 21:24:16 +0000474bool BaseChannel::AddSendStream(const StreamParams& sp) {
sergeyu@chromium.org9cf037b2014-02-07 19:03:26 +0000475 return InvokeOnWorker(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700476 RTC_FROM_HERE, Bind(&MediaChannel::AddSendStream, media_channel(), sp));
wu@webrtc.orgcadf9042013-08-30 21:24:16 +0000477}
478
Peter Boström0c4e06b2015-10-07 12:23:21 +0200479bool BaseChannel::RemoveSendStream(uint32_t ssrc) {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700480 return InvokeOnWorker(RTC_FROM_HERE, Bind(&MediaChannel::RemoveSendStream,
481 media_channel(), ssrc));
wu@webrtc.orgcadf9042013-08-30 21:24:16 +0000482}
483
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000484bool BaseChannel::SetLocalContent(const MediaContentDescription* content,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000485 ContentAction action,
486 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +0100487 TRACE_EVENT0("webrtc", "BaseChannel::SetLocalContent");
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700488 return InvokeOnWorker(RTC_FROM_HERE, Bind(&BaseChannel::SetLocalContent_w,
489 this, content, action, error_desc));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000490}
491
492bool BaseChannel::SetRemoteContent(const MediaContentDescription* content,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000493 ContentAction action,
494 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +0100495 TRACE_EVENT0("webrtc", "BaseChannel::SetRemoteContent");
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700496 return InvokeOnWorker(RTC_FROM_HERE, Bind(&BaseChannel::SetRemoteContent_w,
497 this, content, action, error_desc));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000498}
499
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000500void BaseChannel::StartConnectionMonitor(int cms) {
zhihuangb2cdd932017-01-19 16:54:25 -0800501 // We pass in the BaseChannel instead of the rtp_dtls_transport_
502 // because if the rtp_dtls_transport_ changes, the ConnectionMonitor
pthatcher@webrtc.orgb4aac132015-03-13 18:25:21 +0000503 // would be pointing to the wrong TransportChannel.
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200504 // We pass in the network thread because on that thread connection monitor
505 // will call BaseChannel::GetConnectionStats which must be called on the
506 // network thread.
507 connection_monitor_.reset(
508 new ConnectionMonitor(this, network_thread(), rtc::Thread::Current()));
pthatcher@webrtc.orgb4aac132015-03-13 18:25:21 +0000509 connection_monitor_->SignalUpdate.connect(
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000510 this, &BaseChannel::OnConnectionMonitorUpdate);
pthatcher@webrtc.orgb4aac132015-03-13 18:25:21 +0000511 connection_monitor_->Start(cms);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000512}
513
514void BaseChannel::StopConnectionMonitor() {
pthatcher@webrtc.orgb4aac132015-03-13 18:25:21 +0000515 if (connection_monitor_) {
516 connection_monitor_->Stop();
517 connection_monitor_.reset();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000518 }
519}
520
pthatcher@webrtc.orgb4aac132015-03-13 18:25:21 +0000521bool BaseChannel::GetConnectionStats(ConnectionInfos* infos) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200522 RTC_DCHECK(network_thread_->IsCurrent());
deadbeeff5346592017-01-24 21:51:21 -0800523 if (!rtp_dtls_transport_) {
524 return false;
525 }
zhihuangb2cdd932017-01-19 16:54:25 -0800526 return rtp_dtls_transport_->ice_transport()->GetStats(infos);
zhihuangf5b251b2017-01-12 19:37:48 -0800527}
528
529bool BaseChannel::NeedsRtcpTransport() {
deadbeefac22f702017-01-12 21:59:29 -0800530 // If this BaseChannel doesn't require RTCP mux and we haven't fully
531 // negotiated RTCP mux, we need an RTCP transport.
zsteind48dbda2017-04-04 19:45:57 -0700532 return !rtp_transport_.rtcp_mux_required() &&
533 !rtcp_mux_filter_.IsFullyActive();
pthatcher@webrtc.orgb4aac132015-03-13 18:25:21 +0000534}
535
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700536bool BaseChannel::IsReadyToReceiveMedia_w() const {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000537 // Receive data if we are enabled and have local content,
538 return enabled() && IsReceiveContentDirection(local_content_direction_);
539}
540
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700541bool BaseChannel::IsReadyToSendMedia_w() const {
542 // Need to access some state updated on the network thread.
543 return network_thread_->Invoke<bool>(
544 RTC_FROM_HERE, Bind(&BaseChannel::IsReadyToSendMedia_n, this));
545}
546
547bool BaseChannel::IsReadyToSendMedia_n() const {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000548 // Send outgoing data if we are enabled, have local and remote content,
549 // and we have had some form of connectivity.
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -0800550 return enabled() && IsReceiveContentDirection(remote_content_direction_) &&
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000551 IsSendContentDirection(local_content_direction_) &&
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700552 was_ever_writable() &&
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200553 (srtp_filter_.IsActive() || !ShouldSetupDtlsSrtp_n());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000554}
555
jbaucheec21bd2016-03-20 06:15:43 -0700556bool BaseChannel::SendPacket(rtc::CopyOnWriteBuffer* packet,
stefanc1aeaf02015-10-15 07:26:07 -0700557 const rtc::PacketOptions& options) {
558 return SendPacket(false, packet, options);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000559}
560
jbaucheec21bd2016-03-20 06:15:43 -0700561bool BaseChannel::SendRtcp(rtc::CopyOnWriteBuffer* packet,
stefanc1aeaf02015-10-15 07:26:07 -0700562 const rtc::PacketOptions& options) {
563 return SendPacket(true, packet, options);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000564}
565
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000566int BaseChannel::SetOption(SocketType type, rtc::Socket::Option opt,
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000567 int value) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200568 return network_thread_->Invoke<int>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700569 RTC_FROM_HERE, Bind(&BaseChannel::SetOption_n, this, type, opt, value));
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200570}
571
572int BaseChannel::SetOption_n(SocketType type,
573 rtc::Socket::Option opt,
574 int value) {
575 RTC_DCHECK(network_thread_->IsCurrent());
deadbeef5bd5ca32017-02-10 11:31:50 -0800576 rtc::PacketTransportInternal* transport = nullptr;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000577 switch (type) {
wu@webrtc.org9caf2762013-12-11 18:25:07 +0000578 case ST_RTP:
zsteind48dbda2017-04-04 19:45:57 -0700579 transport = rtp_transport_.rtp_packet_transport();
deadbeefcbecd352015-09-23 11:50:27 -0700580 socket_options_.push_back(
581 std::pair<rtc::Socket::Option, int>(opt, value));
wu@webrtc.org9caf2762013-12-11 18:25:07 +0000582 break;
583 case ST_RTCP:
zsteind48dbda2017-04-04 19:45:57 -0700584 transport = rtp_transport_.rtcp_packet_transport();
deadbeefcbecd352015-09-23 11:50:27 -0700585 rtcp_socket_options_.push_back(
586 std::pair<rtc::Socket::Option, int>(opt, value));
wu@webrtc.org9caf2762013-12-11 18:25:07 +0000587 break;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000588 }
deadbeeff5346592017-01-24 21:51:21 -0800589 return transport ? transport->SetOption(opt, value) : -1;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000590}
591
jbauchcb560652016-08-04 05:20:32 -0700592bool BaseChannel::SetCryptoOptions(const rtc::CryptoOptions& crypto_options) {
593 crypto_options_ = crypto_options;
594 return true;
595}
596
deadbeef5bd5ca32017-02-10 11:31:50 -0800597void BaseChannel::OnWritableState(rtc::PacketTransportInternal* transport) {
zsteind48dbda2017-04-04 19:45:57 -0700598 RTC_DCHECK(transport == rtp_transport_.rtp_packet_transport() ||
599 transport == rtp_transport_.rtcp_packet_transport());
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200600 RTC_DCHECK(network_thread_->IsCurrent());
601 UpdateWritableState_n();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000602}
603
deadbeef5bd5ca32017-02-10 11:31:50 -0800604void BaseChannel::OnPacketRead(rtc::PacketTransportInternal* transport,
johand89ab142016-10-25 10:50:32 -0700605 const char* data,
606 size_t len,
607 const rtc::PacketTime& packet_time,
608 int flags) {
609 TRACE_EVENT0("webrtc", "BaseChannel::OnPacketRead");
610 // OnPacketRead gets called from P2PSocket; now pass data to MediaEngine
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200611 RTC_DCHECK(network_thread_->IsCurrent());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000612
613 // When using RTCP multiplexing we might get RTCP packets on the RTP
614 // transport. We feed RTP traffic into the demuxer to determine if it is RTCP.
johand89ab142016-10-25 10:50:32 -0700615 bool rtcp = PacketIsRtcp(transport, data, len);
jbaucheec21bd2016-03-20 06:15:43 -0700616 rtc::CopyOnWriteBuffer packet(data, len);
wu@webrtc.orga9890802013-12-13 00:21:03 +0000617 HandlePacket(rtcp, &packet, packet_time);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000618}
619
deadbeef5bd5ca32017-02-10 11:31:50 -0800620void BaseChannel::OnReadyToSend(rtc::PacketTransportInternal* transport) {
zsteind48dbda2017-04-04 19:45:57 -0700621 RTC_DCHECK(transport == rtp_transport_.rtp_packet_transport() ||
622 transport == rtp_transport_.rtcp_packet_transport());
623 SetTransportChannelReadyToSend(
624 transport == rtp_transport_.rtcp_packet_transport(), true);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000625}
626
zhihuangb2cdd932017-01-19 16:54:25 -0800627void BaseChannel::OnDtlsState(DtlsTransportInternal* transport,
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -0800628 DtlsTransportState state) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200629 if (!ShouldSetupDtlsSrtp_n()) {
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -0800630 return;
631 }
632
633 // Reset the srtp filter if it's not the CONNECTED state. For the CONNECTED
634 // state, setting up DTLS-SRTP context is deferred to ChannelWritable_w to
zhihuangb2cdd932017-01-19 16:54:25 -0800635 // cover other scenarios like the whole transport is writable (not just this
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -0800636 // TransportChannel) or when TransportChannel is attached after DTLS is
637 // negotiated.
638 if (state != DTLS_TRANSPORT_CONNECTED) {
639 srtp_filter_.ResetParams();
640 }
641}
642
Honghai Zhangcc411c02016-03-29 17:27:21 -0700643void BaseChannel::OnSelectedCandidatePairChanged(
zhihuangb2cdd932017-01-19 16:54:25 -0800644 IceTransportInternal* ice_transport,
Honghai Zhang52dce732016-03-31 12:37:31 -0700645 CandidatePairInterface* selected_candidate_pair,
Taylor Brandstetter6bb1ef22016-06-27 18:09:03 -0700646 int last_sent_packet_id,
647 bool ready_to_send) {
deadbeeff5346592017-01-24 21:51:21 -0800648 RTC_DCHECK((rtp_dtls_transport_ &&
649 ice_transport == rtp_dtls_transport_->ice_transport()) ||
650 (rtcp_dtls_transport_ &&
651 ice_transport == rtcp_dtls_transport_->ice_transport()));
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200652 RTC_DCHECK(network_thread_->IsCurrent());
michaelt79e05882016-11-08 02:50:09 -0800653 selected_candidate_pair_ = selected_candidate_pair;
zhihuangb2cdd932017-01-19 16:54:25 -0800654 std::string transport_name = ice_transport->transport_name();
Honghai Zhang0e533ef2016-04-19 15:41:36 -0700655 rtc::NetworkRoute network_route;
Honghai Zhangcc411c02016-03-29 17:27:21 -0700656 if (selected_candidate_pair) {
Honghai Zhang0e533ef2016-04-19 15:41:36 -0700657 network_route = rtc::NetworkRoute(
Taylor Brandstetter6bb1ef22016-06-27 18:09:03 -0700658 ready_to_send, selected_candidate_pair->local_candidate().network_id(),
Honghai Zhang0e533ef2016-04-19 15:41:36 -0700659 selected_candidate_pair->remote_candidate().network_id(),
660 last_sent_packet_id);
michaelt79e05882016-11-08 02:50:09 -0800661
662 UpdateTransportOverhead();
Honghai Zhangcc411c02016-03-29 17:27:21 -0700663 }
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200664 invoker_.AsyncInvoke<void>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700665 RTC_FROM_HERE, worker_thread_,
666 Bind(&MediaChannel::OnNetworkRouteChanged, media_channel_, transport_name,
667 network_route));
Honghai Zhangcc411c02016-03-29 17:27:21 -0700668}
669
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700670void BaseChannel::SetTransportChannelReadyToSend(bool rtcp, bool ready) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200671 RTC_DCHECK(network_thread_->IsCurrent());
deadbeefcbecd352015-09-23 11:50:27 -0700672 if (rtcp) {
673 rtcp_ready_to_send_ = ready;
674 } else {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000675 rtp_ready_to_send_ = ready;
676 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000677
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200678 bool ready_to_send =
679 (rtp_ready_to_send_ &&
deadbeeff5346592017-01-24 21:51:21 -0800680 // In the case of rtcp mux |rtcp_packet_transport_| will be null.
zsteind48dbda2017-04-04 19:45:57 -0700681 (rtcp_ready_to_send_ || !rtp_transport_.rtcp_packet_transport()));
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200682
683 invoker_.AsyncInvoke<void>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700684 RTC_FROM_HERE, worker_thread_,
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200685 Bind(&MediaChannel::OnReadyToSend, media_channel_, ready_to_send));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000686}
687
deadbeef5bd5ca32017-02-10 11:31:50 -0800688bool BaseChannel::PacketIsRtcp(const rtc::PacketTransportInternal* transport,
johand89ab142016-10-25 10:50:32 -0700689 const char* data,
690 size_t len) {
zsteind48dbda2017-04-04 19:45:57 -0700691 return (transport == rtp_transport_.rtcp_packet_transport() ||
henrike@webrtc.org28654cb2013-07-22 21:07:49 +0000692 rtcp_mux_filter_.DemuxRtcp(data, static_cast<int>(len)));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000693}
694
stefanc1aeaf02015-10-15 07:26:07 -0700695bool BaseChannel::SendPacket(bool rtcp,
jbaucheec21bd2016-03-20 06:15:43 -0700696 rtc::CopyOnWriteBuffer* packet,
stefanc1aeaf02015-10-15 07:26:07 -0700697 const rtc::PacketOptions& options) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200698 // SendPacket gets called from MediaEngine, on a pacer or an encoder thread.
699 // If the thread is not our network thread, we will post to our network
700 // so that the real work happens on our network. This avoids us having to
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000701 // synchronize access to all the pieces of the send path, including
702 // SRTP and the inner workings of the transport channels.
703 // The only downside is that we can't return a proper failure code if
704 // needed. Since UDP is unreliable anyway, this should be a non-issue.
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200705 if (!network_thread_->IsCurrent()) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000706 // Avoid a copy by transferring the ownership of the packet data.
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200707 int message_id = rtcp ? MSG_SEND_RTCP_PACKET : MSG_SEND_RTP_PACKET;
708 SendPacketMessageData* data = new SendPacketMessageData;
kwiberg0eb15ed2015-12-17 03:04:15 -0800709 data->packet = std::move(*packet);
stefanc1aeaf02015-10-15 07:26:07 -0700710 data->options = options;
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700711 network_thread_->Post(RTC_FROM_HERE, this, message_id, data);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000712 return true;
713 }
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200714 TRACE_EVENT0("webrtc", "BaseChannel::SendPacket");
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000715
716 // Now that we are on the correct thread, ensure we have a place to send this
717 // packet before doing anything. (We might get RTCP packets that we don't
718 // intend to send.) If we've negotiated RTCP mux, send RTCP over the RTP
719 // transport.
deadbeef5bd5ca32017-02-10 11:31:50 -0800720 rtc::PacketTransportInternal* transport =
zsteind48dbda2017-04-04 19:45:57 -0700721 (!rtcp || rtcp_mux_filter_.IsActive())
722 ? rtp_transport_.rtp_packet_transport()
723 : rtp_transport_.rtcp_packet_transport();
zhihuangb2cdd932017-01-19 16:54:25 -0800724 if (!transport || !transport->writable()) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000725 return false;
726 }
727
728 // Protect ourselves against crazy data.
729 if (!ValidPacket(rtcp, packet)) {
730 LOG(LS_ERROR) << "Dropping outgoing " << content_name_ << " "
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +0000731 << PacketType(rtcp)
732 << " packet: wrong size=" << packet->size();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000733 return false;
734 }
735
stefanc1aeaf02015-10-15 07:26:07 -0700736 rtc::PacketOptions updated_options;
737 updated_options = options;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000738 // Protect if needed.
739 if (srtp_filter_.IsActive()) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200740 TRACE_EVENT0("webrtc", "SRTP Encode");
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000741 bool res;
Karl Wibergc56ac1e2015-05-04 14:54:55 +0200742 uint8_t* data = packet->data();
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +0000743 int len = static_cast<int>(packet->size());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000744 if (!rtcp) {
henrike@webrtc.orgd43aa9d2014-02-21 23:43:24 +0000745 // If ENABLE_EXTERNAL_AUTH flag is on then packet authentication is not done
746 // inside libsrtp for a RTP packet. A external HMAC module will be writing
747 // a fake HMAC value. This is ONLY done for a RTP packet.
748 // Socket layer will update rtp sendtime extension header if present in
749 // packet with current time before updating the HMAC.
750#if !defined(ENABLE_EXTERNAL_AUTH)
751 res = srtp_filter_.ProtectRtp(
752 data, len, static_cast<int>(packet->capacity()), &len);
753#else
jbauchd48f4882017-03-01 15:34:36 -0800754 if (!srtp_filter_.IsExternalAuthActive()) {
755 res = srtp_filter_.ProtectRtp(
756 data, len, static_cast<int>(packet->capacity()), &len);
757 } else {
758 updated_options.packet_time_params.rtp_sendtime_extension_id =
759 rtp_abs_sendtime_extn_id_;
760 res = srtp_filter_.ProtectRtp(
761 data, len, static_cast<int>(packet->capacity()), &len,
762 &updated_options.packet_time_params.srtp_packet_index);
763 // If protection succeeds, let's get auth params from srtp.
henrike@webrtc.orgd43aa9d2014-02-21 23:43:24 +0000764 if (res) {
jbauchd48f4882017-03-01 15:34:36 -0800765 uint8_t* auth_key = NULL;
766 int key_len;
767 res = srtp_filter_.GetRtpAuthParams(
768 &auth_key, &key_len,
769 &updated_options.packet_time_params.srtp_auth_tag_len);
770 if (res) {
771 updated_options.packet_time_params.srtp_auth_key.resize(key_len);
772 updated_options.packet_time_params.srtp_auth_key.assign(
773 auth_key, auth_key + key_len);
774 }
henrike@webrtc.orgd43aa9d2014-02-21 23:43:24 +0000775 }
776 }
777#endif
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000778 if (!res) {
779 int seq_num = -1;
Peter Boström0c4e06b2015-10-07 12:23:21 +0200780 uint32_t ssrc = 0;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000781 GetRtpSeqNum(data, len, &seq_num);
782 GetRtpSsrc(data, len, &ssrc);
783 LOG(LS_ERROR) << "Failed to protect " << content_name_
784 << " RTP packet: size=" << len
785 << ", seqnum=" << seq_num << ", SSRC=" << ssrc;
786 return false;
787 }
788 } else {
henrike@webrtc.org28654cb2013-07-22 21:07:49 +0000789 res = srtp_filter_.ProtectRtcp(data, len,
790 static_cast<int>(packet->capacity()),
791 &len);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000792 if (!res) {
793 int type = -1;
794 GetRtcpType(data, len, &type);
795 LOG(LS_ERROR) << "Failed to protect " << content_name_
796 << " RTCP packet: size=" << len << ", type=" << type;
797 return false;
798 }
799 }
800
801 // Update the length of the packet now that we've added the auth tag.
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +0000802 packet->SetSize(len);
deadbeef7af91dd2016-12-13 11:29:11 -0800803 } else if (srtp_required_) {
deadbeef8f425f92016-12-01 12:26:27 -0800804 // The audio/video engines may attempt to send RTCP packets as soon as the
805 // streams are created, so don't treat this as an error for RTCP.
806 // See: https://bugs.chromium.org/p/webrtc/issues/detail?id=6809
807 if (rtcp) {
808 return false;
809 }
810 // However, there shouldn't be any RTP packets sent before SRTP is set up
811 // (and SetSend(true) is called).
812 LOG(LS_ERROR) << "Can't send outgoing RTP packet when SRTP is inactive"
813 << " and crypto is required";
nisseeb4ca4e2017-01-12 02:24:27 -0800814 RTC_NOTREACHED();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000815 return false;
816 }
817
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000818 // Bon voyage.
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200819 int flags = (secure() && secure_dtls()) ? PF_SRTP_BYPASS : PF_NORMAL;
zhihuangb2cdd932017-01-19 16:54:25 -0800820 int ret = transport->SendPacket(packet->data<char>(), packet->size(),
821 updated_options, flags);
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +0000822 if (ret != static_cast<int>(packet->size())) {
zhihuangb2cdd932017-01-19 16:54:25 -0800823 if (transport->GetError() == ENOTCONN) {
skvladc309e0e2016-07-28 17:15:20 -0700824 LOG(LS_WARNING) << "Got ENOTCONN from transport.";
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700825 SetTransportChannelReadyToSend(rtcp, false);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000826 }
827 return false;
828 }
829 return true;
830}
831
jbaucheec21bd2016-03-20 06:15:43 -0700832bool BaseChannel::WantsPacket(bool rtcp, const rtc::CopyOnWriteBuffer* packet) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000833 // Protect ourselves against crazy data.
834 if (!ValidPacket(rtcp, packet)) {
835 LOG(LS_ERROR) << "Dropping incoming " << content_name_ << " "
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +0000836 << PacketType(rtcp)
837 << " packet: wrong size=" << packet->size();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000838 return false;
839 }
pbos482b12e2015-11-16 10:19:58 -0800840 if (rtcp) {
841 // Permit all (seemingly valid) RTCP packets.
842 return true;
843 }
844 // Check whether we handle this payload.
jbaucheec21bd2016-03-20 06:15:43 -0700845 return bundle_filter_.DemuxPacket(packet->data(), packet->size());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000846}
847
jbaucheec21bd2016-03-20 06:15:43 -0700848void BaseChannel::HandlePacket(bool rtcp, rtc::CopyOnWriteBuffer* packet,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000849 const rtc::PacketTime& packet_time) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200850 RTC_DCHECK(network_thread_->IsCurrent());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000851 if (!WantsPacket(rtcp, packet)) {
852 return;
853 }
854
honghaiz@google.coma67ca1a2015-01-28 19:48:33 +0000855 // We are only interested in the first rtp packet because that
856 // indicates the media has started flowing.
857 if (!has_received_packet_ && !rtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000858 has_received_packet_ = true;
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700859 signaling_thread()->Post(RTC_FROM_HERE, this, MSG_FIRSTPACKETRECEIVED);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000860 }
861
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000862 // Unprotect the packet, if needed.
863 if (srtp_filter_.IsActive()) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200864 TRACE_EVENT0("webrtc", "SRTP Decode");
Karl Wiberg94784372015-04-20 14:03:07 +0200865 char* data = packet->data<char>();
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +0000866 int len = static_cast<int>(packet->size());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000867 bool res;
868 if (!rtcp) {
869 res = srtp_filter_.UnprotectRtp(data, len, &len);
870 if (!res) {
871 int seq_num = -1;
Peter Boström0c4e06b2015-10-07 12:23:21 +0200872 uint32_t ssrc = 0;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000873 GetRtpSeqNum(data, len, &seq_num);
874 GetRtpSsrc(data, len, &ssrc);
875 LOG(LS_ERROR) << "Failed to unprotect " << content_name_
876 << " RTP packet: size=" << len
877 << ", seqnum=" << seq_num << ", SSRC=" << ssrc;
878 return;
879 }
880 } else {
881 res = srtp_filter_.UnprotectRtcp(data, len, &len);
882 if (!res) {
883 int type = -1;
884 GetRtcpType(data, len, &type);
885 LOG(LS_ERROR) << "Failed to unprotect " << content_name_
886 << " RTCP packet: size=" << len << ", type=" << type;
887 return;
888 }
889 }
890
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06 +0000891 packet->SetSize(len);
deadbeef7af91dd2016-12-13 11:29:11 -0800892 } else if (srtp_required_) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000893 // Our session description indicates that SRTP is required, but we got a
894 // packet before our SRTP filter is active. This means either that
895 // a) we got SRTP packets before we received the SDES keys, in which case
896 // we can't decrypt it anyway, or
897 // b) we got SRTP packets before DTLS completed on both the RTP and RTCP
zhihuangb2cdd932017-01-19 16:54:25 -0800898 // transports, so we haven't yet extracted keys, even if DTLS did
899 // complete on the transport that the packets are being sent on. It's
900 // really good practice to wait for both RTP and RTCP to be good to go
901 // before sending media, to prevent weird failure modes, so it's fine
902 // for us to just eat packets here. This is all sidestepped if RTCP mux
903 // is used anyway.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000904 LOG(LS_WARNING) << "Can't process incoming " << PacketType(rtcp)
905 << " packet when SRTP is inactive and crypto is required";
906 return;
907 }
908
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200909 invoker_.AsyncInvoke<void>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700910 RTC_FROM_HERE, worker_thread_,
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200911 Bind(&BaseChannel::OnPacketReceived, this, rtcp, *packet, packet_time));
912}
913
914void BaseChannel::OnPacketReceived(bool rtcp,
915 const rtc::CopyOnWriteBuffer& packet,
916 const rtc::PacketTime& packet_time) {
917 RTC_DCHECK(worker_thread_->IsCurrent());
918 // Need to copy variable because OnRtcpReceived/OnPacketReceived
919 // requires non-const pointer to buffer. This doesn't memcpy the actual data.
920 rtc::CopyOnWriteBuffer data(packet);
921 if (rtcp) {
922 media_channel_->OnRtcpReceived(&data, packet_time);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000923 } else {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200924 media_channel_->OnPacketReceived(&data, packet_time);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000925 }
926}
927
pthatcher@webrtc.org592470b2015-03-16 21:15:37 +0000928bool BaseChannel::PushdownLocalDescription(
929 const SessionDescription* local_desc, ContentAction action,
930 std::string* error_desc) {
931 const ContentInfo* content_info = GetFirstContent(local_desc);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000932 const MediaContentDescription* content_desc =
933 GetContentDescription(content_info);
934 if (content_desc && content_info && !content_info->rejected &&
pthatcher@webrtc.org592470b2015-03-16 21:15:37 +0000935 !SetLocalContent(content_desc, action, error_desc)) {
936 LOG(LS_ERROR) << "Failure in SetLocalContent with action " << action;
937 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000938 }
pthatcher@webrtc.org592470b2015-03-16 21:15:37 +0000939 return true;
940}
941
942bool BaseChannel::PushdownRemoteDescription(
943 const SessionDescription* remote_desc, ContentAction action,
944 std::string* error_desc) {
945 const ContentInfo* content_info = GetFirstContent(remote_desc);
946 const MediaContentDescription* content_desc =
947 GetContentDescription(content_info);
948 if (content_desc && content_info && !content_info->rejected &&
949 !SetRemoteContent(content_desc, action, error_desc)) {
950 LOG(LS_ERROR) << "Failure in SetRemoteContent with action " << action;
951 return false;
952 }
953 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000954}
955
956void BaseChannel::EnableMedia_w() {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700957 RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000958 if (enabled_)
959 return;
960
961 LOG(LS_INFO) << "Channel enabled";
962 enabled_ = true;
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700963 UpdateMediaSendRecvState_w();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000964}
965
966void BaseChannel::DisableMedia_w() {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700967 RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000968 if (!enabled_)
969 return;
970
971 LOG(LS_INFO) << "Channel disabled";
972 enabled_ = false;
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700973 UpdateMediaSendRecvState_w();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000974}
975
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200976void BaseChannel::UpdateWritableState_n() {
zsteind48dbda2017-04-04 19:45:57 -0700977 rtc::PacketTransportInternal* rtp_packet_transport =
978 rtp_transport_.rtp_packet_transport();
979 rtc::PacketTransportInternal* rtcp_packet_transport =
980 rtp_transport_.rtcp_packet_transport();
981 if (rtp_packet_transport && rtp_packet_transport->writable() &&
982 (!rtcp_packet_transport || rtcp_packet_transport->writable())) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200983 ChannelWritable_n();
deadbeefcbecd352015-09-23 11:50:27 -0700984 } else {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200985 ChannelNotWritable_n();
deadbeefcbecd352015-09-23 11:50:27 -0700986 }
987}
988
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200989void BaseChannel::ChannelWritable_n() {
990 RTC_DCHECK(network_thread_->IsCurrent());
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -0800991 if (writable_) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000992 return;
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -0800993 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000994
deadbeefcbecd352015-09-23 11:50:27 -0700995 LOG(LS_INFO) << "Channel writable (" << content_name_ << ")"
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000996 << (was_ever_writable_ ? "" : " for the first time");
997
michaelt79e05882016-11-08 02:50:09 -0800998 if (selected_candidate_pair_)
999 LOG(LS_INFO)
1000 << "Using "
1001 << selected_candidate_pair_->local_candidate().ToSensitiveString()
1002 << "->"
1003 << selected_candidate_pair_->remote_candidate().ToSensitiveString();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001004
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001005 was_ever_writable_ = true;
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001006 MaybeSetupDtlsSrtp_n();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001007 writable_ = true;
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001008 UpdateMediaSendRecvState();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001009}
1010
deadbeef953c2ce2017-01-09 14:53:41 -08001011void BaseChannel::SignalDtlsSrtpSetupFailure_n(bool rtcp) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001012 RTC_DCHECK(network_thread_->IsCurrent());
1013 invoker_.AsyncInvoke<void>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001014 RTC_FROM_HERE, signaling_thread(),
deadbeef953c2ce2017-01-09 14:53:41 -08001015 Bind(&BaseChannel::SignalDtlsSrtpSetupFailure_s, this, rtcp));
pthatcher@webrtc.org4eeef582015-03-16 19:34:23 +00001016}
1017
deadbeef953c2ce2017-01-09 14:53:41 -08001018void BaseChannel::SignalDtlsSrtpSetupFailure_s(bool rtcp) {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001019 RTC_DCHECK(signaling_thread() == rtc::Thread::Current());
deadbeef953c2ce2017-01-09 14:53:41 -08001020 SignalDtlsSrtpSetupFailure(this, rtcp);
pthatcher@webrtc.org4eeef582015-03-16 19:34:23 +00001021}
1022
zhihuangb2cdd932017-01-19 16:54:25 -08001023bool BaseChannel::SetDtlsSrtpCryptoSuites_n(DtlsTransportInternal* transport,
1024 bool rtcp) {
Guo-wei Shieh521ed7b2015-11-18 19:41:53 -08001025 std::vector<int> crypto_suites;
1026 // We always use the default SRTP crypto suites for RTCP, but we may use
1027 // different crypto suites for RTP depending on the media type.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001028 if (!rtcp) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001029 GetSrtpCryptoSuites_n(&crypto_suites);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001030 } else {
jbauchcb560652016-08-04 05:20:32 -07001031 GetDefaultSrtpCryptoSuites(crypto_options(), &crypto_suites);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001032 }
zhihuangb2cdd932017-01-19 16:54:25 -08001033 return transport->SetSrtpCryptoSuites(crypto_suites);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001034}
1035
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001036bool BaseChannel::ShouldSetupDtlsSrtp_n() const {
zhihuangb2cdd932017-01-19 16:54:25 -08001037 // Since DTLS is applied to all transports, checking RTP should be enough.
1038 return rtp_dtls_transport_ && rtp_dtls_transport_->IsDtlsActive();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001039}
1040
1041// This function returns true if either DTLS-SRTP is not in use
1042// *or* DTLS-SRTP is successfully set up.
zhihuangb2cdd932017-01-19 16:54:25 -08001043bool BaseChannel::SetupDtlsSrtp_n(bool rtcp) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001044 RTC_DCHECK(network_thread_->IsCurrent());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001045 bool ret = false;
1046
zhihuangb2cdd932017-01-19 16:54:25 -08001047 DtlsTransportInternal* transport =
1048 rtcp ? rtcp_dtls_transport_ : rtp_dtls_transport_;
deadbeeff5346592017-01-24 21:51:21 -08001049 RTC_DCHECK(transport);
zhihuangb2cdd932017-01-19 16:54:25 -08001050 RTC_DCHECK(transport->IsDtlsActive());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001051
Guo-wei Shieh521ed7b2015-11-18 19:41:53 -08001052 int selected_crypto_suite;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001053
zhihuangb2cdd932017-01-19 16:54:25 -08001054 if (!transport->GetSrtpCryptoSuite(&selected_crypto_suite)) {
Guo-wei Shieh521ed7b2015-11-18 19:41:53 -08001055 LOG(LS_ERROR) << "No DTLS-SRTP selected crypto suite";
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001056 return false;
1057 }
1058
zhihuangb2cdd932017-01-19 16:54:25 -08001059 LOG(LS_INFO) << "Installing keys from DTLS-SRTP on " << content_name() << " "
1060 << PacketType(rtcp);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001061
jbauchcb560652016-08-04 05:20:32 -07001062 int key_len;
1063 int salt_len;
1064 if (!rtc::GetSrtpKeyAndSaltLengths(selected_crypto_suite, &key_len,
1065 &salt_len)) {
1066 LOG(LS_ERROR) << "Unknown DTLS-SRTP crypto suite" << selected_crypto_suite;
1067 return false;
1068 }
1069
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001070 // OK, we're now doing DTLS (RFC 5764)
jbauchcb560652016-08-04 05:20:32 -07001071 std::vector<unsigned char> dtls_buffer(key_len * 2 + salt_len * 2);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001072
1073 // RFC 5705 exporter using the RFC 5764 parameters
zhihuangb2cdd932017-01-19 16:54:25 -08001074 if (!transport->ExportKeyingMaterial(kDtlsSrtpExporterLabel, NULL, 0, false,
1075 &dtls_buffer[0], dtls_buffer.size())) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001076 LOG(LS_WARNING) << "DTLS-SRTP key export failed";
nisseeb4ca4e2017-01-12 02:24:27 -08001077 RTC_NOTREACHED(); // This should never happen
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001078 return false;
1079 }
1080
1081 // Sync up the keys with the DTLS-SRTP interface
jbauchcb560652016-08-04 05:20:32 -07001082 std::vector<unsigned char> client_write_key(key_len + salt_len);
1083 std::vector<unsigned char> server_write_key(key_len + salt_len);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001084 size_t offset = 0;
jbauchcb560652016-08-04 05:20:32 -07001085 memcpy(&client_write_key[0], &dtls_buffer[offset], key_len);
1086 offset += key_len;
1087 memcpy(&server_write_key[0], &dtls_buffer[offset], key_len);
1088 offset += key_len;
1089 memcpy(&client_write_key[key_len], &dtls_buffer[offset], salt_len);
1090 offset += salt_len;
1091 memcpy(&server_write_key[key_len], &dtls_buffer[offset], salt_len);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001092
1093 std::vector<unsigned char> *send_key, *recv_key;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001094 rtc::SSLRole role;
zhihuangb2cdd932017-01-19 16:54:25 -08001095 if (!transport->GetSslRole(&role)) {
sergeyu@chromium.org0be6aa02013-08-23 23:21:25 +00001096 LOG(LS_WARNING) << "GetSslRole failed";
1097 return false;
1098 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001099
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001100 if (role == rtc::SSL_SERVER) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001101 send_key = &server_write_key;
1102 recv_key = &client_write_key;
1103 } else {
1104 send_key = &client_write_key;
1105 recv_key = &server_write_key;
1106 }
1107
zhihuangb2cdd932017-01-19 16:54:25 -08001108 if (rtcp) {
Guo-wei Shieh521ed7b2015-11-18 19:41:53 -08001109 ret = srtp_filter_.SetRtcpParams(selected_crypto_suite, &(*send_key)[0],
1110 static_cast<int>(send_key->size()),
1111 selected_crypto_suite, &(*recv_key)[0],
1112 static_cast<int>(recv_key->size()));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001113 } else {
Guo-wei Shieh521ed7b2015-11-18 19:41:53 -08001114 ret = srtp_filter_.SetRtpParams(selected_crypto_suite, &(*send_key)[0],
1115 static_cast<int>(send_key->size()),
1116 selected_crypto_suite, &(*recv_key)[0],
1117 static_cast<int>(recv_key->size()));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001118 }
1119
michaelt79e05882016-11-08 02:50:09 -08001120 if (!ret) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001121 LOG(LS_WARNING) << "DTLS-SRTP key installation failed";
michaelt79e05882016-11-08 02:50:09 -08001122 } else {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001123 dtls_keyed_ = true;
michaelt79e05882016-11-08 02:50:09 -08001124 UpdateTransportOverhead();
1125 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001126 return ret;
1127}
1128
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001129void BaseChannel::MaybeSetupDtlsSrtp_n() {
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -08001130 if (srtp_filter_.IsActive()) {
1131 return;
1132 }
1133
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001134 if (!ShouldSetupDtlsSrtp_n()) {
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -08001135 return;
1136 }
1137
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001138 if (!SetupDtlsSrtp_n(false)) {
deadbeef953c2ce2017-01-09 14:53:41 -08001139 SignalDtlsSrtpSetupFailure_n(false);
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -08001140 return;
1141 }
1142
zhihuangb2cdd932017-01-19 16:54:25 -08001143 if (rtcp_dtls_transport_) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001144 if (!SetupDtlsSrtp_n(true)) {
deadbeef953c2ce2017-01-09 14:53:41 -08001145 SignalDtlsSrtpSetupFailure_n(true);
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -08001146 return;
1147 }
1148 }
1149}
1150
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001151void BaseChannel::ChannelNotWritable_n() {
1152 RTC_DCHECK(network_thread_->IsCurrent());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001153 if (!writable_)
1154 return;
1155
deadbeefcbecd352015-09-23 11:50:27 -07001156 LOG(LS_INFO) << "Channel not writable (" << content_name_ << ")";
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001157 writable_ = false;
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001158 UpdateMediaSendRecvState();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001159}
1160
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001161bool BaseChannel::SetRtpTransportParameters(
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001162 const MediaContentDescription* content,
1163 ContentAction action,
1164 ContentSource src,
1165 std::string* error_desc) {
1166 if (action == CA_UPDATE) {
1167 // These parameters never get changed by a CA_UDPATE.
1168 return true;
1169 }
1170
deadbeef7af91dd2016-12-13 11:29:11 -08001171 // Cache srtp_required_ for belt and suspenders check on SendPacket
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001172 return network_thread_->Invoke<bool>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001173 RTC_FROM_HERE, Bind(&BaseChannel::SetRtpTransportParameters_n, this,
1174 content, action, src, error_desc));
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001175}
1176
1177bool BaseChannel::SetRtpTransportParameters_n(
1178 const MediaContentDescription* content,
1179 ContentAction action,
1180 ContentSource src,
1181 std::string* error_desc) {
1182 RTC_DCHECK(network_thread_->IsCurrent());
1183
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001184 if (!SetSrtp_n(content->cryptos(), action, src, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001185 return false;
1186 }
1187
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001188 if (!SetRtcpMux_n(content->rtcp_mux(), action, src, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001189 return false;
1190 }
1191
1192 return true;
1193}
1194
zhihuangb2cdd932017-01-19 16:54:25 -08001195// |dtls| will be set to true if DTLS is active for transport and crypto is
1196// empty.
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001197bool BaseChannel::CheckSrtpConfig_n(const std::vector<CryptoParams>& cryptos,
1198 bool* dtls,
1199 std::string* error_desc) {
deadbeeff5346592017-01-24 21:51:21 -08001200 *dtls = rtp_dtls_transport_ && rtp_dtls_transport_->IsDtlsActive();
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +00001201 if (*dtls && !cryptos.empty()) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001202 SafeSetError("Cryptos must be empty when DTLS is active.", error_desc);
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +00001203 return false;
1204 }
1205 return true;
1206}
1207
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001208bool BaseChannel::SetSrtp_n(const std::vector<CryptoParams>& cryptos,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001209 ContentAction action,
1210 ContentSource src,
1211 std::string* error_desc) {
Peter Boströmca8b4042016-03-08 14:24:13 -08001212 TRACE_EVENT0("webrtc", "BaseChannel::SetSrtp_w");
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001213 if (action == CA_UPDATE) {
1214 // no crypto params.
1215 return true;
1216 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001217 bool ret = false;
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +00001218 bool dtls = false;
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001219 ret = CheckSrtpConfig_n(cryptos, &dtls, error_desc);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001220 if (!ret) {
1221 return false;
1222 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001223 switch (action) {
1224 case CA_OFFER:
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +00001225 // If DTLS is already active on the channel, we could be renegotiating
1226 // here. We don't update the srtp filter.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001227 if (!dtls) {
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +00001228 ret = srtp_filter_.SetOffer(cryptos, src);
1229 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001230 break;
1231 case CA_PRANSWER:
1232 // If we're doing DTLS-SRTP, we don't want to update the filter
1233 // with an answer, because we already have SRTP parameters.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001234 if (!dtls) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001235 ret = srtp_filter_.SetProvisionalAnswer(cryptos, src);
1236 }
1237 break;
1238 case CA_ANSWER:
1239 // If we're doing DTLS-SRTP, we don't want to update the filter
1240 // with an answer, because we already have SRTP parameters.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001241 if (!dtls) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001242 ret = srtp_filter_.SetAnswer(cryptos, src);
1243 }
1244 break;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001245 default:
1246 break;
1247 }
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001248 if (!ret) {
1249 SafeSetError("Failed to setup SRTP filter.", error_desc);
1250 return false;
1251 }
1252 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001253}
1254
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001255bool BaseChannel::SetRtcpMux_n(bool enable,
1256 ContentAction action,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001257 ContentSource src,
1258 std::string* error_desc) {
deadbeef8e814d72017-01-13 11:34:39 -08001259 // Provide a more specific error message for the RTCP mux "require" policy
1260 // case.
zsteind48dbda2017-04-04 19:45:57 -07001261 if (rtp_transport_.rtcp_mux_required() && !enable) {
deadbeef8e814d72017-01-13 11:34:39 -08001262 SafeSetError(
1263 "rtcpMuxPolicy is 'require', but media description does not "
1264 "contain 'a=rtcp-mux'.",
1265 error_desc);
1266 return false;
1267 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001268 bool ret = false;
1269 switch (action) {
1270 case CA_OFFER:
1271 ret = rtcp_mux_filter_.SetOffer(enable, src);
1272 break;
1273 case CA_PRANSWER:
zhihuangb2cdd932017-01-19 16:54:25 -08001274 // This may activate RTCP muxing, but we don't yet destroy the transport
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001275 // because the final answer may deactivate it.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001276 ret = rtcp_mux_filter_.SetProvisionalAnswer(enable, src);
1277 break;
1278 case CA_ANSWER:
1279 ret = rtcp_mux_filter_.SetAnswer(enable, src);
1280 if (ret && rtcp_mux_filter_.IsActive()) {
deadbeefe814a0d2017-02-25 18:15:09 -08001281 // We permanently activated RTCP muxing; signal that we no longer need
1282 // the RTCP transport.
zsteind48dbda2017-04-04 19:45:57 -07001283 std::string debug_name =
1284 transport_name_.empty()
1285 ? rtp_transport_.rtp_packet_transport()->debug_name()
1286 : transport_name_;
deadbeefe814a0d2017-02-25 18:15:09 -08001287 ;
deadbeefcbecd352015-09-23 11:50:27 -07001288 LOG(LS_INFO) << "Enabling rtcp-mux for " << content_name()
deadbeefe814a0d2017-02-25 18:15:09 -08001289 << "; no longer need RTCP transport for " << debug_name;
zsteind48dbda2017-04-04 19:45:57 -07001290 if (rtp_transport_.rtcp_packet_transport()) {
deadbeeff5346592017-01-24 21:51:21 -08001291 SetTransport_n(true, nullptr, nullptr);
1292 SignalRtcpMuxFullyActive(transport_name_);
zhihuangf5b251b2017-01-12 19:37:48 -08001293 }
deadbeef062ce9f2016-08-26 21:42:15 -07001294 UpdateWritableState_n();
1295 SetTransportChannelReadyToSend(true, false);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001296 }
1297 break;
1298 case CA_UPDATE:
1299 // No RTCP mux info.
1300 ret = true;
Henrik Kjellander7c027b62015-04-22 13:21:30 +02001301 break;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001302 default:
1303 break;
1304 }
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001305 if (!ret) {
1306 SafeSetError("Failed to setup RTCP mux filter.", error_desc);
1307 return false;
1308 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001309 // |rtcp_mux_filter_| can be active if |action| is CA_PRANSWER or
zhihuangb2cdd932017-01-19 16:54:25 -08001310 // CA_ANSWER, but we only want to tear down the RTCP transport if we received
1311 // a final answer.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001312 if (rtcp_mux_filter_.IsActive()) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001313 // If the RTP transport is already writable, then so are we.
zsteind48dbda2017-04-04 19:45:57 -07001314 if (rtp_transport_.rtp_packet_transport()->writable()) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001315 ChannelWritable_n();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001316 }
1317 }
1318
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001319 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001320}
1321
1322bool BaseChannel::AddRecvStream_w(const StreamParams& sp) {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001323 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
pbos482b12e2015-11-16 10:19:58 -08001324 return media_channel()->AddRecvStream(sp);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001325}
1326
Peter Boström0c4e06b2015-10-07 12:23:21 +02001327bool BaseChannel::RemoveRecvStream_w(uint32_t ssrc) {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001328 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001329 return media_channel()->RemoveRecvStream(ssrc);
1330}
1331
1332bool BaseChannel::UpdateLocalStreams_w(const std::vector<StreamParams>& streams,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001333 ContentAction action,
1334 std::string* error_desc) {
nisse7ce109a2017-01-31 00:57:56 -08001335 if (!(action == CA_OFFER || action == CA_ANSWER ||
1336 action == CA_PRANSWER || action == CA_UPDATE))
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001337 return false;
1338
1339 // If this is an update, streams only contain streams that have changed.
1340 if (action == CA_UPDATE) {
1341 for (StreamParamsVec::const_iterator it = streams.begin();
1342 it != streams.end(); ++it) {
tommi@webrtc.org586f2ed2015-01-22 23:00:41 +00001343 const StreamParams* existing_stream =
1344 GetStreamByIds(local_streams_, it->groupid, it->id);
1345 if (!existing_stream && it->has_ssrcs()) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001346 if (media_channel()->AddSendStream(*it)) {
1347 local_streams_.push_back(*it);
1348 LOG(LS_INFO) << "Add send stream ssrc: " << it->first_ssrc();
1349 } else {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001350 std::ostringstream desc;
1351 desc << "Failed to add send stream ssrc: " << it->first_ssrc();
1352 SafeSetError(desc.str(), error_desc);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001353 return false;
1354 }
tommi@webrtc.org586f2ed2015-01-22 23:00:41 +00001355 } else if (existing_stream && !it->has_ssrcs()) {
1356 if (!media_channel()->RemoveSendStream(existing_stream->first_ssrc())) {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001357 std::ostringstream desc;
1358 desc << "Failed to remove send stream with ssrc "
1359 << it->first_ssrc() << ".";
1360 SafeSetError(desc.str(), error_desc);
1361 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001362 }
tommi@webrtc.org586f2ed2015-01-22 23:00:41 +00001363 RemoveStreamBySsrc(&local_streams_, existing_stream->first_ssrc());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001364 } else {
1365 LOG(LS_WARNING) << "Ignore unsupported stream update";
1366 }
1367 }
1368 return true;
1369 }
1370 // Else streams are all the streams we want to send.
1371
1372 // Check for streams that have been removed.
1373 bool ret = true;
1374 for (StreamParamsVec::const_iterator it = local_streams_.begin();
1375 it != local_streams_.end(); ++it) {
tommi@webrtc.org586f2ed2015-01-22 23:00:41 +00001376 if (!GetStreamBySsrc(streams, it->first_ssrc())) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001377 if (!media_channel()->RemoveSendStream(it->first_ssrc())) {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001378 std::ostringstream desc;
1379 desc << "Failed to remove send stream with ssrc "
1380 << it->first_ssrc() << ".";
1381 SafeSetError(desc.str(), error_desc);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001382 ret = false;
1383 }
1384 }
1385 }
1386 // Check for new streams.
1387 for (StreamParamsVec::const_iterator it = streams.begin();
1388 it != streams.end(); ++it) {
tommi@webrtc.org586f2ed2015-01-22 23:00:41 +00001389 if (!GetStreamBySsrc(local_streams_, it->first_ssrc())) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001390 if (media_channel()->AddSendStream(*it)) {
stefanc1aeaf02015-10-15 07:26:07 -07001391 LOG(LS_INFO) << "Add send stream ssrc: " << it->ssrcs[0];
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001392 } else {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001393 std::ostringstream desc;
1394 desc << "Failed to add send stream ssrc: " << it->first_ssrc();
1395 SafeSetError(desc.str(), error_desc);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001396 ret = false;
1397 }
1398 }
1399 }
1400 local_streams_ = streams;
1401 return ret;
1402}
1403
1404bool BaseChannel::UpdateRemoteStreams_w(
1405 const std::vector<StreamParams>& streams,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001406 ContentAction action,
1407 std::string* error_desc) {
nisse7ce109a2017-01-31 00:57:56 -08001408 if (!(action == CA_OFFER || action == CA_ANSWER ||
1409 action == CA_PRANSWER || action == CA_UPDATE))
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001410 return false;
1411
1412 // If this is an update, streams only contain streams that have changed.
1413 if (action == CA_UPDATE) {
1414 for (StreamParamsVec::const_iterator it = streams.begin();
1415 it != streams.end(); ++it) {
tommi@webrtc.org586f2ed2015-01-22 23:00:41 +00001416 const StreamParams* existing_stream =
1417 GetStreamByIds(remote_streams_, it->groupid, it->id);
1418 if (!existing_stream && it->has_ssrcs()) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001419 if (AddRecvStream_w(*it)) {
1420 remote_streams_.push_back(*it);
1421 LOG(LS_INFO) << "Add remote stream ssrc: " << it->first_ssrc();
1422 } else {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001423 std::ostringstream desc;
1424 desc << "Failed to add remote stream ssrc: " << it->first_ssrc();
1425 SafeSetError(desc.str(), error_desc);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001426 return false;
1427 }
tommi@webrtc.org586f2ed2015-01-22 23:00:41 +00001428 } else if (existing_stream && !it->has_ssrcs()) {
1429 if (!RemoveRecvStream_w(existing_stream->first_ssrc())) {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001430 std::ostringstream desc;
1431 desc << "Failed to remove remote stream with ssrc "
1432 << it->first_ssrc() << ".";
1433 SafeSetError(desc.str(), error_desc);
1434 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001435 }
tommi@webrtc.org586f2ed2015-01-22 23:00:41 +00001436 RemoveStreamBySsrc(&remote_streams_, existing_stream->first_ssrc());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001437 } else {
1438 LOG(LS_WARNING) << "Ignore unsupported stream update."
tommi@webrtc.org586f2ed2015-01-22 23:00:41 +00001439 << " Stream exists? " << (existing_stream != nullptr)
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001440 << " new stream = " << it->ToString();
1441 }
1442 }
1443 return true;
1444 }
1445 // Else streams are all the streams we want to receive.
1446
1447 // Check for streams that have been removed.
1448 bool ret = true;
1449 for (StreamParamsVec::const_iterator it = remote_streams_.begin();
1450 it != remote_streams_.end(); ++it) {
tommi@webrtc.org586f2ed2015-01-22 23:00:41 +00001451 if (!GetStreamBySsrc(streams, it->first_ssrc())) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001452 if (!RemoveRecvStream_w(it->first_ssrc())) {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001453 std::ostringstream desc;
1454 desc << "Failed to remove remote stream with ssrc "
1455 << it->first_ssrc() << ".";
1456 SafeSetError(desc.str(), error_desc);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001457 ret = false;
1458 }
1459 }
1460 }
1461 // Check for new streams.
1462 for (StreamParamsVec::const_iterator it = streams.begin();
1463 it != streams.end(); ++it) {
tommi@webrtc.org586f2ed2015-01-22 23:00:41 +00001464 if (!GetStreamBySsrc(remote_streams_, it->first_ssrc())) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001465 if (AddRecvStream_w(*it)) {
1466 LOG(LS_INFO) << "Add remote ssrc: " << it->ssrcs[0];
1467 } else {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001468 std::ostringstream desc;
1469 desc << "Failed to add remote stream ssrc: " << it->first_ssrc();
1470 SafeSetError(desc.str(), error_desc);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001471 ret = false;
1472 }
1473 }
1474 }
1475 remote_streams_ = streams;
1476 return ret;
1477}
1478
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001479void BaseChannel::MaybeCacheRtpAbsSendTimeHeaderExtension_w(
isheriff6f8d6862016-05-26 11:24:55 -07001480 const std::vector<webrtc::RtpExtension>& extensions) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001481// Absolute Send Time extension id is used only with external auth,
1482// so do not bother searching for it and making asyncronious call to set
1483// something that is not used.
1484#if defined(ENABLE_EXTERNAL_AUTH)
isheriff6f8d6862016-05-26 11:24:55 -07001485 const webrtc::RtpExtension* send_time_extension =
1486 FindHeaderExtension(extensions, webrtc::RtpExtension::kAbsSendTimeUri);
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001487 int rtp_abs_sendtime_extn_id =
henrike@webrtc.orgd43aa9d2014-02-21 23:43:24 +00001488 send_time_extension ? send_time_extension->id : -1;
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001489 invoker_.AsyncInvoke<void>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001490 RTC_FROM_HERE, network_thread_,
1491 Bind(&BaseChannel::CacheRtpAbsSendTimeHeaderExtension_n, this,
1492 rtp_abs_sendtime_extn_id));
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001493#endif
1494}
1495
1496void BaseChannel::CacheRtpAbsSendTimeHeaderExtension_n(
1497 int rtp_abs_sendtime_extn_id) {
1498 rtp_abs_sendtime_extn_id_ = rtp_abs_sendtime_extn_id;
henrike@webrtc.orgd43aa9d2014-02-21 23:43:24 +00001499}
1500
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001501void BaseChannel::OnMessage(rtc::Message *pmsg) {
Peter Boström6f28cf02015-12-07 23:17:15 +01001502 TRACE_EVENT0("webrtc", "BaseChannel::OnMessage");
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001503 switch (pmsg->message_id) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001504 case MSG_SEND_RTP_PACKET:
1505 case MSG_SEND_RTCP_PACKET: {
1506 RTC_DCHECK(network_thread_->IsCurrent());
1507 SendPacketMessageData* data =
1508 static_cast<SendPacketMessageData*>(pmsg->pdata);
1509 bool rtcp = pmsg->message_id == MSG_SEND_RTCP_PACKET;
1510 SendPacket(rtcp, &data->packet, data->options);
1511 delete data;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001512 break;
1513 }
1514 case MSG_FIRSTPACKETRECEIVED: {
1515 SignalFirstPacketReceived(this);
1516 break;
1517 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001518 }
1519}
1520
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001521void BaseChannel::FlushRtcpMessages_n() {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001522 // Flush all remaining RTCP messages. This should only be called in
1523 // destructor.
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001524 RTC_DCHECK(network_thread_->IsCurrent());
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001525 rtc::MessageList rtcp_messages;
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001526 network_thread_->Clear(this, MSG_SEND_RTCP_PACKET, &rtcp_messages);
1527 for (const auto& message : rtcp_messages) {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001528 network_thread_->Send(RTC_FROM_HERE, this, MSG_SEND_RTCP_PACKET,
1529 message.pdata);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001530 }
1531}
1532
johand89ab142016-10-25 10:50:32 -07001533void BaseChannel::SignalSentPacket_n(
deadbeef5bd5ca32017-02-10 11:31:50 -08001534 rtc::PacketTransportInternal* /* transport */,
johand89ab142016-10-25 10:50:32 -07001535 const rtc::SentPacket& sent_packet) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001536 RTC_DCHECK(network_thread_->IsCurrent());
1537 invoker_.AsyncInvoke<void>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001538 RTC_FROM_HERE, worker_thread_,
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001539 rtc::Bind(&BaseChannel::SignalSentPacket_w, this, sent_packet));
1540}
1541
1542void BaseChannel::SignalSentPacket_w(const rtc::SentPacket& sent_packet) {
1543 RTC_DCHECK(worker_thread_->IsCurrent());
1544 SignalSentPacket(sent_packet);
1545}
1546
1547VoiceChannel::VoiceChannel(rtc::Thread* worker_thread,
1548 rtc::Thread* network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -08001549 rtc::Thread* signaling_thread,
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001550 MediaEngineInterface* media_engine,
1551 VoiceMediaChannel* media_channel,
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001552 const std::string& content_name,
deadbeefac22f702017-01-12 21:59:29 -08001553 bool rtcp_mux_required,
deadbeef7af91dd2016-12-13 11:29:11 -08001554 bool srtp_required)
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001555 : BaseChannel(worker_thread,
1556 network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -08001557 signaling_thread,
deadbeefcbecd352015-09-23 11:50:27 -07001558 media_channel,
deadbeefcbecd352015-09-23 11:50:27 -07001559 content_name,
deadbeefac22f702017-01-12 21:59:29 -08001560 rtcp_mux_required,
deadbeef7af91dd2016-12-13 11:29:11 -08001561 srtp_required),
Fredrik Solenberg0c022642015-08-05 12:25:22 +02001562 media_engine_(media_engine),
deadbeefcbecd352015-09-23 11:50:27 -07001563 received_media_(false) {}
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001564
1565VoiceChannel::~VoiceChannel() {
Peter Boströmca8b4042016-03-08 14:24:13 -08001566 TRACE_EVENT0("webrtc", "VoiceChannel::~VoiceChannel");
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001567 StopAudioMonitor();
1568 StopMediaMonitor();
1569 // this can't be done in the base class, since it calls a virtual
1570 DisableMedia_w();
wu@webrtc.org78187522013-10-07 23:32:02 +00001571 Deinit();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001572}
1573
Peter Boström0c4e06b2015-10-07 12:23:21 +02001574bool VoiceChannel::SetAudioSend(uint32_t ssrc,
solenbergdfc8f4f2015-10-01 02:31:10 -07001575 bool enable,
solenberg1dd98f32015-09-10 01:57:14 -07001576 const AudioOptions* options,
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08001577 AudioSource* source) {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001578 return InvokeOnWorker(RTC_FROM_HERE,
1579 Bind(&VoiceMediaChannel::SetAudioSend, media_channel(),
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08001580 ssrc, enable, options, source));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001581}
1582
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001583// TODO(juberti): Handle early media the right way. We should get an explicit
1584// ringing message telling us to start playing local ringback, which we cancel
1585// if any early media actually arrives. For now, we do the opposite, which is
1586// to wait 1 second for early media, and start playing local ringback if none
1587// arrives.
1588void VoiceChannel::SetEarlyMedia(bool enable) {
1589 if (enable) {
1590 // Start the early media timeout
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001591 worker_thread()->PostDelayed(RTC_FROM_HERE, kEarlyMediaTimeout, this,
1592 MSG_EARLYMEDIATIMEOUT);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001593 } else {
1594 // Stop the timeout if currently going.
sergeyu@chromium.org9cf037b2014-02-07 19:03:26 +00001595 worker_thread()->Clear(this, MSG_EARLYMEDIATIMEOUT);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001596 }
1597}
1598
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001599bool VoiceChannel::CanInsertDtmf() {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001600 return InvokeOnWorker(
1601 RTC_FROM_HERE, Bind(&VoiceMediaChannel::CanInsertDtmf, media_channel()));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001602}
1603
Peter Boström0c4e06b2015-10-07 12:23:21 +02001604bool VoiceChannel::InsertDtmf(uint32_t ssrc,
1605 int event_code,
solenberg1d63dd02015-12-02 12:35:09 -08001606 int duration) {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001607 return InvokeOnWorker(RTC_FROM_HERE, Bind(&VoiceChannel::InsertDtmf_w, this,
1608 ssrc, event_code, duration));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001609}
1610
solenberg4bac9c52015-10-09 02:32:53 -07001611bool VoiceChannel::SetOutputVolume(uint32_t ssrc, double volume) {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001612 return InvokeOnWorker(RTC_FROM_HERE, Bind(&VoiceMediaChannel::SetOutputVolume,
1613 media_channel(), ssrc, volume));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001614}
sergeyu@chromium.org9cf037b2014-02-07 19:03:26 +00001615
Tommif888bb52015-12-12 01:37:01 +01001616void VoiceChannel::SetRawAudioSink(
1617 uint32_t ssrc,
kwiberg31022942016-03-11 14:18:21 -08001618 std::unique_ptr<webrtc::AudioSinkInterface> sink) {
1619 // We need to work around Bind's lack of support for unique_ptr and ownership
deadbeef2d110be2016-01-13 12:00:26 -08001620 // passing. So we invoke to our own little routine that gets a pointer to
1621 // our local variable. This is OK since we're synchronously invoking.
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001622 InvokeOnWorker(RTC_FROM_HERE,
1623 Bind(&SetRawAudioSink_w, media_channel(), ssrc, &sink));
Tommif888bb52015-12-12 01:37:01 +01001624}
1625
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001626webrtc::RtpParameters VoiceChannel::GetRtpSendParameters(uint32_t ssrc) const {
skvladdc1c62c2016-03-16 19:07:43 -07001627 return worker_thread()->Invoke<webrtc::RtpParameters>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001628 RTC_FROM_HERE, Bind(&VoiceChannel::GetRtpSendParameters_w, this, ssrc));
skvladdc1c62c2016-03-16 19:07:43 -07001629}
1630
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001631webrtc::RtpParameters VoiceChannel::GetRtpSendParameters_w(
1632 uint32_t ssrc) const {
1633 return media_channel()->GetRtpSendParameters(ssrc);
skvladdc1c62c2016-03-16 19:07:43 -07001634}
1635
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001636bool VoiceChannel::SetRtpSendParameters(
1637 uint32_t ssrc,
1638 const webrtc::RtpParameters& parameters) {
skvladdc1c62c2016-03-16 19:07:43 -07001639 return InvokeOnWorker(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001640 RTC_FROM_HERE,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001641 Bind(&VoiceChannel::SetRtpSendParameters_w, this, ssrc, parameters));
skvladdc1c62c2016-03-16 19:07:43 -07001642}
1643
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001644bool VoiceChannel::SetRtpSendParameters_w(uint32_t ssrc,
1645 webrtc::RtpParameters parameters) {
1646 return media_channel()->SetRtpSendParameters(ssrc, parameters);
1647}
1648
1649webrtc::RtpParameters VoiceChannel::GetRtpReceiveParameters(
1650 uint32_t ssrc) const {
1651 return worker_thread()->Invoke<webrtc::RtpParameters>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001652 RTC_FROM_HERE,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001653 Bind(&VoiceChannel::GetRtpReceiveParameters_w, this, ssrc));
1654}
1655
1656webrtc::RtpParameters VoiceChannel::GetRtpReceiveParameters_w(
1657 uint32_t ssrc) const {
1658 return media_channel()->GetRtpReceiveParameters(ssrc);
1659}
1660
1661bool VoiceChannel::SetRtpReceiveParameters(
1662 uint32_t ssrc,
1663 const webrtc::RtpParameters& parameters) {
1664 return InvokeOnWorker(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001665 RTC_FROM_HERE,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001666 Bind(&VoiceChannel::SetRtpReceiveParameters_w, this, ssrc, parameters));
1667}
1668
1669bool VoiceChannel::SetRtpReceiveParameters_w(uint32_t ssrc,
1670 webrtc::RtpParameters parameters) {
1671 return media_channel()->SetRtpReceiveParameters(ssrc, parameters);
skvladdc1c62c2016-03-16 19:07:43 -07001672}
1673
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001674bool VoiceChannel::GetStats(VoiceMediaInfo* stats) {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001675 return InvokeOnWorker(RTC_FROM_HERE, Bind(&VoiceMediaChannel::GetStats,
1676 media_channel(), stats));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001677}
1678
1679void VoiceChannel::StartMediaMonitor(int cms) {
1680 media_monitor_.reset(new VoiceMediaMonitor(media_channel(), worker_thread(),
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001681 rtc::Thread::Current()));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001682 media_monitor_->SignalUpdate.connect(
1683 this, &VoiceChannel::OnMediaMonitorUpdate);
1684 media_monitor_->Start(cms);
1685}
1686
1687void VoiceChannel::StopMediaMonitor() {
1688 if (media_monitor_) {
1689 media_monitor_->Stop();
1690 media_monitor_->SignalUpdate.disconnect(this);
1691 media_monitor_.reset();
1692 }
1693}
1694
1695void VoiceChannel::StartAudioMonitor(int cms) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001696 audio_monitor_.reset(new AudioMonitor(this, rtc::Thread::Current()));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001697 audio_monitor_
1698 ->SignalUpdate.connect(this, &VoiceChannel::OnAudioMonitorUpdate);
1699 audio_monitor_->Start(cms);
1700}
1701
1702void VoiceChannel::StopAudioMonitor() {
1703 if (audio_monitor_) {
1704 audio_monitor_->Stop();
1705 audio_monitor_.reset();
1706 }
1707}
1708
1709bool VoiceChannel::IsAudioMonitorRunning() const {
1710 return (audio_monitor_.get() != NULL);
1711}
1712
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001713int VoiceChannel::GetInputLevel_w() {
Fredrik Solenberg0c022642015-08-05 12:25:22 +02001714 return media_engine_->GetInputLevel();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001715}
1716
1717int VoiceChannel::GetOutputLevel_w() {
1718 return media_channel()->GetOutputLevel();
1719}
1720
1721void VoiceChannel::GetActiveStreams_w(AudioInfo::StreamList* actives) {
1722 media_channel()->GetActiveStreams(actives);
1723}
1724
deadbeef5bd5ca32017-02-10 11:31:50 -08001725void VoiceChannel::OnPacketRead(rtc::PacketTransportInternal* transport,
johand89ab142016-10-25 10:50:32 -07001726 const char* data,
1727 size_t len,
1728 const rtc::PacketTime& packet_time,
wu@webrtc.orga9890802013-12-13 00:21:03 +00001729 int flags) {
johand89ab142016-10-25 10:50:32 -07001730 BaseChannel::OnPacketRead(transport, data, len, packet_time, flags);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001731 // Set a flag when we've received an RTP packet. If we're waiting for early
1732 // media, this will disable the timeout.
johand89ab142016-10-25 10:50:32 -07001733 if (!received_media_ && !PacketIsRtcp(transport, data, len)) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001734 received_media_ = true;
1735 }
1736}
1737
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001738void BaseChannel::UpdateMediaSendRecvState() {
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001739 RTC_DCHECK(network_thread_->IsCurrent());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001740 invoker_.AsyncInvoke<void>(
1741 RTC_FROM_HERE, worker_thread_,
1742 Bind(&BaseChannel::UpdateMediaSendRecvState_w, this));
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001743}
1744
michaelt79e05882016-11-08 02:50:09 -08001745int BaseChannel::GetTransportOverheadPerPacket() const {
1746 RTC_DCHECK(network_thread_->IsCurrent());
1747
1748 if (!selected_candidate_pair_)
1749 return 0;
1750
1751 int transport_overhead_per_packet = 0;
1752
1753 constexpr int kIpv4Overhaed = 20;
1754 constexpr int kIpv6Overhaed = 40;
1755 transport_overhead_per_packet +=
1756 selected_candidate_pair_->local_candidate().address().family() == AF_INET
1757 ? kIpv4Overhaed
1758 : kIpv6Overhaed;
1759
1760 constexpr int kUdpOverhaed = 8;
1761 constexpr int kTcpOverhaed = 20;
1762 transport_overhead_per_packet +=
1763 selected_candidate_pair_->local_candidate().protocol() ==
1764 TCP_PROTOCOL_NAME
1765 ? kTcpOverhaed
1766 : kUdpOverhaed;
1767
1768 if (secure()) {
1769 int srtp_overhead = 0;
1770 if (srtp_filter_.GetSrtpOverhead(&srtp_overhead))
1771 transport_overhead_per_packet += srtp_overhead;
1772 }
1773
1774 return transport_overhead_per_packet;
1775}
1776
1777void BaseChannel::UpdateTransportOverhead() {
1778 int transport_overhead_per_packet = GetTransportOverheadPerPacket();
1779 if (transport_overhead_per_packet)
1780 invoker_.AsyncInvoke<void>(
1781 RTC_FROM_HERE, worker_thread_,
1782 Bind(&MediaChannel::OnTransportOverheadChanged, media_channel_,
1783 transport_overhead_per_packet));
1784}
1785
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001786void VoiceChannel::UpdateMediaSendRecvState_w() {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001787 // Render incoming data if we're the active call, and we have the local
1788 // content. We receive data on the default channel and multiplexed streams.
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001789 bool recv = IsReadyToReceiveMedia_w();
solenberg5b14b422015-10-01 04:10:31 -07001790 media_channel()->SetPlayout(recv);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001791
1792 // Send outgoing data if we're the active call, we have the remote content,
1793 // and we have had some form of connectivity.
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001794 bool send = IsReadyToSendMedia_w();
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08001795 media_channel()->SetSend(send);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001796
1797 LOG(LS_INFO) << "Changing voice state, recv=" << recv << " send=" << send;
1798}
1799
1800const ContentInfo* VoiceChannel::GetFirstContent(
1801 const SessionDescription* sdesc) {
1802 return GetFirstAudioContent(sdesc);
1803}
1804
1805bool VoiceChannel::SetLocalContent_w(const MediaContentDescription* content,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001806 ContentAction action,
1807 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +01001808 TRACE_EVENT0("webrtc", "VoiceChannel::SetLocalContent_w");
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001809 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001810 LOG(LS_INFO) << "Setting local voice description";
1811
1812 const AudioContentDescription* audio =
1813 static_cast<const AudioContentDescription*>(content);
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001814 RTC_DCHECK(audio != NULL);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001815 if (!audio) {
1816 SafeSetError("Can't find audio content in local description.", error_desc);
1817 return false;
1818 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001819
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001820 if (!SetRtpTransportParameters(content, action, CS_LOCAL, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001821 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001822 }
1823
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001824 AudioRecvParameters recv_params = last_recv_params_;
1825 RtpParametersFromMediaDescription(audio, &recv_params);
1826 if (!media_channel()->SetRecvParameters(recv_params)) {
Peter Thatcherbfab5cb2015-08-20 17:40:24 -07001827 SafeSetError("Failed to set local audio description recv parameters.",
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001828 error_desc);
1829 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001830 }
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001831 for (const AudioCodec& codec : audio->codecs()) {
1832 bundle_filter()->AddPayloadType(codec.id);
1833 }
1834 last_recv_params_ = recv_params;
1835
1836 // TODO(pthatcher): Move local streams into AudioSendParameters, and
1837 // only give it to the media channel once we have a remote
1838 // description too (without a remote description, we won't be able
1839 // to send them anyway).
1840 if (!UpdateLocalStreams_w(audio->streams(), action, error_desc)) {
1841 SafeSetError("Failed to set local audio description streams.", error_desc);
1842 return false;
1843 }
1844
1845 set_local_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001846 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001847 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001848}
1849
1850bool VoiceChannel::SetRemoteContent_w(const MediaContentDescription* content,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001851 ContentAction action,
1852 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +01001853 TRACE_EVENT0("webrtc", "VoiceChannel::SetRemoteContent_w");
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001854 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001855 LOG(LS_INFO) << "Setting remote voice description";
1856
1857 const AudioContentDescription* audio =
1858 static_cast<const AudioContentDescription*>(content);
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001859 RTC_DCHECK(audio != NULL);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001860 if (!audio) {
1861 SafeSetError("Can't find audio content in remote description.", error_desc);
1862 return false;
1863 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001864
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001865 if (!SetRtpTransportParameters(content, action, CS_REMOTE, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001866 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001867 }
1868
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001869 AudioSendParameters send_params = last_send_params_;
1870 RtpSendParametersFromMediaDescription(audio, &send_params);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001871 if (audio->agc_minus_10db()) {
Karl Wibergbe579832015-11-10 22:34:18 +01001872 send_params.options.adjust_agc_delta = rtc::Optional<int>(kAgcMinus10db);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001873 }
skvladdc1c62c2016-03-16 19:07:43 -07001874
1875 bool parameters_applied = media_channel()->SetSendParameters(send_params);
1876 if (!parameters_applied) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001877 SafeSetError("Failed to set remote audio description send parameters.",
1878 error_desc);
1879 return false;
1880 }
1881 last_send_params_ = send_params;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001882
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001883 // TODO(pthatcher): Move remote streams into AudioRecvParameters,
1884 // and only give it to the media channel once we have a local
1885 // description too (without a local description, we won't be able to
1886 // recv them anyway).
1887 if (!UpdateRemoteStreams_w(audio->streams(), action, error_desc)) {
1888 SafeSetError("Failed to set remote audio description streams.", error_desc);
1889 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001890 }
1891
Peter Thatcherbfab5cb2015-08-20 17:40:24 -07001892 if (audio->rtp_header_extensions_set()) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001893 MaybeCacheRtpAbsSendTimeHeaderExtension_w(audio->rtp_header_extensions());
Peter Thatcherbfab5cb2015-08-20 17:40:24 -07001894 }
1895
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001896 set_remote_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001897 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001898 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001899}
1900
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001901void VoiceChannel::HandleEarlyMediaTimeout() {
1902 // This occurs on the main thread, not the worker thread.
1903 if (!received_media_) {
1904 LOG(LS_INFO) << "No early media received before timeout";
1905 SignalEarlyMediaTimeout(this);
1906 }
1907}
1908
Peter Boström0c4e06b2015-10-07 12:23:21 +02001909bool VoiceChannel::InsertDtmf_w(uint32_t ssrc,
1910 int event,
solenberg1d63dd02015-12-02 12:35:09 -08001911 int duration) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001912 if (!enabled()) {
1913 return false;
1914 }
solenberg1d63dd02015-12-02 12:35:09 -08001915 return media_channel()->InsertDtmf(ssrc, event, duration);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001916}
1917
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001918void VoiceChannel::OnMessage(rtc::Message *pmsg) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001919 switch (pmsg->message_id) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001920 case MSG_EARLYMEDIATIMEOUT:
1921 HandleEarlyMediaTimeout();
1922 break;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001923 case MSG_CHANNEL_ERROR: {
1924 VoiceChannelErrorMessageData* data =
1925 static_cast<VoiceChannelErrorMessageData*>(pmsg->pdata);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001926 delete data;
1927 break;
1928 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001929 default:
1930 BaseChannel::OnMessage(pmsg);
1931 break;
1932 }
1933}
1934
1935void VoiceChannel::OnConnectionMonitorUpdate(
pthatcher@webrtc.orgb4aac132015-03-13 18:25:21 +00001936 ConnectionMonitor* monitor, const std::vector<ConnectionInfo>& infos) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001937 SignalConnectionMonitor(this, infos);
1938}
1939
1940void VoiceChannel::OnMediaMonitorUpdate(
1941 VoiceMediaChannel* media_channel, const VoiceMediaInfo& info) {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001942 RTC_DCHECK(media_channel == this->media_channel());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001943 SignalMediaMonitor(this, info);
1944}
1945
1946void VoiceChannel::OnAudioMonitorUpdate(AudioMonitor* monitor,
1947 const AudioInfo& info) {
1948 SignalAudioMonitor(this, info);
1949}
1950
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001951void VoiceChannel::GetSrtpCryptoSuites_n(
1952 std::vector<int>* crypto_suites) const {
jbauchcb560652016-08-04 05:20:32 -07001953 GetSupportedAudioCryptoSuites(crypto_options(), crypto_suites);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001954}
1955
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001956VideoChannel::VideoChannel(rtc::Thread* worker_thread,
1957 rtc::Thread* network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -08001958 rtc::Thread* signaling_thread,
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001959 VideoMediaChannel* media_channel,
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001960 const std::string& content_name,
deadbeefac22f702017-01-12 21:59:29 -08001961 bool rtcp_mux_required,
deadbeef7af91dd2016-12-13 11:29:11 -08001962 bool srtp_required)
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001963 : BaseChannel(worker_thread,
1964 network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -08001965 signaling_thread,
deadbeefcbecd352015-09-23 11:50:27 -07001966 media_channel,
deadbeefcbecd352015-09-23 11:50:27 -07001967 content_name,
deadbeefac22f702017-01-12 21:59:29 -08001968 rtcp_mux_required,
deadbeef7af91dd2016-12-13 11:29:11 -08001969 srtp_required) {}
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001970
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001971VideoChannel::~VideoChannel() {
Peter Boströmca8b4042016-03-08 14:24:13 -08001972 TRACE_EVENT0("webrtc", "VideoChannel::~VideoChannel");
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001973 StopMediaMonitor();
1974 // this can't be done in the base class, since it calls a virtual
1975 DisableMedia_w();
wu@webrtc.org78187522013-10-07 23:32:02 +00001976
1977 Deinit();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001978}
1979
nisse08582ff2016-02-04 01:24:52 -08001980bool VideoChannel::SetSink(uint32_t ssrc,
nisseacd935b2016-11-11 03:55:13 -08001981 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
nisse08582ff2016-02-04 01:24:52 -08001982 worker_thread()->Invoke<void>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001983 RTC_FROM_HERE,
nisse08582ff2016-02-04 01:24:52 -08001984 Bind(&VideoMediaChannel::SetSink, media_channel(), ssrc, sink));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001985 return true;
1986}
1987
deadbeef5a4a75a2016-06-02 16:23:38 -07001988bool VideoChannel::SetVideoSend(
nisse2ded9b12016-04-08 02:23:55 -07001989 uint32_t ssrc,
deadbeef5a4a75a2016-06-02 16:23:38 -07001990 bool mute,
1991 const VideoOptions* options,
nisseacd935b2016-11-11 03:55:13 -08001992 rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001993 return InvokeOnWorker(RTC_FROM_HERE,
1994 Bind(&VideoMediaChannel::SetVideoSend, media_channel(),
deadbeef5a4a75a2016-06-02 16:23:38 -07001995 ssrc, mute, options, source));
solenberg1dd98f32015-09-10 01:57:14 -07001996}
1997
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001998webrtc::RtpParameters VideoChannel::GetRtpSendParameters(uint32_t ssrc) const {
skvladdc1c62c2016-03-16 19:07:43 -07001999 return worker_thread()->Invoke<webrtc::RtpParameters>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07002000 RTC_FROM_HERE, Bind(&VideoChannel::GetRtpSendParameters_w, this, ssrc));
skvladdc1c62c2016-03-16 19:07:43 -07002001}
2002
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002003webrtc::RtpParameters VideoChannel::GetRtpSendParameters_w(
2004 uint32_t ssrc) const {
2005 return media_channel()->GetRtpSendParameters(ssrc);
skvladdc1c62c2016-03-16 19:07:43 -07002006}
2007
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002008bool VideoChannel::SetRtpSendParameters(
2009 uint32_t ssrc,
2010 const webrtc::RtpParameters& parameters) {
skvladdc1c62c2016-03-16 19:07:43 -07002011 return InvokeOnWorker(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07002012 RTC_FROM_HERE,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002013 Bind(&VideoChannel::SetRtpSendParameters_w, this, ssrc, parameters));
skvladdc1c62c2016-03-16 19:07:43 -07002014}
2015
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002016bool VideoChannel::SetRtpSendParameters_w(uint32_t ssrc,
2017 webrtc::RtpParameters parameters) {
2018 return media_channel()->SetRtpSendParameters(ssrc, parameters);
2019}
2020
2021webrtc::RtpParameters VideoChannel::GetRtpReceiveParameters(
2022 uint32_t ssrc) const {
2023 return worker_thread()->Invoke<webrtc::RtpParameters>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07002024 RTC_FROM_HERE,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002025 Bind(&VideoChannel::GetRtpReceiveParameters_w, this, ssrc));
2026}
2027
2028webrtc::RtpParameters VideoChannel::GetRtpReceiveParameters_w(
2029 uint32_t ssrc) const {
2030 return media_channel()->GetRtpReceiveParameters(ssrc);
2031}
2032
2033bool VideoChannel::SetRtpReceiveParameters(
2034 uint32_t ssrc,
2035 const webrtc::RtpParameters& parameters) {
2036 return InvokeOnWorker(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07002037 RTC_FROM_HERE,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07002038 Bind(&VideoChannel::SetRtpReceiveParameters_w, this, ssrc, parameters));
2039}
2040
2041bool VideoChannel::SetRtpReceiveParameters_w(uint32_t ssrc,
2042 webrtc::RtpParameters parameters) {
2043 return media_channel()->SetRtpReceiveParameters(ssrc, parameters);
skvladdc1c62c2016-03-16 19:07:43 -07002044}
Danil Chapovalov33b01f22016-05-11 19:55:27 +02002045
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002046void VideoChannel::UpdateMediaSendRecvState_w() {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002047 // Send outgoing data if we're the active call, we have the remote content,
2048 // and we have had some form of connectivity.
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002049 bool send = IsReadyToSendMedia_w();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002050 if (!media_channel()->SetSend(send)) {
2051 LOG(LS_ERROR) << "Failed to SetSend on video channel";
2052 // TODO(gangji): Report error back to server.
2053 }
2054
Peter Boström34fbfff2015-09-24 19:20:30 +02002055 LOG(LS_INFO) << "Changing video state, send=" << send;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002056}
2057
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00002058bool VideoChannel::GetStats(VideoMediaInfo* stats) {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07002059 return InvokeOnWorker(RTC_FROM_HERE, Bind(&VideoMediaChannel::GetStats,
2060 media_channel(), stats));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002061}
2062
2063void VideoChannel::StartMediaMonitor(int cms) {
2064 media_monitor_.reset(new VideoMediaMonitor(media_channel(), worker_thread(),
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002065 rtc::Thread::Current()));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002066 media_monitor_->SignalUpdate.connect(
2067 this, &VideoChannel::OnMediaMonitorUpdate);
2068 media_monitor_->Start(cms);
2069}
2070
2071void VideoChannel::StopMediaMonitor() {
2072 if (media_monitor_) {
2073 media_monitor_->Stop();
2074 media_monitor_.reset();
2075 }
2076}
2077
2078const ContentInfo* VideoChannel::GetFirstContent(
2079 const SessionDescription* sdesc) {
2080 return GetFirstVideoContent(sdesc);
2081}
2082
2083bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00002084 ContentAction action,
2085 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +01002086 TRACE_EVENT0("webrtc", "VideoChannel::SetLocalContent_w");
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002087 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002088 LOG(LS_INFO) << "Setting local video description";
2089
2090 const VideoContentDescription* video =
2091 static_cast<const VideoContentDescription*>(content);
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002092 RTC_DCHECK(video != NULL);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00002093 if (!video) {
2094 SafeSetError("Can't find video content in local description.", error_desc);
2095 return false;
2096 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002097
Danil Chapovalov33b01f22016-05-11 19:55:27 +02002098 if (!SetRtpTransportParameters(content, action, CS_LOCAL, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002099 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002100 }
2101
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002102 VideoRecvParameters recv_params = last_recv_params_;
2103 RtpParametersFromMediaDescription(video, &recv_params);
2104 if (!media_channel()->SetRecvParameters(recv_params)) {
2105 SafeSetError("Failed to set local video description recv parameters.",
2106 error_desc);
2107 return false;
2108 }
2109 for (const VideoCodec& codec : video->codecs()) {
2110 bundle_filter()->AddPayloadType(codec.id);
2111 }
2112 last_recv_params_ = recv_params;
2113
2114 // TODO(pthatcher): Move local streams into VideoSendParameters, and
2115 // only give it to the media channel once we have a remote
2116 // description too (without a remote description, we won't be able
2117 // to send them anyway).
2118 if (!UpdateLocalStreams_w(video->streams(), action, error_desc)) {
2119 SafeSetError("Failed to set local video description streams.", error_desc);
2120 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002121 }
2122
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002123 set_local_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002124 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002125 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002126}
2127
2128bool VideoChannel::SetRemoteContent_w(const MediaContentDescription* content,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00002129 ContentAction action,
2130 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +01002131 TRACE_EVENT0("webrtc", "VideoChannel::SetRemoteContent_w");
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002132 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002133 LOG(LS_INFO) << "Setting remote video description";
2134
2135 const VideoContentDescription* video =
2136 static_cast<const VideoContentDescription*>(content);
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002137 RTC_DCHECK(video != NULL);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00002138 if (!video) {
2139 SafeSetError("Can't find video content in remote description.", error_desc);
2140 return false;
2141 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002142
Danil Chapovalov33b01f22016-05-11 19:55:27 +02002143 if (!SetRtpTransportParameters(content, action, CS_REMOTE, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002144 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002145 }
2146
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002147 VideoSendParameters send_params = last_send_params_;
2148 RtpSendParametersFromMediaDescription(video, &send_params);
2149 if (video->conference_mode()) {
nisse4b4dc862016-02-17 05:25:36 -08002150 send_params.conference_mode = true;
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002151 }
skvladdc1c62c2016-03-16 19:07:43 -07002152
2153 bool parameters_applied = media_channel()->SetSendParameters(send_params);
2154
2155 if (!parameters_applied) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002156 SafeSetError("Failed to set remote video description send parameters.",
2157 error_desc);
2158 return false;
2159 }
2160 last_send_params_ = send_params;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002161
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002162 // TODO(pthatcher): Move remote streams into VideoRecvParameters,
2163 // and only give it to the media channel once we have a local
2164 // description too (without a local description, we won't be able to
2165 // recv them anyway).
2166 if (!UpdateRemoteStreams_w(video->streams(), action, error_desc)) {
2167 SafeSetError("Failed to set remote video description streams.", error_desc);
2168 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002169 }
2170
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002171 if (video->rtp_header_extensions_set()) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +02002172 MaybeCacheRtpAbsSendTimeHeaderExtension_w(video->rtp_header_extensions());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002173 }
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002174
2175 set_remote_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002176 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002177 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002178}
2179
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002180void VideoChannel::OnMessage(rtc::Message *pmsg) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002181 switch (pmsg->message_id) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002182 case MSG_CHANNEL_ERROR: {
2183 const VideoChannelErrorMessageData* data =
2184 static_cast<VideoChannelErrorMessageData*>(pmsg->pdata);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002185 delete data;
2186 break;
2187 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002188 default:
2189 BaseChannel::OnMessage(pmsg);
2190 break;
2191 }
2192}
2193
2194void VideoChannel::OnConnectionMonitorUpdate(
pthatcher@webrtc.orgb4aac132015-03-13 18:25:21 +00002195 ConnectionMonitor* monitor, const std::vector<ConnectionInfo> &infos) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002196 SignalConnectionMonitor(this, infos);
2197}
2198
2199// TODO(pthatcher): Look into removing duplicate code between
2200// audio, video, and data, perhaps by using templates.
2201void VideoChannel::OnMediaMonitorUpdate(
2202 VideoMediaChannel* media_channel, const VideoMediaInfo &info) {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002203 RTC_DCHECK(media_channel == this->media_channel());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002204 SignalMediaMonitor(this, info);
2205}
2206
Danil Chapovalov33b01f22016-05-11 19:55:27 +02002207void VideoChannel::GetSrtpCryptoSuites_n(
2208 std::vector<int>* crypto_suites) const {
jbauchcb560652016-08-04 05:20:32 -07002209 GetSupportedVideoCryptoSuites(crypto_options(), crypto_suites);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002210}
2211
deadbeef953c2ce2017-01-09 14:53:41 -08002212RtpDataChannel::RtpDataChannel(rtc::Thread* worker_thread,
2213 rtc::Thread* network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -08002214 rtc::Thread* signaling_thread,
deadbeef953c2ce2017-01-09 14:53:41 -08002215 DataMediaChannel* media_channel,
deadbeef953c2ce2017-01-09 14:53:41 -08002216 const std::string& content_name,
deadbeefac22f702017-01-12 21:59:29 -08002217 bool rtcp_mux_required,
deadbeef953c2ce2017-01-09 14:53:41 -08002218 bool srtp_required)
Danil Chapovalov33b01f22016-05-11 19:55:27 +02002219 : BaseChannel(worker_thread,
2220 network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -08002221 signaling_thread,
deadbeefcbecd352015-09-23 11:50:27 -07002222 media_channel,
deadbeefcbecd352015-09-23 11:50:27 -07002223 content_name,
deadbeefac22f702017-01-12 21:59:29 -08002224 rtcp_mux_required,
deadbeef953c2ce2017-01-09 14:53:41 -08002225 srtp_required) {}
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002226
deadbeef953c2ce2017-01-09 14:53:41 -08002227RtpDataChannel::~RtpDataChannel() {
2228 TRACE_EVENT0("webrtc", "RtpDataChannel::~RtpDataChannel");
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002229 StopMediaMonitor();
2230 // this can't be done in the base class, since it calls a virtual
2231 DisableMedia_w();
wu@webrtc.org78187522013-10-07 23:32:02 +00002232
2233 Deinit();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002234}
2235
deadbeeff5346592017-01-24 21:51:21 -08002236bool RtpDataChannel::Init_w(
2237 DtlsTransportInternal* rtp_dtls_transport,
2238 DtlsTransportInternal* rtcp_dtls_transport,
deadbeef5bd5ca32017-02-10 11:31:50 -08002239 rtc::PacketTransportInternal* rtp_packet_transport,
2240 rtc::PacketTransportInternal* rtcp_packet_transport) {
deadbeeff5346592017-01-24 21:51:21 -08002241 if (!BaseChannel::Init_w(rtp_dtls_transport, rtcp_dtls_transport,
2242 rtp_packet_transport, rtcp_packet_transport)) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002243 return false;
2244 }
deadbeef953c2ce2017-01-09 14:53:41 -08002245 media_channel()->SignalDataReceived.connect(this,
2246 &RtpDataChannel::OnDataReceived);
wu@webrtc.orgd64719d2013-08-01 00:00:07 +00002247 media_channel()->SignalReadyToSend.connect(
deadbeef953c2ce2017-01-09 14:53:41 -08002248 this, &RtpDataChannel::OnDataChannelReadyToSend);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002249 return true;
2250}
2251
deadbeef953c2ce2017-01-09 14:53:41 -08002252bool RtpDataChannel::SendData(const SendDataParams& params,
2253 const rtc::CopyOnWriteBuffer& payload,
2254 SendDataResult* result) {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07002255 return InvokeOnWorker(
2256 RTC_FROM_HERE, Bind(&DataMediaChannel::SendData, media_channel(), params,
2257 payload, result));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002258}
2259
deadbeef953c2ce2017-01-09 14:53:41 -08002260const ContentInfo* RtpDataChannel::GetFirstContent(
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002261 const SessionDescription* sdesc) {
2262 return GetFirstDataContent(sdesc);
2263}
2264
deadbeef953c2ce2017-01-09 14:53:41 -08002265bool RtpDataChannel::CheckDataChannelTypeFromContent(
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00002266 const DataContentDescription* content,
2267 std::string* error_desc) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002268 bool is_sctp = ((content->protocol() == kMediaProtocolSctp) ||
2269 (content->protocol() == kMediaProtocolDtlsSctp));
deadbeef953c2ce2017-01-09 14:53:41 -08002270 // It's been set before, but doesn't match. That's bad.
2271 if (is_sctp) {
2272 SafeSetError("Data channel type mismatch. Expected RTP, got SCTP.",
2273 error_desc);
2274 return false;
2275 }
2276 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002277}
2278
deadbeef953c2ce2017-01-09 14:53:41 -08002279bool RtpDataChannel::SetLocalContent_w(const MediaContentDescription* content,
2280 ContentAction action,
2281 std::string* error_desc) {
2282 TRACE_EVENT0("webrtc", "RtpDataChannel::SetLocalContent_w");
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002283 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002284 LOG(LS_INFO) << "Setting local data description";
2285
2286 const DataContentDescription* data =
2287 static_cast<const DataContentDescription*>(content);
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002288 RTC_DCHECK(data != NULL);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00002289 if (!data) {
2290 SafeSetError("Can't find data content in local description.", error_desc);
2291 return false;
2292 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002293
deadbeef953c2ce2017-01-09 14:53:41 -08002294 if (!CheckDataChannelTypeFromContent(data, error_desc)) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002295 return false;
2296 }
2297
deadbeef953c2ce2017-01-09 14:53:41 -08002298 if (!SetRtpTransportParameters(content, action, CS_LOCAL, error_desc)) {
2299 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002300 }
2301
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002302 DataRecvParameters recv_params = last_recv_params_;
2303 RtpParametersFromMediaDescription(data, &recv_params);
2304 if (!media_channel()->SetRecvParameters(recv_params)) {
2305 SafeSetError("Failed to set remote data description recv parameters.",
2306 error_desc);
2307 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002308 }
deadbeef953c2ce2017-01-09 14:53:41 -08002309 for (const DataCodec& codec : data->codecs()) {
2310 bundle_filter()->AddPayloadType(codec.id);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002311 }
2312 last_recv_params_ = recv_params;
2313
2314 // TODO(pthatcher): Move local streams into DataSendParameters, and
2315 // only give it to the media channel once we have a remote
2316 // description too (without a remote description, we won't be able
2317 // to send them anyway).
2318 if (!UpdateLocalStreams_w(data->streams(), action, error_desc)) {
2319 SafeSetError("Failed to set local data description streams.", error_desc);
2320 return false;
2321 }
2322
2323 set_local_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002324 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002325 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002326}
2327
deadbeef953c2ce2017-01-09 14:53:41 -08002328bool RtpDataChannel::SetRemoteContent_w(const MediaContentDescription* content,
2329 ContentAction action,
2330 std::string* error_desc) {
2331 TRACE_EVENT0("webrtc", "RtpDataChannel::SetRemoteContent_w");
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002332 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002333
2334 const DataContentDescription* data =
2335 static_cast<const DataContentDescription*>(content);
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002336 RTC_DCHECK(data != NULL);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00002337 if (!data) {
2338 SafeSetError("Can't find data content in remote description.", error_desc);
2339 return false;
2340 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002341
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002342 // If the remote data doesn't have codecs and isn't an update, it
2343 // must be empty, so ignore it.
2344 if (!data->has_codecs() && action != CA_UPDATE) {
2345 return true;
2346 }
2347
deadbeef953c2ce2017-01-09 14:53:41 -08002348 if (!CheckDataChannelTypeFromContent(data, error_desc)) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002349 return false;
2350 }
2351
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002352 LOG(LS_INFO) << "Setting remote data description";
deadbeef953c2ce2017-01-09 14:53:41 -08002353 if (!SetRtpTransportParameters(content, action, CS_REMOTE, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002354 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002355 }
2356
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002357 DataSendParameters send_params = last_send_params_;
2358 RtpSendParametersFromMediaDescription<DataCodec>(data, &send_params);
2359 if (!media_channel()->SetSendParameters(send_params)) {
2360 SafeSetError("Failed to set remote data description send parameters.",
2361 error_desc);
2362 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002363 }
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002364 last_send_params_ = send_params;
2365
2366 // TODO(pthatcher): Move remote streams into DataRecvParameters,
2367 // and only give it to the media channel once we have a local
2368 // description too (without a local description, we won't be able to
2369 // recv them anyway).
2370 if (!UpdateRemoteStreams_w(data->streams(), action, error_desc)) {
2371 SafeSetError("Failed to set remote data description streams.",
2372 error_desc);
2373 return false;
2374 }
2375
2376 set_remote_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002377 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07002378 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002379}
2380
deadbeef953c2ce2017-01-09 14:53:41 -08002381void RtpDataChannel::UpdateMediaSendRecvState_w() {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002382 // Render incoming data if we're the active call, and we have the local
2383 // content. We receive data on the default channel and multiplexed streams.
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002384 bool recv = IsReadyToReceiveMedia_w();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002385 if (!media_channel()->SetReceive(recv)) {
2386 LOG(LS_ERROR) << "Failed to SetReceive on data channel";
2387 }
2388
2389 // Send outgoing data if we're the active call, we have the remote content,
2390 // and we have had some form of connectivity.
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002391 bool send = IsReadyToSendMedia_w();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002392 if (!media_channel()->SetSend(send)) {
2393 LOG(LS_ERROR) << "Failed to SetSend on data channel";
2394 }
2395
sergeyu@chromium.org9cf037b2014-02-07 19:03:26 +00002396 // Trigger SignalReadyToSendData asynchronously.
2397 OnDataChannelReadyToSend(send);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002398
2399 LOG(LS_INFO) << "Changing data state, recv=" << recv << " send=" << send;
2400}
2401
deadbeef953c2ce2017-01-09 14:53:41 -08002402void RtpDataChannel::OnMessage(rtc::Message* pmsg) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002403 switch (pmsg->message_id) {
2404 case MSG_READYTOSENDDATA: {
wu@webrtc.orgd64719d2013-08-01 00:00:07 +00002405 DataChannelReadyToSendMessageData* data =
2406 static_cast<DataChannelReadyToSendMessageData*>(pmsg->pdata);
wu@webrtc.org07a6fbe2013-11-04 18:41:34 +00002407 ready_to_send_data_ = data->data();
2408 SignalReadyToSendData(ready_to_send_data_);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002409 delete data;
2410 break;
2411 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002412 case MSG_DATARECEIVED: {
2413 DataReceivedMessageData* data =
2414 static_cast<DataReceivedMessageData*>(pmsg->pdata);
deadbeef953c2ce2017-01-09 14:53:41 -08002415 SignalDataReceived(data->params, data->payload);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002416 delete data;
2417 break;
2418 }
2419 case MSG_CHANNEL_ERROR: {
2420 const DataChannelErrorMessageData* data =
2421 static_cast<DataChannelErrorMessageData*>(pmsg->pdata);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002422 delete data;
2423 break;
2424 }
2425 default:
2426 BaseChannel::OnMessage(pmsg);
2427 break;
2428 }
2429}
2430
deadbeef953c2ce2017-01-09 14:53:41 -08002431void RtpDataChannel::OnConnectionMonitorUpdate(
2432 ConnectionMonitor* monitor,
2433 const std::vector<ConnectionInfo>& infos) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002434 SignalConnectionMonitor(this, infos);
2435}
2436
deadbeef953c2ce2017-01-09 14:53:41 -08002437void RtpDataChannel::StartMediaMonitor(int cms) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002438 media_monitor_.reset(new DataMediaMonitor(media_channel(), worker_thread(),
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002439 rtc::Thread::Current()));
deadbeef953c2ce2017-01-09 14:53:41 -08002440 media_monitor_->SignalUpdate.connect(this,
2441 &RtpDataChannel::OnMediaMonitorUpdate);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002442 media_monitor_->Start(cms);
2443}
2444
deadbeef953c2ce2017-01-09 14:53:41 -08002445void RtpDataChannel::StopMediaMonitor() {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002446 if (media_monitor_) {
2447 media_monitor_->Stop();
2448 media_monitor_->SignalUpdate.disconnect(this);
2449 media_monitor_.reset();
2450 }
2451}
2452
deadbeef953c2ce2017-01-09 14:53:41 -08002453void RtpDataChannel::OnMediaMonitorUpdate(DataMediaChannel* media_channel,
2454 const DataMediaInfo& info) {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002455 RTC_DCHECK(media_channel == this->media_channel());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002456 SignalMediaMonitor(this, info);
2457}
2458
deadbeef953c2ce2017-01-09 14:53:41 -08002459void RtpDataChannel::OnDataReceived(const ReceiveDataParams& params,
2460 const char* data,
2461 size_t len) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002462 DataReceivedMessageData* msg = new DataReceivedMessageData(
2463 params, data, len);
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07002464 signaling_thread()->Post(RTC_FROM_HERE, this, MSG_DATARECEIVED, msg);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002465}
2466
deadbeef953c2ce2017-01-09 14:53:41 -08002467void RtpDataChannel::OnDataChannelError(uint32_t ssrc,
2468 DataMediaChannel::Error err) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002469 DataChannelErrorMessageData* data = new DataChannelErrorMessageData(
2470 ssrc, err);
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07002471 signaling_thread()->Post(RTC_FROM_HERE, this, MSG_CHANNEL_ERROR, data);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002472}
2473
deadbeef953c2ce2017-01-09 14:53:41 -08002474void RtpDataChannel::OnDataChannelReadyToSend(bool writable) {
wu@webrtc.orgd64719d2013-08-01 00:00:07 +00002475 // This is usded for congestion control to indicate that the stream is ready
2476 // to send by the MediaChannel, as opposed to OnReadyToSend, which indicates
2477 // that the transport channel is ready.
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07002478 signaling_thread()->Post(RTC_FROM_HERE, this, MSG_READYTOSENDDATA,
wu@webrtc.orgd64719d2013-08-01 00:00:07 +00002479 new DataChannelReadyToSendMessageData(writable));
2480}
2481
deadbeef953c2ce2017-01-09 14:53:41 -08002482void RtpDataChannel::GetSrtpCryptoSuites_n(
2483 std::vector<int>* crypto_suites) const {
jbauchcb560652016-08-04 05:20:32 -07002484 GetSupportedDataCryptoSuites(crypto_options(), crypto_suites);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002485}
2486
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002487} // namespace cricket