blob: 187c83236e4d191aa775313e5f587151b3931d9d [file] [log] [blame]
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001/*
kjellander65c7f672016-02-12 00:05:01 -08002 * Copyright 2004 The WebRTC project authors. All Rights Reserved.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003 *
kjellander65c7f672016-02-12 00:05:01 -08004 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00009 */
10
jbauch5869f502017-06-29 12:31:36 -070011#include <algorithm>
12#include <iterator>
kwiberg0eb15ed2015-12-17 03:04:15 -080013#include <utility>
14
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020015#include "pc/channel.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000016
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020017#include "api/call/audio_sink.h"
18#include "media/base/mediaconstants.h"
19#include "media/base/rtputils.h"
20#include "rtc_base/bind.h"
21#include "rtc_base/byteorder.h"
22#include "rtc_base/checks.h"
23#include "rtc_base/copyonwritebuffer.h"
24#include "rtc_base/dscp.h"
25#include "rtc_base/logging.h"
26#include "rtc_base/networkroute.h"
27#include "rtc_base/ptr_util.h"
28#include "rtc_base/trace_event.h"
zhihuang38ede132017-06-15 12:52:32 -070029// Adding 'nogncheck' to disable the gn include headers check to support modular
30// WebRTC build targets.
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020031#include "media/engine/webrtcvoiceengine.h" // nogncheck
32#include "p2p/base/packettransportinternal.h"
33#include "pc/channelmanager.h"
Steve Anton4e70a722017-11-28 14:57:10 -080034#include "pc/rtpmediautils.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000035
36namespace cricket {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000037using rtc::Bind;
sergeyu@chromium.org9cf037b2014-02-07 19:03:26 +000038
deadbeef2d110be2016-01-13 12:00:26 -080039namespace {
kwiberg31022942016-03-11 14:18:21 -080040// See comment below for why we need to use a pointer to a unique_ptr.
deadbeef2d110be2016-01-13 12:00:26 -080041bool SetRawAudioSink_w(VoiceMediaChannel* channel,
42 uint32_t ssrc,
kwiberg31022942016-03-11 14:18:21 -080043 std::unique_ptr<webrtc::AudioSinkInterface>* sink) {
44 channel->SetRawAudioSink(ssrc, std::move(*sink));
deadbeef2d110be2016-01-13 12:00:26 -080045 return true;
46}
Danil Chapovalov33b01f22016-05-11 19:55:27 +020047
48struct SendPacketMessageData : public rtc::MessageData {
49 rtc::CopyOnWriteBuffer packet;
50 rtc::PacketOptions options;
51};
52
deadbeef2d110be2016-01-13 12:00:26 -080053} // namespace
54
henrike@webrtc.org28e20752013-07-10 00:45:36 +000055enum {
sergeyu@chromium.org9cf037b2014-02-07 19:03:26 +000056 MSG_EARLYMEDIATIMEOUT = 1,
Danil Chapovalov33b01f22016-05-11 19:55:27 +020057 MSG_SEND_RTP_PACKET,
58 MSG_SEND_RTCP_PACKET,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000059 MSG_CHANNEL_ERROR,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000060 MSG_READYTOSENDDATA,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000061 MSG_DATARECEIVED,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000062 MSG_FIRSTPACKETRECEIVED,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000063};
64
henrike@webrtc.org28e20752013-07-10 00:45:36 +000065static const int kAgcMinus10db = -10;
66
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +000067static void SafeSetError(const std::string& message, std::string* error_desc) {
68 if (error_desc) {
69 *error_desc = message;
70 }
71}
72
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000073struct VoiceChannelErrorMessageData : public rtc::MessageData {
Peter Boström0c4e06b2015-10-07 12:23:21 +020074 VoiceChannelErrorMessageData(uint32_t in_ssrc,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000075 VoiceMediaChannel::Error in_error)
Peter Boström0c4e06b2015-10-07 12:23:21 +020076 : ssrc(in_ssrc), error(in_error) {}
77 uint32_t ssrc;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000078 VoiceMediaChannel::Error error;
79};
80
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000081struct VideoChannelErrorMessageData : public rtc::MessageData {
Peter Boström0c4e06b2015-10-07 12:23:21 +020082 VideoChannelErrorMessageData(uint32_t in_ssrc,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000083 VideoMediaChannel::Error in_error)
Peter Boström0c4e06b2015-10-07 12:23:21 +020084 : ssrc(in_ssrc), error(in_error) {}
85 uint32_t ssrc;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000086 VideoMediaChannel::Error error;
87};
88
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000089struct DataChannelErrorMessageData : public rtc::MessageData {
Peter Boström0c4e06b2015-10-07 12:23:21 +020090 DataChannelErrorMessageData(uint32_t in_ssrc,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000091 DataMediaChannel::Error in_error)
Peter Boström0c4e06b2015-10-07 12:23:21 +020092 : ssrc(in_ssrc), error(in_error) {}
93 uint32_t ssrc;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000094 DataMediaChannel::Error error;
95};
96
jbaucheec21bd2016-03-20 06:15:43 -070097static bool ValidPacket(bool rtcp, const rtc::CopyOnWriteBuffer* packet) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +000098 // Check the packet size. We could check the header too if needed.
zstein3dcf0e92017-06-01 13:22:42 -070099 return packet && IsValidRtpRtcpPacketSize(rtcp, packet->size());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000100}
101
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700102template <class Codec>
103void RtpParametersFromMediaDescription(
104 const MediaContentDescriptionImpl<Codec>* desc,
jbauch5869f502017-06-29 12:31:36 -0700105 const RtpHeaderExtensions& extensions,
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700106 RtpParameters<Codec>* params) {
107 // TODO(pthatcher): Remove this once we're sure no one will give us
Zhi Huang801b8682017-11-15 11:36:43 -0800108 // a description without codecs. Currently the ORTC implementation is relying
109 // on this.
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700110 if (desc->has_codecs()) {
111 params->codecs = desc->codecs();
112 }
113 // TODO(pthatcher): See if we really need
114 // rtp_header_extensions_set() and remove it if we don't.
115 if (desc->rtp_header_extensions_set()) {
jbauch5869f502017-06-29 12:31:36 -0700116 params->extensions = extensions;
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700117 }
deadbeef13871492015-12-09 12:37:51 -0800118 params->rtcp.reduced_size = desc->rtcp_reduced_size();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700119}
120
nisse05103312016-03-16 02:22:50 -0700121template <class Codec>
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700122void RtpSendParametersFromMediaDescription(
123 const MediaContentDescriptionImpl<Codec>* desc,
jbauch5869f502017-06-29 12:31:36 -0700124 const RtpHeaderExtensions& extensions,
nisse05103312016-03-16 02:22:50 -0700125 RtpSendParameters<Codec>* send_params) {
jbauch5869f502017-06-29 12:31:36 -0700126 RtpParametersFromMediaDescription(desc, extensions, send_params);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700127 send_params->max_bandwidth_bps = desc->bandwidth();
128}
129
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200130BaseChannel::BaseChannel(rtc::Thread* worker_thread,
131 rtc::Thread* network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -0800132 rtc::Thread* signaling_thread,
Steve Anton8699a322017-11-06 15:53:33 -0800133 std::unique_ptr<MediaChannel> media_channel,
deadbeefcbecd352015-09-23 11:50:27 -0700134 const std::string& content_name,
deadbeefac22f702017-01-12 21:59:29 -0800135 bool rtcp_mux_required,
deadbeef7af91dd2016-12-13 11:29:11 -0800136 bool srtp_required)
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200137 : worker_thread_(worker_thread),
138 network_thread_(network_thread),
zhihuangf5b251b2017-01-12 19:37:48 -0800139 signaling_thread_(signaling_thread),
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000140 content_name_(content_name),
zstein56162b92017-04-24 16:54:35 -0700141 rtcp_mux_required_(rtcp_mux_required),
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800142 unencrypted_rtp_transport_(
143 rtc::MakeUnique<webrtc::RtpTransport>(rtcp_mux_required)),
deadbeef7af91dd2016-12-13 11:29:11 -0800144 srtp_required_(srtp_required),
Zhi Huang1d88d742017-11-15 15:58:49 -0800145 media_channel_(std::move(media_channel)) {
Steve Anton8699a322017-11-06 15:53:33 -0800146 RTC_DCHECK_RUN_ON(worker_thread_);
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800147 rtp_transport_ = unencrypted_rtp_transport_.get();
148 ConnectToRtpTransport();
Mirko Bonadei675513b2017-11-09 11:09:25 +0100149 RTC_LOG(LS_INFO) << "Created channel for " << content_name;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000150}
151
152BaseChannel::~BaseChannel() {
Peter Boströmca8b4042016-03-08 14:24:13 -0800153 TRACE_EVENT0("webrtc", "BaseChannel::~BaseChannel");
Steve Anton8699a322017-11-06 15:53:33 -0800154 RTC_DCHECK_RUN_ON(worker_thread_);
wu@webrtc.org78187522013-10-07 23:32:02 +0000155 Deinit();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000156 StopConnectionMonitor();
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200157 // Eats any outstanding messages or packets.
158 worker_thread_->Clear(&invoker_);
159 worker_thread_->Clear(this);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000160 // We must destroy the media channel before the transport channel, otherwise
161 // the media channel may try to send on the dead transport channel. NULLing
162 // is not an effective strategy since the sends will come on another thread.
Steve Anton8699a322017-11-06 15:53:33 -0800163 media_channel_.reset();
Mirko Bonadei675513b2017-11-09 11:09:25 +0100164 RTC_LOG(LS_INFO) << "Destroyed channel: " << content_name_;
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200165}
166
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800167void BaseChannel::ConnectToRtpTransport() {
168 RTC_DCHECK(rtp_transport_);
169 rtp_transport_->SignalReadyToSend.connect(
170 this, &BaseChannel::OnTransportReadyToSend);
171 // TODO(zstein): RtpTransport::SignalPacketReceived will probably be replaced
172 // with a callback interface later so that the demuxer can select which
173 // channel to signal.
174 rtp_transport_->SignalPacketReceived.connect(this,
175 &BaseChannel::OnPacketReceived);
176 rtp_transport_->SignalNetworkRouteChanged.connect(
177 this, &BaseChannel::OnNetworkRouteChanged);
178 rtp_transport_->SignalWritableState.connect(this,
179 &BaseChannel::OnWritableState);
180 rtp_transport_->SignalSentPacket.connect(this,
181 &BaseChannel::SignalSentPacket_n);
182}
Danil Chapovalovdae07ba2016-05-14 01:43:50 +0200183
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800184void BaseChannel::DisconnectFromRtpTransport() {
185 RTC_DCHECK(rtp_transport_);
186 rtp_transport_->SignalReadyToSend.disconnect(this);
187 rtp_transport_->SignalPacketReceived.disconnect(this);
188 rtp_transport_->SignalNetworkRouteChanged.disconnect(this);
189 rtp_transport_->SignalWritableState.disconnect(this);
190 rtp_transport_->SignalSentPacket.disconnect(this);
Danil Chapovalovdae07ba2016-05-14 01:43:50 +0200191}
192
Steve Anton8699a322017-11-06 15:53:33 -0800193void BaseChannel::Init_w(DtlsTransportInternal* rtp_dtls_transport,
deadbeeff5346592017-01-24 21:51:21 -0800194 DtlsTransportInternal* rtcp_dtls_transport,
deadbeef5bd5ca32017-02-10 11:31:50 -0800195 rtc::PacketTransportInternal* rtp_packet_transport,
196 rtc::PacketTransportInternal* rtcp_packet_transport) {
Steve Anton8699a322017-11-06 15:53:33 -0800197 RTC_DCHECK_RUN_ON(worker_thread_);
198 network_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
199 return InitNetwork_n(rtp_dtls_transport, rtcp_dtls_transport,
200 rtp_packet_transport, rtcp_packet_transport);
201 });
202
deadbeeff5346592017-01-24 21:51:21 -0800203 // Both RTP and RTCP channels should be set, we can call SetInterface on
204 // the media channel and it can set network options.
wu@webrtc.orgde305012013-10-31 15:40:38 +0000205 media_channel_->SetInterface(this);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000206}
207
Steve Anton8699a322017-11-06 15:53:33 -0800208void BaseChannel::InitNetwork_n(
deadbeeff5346592017-01-24 21:51:21 -0800209 DtlsTransportInternal* rtp_dtls_transport,
210 DtlsTransportInternal* rtcp_dtls_transport,
deadbeef5bd5ca32017-02-10 11:31:50 -0800211 rtc::PacketTransportInternal* rtp_packet_transport,
212 rtc::PacketTransportInternal* rtcp_packet_transport) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200213 RTC_DCHECK(network_thread_->IsCurrent());
deadbeeff5346592017-01-24 21:51:21 -0800214 SetTransports_n(rtp_dtls_transport, rtcp_dtls_transport, rtp_packet_transport,
215 rtcp_packet_transport);
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200216
zstein56162b92017-04-24 16:54:35 -0700217 if (rtcp_mux_required_) {
deadbeefac22f702017-01-12 21:59:29 -0800218 rtcp_mux_filter_.SetActive();
219 }
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200220}
221
wu@webrtc.org78187522013-10-07 23:32:02 +0000222void BaseChannel::Deinit() {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200223 RTC_DCHECK(worker_thread_->IsCurrent());
wu@webrtc.org78187522013-10-07 23:32:02 +0000224 media_channel_->SetInterface(NULL);
Danil Chapovalovdae07ba2016-05-14 01:43:50 +0200225 // Packets arrive on the network thread, processing packets calls virtual
226 // functions, so need to stop this process in Deinit that is called in
227 // derived classes destructor.
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800228 network_thread_->Invoke<void>(RTC_FROM_HERE, [&] {
229 FlushRtcpMessages_n();
230
231 if (dtls_srtp_transport_) {
232 dtls_srtp_transport_->SetDtlsTransports(nullptr, nullptr);
233 } else {
234 rtp_transport_->SetRtpPacketTransport(nullptr);
235 rtp_transport_->SetRtcpPacketTransport(nullptr);
236 }
237 // Clear pending read packets/messages.
238 network_thread_->Clear(&invoker_);
239 network_thread_->Clear(this);
240 });
wu@webrtc.org78187522013-10-07 23:32:02 +0000241}
242
zhihuangb2cdd932017-01-19 16:54:25 -0800243void BaseChannel::SetTransports(DtlsTransportInternal* rtp_dtls_transport,
244 DtlsTransportInternal* rtcp_dtls_transport) {
deadbeeff5346592017-01-24 21:51:21 -0800245 network_thread_->Invoke<void>(
246 RTC_FROM_HERE,
247 Bind(&BaseChannel::SetTransports_n, this, rtp_dtls_transport,
248 rtcp_dtls_transport, rtp_dtls_transport, rtcp_dtls_transport));
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000249}
250
deadbeeff5346592017-01-24 21:51:21 -0800251void BaseChannel::SetTransports(
deadbeef5bd5ca32017-02-10 11:31:50 -0800252 rtc::PacketTransportInternal* rtp_packet_transport,
253 rtc::PacketTransportInternal* rtcp_packet_transport) {
deadbeeff5346592017-01-24 21:51:21 -0800254 network_thread_->Invoke<void>(
255 RTC_FROM_HERE, Bind(&BaseChannel::SetTransports_n, this, nullptr, nullptr,
256 rtp_packet_transport, rtcp_packet_transport));
257}
zhihuangf5b251b2017-01-12 19:37:48 -0800258
deadbeeff5346592017-01-24 21:51:21 -0800259void BaseChannel::SetTransports_n(
260 DtlsTransportInternal* rtp_dtls_transport,
261 DtlsTransportInternal* rtcp_dtls_transport,
deadbeef5bd5ca32017-02-10 11:31:50 -0800262 rtc::PacketTransportInternal* rtp_packet_transport,
263 rtc::PacketTransportInternal* rtcp_packet_transport) {
deadbeeff5346592017-01-24 21:51:21 -0800264 RTC_DCHECK(network_thread_->IsCurrent());
265 // Validate some assertions about the input.
266 RTC_DCHECK(rtp_packet_transport);
267 RTC_DCHECK_EQ(NeedsRtcpTransport(), rtcp_packet_transport != nullptr);
268 if (rtp_dtls_transport || rtcp_dtls_transport) {
269 // DTLS/non-DTLS pointers should be to the same object.
270 RTC_DCHECK(rtp_dtls_transport == rtp_packet_transport);
271 RTC_DCHECK(rtcp_dtls_transport == rtcp_packet_transport);
272 // Can't go from non-DTLS to DTLS.
zsteine8ab5432017-07-12 11:48:11 -0700273 RTC_DCHECK(!rtp_transport_->rtp_packet_transport() || rtp_dtls_transport_);
deadbeeff5346592017-01-24 21:51:21 -0800274 } else {
275 // Can't go from DTLS to non-DTLS.
276 RTC_DCHECK(!rtp_dtls_transport_);
277 }
278 // Transport names should be the same.
zhihuangb2cdd932017-01-19 16:54:25 -0800279 if (rtp_dtls_transport && rtcp_dtls_transport) {
280 RTC_DCHECK(rtp_dtls_transport->transport_name() ==
281 rtcp_dtls_transport->transport_name());
zhihuangb2cdd932017-01-19 16:54:25 -0800282 }
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800283
284 if (rtp_packet_transport == rtp_transport_->rtp_packet_transport()) {
285 // Nothing to do if transport isn't changing.
286 return;
287 }
288
deadbeeff5346592017-01-24 21:51:21 -0800289 std::string debug_name;
290 if (rtp_dtls_transport) {
291 transport_name_ = rtp_dtls_transport->transport_name();
292 debug_name = transport_name_;
293 } else {
Zhi Huang942bc2e2017-11-13 13:26:07 -0800294 debug_name = rtp_packet_transport->transport_name();
deadbeeff5346592017-01-24 21:51:21 -0800295 }
deadbeefac22f702017-01-12 21:59:29 -0800296 // If this BaseChannel doesn't require RTCP mux and we haven't fully
297 // negotiated RTCP mux, we need an RTCP transport.
deadbeeff5346592017-01-24 21:51:21 -0800298 if (rtcp_packet_transport) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100299 RTC_LOG(LS_INFO) << "Setting RTCP Transport for " << content_name()
300 << " on " << debug_name << " transport "
301 << rtcp_packet_transport;
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800302 SetTransport_n(/*rtcp=*/true, rtcp_dtls_transport, rtcp_packet_transport);
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000303 }
304
Mirko Bonadei675513b2017-11-09 11:09:25 +0100305 RTC_LOG(LS_INFO) << "Setting RTP Transport for " << content_name() << " on "
306 << debug_name << " transport " << rtp_packet_transport;
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800307 SetTransport_n(/*rtcp=*/false, rtp_dtls_transport, rtp_packet_transport);
308
309 // Set DtlsTransport/PacketTransport for RTP-level transport.
310 if ((rtp_dtls_transport_ || rtcp_dtls_transport_) && dtls_srtp_transport_) {
311 // When setting the transport with non-null |dtls_srtp_transport_|, we are
312 // using DTLS-SRTP. This could happen for bundling. If the
313 // |dtls_srtp_transport| is null, we cannot tell if it doing DTLS-SRTP or
314 // SDES until the description is set. So don't call |EnableDtlsSrtp_n| here.
315 dtls_srtp_transport_->SetDtlsTransports(rtp_dtls_transport,
316 rtcp_dtls_transport);
317 } else {
318 rtp_transport_->SetRtpPacketTransport(rtp_packet_transport);
319 rtp_transport_->SetRtcpPacketTransport(rtcp_packet_transport);
320 }
guoweis46383312015-12-17 16:45:59 -0800321
deadbeefcbecd352015-09-23 11:50:27 -0700322 // Update aggregate writable/ready-to-send state between RTP and RTCP upon
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700323 // setting new transport channels.
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200324 UpdateWritableState_n();
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000325}
326
deadbeeff5346592017-01-24 21:51:21 -0800327void BaseChannel::SetTransport_n(
328 bool rtcp,
329 DtlsTransportInternal* new_dtls_transport,
deadbeef5bd5ca32017-02-10 11:31:50 -0800330 rtc::PacketTransportInternal* new_packet_transport) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200331 RTC_DCHECK(network_thread_->IsCurrent());
Zhi Huang942bc2e2017-11-13 13:26:07 -0800332 if (new_dtls_transport) {
333 RTC_DCHECK(new_dtls_transport == new_packet_transport);
334 }
deadbeeff5346592017-01-24 21:51:21 -0800335 DtlsTransportInternal*& old_dtls_transport =
zhihuangb2cdd932017-01-19 16:54:25 -0800336 rtcp ? rtcp_dtls_transport_ : rtp_dtls_transport_;
zsteind48dbda2017-04-04 19:45:57 -0700337 rtc::PacketTransportInternal* old_packet_transport =
zsteine8ab5432017-07-12 11:48:11 -0700338 rtcp ? rtp_transport_->rtcp_packet_transport()
339 : rtp_transport_->rtp_packet_transport();
zhihuangb2cdd932017-01-19 16:54:25 -0800340
deadbeeff5346592017-01-24 21:51:21 -0800341 if (!old_packet_transport && !new_packet_transport) {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700342 // Nothing to do.
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000343 return;
344 }
zhihuangb2cdd932017-01-19 16:54:25 -0800345
deadbeeff5346592017-01-24 21:51:21 -0800346 RTC_DCHECK(old_packet_transport != new_packet_transport);
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000347
deadbeeff5346592017-01-24 21:51:21 -0800348 old_dtls_transport = new_dtls_transport;
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000349
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800350 // If there's no new transport, we're done.
deadbeeff5346592017-01-24 21:51:21 -0800351 if (!new_packet_transport) {
352 return;
353 }
354
355 if (rtcp && new_dtls_transport) {
Zhi Huangcf990f52017-09-22 12:12:30 -0700356 RTC_CHECK(!(ShouldSetupDtlsSrtp_n() && srtp_active()))
357 << "Setting RTCP for DTLS/SRTP after the DTLS is active "
deadbeeff5346592017-01-24 21:51:21 -0800358 << "should never happen.";
359 }
zstein56162b92017-04-24 16:54:35 -0700360
deadbeeff5346592017-01-24 21:51:21 -0800361 auto& socket_options = rtcp ? rtcp_socket_options_ : socket_options_;
362 for (const auto& pair : socket_options) {
363 new_packet_transport->SetOption(pair.first, pair.second);
guoweis46383312015-12-17 16:45:59 -0800364 }
pthatcher@webrtc.org6ad507a2015-03-16 20:19:12 +0000365}
366
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000367bool BaseChannel::Enable(bool enable) {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700368 worker_thread_->Invoke<void>(
369 RTC_FROM_HERE,
370 Bind(enable ? &BaseChannel::EnableMedia_w : &BaseChannel::DisableMedia_w,
371 this));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000372 return true;
373}
374
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000375bool BaseChannel::AddRecvStream(const StreamParams& sp) {
stefanf79ade12017-06-02 06:44:03 -0700376 return InvokeOnWorker<bool>(RTC_FROM_HERE,
377 Bind(&BaseChannel::AddRecvStream_w, this, sp));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000378}
379
Peter Boström0c4e06b2015-10-07 12:23:21 +0200380bool BaseChannel::RemoveRecvStream(uint32_t ssrc) {
stefanf79ade12017-06-02 06:44:03 -0700381 return InvokeOnWorker<bool>(
382 RTC_FROM_HERE, Bind(&BaseChannel::RemoveRecvStream_w, this, ssrc));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000383}
384
wu@webrtc.orgcadf9042013-08-30 21:24:16 +0000385bool BaseChannel::AddSendStream(const StreamParams& sp) {
stefanf79ade12017-06-02 06:44:03 -0700386 return InvokeOnWorker<bool>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700387 RTC_FROM_HERE, Bind(&MediaChannel::AddSendStream, media_channel(), sp));
wu@webrtc.orgcadf9042013-08-30 21:24:16 +0000388}
389
Peter Boström0c4e06b2015-10-07 12:23:21 +0200390bool BaseChannel::RemoveSendStream(uint32_t ssrc) {
stefanf79ade12017-06-02 06:44:03 -0700391 return InvokeOnWorker<bool>(
392 RTC_FROM_HERE,
393 Bind(&MediaChannel::RemoveSendStream, media_channel(), ssrc));
wu@webrtc.orgcadf9042013-08-30 21:24:16 +0000394}
395
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000396bool BaseChannel::SetLocalContent(const MediaContentDescription* content,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000397 ContentAction action,
398 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +0100399 TRACE_EVENT0("webrtc", "BaseChannel::SetLocalContent");
stefanf79ade12017-06-02 06:44:03 -0700400 return InvokeOnWorker<bool>(
401 RTC_FROM_HERE,
402 Bind(&BaseChannel::SetLocalContent_w, this, content, action, error_desc));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000403}
404
405bool BaseChannel::SetRemoteContent(const MediaContentDescription* content,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000406 ContentAction action,
407 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +0100408 TRACE_EVENT0("webrtc", "BaseChannel::SetRemoteContent");
stefanf79ade12017-06-02 06:44:03 -0700409 return InvokeOnWorker<bool>(
410 RTC_FROM_HERE, Bind(&BaseChannel::SetRemoteContent_w, this, content,
411 action, error_desc));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000412}
413
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000414void BaseChannel::StartConnectionMonitor(int cms) {
zhihuangb2cdd932017-01-19 16:54:25 -0800415 // We pass in the BaseChannel instead of the rtp_dtls_transport_
416 // because if the rtp_dtls_transport_ changes, the ConnectionMonitor
pthatcher@webrtc.orgb4aac132015-03-13 18:25:21 +0000417 // would be pointing to the wrong TransportChannel.
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200418 // We pass in the network thread because on that thread connection monitor
419 // will call BaseChannel::GetConnectionStats which must be called on the
420 // network thread.
421 connection_monitor_.reset(
422 new ConnectionMonitor(this, network_thread(), rtc::Thread::Current()));
pthatcher@webrtc.orgb4aac132015-03-13 18:25:21 +0000423 connection_monitor_->SignalUpdate.connect(
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000424 this, &BaseChannel::OnConnectionMonitorUpdate);
pthatcher@webrtc.orgb4aac132015-03-13 18:25:21 +0000425 connection_monitor_->Start(cms);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000426}
427
428void BaseChannel::StopConnectionMonitor() {
pthatcher@webrtc.orgb4aac132015-03-13 18:25:21 +0000429 if (connection_monitor_) {
430 connection_monitor_->Stop();
431 connection_monitor_.reset();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000432 }
433}
434
pthatcher@webrtc.orgb4aac132015-03-13 18:25:21 +0000435bool BaseChannel::GetConnectionStats(ConnectionInfos* infos) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200436 RTC_DCHECK(network_thread_->IsCurrent());
deadbeeff5346592017-01-24 21:51:21 -0800437 if (!rtp_dtls_transport_) {
438 return false;
439 }
zhihuangb2cdd932017-01-19 16:54:25 -0800440 return rtp_dtls_transport_->ice_transport()->GetStats(infos);
zhihuangf5b251b2017-01-12 19:37:48 -0800441}
442
443bool BaseChannel::NeedsRtcpTransport() {
deadbeefac22f702017-01-12 21:59:29 -0800444 // If this BaseChannel doesn't require RTCP mux and we haven't fully
445 // negotiated RTCP mux, we need an RTCP transport.
zstein56162b92017-04-24 16:54:35 -0700446 return !rtcp_mux_required_ && !rtcp_mux_filter_.IsFullyActive();
pthatcher@webrtc.orgb4aac132015-03-13 18:25:21 +0000447}
448
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700449bool BaseChannel::IsReadyToReceiveMedia_w() const {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000450 // Receive data if we are enabled and have local content,
Steve Anton4e70a722017-11-28 14:57:10 -0800451 return enabled() &&
452 webrtc::RtpTransceiverDirectionHasRecv(local_content_direction_);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000453}
454
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700455bool BaseChannel::IsReadyToSendMedia_w() const {
456 // Need to access some state updated on the network thread.
457 return network_thread_->Invoke<bool>(
458 RTC_FROM_HERE, Bind(&BaseChannel::IsReadyToSendMedia_n, this));
459}
460
461bool BaseChannel::IsReadyToSendMedia_n() const {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000462 // Send outgoing data if we are enabled, have local and remote content,
463 // and we have had some form of connectivity.
Steve Anton4e70a722017-11-28 14:57:10 -0800464 return enabled() &&
465 webrtc::RtpTransceiverDirectionHasRecv(remote_content_direction_) &&
466 webrtc::RtpTransceiverDirectionHasSend(local_content_direction_) &&
Zhi Huangcf990f52017-09-22 12:12:30 -0700467 was_ever_writable() && (srtp_active() || !ShouldSetupDtlsSrtp_n());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000468}
469
jbaucheec21bd2016-03-20 06:15:43 -0700470bool BaseChannel::SendPacket(rtc::CopyOnWriteBuffer* packet,
stefanc1aeaf02015-10-15 07:26:07 -0700471 const rtc::PacketOptions& options) {
472 return SendPacket(false, packet, options);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000473}
474
jbaucheec21bd2016-03-20 06:15:43 -0700475bool BaseChannel::SendRtcp(rtc::CopyOnWriteBuffer* packet,
stefanc1aeaf02015-10-15 07:26:07 -0700476 const rtc::PacketOptions& options) {
477 return SendPacket(true, packet, options);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000478}
479
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000480int BaseChannel::SetOption(SocketType type, rtc::Socket::Option opt,
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000481 int value) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200482 return network_thread_->Invoke<int>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700483 RTC_FROM_HERE, Bind(&BaseChannel::SetOption_n, this, type, opt, value));
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200484}
485
486int BaseChannel::SetOption_n(SocketType type,
487 rtc::Socket::Option opt,
488 int value) {
489 RTC_DCHECK(network_thread_->IsCurrent());
deadbeef5bd5ca32017-02-10 11:31:50 -0800490 rtc::PacketTransportInternal* transport = nullptr;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000491 switch (type) {
wu@webrtc.org9caf2762013-12-11 18:25:07 +0000492 case ST_RTP:
zsteine8ab5432017-07-12 11:48:11 -0700493 transport = rtp_transport_->rtp_packet_transport();
deadbeefcbecd352015-09-23 11:50:27 -0700494 socket_options_.push_back(
495 std::pair<rtc::Socket::Option, int>(opt, value));
wu@webrtc.org9caf2762013-12-11 18:25:07 +0000496 break;
497 case ST_RTCP:
zsteine8ab5432017-07-12 11:48:11 -0700498 transport = rtp_transport_->rtcp_packet_transport();
deadbeefcbecd352015-09-23 11:50:27 -0700499 rtcp_socket_options_.push_back(
500 std::pair<rtc::Socket::Option, int>(opt, value));
wu@webrtc.org9caf2762013-12-11 18:25:07 +0000501 break;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000502 }
deadbeeff5346592017-01-24 21:51:21 -0800503 return transport ? transport->SetOption(opt, value) : -1;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000504}
505
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800506void BaseChannel::OnWritableState(bool writable) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200507 RTC_DCHECK(network_thread_->IsCurrent());
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800508 if (writable) {
509 // This is used to cover the scenario when the DTLS handshake is completed
510 // and DtlsTransport becomes writable before the remote description is set.
511 if (ShouldSetupDtlsSrtp_n()) {
512 EnableDtlsSrtp_n();
Zhi Huangcf990f52017-09-22 12:12:30 -0700513 }
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800514 ChannelWritable_n();
515 } else {
516 ChannelNotWritable_n();
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -0800517 }
518}
519
Zhi Huang942bc2e2017-11-13 13:26:07 -0800520void BaseChannel::OnNetworkRouteChanged(
521 rtc::Optional<rtc::NetworkRoute> network_route) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200522 RTC_DCHECK(network_thread_->IsCurrent());
Zhi Huang942bc2e2017-11-13 13:26:07 -0800523 rtc::NetworkRoute new_route;
524 if (network_route) {
Zhi Huang942bc2e2017-11-13 13:26:07 -0800525 new_route = *(network_route);
Zhi Huang8c316c12017-11-13 21:13:45 +0000526 }
Zhi Huang942bc2e2017-11-13 13:26:07 -0800527 // Note: When the RTCP-muxing is not enabled, RTCP transport and RTP transport
528 // use the same transport name and MediaChannel::OnNetworkRouteChanged cannot
529 // work correctly. Intentionally leave it broken to simplify the code and
530 // encourage the users to stop using non-muxing RTCP.
Steve Anton8699a322017-11-06 15:53:33 -0800531 invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_, [=] {
Zhi Huang942bc2e2017-11-13 13:26:07 -0800532 media_channel_->OnNetworkRouteChanged(transport_name_, new_route);
Steve Anton8699a322017-11-06 15:53:33 -0800533 });
Honghai Zhangcc411c02016-03-29 17:27:21 -0700534}
535
zstein56162b92017-04-24 16:54:35 -0700536void BaseChannel::OnTransportReadyToSend(bool ready) {
Steve Anton8699a322017-11-06 15:53:33 -0800537 invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_,
538 [=] { media_channel_->OnReadyToSend(ready); });
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000539}
540
stefanc1aeaf02015-10-15 07:26:07 -0700541bool BaseChannel::SendPacket(bool rtcp,
jbaucheec21bd2016-03-20 06:15:43 -0700542 rtc::CopyOnWriteBuffer* packet,
stefanc1aeaf02015-10-15 07:26:07 -0700543 const rtc::PacketOptions& options) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200544 // SendPacket gets called from MediaEngine, on a pacer or an encoder thread.
545 // If the thread is not our network thread, we will post to our network
546 // so that the real work happens on our network. This avoids us having to
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000547 // synchronize access to all the pieces of the send path, including
548 // SRTP and the inner workings of the transport channels.
549 // The only downside is that we can't return a proper failure code if
550 // needed. Since UDP is unreliable anyway, this should be a non-issue.
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200551 if (!network_thread_->IsCurrent()) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000552 // Avoid a copy by transferring the ownership of the packet data.
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200553 int message_id = rtcp ? MSG_SEND_RTCP_PACKET : MSG_SEND_RTP_PACKET;
554 SendPacketMessageData* data = new SendPacketMessageData;
kwiberg0eb15ed2015-12-17 03:04:15 -0800555 data->packet = std::move(*packet);
stefanc1aeaf02015-10-15 07:26:07 -0700556 data->options = options;
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700557 network_thread_->Post(RTC_FROM_HERE, this, message_id, data);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000558 return true;
559 }
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200560 TRACE_EVENT0("webrtc", "BaseChannel::SendPacket");
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000561
562 // Now that we are on the correct thread, ensure we have a place to send this
563 // packet before doing anything. (We might get RTCP packets that we don't
564 // intend to send.) If we've negotiated RTCP mux, send RTCP over the RTP
565 // transport.
zsteine8ab5432017-07-12 11:48:11 -0700566 if (!rtp_transport_->IsWritable(rtcp)) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000567 return false;
568 }
569
570 // Protect ourselves against crazy data.
571 if (!ValidPacket(rtcp, packet)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100572 RTC_LOG(LS_ERROR) << "Dropping outgoing " << content_name_ << " "
573 << RtpRtcpStringLiteral(rtcp)
574 << " packet: wrong size=" << packet->size();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000575 return false;
576 }
577
Zhi Huangcf990f52017-09-22 12:12:30 -0700578 if (!srtp_active()) {
579 if (srtp_required_) {
580 // The audio/video engines may attempt to send RTCP packets as soon as the
581 // streams are created, so don't treat this as an error for RTCP.
582 // See: https://bugs.chromium.org/p/webrtc/issues/detail?id=6809
583 if (rtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000584 return false;
585 }
Zhi Huangcf990f52017-09-22 12:12:30 -0700586 // However, there shouldn't be any RTP packets sent before SRTP is set up
587 // (and SetSend(true) is called).
Mirko Bonadei675513b2017-11-09 11:09:25 +0100588 RTC_LOG(LS_ERROR)
589 << "Can't send outgoing RTP packet when SRTP is inactive"
590 << " and crypto is required";
Zhi Huangcf990f52017-09-22 12:12:30 -0700591 RTC_NOTREACHED();
deadbeef8f425f92016-12-01 12:26:27 -0800592 return false;
593 }
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800594
595 std::string packet_type = rtcp ? "RTCP" : "RTP";
596 RTC_LOG(LS_WARNING) << "Sending an " << packet_type
597 << " packet without encryption.";
598 } else {
599 // Make sure we didn't accidentally send any packets without encryption.
600 RTC_DCHECK(rtp_transport_ == sdes_transport_.get() ||
601 rtp_transport_ == dtls_srtp_transport_.get());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000602 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000603 // Bon voyage.
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800604 return rtcp ? rtp_transport_->SendRtcpPacket(packet, options, PF_SRTP_BYPASS)
605 : rtp_transport_->SendRtpPacket(packet, options, PF_SRTP_BYPASS);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000606}
607
zstein3dcf0e92017-06-01 13:22:42 -0700608bool BaseChannel::HandlesPayloadType(int packet_type) const {
zsteine8ab5432017-07-12 11:48:11 -0700609 return rtp_transport_->HandlesPayloadType(packet_type);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000610}
611
zstein3dcf0e92017-06-01 13:22:42 -0700612void BaseChannel::OnPacketReceived(bool rtcp,
zstein634977b2017-07-14 12:30:04 -0700613 rtc::CopyOnWriteBuffer* packet,
zstein3dcf0e92017-06-01 13:22:42 -0700614 const rtc::PacketTime& packet_time) {
honghaiz@google.coma67ca1a2015-01-28 19:48:33 +0000615 if (!has_received_packet_ && !rtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000616 has_received_packet_ = true;
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700617 signaling_thread()->Post(RTC_FROM_HERE, this, MSG_FIRSTPACKETRECEIVED);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000618 }
619
Zhi Huangcf990f52017-09-22 12:12:30 -0700620 if (!srtp_active() && srtp_required_) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000621 // Our session description indicates that SRTP is required, but we got a
622 // packet before our SRTP filter is active. This means either that
623 // a) we got SRTP packets before we received the SDES keys, in which case
624 // we can't decrypt it anyway, or
625 // b) we got SRTP packets before DTLS completed on both the RTP and RTCP
zhihuangb2cdd932017-01-19 16:54:25 -0800626 // transports, so we haven't yet extracted keys, even if DTLS did
627 // complete on the transport that the packets are being sent on. It's
628 // really good practice to wait for both RTP and RTCP to be good to go
629 // before sending media, to prevent weird failure modes, so it's fine
630 // for us to just eat packets here. This is all sidestepped if RTCP mux
631 // is used anyway.
Mirko Bonadei675513b2017-11-09 11:09:25 +0100632 RTC_LOG(LS_WARNING)
633 << "Can't process incoming " << RtpRtcpStringLiteral(rtcp)
634 << " packet when SRTP is inactive and crypto is required";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000635 return;
636 }
637
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200638 invoker_.AsyncInvoke<void>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700639 RTC_FROM_HERE, worker_thread_,
zstein634977b2017-07-14 12:30:04 -0700640 Bind(&BaseChannel::ProcessPacket, this, rtcp, *packet, packet_time));
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200641}
642
zstein3dcf0e92017-06-01 13:22:42 -0700643void BaseChannel::ProcessPacket(bool rtcp,
644 const rtc::CopyOnWriteBuffer& packet,
645 const rtc::PacketTime& packet_time) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200646 RTC_DCHECK(worker_thread_->IsCurrent());
zstein3dcf0e92017-06-01 13:22:42 -0700647
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200648 // Need to copy variable because OnRtcpReceived/OnPacketReceived
649 // requires non-const pointer to buffer. This doesn't memcpy the actual data.
650 rtc::CopyOnWriteBuffer data(packet);
651 if (rtcp) {
652 media_channel_->OnRtcpReceived(&data, packet_time);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000653 } else {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200654 media_channel_->OnPacketReceived(&data, packet_time);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000655 }
656}
657
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000658void BaseChannel::EnableMedia_w() {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700659 RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000660 if (enabled_)
661 return;
662
Mirko Bonadei675513b2017-11-09 11:09:25 +0100663 RTC_LOG(LS_INFO) << "Channel enabled";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000664 enabled_ = true;
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700665 UpdateMediaSendRecvState_w();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000666}
667
668void BaseChannel::DisableMedia_w() {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700669 RTC_DCHECK(worker_thread_ == rtc::Thread::Current());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000670 if (!enabled_)
671 return;
672
Mirko Bonadei675513b2017-11-09 11:09:25 +0100673 RTC_LOG(LS_INFO) << "Channel disabled";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000674 enabled_ = false;
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700675 UpdateMediaSendRecvState_w();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000676}
677
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200678void BaseChannel::UpdateWritableState_n() {
zsteind48dbda2017-04-04 19:45:57 -0700679 rtc::PacketTransportInternal* rtp_packet_transport =
zsteine8ab5432017-07-12 11:48:11 -0700680 rtp_transport_->rtp_packet_transport();
zsteind48dbda2017-04-04 19:45:57 -0700681 rtc::PacketTransportInternal* rtcp_packet_transport =
zsteine8ab5432017-07-12 11:48:11 -0700682 rtp_transport_->rtcp_packet_transport();
zsteind48dbda2017-04-04 19:45:57 -0700683 if (rtp_packet_transport && rtp_packet_transport->writable() &&
684 (!rtcp_packet_transport || rtcp_packet_transport->writable())) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200685 ChannelWritable_n();
deadbeefcbecd352015-09-23 11:50:27 -0700686 } else {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200687 ChannelNotWritable_n();
deadbeefcbecd352015-09-23 11:50:27 -0700688 }
689}
690
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200691void BaseChannel::ChannelWritable_n() {
692 RTC_DCHECK(network_thread_->IsCurrent());
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -0800693 if (writable_) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000694 return;
Guo-wei Shieh1218d7a2015-12-05 09:59:56 -0800695 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000696
Mirko Bonadei675513b2017-11-09 11:09:25 +0100697 RTC_LOG(LS_INFO) << "Channel writable (" << content_name_ << ")"
698 << (was_ever_writable_ ? "" : " for the first time");
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000699
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000700 was_ever_writable_ = true;
701 writable_ = true;
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700702 UpdateMediaSendRecvState();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000703}
704
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200705bool BaseChannel::ShouldSetupDtlsSrtp_n() const {
zhihuangb2cdd932017-01-19 16:54:25 -0800706 // Since DTLS is applied to all transports, checking RTP should be enough.
707 return rtp_dtls_transport_ && rtp_dtls_transport_->IsDtlsActive();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000708}
709
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200710void BaseChannel::ChannelNotWritable_n() {
711 RTC_DCHECK(network_thread_->IsCurrent());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000712 if (!writable_)
713 return;
714
Mirko Bonadei675513b2017-11-09 11:09:25 +0100715 RTC_LOG(LS_INFO) << "Channel not writable (" << content_name_ << ")";
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000716 writable_ = false;
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700717 UpdateMediaSendRecvState();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000718}
719
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200720bool BaseChannel::SetRtpTransportParameters(
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700721 const MediaContentDescription* content,
722 ContentAction action,
723 ContentSource src,
jbauch5869f502017-06-29 12:31:36 -0700724 const RtpHeaderExtensions& extensions,
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700725 std::string* error_desc) {
jbauch5869f502017-06-29 12:31:36 -0700726 std::vector<int> encrypted_extension_ids;
727 for (const webrtc::RtpExtension& extension : extensions) {
728 if (extension.encrypt) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100729 RTC_LOG(LS_INFO) << "Using " << (src == CS_LOCAL ? "local" : "remote")
730 << " encrypted extension: " << extension.ToString();
jbauch5869f502017-06-29 12:31:36 -0700731 encrypted_extension_ids.push_back(extension.id);
732 }
733 }
734
deadbeef7af91dd2016-12-13 11:29:11 -0800735 // Cache srtp_required_ for belt and suspenders check on SendPacket
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200736 return network_thread_->Invoke<bool>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -0700737 RTC_FROM_HERE, Bind(&BaseChannel::SetRtpTransportParameters_n, this,
jbauch5869f502017-06-29 12:31:36 -0700738 content, action, src, encrypted_extension_ids,
739 error_desc));
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200740}
741
742bool BaseChannel::SetRtpTransportParameters_n(
743 const MediaContentDescription* content,
744 ContentAction action,
745 ContentSource src,
jbauch5869f502017-06-29 12:31:36 -0700746 const std::vector<int>& encrypted_extension_ids,
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200747 std::string* error_desc) {
748 RTC_DCHECK(network_thread_->IsCurrent());
749
jbauch5869f502017-06-29 12:31:36 -0700750 if (!SetSrtp_n(content->cryptos(), action, src, encrypted_extension_ids,
751 error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700752 return false;
753 }
754
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200755 if (!SetRtcpMux_n(content->rtcp_mux(), action, src, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -0700756 return false;
757 }
758
759 return true;
760}
761
zhihuangb2cdd932017-01-19 16:54:25 -0800762// |dtls| will be set to true if DTLS is active for transport and crypto is
763// empty.
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200764bool BaseChannel::CheckSrtpConfig_n(const std::vector<CryptoParams>& cryptos,
765 bool* dtls,
766 std::string* error_desc) {
deadbeeff5346592017-01-24 21:51:21 -0800767 *dtls = rtp_dtls_transport_ && rtp_dtls_transport_->IsDtlsActive();
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +0000768 if (*dtls && !cryptos.empty()) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200769 SafeSetError("Cryptos must be empty when DTLS is active.", error_desc);
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +0000770 return false;
771 }
772 return true;
773}
774
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800775void BaseChannel::EnableSdes_n() {
776 if (sdes_transport_) {
777 return;
Zhi Huangcf990f52017-09-22 12:12:30 -0700778 }
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800779 // DtlsSrtpTransport and SrtpTransport shouldn't be enabled at the same
780 // time.
781 RTC_DCHECK(!dtls_srtp_transport_);
782 RTC_DCHECK(unencrypted_rtp_transport_);
783 DisconnectFromRtpTransport();
784 sdes_transport_ = rtc::MakeUnique<webrtc::SrtpTransport>(
785 std::move(unencrypted_rtp_transport_), content_name_);
Zhi Huangd7455782017-11-30 14:50:52 -0800786#if defined(ENABLE_EXTERNAL_AUTH)
787 sdes_transport_->EnableExternalAuth();
788#endif
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800789 rtp_transport_ = sdes_transport_.get();
790 ConnectToRtpTransport();
791 RTC_LOG(LS_INFO) << "Wrapping RtpTransport in SrtpTransport.";
792}
793
794void BaseChannel::EnableDtlsSrtp_n() {
795 if (dtls_srtp_transport_) {
796 return;
797 }
798 // DtlsSrtpTransport and SrtpTransport shouldn't be enabled at the same
799 // time.
800 RTC_DCHECK(!sdes_transport_);
801 RTC_DCHECK(unencrypted_rtp_transport_);
802 DisconnectFromRtpTransport();
803
804 auto srtp_transport = rtc::MakeUnique<webrtc::SrtpTransport>(
805 std::move(unencrypted_rtp_transport_), content_name_);
806#if defined(ENABLE_EXTERNAL_AUTH)
807 srtp_transport->EnableExternalAuth();
808#endif
809 dtls_srtp_transport_ =
810 rtc::MakeUnique<webrtc::DtlsSrtpTransport>(std::move(srtp_transport));
811
812 rtp_transport_ = dtls_srtp_transport_.get();
813 ConnectToRtpTransport();
814 if (cached_send_extension_ids_) {
815 dtls_srtp_transport_->UpdateSendEncryptedHeaderExtensionIds(
816 *cached_send_extension_ids_);
817 }
818 if (cached_recv_extension_ids_) {
819 dtls_srtp_transport_->UpdateRecvEncryptedHeaderExtensionIds(
820 *cached_recv_extension_ids_);
821 }
822 // Set the DtlsTransport and the |dtls_srtp_transport_| will handle the DTLS
823 // relate signal internally.
824 RTC_DCHECK(rtp_dtls_transport_);
825 dtls_srtp_transport_->SetDtlsTransports(rtp_dtls_transport_,
826 rtcp_dtls_transport_);
827
828 RTC_LOG(LS_INFO) << "Wrapping SrtpTransport in DtlsSrtpTransport.";
Zhi Huangcf990f52017-09-22 12:12:30 -0700829}
830
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200831bool BaseChannel::SetSrtp_n(const std::vector<CryptoParams>& cryptos,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000832 ContentAction action,
833 ContentSource src,
jbauch5869f502017-06-29 12:31:36 -0700834 const std::vector<int>& encrypted_extension_ids,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000835 std::string* error_desc) {
Peter Boströmca8b4042016-03-08 14:24:13 -0800836 TRACE_EVENT0("webrtc", "BaseChannel::SetSrtp_w");
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000837 bool ret = false;
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +0000838 bool dtls = false;
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200839 ret = CheckSrtpConfig_n(cryptos, &dtls, error_desc);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000840 if (!ret) {
841 return false;
842 }
Zhi Huangcf990f52017-09-22 12:12:30 -0700843
844 // If SRTP was not required, but we're setting a description that uses SDES,
845 // we need to upgrade to an SrtpTransport.
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800846 if (!sdes_transport_ && !dtls && !cryptos.empty()) {
847 EnableSdes_n();
Zhi Huangcf990f52017-09-22 12:12:30 -0700848 }
Zhi Huangc99b6c72017-11-10 16:44:46 -0800849
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800850 if ((action == CA_ANSWER || action == CA_PRANSWER) && dtls) {
851 EnableDtlsSrtp_n();
852 }
Zhi Huangc99b6c72017-11-10 16:44:46 -0800853
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800854 UpdateEncryptedHeaderExtensionIds(src, encrypted_extension_ids);
855
856 if (!dtls) {
857 switch (action) {
858 case CA_OFFER:
Zhi Huangcf990f52017-09-22 12:12:30 -0700859 ret = sdes_negotiator_.SetOffer(cryptos, src);
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800860 break;
861 case CA_PRANSWER:
Zhi Huangcf990f52017-09-22 12:12:30 -0700862 ret = sdes_negotiator_.SetProvisionalAnswer(cryptos, src);
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800863 break;
864 case CA_ANSWER:
Zhi Huangcf990f52017-09-22 12:12:30 -0700865 ret = sdes_negotiator_.SetAnswer(cryptos, src);
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800866 break;
867 default:
868 break;
869 }
Zhi Huangcf990f52017-09-22 12:12:30 -0700870
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800871 // If setting an SDES answer succeeded, apply the negotiated parameters
872 // to the SRTP transport.
873 if ((action == CA_PRANSWER || action == CA_ANSWER) && ret) {
874 if (sdes_negotiator_.send_cipher_suite() &&
875 sdes_negotiator_.recv_cipher_suite()) {
876 RTC_DCHECK(cached_send_extension_ids_);
877 RTC_DCHECK(cached_recv_extension_ids_);
878 ret = sdes_transport_->SetRtpParams(
879 *(sdes_negotiator_.send_cipher_suite()),
880 sdes_negotiator_.send_key().data(),
881 static_cast<int>(sdes_negotiator_.send_key().size()),
882 *(cached_send_extension_ids_),
883 *(sdes_negotiator_.recv_cipher_suite()),
884 sdes_negotiator_.recv_key().data(),
885 static_cast<int>(sdes_negotiator_.recv_key().size()),
886 *(cached_recv_extension_ids_));
887 } else {
888 RTC_LOG(LS_INFO) << "No crypto keys are provided for SDES.";
889 if (action == CA_ANSWER && sdes_transport_) {
890 // Explicitly reset the |sdes_transport_| if no crypto param is
891 // provided in the answer. No need to call |ResetParams()| for
892 // |sdes_negotiator_| because it resets the params inside |SetAnswer|.
893 sdes_transport_->ResetParams();
894 }
Zhi Huangcf990f52017-09-22 12:12:30 -0700895 }
896 }
897 }
898
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000899 if (!ret) {
Zhi Huangc99b6c72017-11-10 16:44:46 -0800900 SafeSetError("Failed to setup SRTP.", error_desc);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000901 return false;
902 }
903 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000904}
905
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200906bool BaseChannel::SetRtcpMux_n(bool enable,
907 ContentAction action,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000908 ContentSource src,
909 std::string* error_desc) {
deadbeef8e814d72017-01-13 11:34:39 -0800910 // Provide a more specific error message for the RTCP mux "require" policy
911 // case.
zstein56162b92017-04-24 16:54:35 -0700912 if (rtcp_mux_required_ && !enable) {
deadbeef8e814d72017-01-13 11:34:39 -0800913 SafeSetError(
914 "rtcpMuxPolicy is 'require', but media description does not "
915 "contain 'a=rtcp-mux'.",
916 error_desc);
917 return false;
918 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000919 bool ret = false;
920 switch (action) {
921 case CA_OFFER:
922 ret = rtcp_mux_filter_.SetOffer(enable, src);
923 break;
924 case CA_PRANSWER:
zhihuangb2cdd932017-01-19 16:54:25 -0800925 // This may activate RTCP muxing, but we don't yet destroy the transport
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700926 // because the final answer may deactivate it.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000927 ret = rtcp_mux_filter_.SetProvisionalAnswer(enable, src);
928 break;
929 case CA_ANSWER:
930 ret = rtcp_mux_filter_.SetAnswer(enable, src);
931 if (ret && rtcp_mux_filter_.IsActive()) {
Zhi Huangcd3fc5d2017-11-29 10:41:57 -0800932 ActivateRtcpMux();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000933 }
934 break;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000935 default:
936 break;
937 }
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000938 if (!ret) {
939 SafeSetError("Failed to setup RTCP mux filter.", error_desc);
940 return false;
941 }
zsteine8ab5432017-07-12 11:48:11 -0700942 rtp_transport_->SetRtcpMuxEnabled(rtcp_mux_filter_.IsActive());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000943 // |rtcp_mux_filter_| can be active if |action| is CA_PRANSWER or
zhihuangb2cdd932017-01-19 16:54:25 -0800944 // CA_ANSWER, but we only want to tear down the RTCP transport if we received
945 // a final answer.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000946 if (rtcp_mux_filter_.IsActive()) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000947 // If the RTP transport is already writable, then so are we.
zsteine8ab5432017-07-12 11:48:11 -0700948 if (rtp_transport_->rtp_packet_transport()->writable()) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +0200949 ChannelWritable_n();
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000950 }
951 }
952
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000953 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000954}
955
956bool BaseChannel::AddRecvStream_w(const StreamParams& sp) {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700957 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
pbos482b12e2015-11-16 10:19:58 -0800958 return media_channel()->AddRecvStream(sp);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000959}
960
Peter Boström0c4e06b2015-10-07 12:23:21 +0200961bool BaseChannel::RemoveRecvStream_w(uint32_t ssrc) {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -0700962 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000963 return media_channel()->RemoveRecvStream(ssrc);
964}
965
966bool BaseChannel::UpdateLocalStreams_w(const std::vector<StreamParams>& streams,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000967 ContentAction action,
968 std::string* error_desc) {
Zhi Huang801b8682017-11-15 11:36:43 -0800969 if (!(action == CA_OFFER || action == CA_ANSWER || action == CA_PRANSWER))
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000970 return false;
971
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000972 // Check for streams that have been removed.
973 bool ret = true;
974 for (StreamParamsVec::const_iterator it = local_streams_.begin();
975 it != local_streams_.end(); ++it) {
tommi@webrtc.org586f2ed2015-01-22 23:00:41 +0000976 if (!GetStreamBySsrc(streams, it->first_ssrc())) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000977 if (!media_channel()->RemoveSendStream(it->first_ssrc())) {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000978 std::ostringstream desc;
979 desc << "Failed to remove send stream with ssrc "
980 << it->first_ssrc() << ".";
981 SafeSetError(desc.str(), error_desc);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000982 ret = false;
983 }
984 }
985 }
986 // Check for new streams.
987 for (StreamParamsVec::const_iterator it = streams.begin();
988 it != streams.end(); ++it) {
tommi@webrtc.org586f2ed2015-01-22 23:00:41 +0000989 if (!GetStreamBySsrc(local_streams_, it->first_ssrc())) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000990 if (media_channel()->AddSendStream(*it)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100991 RTC_LOG(LS_INFO) << "Add send stream ssrc: " << it->ssrcs[0];
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000992 } else {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +0000993 std::ostringstream desc;
994 desc << "Failed to add send stream ssrc: " << it->first_ssrc();
995 SafeSetError(desc.str(), error_desc);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000996 ret = false;
997 }
998 }
999 }
1000 local_streams_ = streams;
1001 return ret;
1002}
1003
1004bool BaseChannel::UpdateRemoteStreams_w(
1005 const std::vector<StreamParams>& streams,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001006 ContentAction action,
1007 std::string* error_desc) {
Zhi Huang801b8682017-11-15 11:36:43 -08001008 if (!(action == CA_OFFER || action == CA_ANSWER || action == CA_PRANSWER))
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001009 return false;
1010
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001011 // Check for streams that have been removed.
1012 bool ret = true;
1013 for (StreamParamsVec::const_iterator it = remote_streams_.begin();
1014 it != remote_streams_.end(); ++it) {
tommi@webrtc.org586f2ed2015-01-22 23:00:41 +00001015 if (!GetStreamBySsrc(streams, it->first_ssrc())) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001016 if (!RemoveRecvStream_w(it->first_ssrc())) {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001017 std::ostringstream desc;
1018 desc << "Failed to remove remote stream with ssrc "
1019 << it->first_ssrc() << ".";
1020 SafeSetError(desc.str(), error_desc);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001021 ret = false;
1022 }
1023 }
1024 }
1025 // Check for new streams.
1026 for (StreamParamsVec::const_iterator it = streams.begin();
1027 it != streams.end(); ++it) {
tommi@webrtc.org586f2ed2015-01-22 23:00:41 +00001028 if (!GetStreamBySsrc(remote_streams_, it->first_ssrc())) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001029 if (AddRecvStream_w(*it)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001030 RTC_LOG(LS_INFO) << "Add remote ssrc: " << it->ssrcs[0];
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001031 } else {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001032 std::ostringstream desc;
1033 desc << "Failed to add remote stream ssrc: " << it->first_ssrc();
1034 SafeSetError(desc.str(), error_desc);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001035 ret = false;
1036 }
1037 }
1038 }
1039 remote_streams_ = streams;
1040 return ret;
1041}
1042
jbauch5869f502017-06-29 12:31:36 -07001043RtpHeaderExtensions BaseChannel::GetFilteredRtpHeaderExtensions(
1044 const RtpHeaderExtensions& extensions) {
1045 if (!rtp_dtls_transport_ ||
1046 !rtp_dtls_transport_->crypto_options()
1047 .enable_encrypted_rtp_header_extensions) {
1048 RtpHeaderExtensions filtered;
1049 auto pred = [](const webrtc::RtpExtension& extension) {
1050 return !extension.encrypt;
1051 };
1052 std::copy_if(extensions.begin(), extensions.end(),
1053 std::back_inserter(filtered), pred);
1054 return filtered;
1055 }
1056
1057 return webrtc::RtpExtension::FilterDuplicateNonEncrypted(extensions);
1058}
1059
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001060void BaseChannel::MaybeCacheRtpAbsSendTimeHeaderExtension_w(
isheriff6f8d6862016-05-26 11:24:55 -07001061 const std::vector<webrtc::RtpExtension>& extensions) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001062// Absolute Send Time extension id is used only with external auth,
1063// so do not bother searching for it and making asyncronious call to set
1064// something that is not used.
1065#if defined(ENABLE_EXTERNAL_AUTH)
isheriff6f8d6862016-05-26 11:24:55 -07001066 const webrtc::RtpExtension* send_time_extension =
jbauch5869f502017-06-29 12:31:36 -07001067 webrtc::RtpExtension::FindHeaderExtensionByUri(
1068 extensions, webrtc::RtpExtension::kAbsSendTimeUri);
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001069 int rtp_abs_sendtime_extn_id =
henrike@webrtc.orgd43aa9d2014-02-21 23:43:24 +00001070 send_time_extension ? send_time_extension->id : -1;
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001071 invoker_.AsyncInvoke<void>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001072 RTC_FROM_HERE, network_thread_,
1073 Bind(&BaseChannel::CacheRtpAbsSendTimeHeaderExtension_n, this,
1074 rtp_abs_sendtime_extn_id));
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001075#endif
1076}
1077
1078void BaseChannel::CacheRtpAbsSendTimeHeaderExtension_n(
1079 int rtp_abs_sendtime_extn_id) {
Zhi Huangcd3fc5d2017-11-29 10:41:57 -08001080 if (sdes_transport_) {
1081 sdes_transport_->CacheRtpAbsSendTimeHeaderExtension(
Zhi Huangcf990f52017-09-22 12:12:30 -07001082 rtp_abs_sendtime_extn_id);
Zhi Huang2a4d70c2017-11-29 15:41:59 -08001083 } else if (dtls_srtp_transport_) {
1084 dtls_srtp_transport_->CacheRtpAbsSendTimeHeaderExtension(
1085 rtp_abs_sendtime_extn_id);
Zhi Huangcf990f52017-09-22 12:12:30 -07001086 } else {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001087 RTC_LOG(LS_WARNING)
1088 << "Trying to cache the Absolute Send Time extension id "
1089 "but the SRTP is not active.";
Zhi Huangcf990f52017-09-22 12:12:30 -07001090 }
henrike@webrtc.orgd43aa9d2014-02-21 23:43:24 +00001091}
1092
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001093void BaseChannel::OnMessage(rtc::Message *pmsg) {
Peter Boström6f28cf02015-12-07 23:17:15 +01001094 TRACE_EVENT0("webrtc", "BaseChannel::OnMessage");
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001095 switch (pmsg->message_id) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001096 case MSG_SEND_RTP_PACKET:
1097 case MSG_SEND_RTCP_PACKET: {
1098 RTC_DCHECK(network_thread_->IsCurrent());
1099 SendPacketMessageData* data =
1100 static_cast<SendPacketMessageData*>(pmsg->pdata);
1101 bool rtcp = pmsg->message_id == MSG_SEND_RTCP_PACKET;
1102 SendPacket(rtcp, &data->packet, data->options);
1103 delete data;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001104 break;
1105 }
1106 case MSG_FIRSTPACKETRECEIVED: {
1107 SignalFirstPacketReceived(this);
1108 break;
1109 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001110 }
1111}
1112
zstein3dcf0e92017-06-01 13:22:42 -07001113void BaseChannel::AddHandledPayloadType(int payload_type) {
zsteine8ab5432017-07-12 11:48:11 -07001114 rtp_transport_->AddHandledPayloadType(payload_type);
zstein3dcf0e92017-06-01 13:22:42 -07001115}
1116
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001117void BaseChannel::FlushRtcpMessages_n() {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001118 // Flush all remaining RTCP messages. This should only be called in
1119 // destructor.
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001120 RTC_DCHECK(network_thread_->IsCurrent());
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001121 rtc::MessageList rtcp_messages;
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001122 network_thread_->Clear(this, MSG_SEND_RTCP_PACKET, &rtcp_messages);
1123 for (const auto& message : rtcp_messages) {
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001124 network_thread_->Send(RTC_FROM_HERE, this, MSG_SEND_RTCP_PACKET,
1125 message.pdata);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001126 }
1127}
1128
Zhi Huangcd3fc5d2017-11-29 10:41:57 -08001129void BaseChannel::SignalSentPacket_n(const rtc::SentPacket& sent_packet) {
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001130 RTC_DCHECK(network_thread_->IsCurrent());
1131 invoker_.AsyncInvoke<void>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001132 RTC_FROM_HERE, worker_thread_,
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001133 rtc::Bind(&BaseChannel::SignalSentPacket_w, this, sent_packet));
1134}
1135
1136void BaseChannel::SignalSentPacket_w(const rtc::SentPacket& sent_packet) {
1137 RTC_DCHECK(worker_thread_->IsCurrent());
1138 SignalSentPacket(sent_packet);
1139}
1140
Zhi Huangcd3fc5d2017-11-29 10:41:57 -08001141void BaseChannel::UpdateEncryptedHeaderExtensionIds(
Zhi Huangc99b6c72017-11-10 16:44:46 -08001142 cricket::ContentSource source,
1143 const std::vector<int>& extension_ids) {
Zhi Huangcd3fc5d2017-11-29 10:41:57 -08001144 if (source == ContentSource::CS_LOCAL) {
1145 cached_recv_extension_ids_ = std::move(extension_ids);
1146 if (dtls_srtp_transport_) {
1147 dtls_srtp_transport_->UpdateRecvEncryptedHeaderExtensionIds(
1148 extension_ids);
1149 }
1150 } else {
1151 cached_send_extension_ids_ = std::move(extension_ids);
1152 if (dtls_srtp_transport_) {
1153 dtls_srtp_transport_->UpdateSendEncryptedHeaderExtensionIds(
1154 extension_ids);
1155 }
1156 }
Zhi Huangc99b6c72017-11-10 16:44:46 -08001157}
1158
Zhi Huangcd3fc5d2017-11-29 10:41:57 -08001159void BaseChannel::ActivateRtcpMux() {
1160 // We permanently activated RTCP muxing; signal that we no longer need
1161 // the RTCP transport.
1162 std::string debug_name =
1163 transport_name_.empty()
1164 ? rtp_transport_->rtp_packet_transport()->transport_name()
1165 : transport_name_;
1166 RTC_LOG(LS_INFO) << "Enabling rtcp-mux for " << content_name()
1167 << "; no longer need RTCP transport for " << debug_name;
1168 if (rtp_transport_->rtcp_packet_transport()) {
1169 SetTransport_n(/*rtcp=*/true, nullptr, nullptr);
1170 if (dtls_srtp_transport_) {
1171 RTC_DCHECK(rtp_dtls_transport_);
1172 dtls_srtp_transport_->SetDtlsTransports(rtp_dtls_transport_,
1173 /*rtcp_dtls_transport_=*/nullptr);
1174 } else {
1175 rtp_transport_->SetRtcpPacketTransport(nullptr);
1176 }
1177 SignalRtcpMuxFullyActive(transport_name_);
Zhi Huangc99b6c72017-11-10 16:44:46 -08001178 }
Zhi Huangcd3fc5d2017-11-29 10:41:57 -08001179 UpdateWritableState_n();
Zhi Huangc99b6c72017-11-10 16:44:46 -08001180}
1181
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001182VoiceChannel::VoiceChannel(rtc::Thread* worker_thread,
1183 rtc::Thread* network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -08001184 rtc::Thread* signaling_thread,
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001185 MediaEngineInterface* media_engine,
Steve Anton8699a322017-11-06 15:53:33 -08001186 std::unique_ptr<VoiceMediaChannel> media_channel,
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001187 const std::string& content_name,
deadbeefac22f702017-01-12 21:59:29 -08001188 bool rtcp_mux_required,
deadbeef7af91dd2016-12-13 11:29:11 -08001189 bool srtp_required)
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001190 : BaseChannel(worker_thread,
1191 network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -08001192 signaling_thread,
Steve Anton8699a322017-11-06 15:53:33 -08001193 std::move(media_channel),
deadbeefcbecd352015-09-23 11:50:27 -07001194 content_name,
deadbeefac22f702017-01-12 21:59:29 -08001195 rtcp_mux_required,
deadbeef7af91dd2016-12-13 11:29:11 -08001196 srtp_required),
Steve Anton8699a322017-11-06 15:53:33 -08001197 media_engine_(media_engine) {}
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001198
1199VoiceChannel::~VoiceChannel() {
Peter Boströmca8b4042016-03-08 14:24:13 -08001200 TRACE_EVENT0("webrtc", "VoiceChannel::~VoiceChannel");
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001201 StopAudioMonitor();
1202 StopMediaMonitor();
1203 // this can't be done in the base class, since it calls a virtual
1204 DisableMedia_w();
wu@webrtc.org78187522013-10-07 23:32:02 +00001205 Deinit();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001206}
1207
Peter Boström0c4e06b2015-10-07 12:23:21 +02001208bool VoiceChannel::SetAudioSend(uint32_t ssrc,
solenbergdfc8f4f2015-10-01 02:31:10 -07001209 bool enable,
solenberg1dd98f32015-09-10 01:57:14 -07001210 const AudioOptions* options,
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08001211 AudioSource* source) {
stefanf79ade12017-06-02 06:44:03 -07001212 return InvokeOnWorker<bool>(
1213 RTC_FROM_HERE, Bind(&VoiceMediaChannel::SetAudioSend, media_channel(),
1214 ssrc, enable, options, source));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001215}
1216
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001217// TODO(juberti): Handle early media the right way. We should get an explicit
1218// ringing message telling us to start playing local ringback, which we cancel
1219// if any early media actually arrives. For now, we do the opposite, which is
1220// to wait 1 second for early media, and start playing local ringback if none
1221// arrives.
1222void VoiceChannel::SetEarlyMedia(bool enable) {
1223 if (enable) {
1224 // Start the early media timeout
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001225 worker_thread()->PostDelayed(RTC_FROM_HERE, kEarlyMediaTimeout, this,
1226 MSG_EARLYMEDIATIMEOUT);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001227 } else {
1228 // Stop the timeout if currently going.
sergeyu@chromium.org9cf037b2014-02-07 19:03:26 +00001229 worker_thread()->Clear(this, MSG_EARLYMEDIATIMEOUT);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001230 }
1231}
1232
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001233bool VoiceChannel::CanInsertDtmf() {
stefanf79ade12017-06-02 06:44:03 -07001234 return InvokeOnWorker<bool>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001235 RTC_FROM_HERE, Bind(&VoiceMediaChannel::CanInsertDtmf, media_channel()));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001236}
1237
Peter Boström0c4e06b2015-10-07 12:23:21 +02001238bool VoiceChannel::InsertDtmf(uint32_t ssrc,
1239 int event_code,
solenberg1d63dd02015-12-02 12:35:09 -08001240 int duration) {
stefanf79ade12017-06-02 06:44:03 -07001241 return InvokeOnWorker<bool>(
1242 RTC_FROM_HERE,
1243 Bind(&VoiceChannel::InsertDtmf_w, this, ssrc, event_code, duration));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001244}
1245
solenberg4bac9c52015-10-09 02:32:53 -07001246bool VoiceChannel::SetOutputVolume(uint32_t ssrc, double volume) {
stefanf79ade12017-06-02 06:44:03 -07001247 return InvokeOnWorker<bool>(
1248 RTC_FROM_HERE,
1249 Bind(&VoiceMediaChannel::SetOutputVolume, media_channel(), ssrc, volume));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001250}
sergeyu@chromium.org9cf037b2014-02-07 19:03:26 +00001251
Tommif888bb52015-12-12 01:37:01 +01001252void VoiceChannel::SetRawAudioSink(
1253 uint32_t ssrc,
kwiberg31022942016-03-11 14:18:21 -08001254 std::unique_ptr<webrtc::AudioSinkInterface> sink) {
1255 // We need to work around Bind's lack of support for unique_ptr and ownership
deadbeef2d110be2016-01-13 12:00:26 -08001256 // passing. So we invoke to our own little routine that gets a pointer to
1257 // our local variable. This is OK since we're synchronously invoking.
stefanf79ade12017-06-02 06:44:03 -07001258 InvokeOnWorker<bool>(RTC_FROM_HERE,
1259 Bind(&SetRawAudioSink_w, media_channel(), ssrc, &sink));
Tommif888bb52015-12-12 01:37:01 +01001260}
1261
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001262webrtc::RtpParameters VoiceChannel::GetRtpSendParameters(uint32_t ssrc) const {
skvladdc1c62c2016-03-16 19:07:43 -07001263 return worker_thread()->Invoke<webrtc::RtpParameters>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001264 RTC_FROM_HERE, Bind(&VoiceChannel::GetRtpSendParameters_w, this, ssrc));
skvladdc1c62c2016-03-16 19:07:43 -07001265}
1266
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001267webrtc::RtpParameters VoiceChannel::GetRtpSendParameters_w(
1268 uint32_t ssrc) const {
1269 return media_channel()->GetRtpSendParameters(ssrc);
skvladdc1c62c2016-03-16 19:07:43 -07001270}
1271
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001272bool VoiceChannel::SetRtpSendParameters(
1273 uint32_t ssrc,
1274 const webrtc::RtpParameters& parameters) {
stefanf79ade12017-06-02 06:44:03 -07001275 return InvokeOnWorker<bool>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001276 RTC_FROM_HERE,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001277 Bind(&VoiceChannel::SetRtpSendParameters_w, this, ssrc, parameters));
skvladdc1c62c2016-03-16 19:07:43 -07001278}
1279
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001280bool VoiceChannel::SetRtpSendParameters_w(uint32_t ssrc,
1281 webrtc::RtpParameters parameters) {
1282 return media_channel()->SetRtpSendParameters(ssrc, parameters);
1283}
1284
1285webrtc::RtpParameters VoiceChannel::GetRtpReceiveParameters(
1286 uint32_t ssrc) const {
1287 return worker_thread()->Invoke<webrtc::RtpParameters>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001288 RTC_FROM_HERE,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001289 Bind(&VoiceChannel::GetRtpReceiveParameters_w, this, ssrc));
1290}
1291
1292webrtc::RtpParameters VoiceChannel::GetRtpReceiveParameters_w(
1293 uint32_t ssrc) const {
1294 return media_channel()->GetRtpReceiveParameters(ssrc);
1295}
1296
1297bool VoiceChannel::SetRtpReceiveParameters(
1298 uint32_t ssrc,
1299 const webrtc::RtpParameters& parameters) {
stefanf79ade12017-06-02 06:44:03 -07001300 return InvokeOnWorker<bool>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001301 RTC_FROM_HERE,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001302 Bind(&VoiceChannel::SetRtpReceiveParameters_w, this, ssrc, parameters));
1303}
1304
1305bool VoiceChannel::SetRtpReceiveParameters_w(uint32_t ssrc,
1306 webrtc::RtpParameters parameters) {
1307 return media_channel()->SetRtpReceiveParameters(ssrc, parameters);
skvladdc1c62c2016-03-16 19:07:43 -07001308}
1309
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001310bool VoiceChannel::GetStats(VoiceMediaInfo* stats) {
stefanf79ade12017-06-02 06:44:03 -07001311 return InvokeOnWorker<bool>(RTC_FROM_HERE, Bind(&VoiceMediaChannel::GetStats,
1312 media_channel(), stats));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001313}
1314
hbos8d609f62017-04-10 07:39:05 -07001315std::vector<webrtc::RtpSource> VoiceChannel::GetSources(uint32_t ssrc) const {
1316 return worker_thread()->Invoke<std::vector<webrtc::RtpSource>>(
zhihuang38ede132017-06-15 12:52:32 -07001317 RTC_FROM_HERE, Bind(&VoiceChannel::GetSources_w, this, ssrc));
1318}
1319
1320std::vector<webrtc::RtpSource> VoiceChannel::GetSources_w(uint32_t ssrc) const {
1321 RTC_DCHECK(worker_thread()->IsCurrent());
1322 return media_channel()->GetSources(ssrc);
hbos8d609f62017-04-10 07:39:05 -07001323}
1324
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001325void VoiceChannel::StartMediaMonitor(int cms) {
1326 media_monitor_.reset(new VoiceMediaMonitor(media_channel(), worker_thread(),
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001327 rtc::Thread::Current()));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001328 media_monitor_->SignalUpdate.connect(
1329 this, &VoiceChannel::OnMediaMonitorUpdate);
1330 media_monitor_->Start(cms);
1331}
1332
1333void VoiceChannel::StopMediaMonitor() {
1334 if (media_monitor_) {
1335 media_monitor_->Stop();
1336 media_monitor_->SignalUpdate.disconnect(this);
1337 media_monitor_.reset();
1338 }
1339}
1340
1341void VoiceChannel::StartAudioMonitor(int cms) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001342 audio_monitor_.reset(new AudioMonitor(this, rtc::Thread::Current()));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001343 audio_monitor_
1344 ->SignalUpdate.connect(this, &VoiceChannel::OnAudioMonitorUpdate);
1345 audio_monitor_->Start(cms);
1346}
1347
1348void VoiceChannel::StopAudioMonitor() {
1349 if (audio_monitor_) {
1350 audio_monitor_->Stop();
1351 audio_monitor_.reset();
1352 }
1353}
1354
1355bool VoiceChannel::IsAudioMonitorRunning() const {
1356 return (audio_monitor_.get() != NULL);
1357}
1358
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001359int VoiceChannel::GetInputLevel_w() {
Fredrik Solenberg0c022642015-08-05 12:25:22 +02001360 return media_engine_->GetInputLevel();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001361}
1362
1363int VoiceChannel::GetOutputLevel_w() {
1364 return media_channel()->GetOutputLevel();
1365}
1366
1367void VoiceChannel::GetActiveStreams_w(AudioInfo::StreamList* actives) {
1368 media_channel()->GetActiveStreams(actives);
1369}
1370
zstein3dcf0e92017-06-01 13:22:42 -07001371void VoiceChannel::OnPacketReceived(bool rtcp,
zstein634977b2017-07-14 12:30:04 -07001372 rtc::CopyOnWriteBuffer* packet,
zstein3dcf0e92017-06-01 13:22:42 -07001373 const rtc::PacketTime& packet_time) {
1374 BaseChannel::OnPacketReceived(rtcp, packet, packet_time);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001375 // Set a flag when we've received an RTP packet. If we're waiting for early
1376 // media, this will disable the timeout.
zstein3dcf0e92017-06-01 13:22:42 -07001377 if (!received_media_ && !rtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001378 received_media_ = true;
1379 }
1380}
1381
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001382void BaseChannel::UpdateMediaSendRecvState() {
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001383 RTC_DCHECK(network_thread_->IsCurrent());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001384 invoker_.AsyncInvoke<void>(
1385 RTC_FROM_HERE, worker_thread_,
1386 Bind(&BaseChannel::UpdateMediaSendRecvState_w, this));
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001387}
1388
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001389void VoiceChannel::UpdateMediaSendRecvState_w() {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001390 // Render incoming data if we're the active call, and we have the local
1391 // content. We receive data on the default channel and multiplexed streams.
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001392 bool recv = IsReadyToReceiveMedia_w();
solenberg5b14b422015-10-01 04:10:31 -07001393 media_channel()->SetPlayout(recv);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001394
1395 // Send outgoing data if we're the active call, we have the remote content,
1396 // and we have had some form of connectivity.
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001397 bool send = IsReadyToSendMedia_w();
Taylor Brandstetter1a018dc2016-03-08 12:37:39 -08001398 media_channel()->SetSend(send);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001399
Mirko Bonadei675513b2017-11-09 11:09:25 +01001400 RTC_LOG(LS_INFO) << "Changing voice state, recv=" << recv << " send=" << send;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001401}
1402
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001403bool VoiceChannel::SetLocalContent_w(const MediaContentDescription* content,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001404 ContentAction action,
1405 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +01001406 TRACE_EVENT0("webrtc", "VoiceChannel::SetLocalContent_w");
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001407 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
Mirko Bonadei675513b2017-11-09 11:09:25 +01001408 RTC_LOG(LS_INFO) << "Setting local voice description";
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001409
1410 const AudioContentDescription* audio =
1411 static_cast<const AudioContentDescription*>(content);
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001412 RTC_DCHECK(audio != NULL);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001413 if (!audio) {
1414 SafeSetError("Can't find audio content in local description.", error_desc);
1415 return false;
1416 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001417
jbauch5869f502017-06-29 12:31:36 -07001418 RtpHeaderExtensions rtp_header_extensions =
1419 GetFilteredRtpHeaderExtensions(audio->rtp_header_extensions());
1420
1421 if (!SetRtpTransportParameters(content, action, CS_LOCAL,
1422 rtp_header_extensions, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001423 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001424 }
1425
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001426 AudioRecvParameters recv_params = last_recv_params_;
jbauch5869f502017-06-29 12:31:36 -07001427 RtpParametersFromMediaDescription(audio, rtp_header_extensions, &recv_params);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001428 if (!media_channel()->SetRecvParameters(recv_params)) {
Peter Thatcherbfab5cb2015-08-20 17:40:24 -07001429 SafeSetError("Failed to set local audio description recv parameters.",
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001430 error_desc);
1431 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001432 }
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001433 for (const AudioCodec& codec : audio->codecs()) {
zstein3dcf0e92017-06-01 13:22:42 -07001434 AddHandledPayloadType(codec.id);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001435 }
1436 last_recv_params_ = recv_params;
1437
1438 // TODO(pthatcher): Move local streams into AudioSendParameters, and
1439 // only give it to the media channel once we have a remote
1440 // description too (without a remote description, we won't be able
1441 // to send them anyway).
1442 if (!UpdateLocalStreams_w(audio->streams(), action, error_desc)) {
1443 SafeSetError("Failed to set local audio description streams.", error_desc);
1444 return false;
1445 }
1446
1447 set_local_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001448 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001449 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001450}
1451
1452bool VoiceChannel::SetRemoteContent_w(const MediaContentDescription* content,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001453 ContentAction action,
1454 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +01001455 TRACE_EVENT0("webrtc", "VoiceChannel::SetRemoteContent_w");
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001456 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
Mirko Bonadei675513b2017-11-09 11:09:25 +01001457 RTC_LOG(LS_INFO) << "Setting remote voice description";
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001458
1459 const AudioContentDescription* audio =
1460 static_cast<const AudioContentDescription*>(content);
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001461 RTC_DCHECK(audio != NULL);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001462 if (!audio) {
1463 SafeSetError("Can't find audio content in remote description.", error_desc);
1464 return false;
1465 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001466
jbauch5869f502017-06-29 12:31:36 -07001467 RtpHeaderExtensions rtp_header_extensions =
1468 GetFilteredRtpHeaderExtensions(audio->rtp_header_extensions());
1469
1470 if (!SetRtpTransportParameters(content, action, CS_REMOTE,
1471 rtp_header_extensions, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001472 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001473 }
1474
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001475 AudioSendParameters send_params = last_send_params_;
jbauch5869f502017-06-29 12:31:36 -07001476 RtpSendParametersFromMediaDescription(audio, rtp_header_extensions,
1477 &send_params);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001478 if (audio->agc_minus_10db()) {
Oskar Sundbom36f8f3e2017-11-16 10:54:27 +01001479 send_params.options.adjust_agc_delta = kAgcMinus10db;
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001480 }
skvladdc1c62c2016-03-16 19:07:43 -07001481
1482 bool parameters_applied = media_channel()->SetSendParameters(send_params);
1483 if (!parameters_applied) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001484 SafeSetError("Failed to set remote audio description send parameters.",
1485 error_desc);
1486 return false;
1487 }
1488 last_send_params_ = send_params;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001489
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001490 // TODO(pthatcher): Move remote streams into AudioRecvParameters,
1491 // and only give it to the media channel once we have a local
1492 // description too (without a local description, we won't be able to
1493 // recv them anyway).
1494 if (!UpdateRemoteStreams_w(audio->streams(), action, error_desc)) {
1495 SafeSetError("Failed to set remote audio description streams.", error_desc);
1496 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001497 }
1498
Peter Thatcherbfab5cb2015-08-20 17:40:24 -07001499 if (audio->rtp_header_extensions_set()) {
jbauch5869f502017-06-29 12:31:36 -07001500 MaybeCacheRtpAbsSendTimeHeaderExtension_w(rtp_header_extensions);
Peter Thatcherbfab5cb2015-08-20 17:40:24 -07001501 }
1502
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001503 set_remote_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001504 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001505 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001506}
1507
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001508void VoiceChannel::HandleEarlyMediaTimeout() {
1509 // This occurs on the main thread, not the worker thread.
1510 if (!received_media_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001511 RTC_LOG(LS_INFO) << "No early media received before timeout";
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001512 SignalEarlyMediaTimeout(this);
1513 }
1514}
1515
Peter Boström0c4e06b2015-10-07 12:23:21 +02001516bool VoiceChannel::InsertDtmf_w(uint32_t ssrc,
1517 int event,
solenberg1d63dd02015-12-02 12:35:09 -08001518 int duration) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001519 if (!enabled()) {
1520 return false;
1521 }
solenberg1d63dd02015-12-02 12:35:09 -08001522 return media_channel()->InsertDtmf(ssrc, event, duration);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001523}
1524
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001525void VoiceChannel::OnMessage(rtc::Message *pmsg) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001526 switch (pmsg->message_id) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001527 case MSG_EARLYMEDIATIMEOUT:
1528 HandleEarlyMediaTimeout();
1529 break;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001530 case MSG_CHANNEL_ERROR: {
1531 VoiceChannelErrorMessageData* data =
1532 static_cast<VoiceChannelErrorMessageData*>(pmsg->pdata);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001533 delete data;
1534 break;
1535 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001536 default:
1537 BaseChannel::OnMessage(pmsg);
1538 break;
1539 }
1540}
1541
1542void VoiceChannel::OnConnectionMonitorUpdate(
pthatcher@webrtc.orgb4aac132015-03-13 18:25:21 +00001543 ConnectionMonitor* monitor, const std::vector<ConnectionInfo>& infos) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001544 SignalConnectionMonitor(this, infos);
1545}
1546
1547void VoiceChannel::OnMediaMonitorUpdate(
1548 VoiceMediaChannel* media_channel, const VoiceMediaInfo& info) {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001549 RTC_DCHECK(media_channel == this->media_channel());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001550 SignalMediaMonitor(this, info);
1551}
1552
1553void VoiceChannel::OnAudioMonitorUpdate(AudioMonitor* monitor,
1554 const AudioInfo& info) {
1555 SignalAudioMonitor(this, info);
1556}
1557
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001558VideoChannel::VideoChannel(rtc::Thread* worker_thread,
1559 rtc::Thread* network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -08001560 rtc::Thread* signaling_thread,
Steve Anton8699a322017-11-06 15:53:33 -08001561 std::unique_ptr<VideoMediaChannel> media_channel,
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001562 const std::string& content_name,
deadbeefac22f702017-01-12 21:59:29 -08001563 bool rtcp_mux_required,
deadbeef7af91dd2016-12-13 11:29:11 -08001564 bool srtp_required)
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001565 : BaseChannel(worker_thread,
1566 network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -08001567 signaling_thread,
Steve Anton8699a322017-11-06 15:53:33 -08001568 std::move(media_channel),
deadbeefcbecd352015-09-23 11:50:27 -07001569 content_name,
deadbeefac22f702017-01-12 21:59:29 -08001570 rtcp_mux_required,
deadbeef7af91dd2016-12-13 11:29:11 -08001571 srtp_required) {}
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001572
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001573VideoChannel::~VideoChannel() {
Peter Boströmca8b4042016-03-08 14:24:13 -08001574 TRACE_EVENT0("webrtc", "VideoChannel::~VideoChannel");
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001575 StopMediaMonitor();
1576 // this can't be done in the base class, since it calls a virtual
1577 DisableMedia_w();
wu@webrtc.org78187522013-10-07 23:32:02 +00001578
1579 Deinit();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001580}
1581
nisse08582ff2016-02-04 01:24:52 -08001582bool VideoChannel::SetSink(uint32_t ssrc,
nisseacd935b2016-11-11 03:55:13 -08001583 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) {
nisse08582ff2016-02-04 01:24:52 -08001584 worker_thread()->Invoke<void>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001585 RTC_FROM_HERE,
nisse08582ff2016-02-04 01:24:52 -08001586 Bind(&VideoMediaChannel::SetSink, media_channel(), ssrc, sink));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001587 return true;
1588}
1589
deadbeef5a4a75a2016-06-02 16:23:38 -07001590bool VideoChannel::SetVideoSend(
nisse2ded9b12016-04-08 02:23:55 -07001591 uint32_t ssrc,
deadbeef5a4a75a2016-06-02 16:23:38 -07001592 bool mute,
1593 const VideoOptions* options,
nisseacd935b2016-11-11 03:55:13 -08001594 rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
stefanf79ade12017-06-02 06:44:03 -07001595 return InvokeOnWorker<bool>(
1596 RTC_FROM_HERE, Bind(&VideoMediaChannel::SetVideoSend, media_channel(),
1597 ssrc, mute, options, source));
solenberg1dd98f32015-09-10 01:57:14 -07001598}
1599
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001600webrtc::RtpParameters VideoChannel::GetRtpSendParameters(uint32_t ssrc) const {
skvladdc1c62c2016-03-16 19:07:43 -07001601 return worker_thread()->Invoke<webrtc::RtpParameters>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001602 RTC_FROM_HERE, Bind(&VideoChannel::GetRtpSendParameters_w, this, ssrc));
skvladdc1c62c2016-03-16 19:07:43 -07001603}
1604
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001605webrtc::RtpParameters VideoChannel::GetRtpSendParameters_w(
1606 uint32_t ssrc) const {
1607 return media_channel()->GetRtpSendParameters(ssrc);
skvladdc1c62c2016-03-16 19:07:43 -07001608}
1609
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001610bool VideoChannel::SetRtpSendParameters(
1611 uint32_t ssrc,
1612 const webrtc::RtpParameters& parameters) {
stefanf79ade12017-06-02 06:44:03 -07001613 return InvokeOnWorker<bool>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001614 RTC_FROM_HERE,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001615 Bind(&VideoChannel::SetRtpSendParameters_w, this, ssrc, parameters));
skvladdc1c62c2016-03-16 19:07:43 -07001616}
1617
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001618bool VideoChannel::SetRtpSendParameters_w(uint32_t ssrc,
1619 webrtc::RtpParameters parameters) {
1620 return media_channel()->SetRtpSendParameters(ssrc, parameters);
1621}
1622
1623webrtc::RtpParameters VideoChannel::GetRtpReceiveParameters(
1624 uint32_t ssrc) const {
1625 return worker_thread()->Invoke<webrtc::RtpParameters>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001626 RTC_FROM_HERE,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001627 Bind(&VideoChannel::GetRtpReceiveParameters_w, this, ssrc));
1628}
1629
1630webrtc::RtpParameters VideoChannel::GetRtpReceiveParameters_w(
1631 uint32_t ssrc) const {
1632 return media_channel()->GetRtpReceiveParameters(ssrc);
1633}
1634
1635bool VideoChannel::SetRtpReceiveParameters(
1636 uint32_t ssrc,
1637 const webrtc::RtpParameters& parameters) {
stefanf79ade12017-06-02 06:44:03 -07001638 return InvokeOnWorker<bool>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001639 RTC_FROM_HERE,
Taylor Brandstetterdb0cd9e2016-05-16 11:40:30 -07001640 Bind(&VideoChannel::SetRtpReceiveParameters_w, this, ssrc, parameters));
1641}
1642
1643bool VideoChannel::SetRtpReceiveParameters_w(uint32_t ssrc,
1644 webrtc::RtpParameters parameters) {
1645 return media_channel()->SetRtpReceiveParameters(ssrc, parameters);
skvladdc1c62c2016-03-16 19:07:43 -07001646}
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001647
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001648void VideoChannel::UpdateMediaSendRecvState_w() {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001649 // Send outgoing data if we're the active call, we have the remote content,
1650 // and we have had some form of connectivity.
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001651 bool send = IsReadyToSendMedia_w();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001652 if (!media_channel()->SetSend(send)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001653 RTC_LOG(LS_ERROR) << "Failed to SetSend on video channel";
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001654 // TODO(gangji): Report error back to server.
1655 }
1656
Mirko Bonadei675513b2017-11-09 11:09:25 +01001657 RTC_LOG(LS_INFO) << "Changing video state, send=" << send;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001658}
1659
stefanf79ade12017-06-02 06:44:03 -07001660void VideoChannel::FillBitrateInfo(BandwidthEstimationInfo* bwe_info) {
1661 InvokeOnWorker<void>(RTC_FROM_HERE, Bind(&VideoMediaChannel::FillBitrateInfo,
1662 media_channel(), bwe_info));
1663}
1664
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00001665bool VideoChannel::GetStats(VideoMediaInfo* stats) {
stefanf79ade12017-06-02 06:44:03 -07001666 return InvokeOnWorker<bool>(RTC_FROM_HERE, Bind(&VideoMediaChannel::GetStats,
1667 media_channel(), stats));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001668}
1669
1670void VideoChannel::StartMediaMonitor(int cms) {
1671 media_monitor_.reset(new VideoMediaMonitor(media_channel(), worker_thread(),
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001672 rtc::Thread::Current()));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001673 media_monitor_->SignalUpdate.connect(
1674 this, &VideoChannel::OnMediaMonitorUpdate);
1675 media_monitor_->Start(cms);
1676}
1677
1678void VideoChannel::StopMediaMonitor() {
1679 if (media_monitor_) {
1680 media_monitor_->Stop();
1681 media_monitor_.reset();
1682 }
1683}
1684
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001685bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001686 ContentAction action,
1687 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +01001688 TRACE_EVENT0("webrtc", "VideoChannel::SetLocalContent_w");
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001689 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
Mirko Bonadei675513b2017-11-09 11:09:25 +01001690 RTC_LOG(LS_INFO) << "Setting local video description";
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001691
1692 const VideoContentDescription* video =
1693 static_cast<const VideoContentDescription*>(content);
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001694 RTC_DCHECK(video != NULL);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001695 if (!video) {
1696 SafeSetError("Can't find video content in local description.", error_desc);
1697 return false;
1698 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001699
jbauch5869f502017-06-29 12:31:36 -07001700 RtpHeaderExtensions rtp_header_extensions =
1701 GetFilteredRtpHeaderExtensions(video->rtp_header_extensions());
1702
1703 if (!SetRtpTransportParameters(content, action, CS_LOCAL,
1704 rtp_header_extensions, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001705 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001706 }
1707
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001708 VideoRecvParameters recv_params = last_recv_params_;
jbauch5869f502017-06-29 12:31:36 -07001709 RtpParametersFromMediaDescription(video, rtp_header_extensions, &recv_params);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001710 if (!media_channel()->SetRecvParameters(recv_params)) {
1711 SafeSetError("Failed to set local video description recv parameters.",
1712 error_desc);
1713 return false;
1714 }
1715 for (const VideoCodec& codec : video->codecs()) {
zstein3dcf0e92017-06-01 13:22:42 -07001716 AddHandledPayloadType(codec.id);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001717 }
1718 last_recv_params_ = recv_params;
1719
1720 // TODO(pthatcher): Move local streams into VideoSendParameters, and
1721 // only give it to the media channel once we have a remote
1722 // description too (without a remote description, we won't be able
1723 // to send them anyway).
1724 if (!UpdateLocalStreams_w(video->streams(), action, error_desc)) {
1725 SafeSetError("Failed to set local video description streams.", error_desc);
1726 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001727 }
1728
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001729 set_local_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001730 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001731 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001732}
1733
1734bool VideoChannel::SetRemoteContent_w(const MediaContentDescription* content,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001735 ContentAction action,
1736 std::string* error_desc) {
Peter Boström9f45a452015-12-08 13:25:57 +01001737 TRACE_EVENT0("webrtc", "VideoChannel::SetRemoteContent_w");
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001738 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
Mirko Bonadei675513b2017-11-09 11:09:25 +01001739 RTC_LOG(LS_INFO) << "Setting remote video description";
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001740
1741 const VideoContentDescription* video =
1742 static_cast<const VideoContentDescription*>(content);
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001743 RTC_DCHECK(video != NULL);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001744 if (!video) {
1745 SafeSetError("Can't find video content in remote description.", error_desc);
1746 return false;
1747 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001748
jbauch5869f502017-06-29 12:31:36 -07001749 RtpHeaderExtensions rtp_header_extensions =
1750 GetFilteredRtpHeaderExtensions(video->rtp_header_extensions());
1751
1752 if (!SetRtpTransportParameters(content, action, CS_REMOTE,
1753 rtp_header_extensions, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001754 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001755 }
1756
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001757 VideoSendParameters send_params = last_send_params_;
jbauch5869f502017-06-29 12:31:36 -07001758 RtpSendParametersFromMediaDescription(video, rtp_header_extensions,
1759 &send_params);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001760 if (video->conference_mode()) {
nisse4b4dc862016-02-17 05:25:36 -08001761 send_params.conference_mode = true;
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001762 }
skvladdc1c62c2016-03-16 19:07:43 -07001763
1764 bool parameters_applied = media_channel()->SetSendParameters(send_params);
1765
1766 if (!parameters_applied) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001767 SafeSetError("Failed to set remote video description send parameters.",
1768 error_desc);
1769 return false;
1770 }
1771 last_send_params_ = send_params;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001772
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001773 // TODO(pthatcher): Move remote streams into VideoRecvParameters,
1774 // and only give it to the media channel once we have a local
1775 // description too (without a local description, we won't be able to
1776 // recv them anyway).
1777 if (!UpdateRemoteStreams_w(video->streams(), action, error_desc)) {
1778 SafeSetError("Failed to set remote video description streams.", error_desc);
1779 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001780 }
1781
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001782 if (video->rtp_header_extensions_set()) {
jbauch5869f502017-06-29 12:31:36 -07001783 MaybeCacheRtpAbsSendTimeHeaderExtension_w(rtp_header_extensions);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001784 }
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001785
1786 set_remote_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001787 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001788 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001789}
1790
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001791void VideoChannel::OnMessage(rtc::Message *pmsg) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001792 switch (pmsg->message_id) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001793 case MSG_CHANNEL_ERROR: {
1794 const VideoChannelErrorMessageData* data =
1795 static_cast<VideoChannelErrorMessageData*>(pmsg->pdata);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001796 delete data;
1797 break;
1798 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001799 default:
1800 BaseChannel::OnMessage(pmsg);
1801 break;
1802 }
1803}
1804
1805void VideoChannel::OnConnectionMonitorUpdate(
pthatcher@webrtc.orgb4aac132015-03-13 18:25:21 +00001806 ConnectionMonitor* monitor, const std::vector<ConnectionInfo> &infos) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001807 SignalConnectionMonitor(this, infos);
1808}
1809
1810// TODO(pthatcher): Look into removing duplicate code between
1811// audio, video, and data, perhaps by using templates.
1812void VideoChannel::OnMediaMonitorUpdate(
1813 VideoMediaChannel* media_channel, const VideoMediaInfo &info) {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001814 RTC_DCHECK(media_channel == this->media_channel());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001815 SignalMediaMonitor(this, info);
1816}
1817
deadbeef953c2ce2017-01-09 14:53:41 -08001818RtpDataChannel::RtpDataChannel(rtc::Thread* worker_thread,
1819 rtc::Thread* network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -08001820 rtc::Thread* signaling_thread,
Steve Anton8699a322017-11-06 15:53:33 -08001821 std::unique_ptr<DataMediaChannel> media_channel,
deadbeef953c2ce2017-01-09 14:53:41 -08001822 const std::string& content_name,
deadbeefac22f702017-01-12 21:59:29 -08001823 bool rtcp_mux_required,
deadbeef953c2ce2017-01-09 14:53:41 -08001824 bool srtp_required)
Danil Chapovalov33b01f22016-05-11 19:55:27 +02001825 : BaseChannel(worker_thread,
1826 network_thread,
zhihuangf5b251b2017-01-12 19:37:48 -08001827 signaling_thread,
Steve Anton8699a322017-11-06 15:53:33 -08001828 std::move(media_channel),
deadbeefcbecd352015-09-23 11:50:27 -07001829 content_name,
deadbeefac22f702017-01-12 21:59:29 -08001830 rtcp_mux_required,
deadbeef953c2ce2017-01-09 14:53:41 -08001831 srtp_required) {}
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001832
deadbeef953c2ce2017-01-09 14:53:41 -08001833RtpDataChannel::~RtpDataChannel() {
1834 TRACE_EVENT0("webrtc", "RtpDataChannel::~RtpDataChannel");
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001835 StopMediaMonitor();
1836 // this can't be done in the base class, since it calls a virtual
1837 DisableMedia_w();
wu@webrtc.org78187522013-10-07 23:32:02 +00001838
1839 Deinit();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001840}
1841
Steve Anton8699a322017-11-06 15:53:33 -08001842void RtpDataChannel::Init_w(
deadbeeff5346592017-01-24 21:51:21 -08001843 DtlsTransportInternal* rtp_dtls_transport,
1844 DtlsTransportInternal* rtcp_dtls_transport,
deadbeef5bd5ca32017-02-10 11:31:50 -08001845 rtc::PacketTransportInternal* rtp_packet_transport,
1846 rtc::PacketTransportInternal* rtcp_packet_transport) {
Steve Anton8699a322017-11-06 15:53:33 -08001847 BaseChannel::Init_w(rtp_dtls_transport, rtcp_dtls_transport,
1848 rtp_packet_transport, rtcp_packet_transport);
1849
deadbeef953c2ce2017-01-09 14:53:41 -08001850 media_channel()->SignalDataReceived.connect(this,
1851 &RtpDataChannel::OnDataReceived);
wu@webrtc.orgd64719d2013-08-01 00:00:07 +00001852 media_channel()->SignalReadyToSend.connect(
deadbeef953c2ce2017-01-09 14:53:41 -08001853 this, &RtpDataChannel::OnDataChannelReadyToSend);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001854}
1855
deadbeef953c2ce2017-01-09 14:53:41 -08001856bool RtpDataChannel::SendData(const SendDataParams& params,
1857 const rtc::CopyOnWriteBuffer& payload,
1858 SendDataResult* result) {
stefanf79ade12017-06-02 06:44:03 -07001859 return InvokeOnWorker<bool>(
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07001860 RTC_FROM_HERE, Bind(&DataMediaChannel::SendData, media_channel(), params,
1861 payload, result));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001862}
1863
deadbeef953c2ce2017-01-09 14:53:41 -08001864bool RtpDataChannel::CheckDataChannelTypeFromContent(
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001865 const DataContentDescription* content,
1866 std::string* error_desc) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001867 bool is_sctp = ((content->protocol() == kMediaProtocolSctp) ||
1868 (content->protocol() == kMediaProtocolDtlsSctp));
deadbeef953c2ce2017-01-09 14:53:41 -08001869 // It's been set before, but doesn't match. That's bad.
1870 if (is_sctp) {
1871 SafeSetError("Data channel type mismatch. Expected RTP, got SCTP.",
1872 error_desc);
1873 return false;
1874 }
1875 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001876}
1877
deadbeef953c2ce2017-01-09 14:53:41 -08001878bool RtpDataChannel::SetLocalContent_w(const MediaContentDescription* content,
1879 ContentAction action,
1880 std::string* error_desc) {
1881 TRACE_EVENT0("webrtc", "RtpDataChannel::SetLocalContent_w");
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001882 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
Mirko Bonadei675513b2017-11-09 11:09:25 +01001883 RTC_LOG(LS_INFO) << "Setting local data description";
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001884
1885 const DataContentDescription* data =
1886 static_cast<const DataContentDescription*>(content);
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001887 RTC_DCHECK(data != NULL);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001888 if (!data) {
1889 SafeSetError("Can't find data content in local description.", error_desc);
1890 return false;
1891 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001892
deadbeef953c2ce2017-01-09 14:53:41 -08001893 if (!CheckDataChannelTypeFromContent(data, error_desc)) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001894 return false;
1895 }
1896
jbauch5869f502017-06-29 12:31:36 -07001897 RtpHeaderExtensions rtp_header_extensions =
1898 GetFilteredRtpHeaderExtensions(data->rtp_header_extensions());
1899
1900 if (!SetRtpTransportParameters(content, action, CS_LOCAL,
1901 rtp_header_extensions, error_desc)) {
deadbeef953c2ce2017-01-09 14:53:41 -08001902 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001903 }
1904
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001905 DataRecvParameters recv_params = last_recv_params_;
jbauch5869f502017-06-29 12:31:36 -07001906 RtpParametersFromMediaDescription(data, rtp_header_extensions, &recv_params);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001907 if (!media_channel()->SetRecvParameters(recv_params)) {
1908 SafeSetError("Failed to set remote data description recv parameters.",
1909 error_desc);
1910 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001911 }
deadbeef953c2ce2017-01-09 14:53:41 -08001912 for (const DataCodec& codec : data->codecs()) {
zstein3dcf0e92017-06-01 13:22:42 -07001913 AddHandledPayloadType(codec.id);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001914 }
1915 last_recv_params_ = recv_params;
1916
1917 // TODO(pthatcher): Move local streams into DataSendParameters, and
1918 // only give it to the media channel once we have a remote
1919 // description too (without a remote description, we won't be able
1920 // to send them anyway).
1921 if (!UpdateLocalStreams_w(data->streams(), action, error_desc)) {
1922 SafeSetError("Failed to set local data description streams.", error_desc);
1923 return false;
1924 }
1925
1926 set_local_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001927 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001928 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001929}
1930
deadbeef953c2ce2017-01-09 14:53:41 -08001931bool RtpDataChannel::SetRemoteContent_w(const MediaContentDescription* content,
1932 ContentAction action,
1933 std::string* error_desc) {
1934 TRACE_EVENT0("webrtc", "RtpDataChannel::SetRemoteContent_w");
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001935 RTC_DCHECK(worker_thread() == rtc::Thread::Current());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001936
1937 const DataContentDescription* data =
1938 static_cast<const DataContentDescription*>(content);
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001939 RTC_DCHECK(data != NULL);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54 +00001940 if (!data) {
1941 SafeSetError("Can't find data content in remote description.", error_desc);
1942 return false;
1943 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001944
Zhi Huang801b8682017-11-15 11:36:43 -08001945 // If the remote data doesn't have codecs, it must be empty, so ignore it.
1946 if (!data->has_codecs()) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001947 return true;
1948 }
1949
deadbeef953c2ce2017-01-09 14:53:41 -08001950 if (!CheckDataChannelTypeFromContent(data, error_desc)) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001951 return false;
1952 }
1953
jbauch5869f502017-06-29 12:31:36 -07001954 RtpHeaderExtensions rtp_header_extensions =
1955 GetFilteredRtpHeaderExtensions(data->rtp_header_extensions());
1956
Mirko Bonadei675513b2017-11-09 11:09:25 +01001957 RTC_LOG(LS_INFO) << "Setting remote data description";
jbauch5869f502017-06-29 12:31:36 -07001958 if (!SetRtpTransportParameters(content, action, CS_REMOTE,
1959 rtp_header_extensions, error_desc)) {
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001960 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001961 }
1962
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001963 DataSendParameters send_params = last_send_params_;
jbauch5869f502017-06-29 12:31:36 -07001964 RtpSendParametersFromMediaDescription<DataCodec>(data, rtp_header_extensions,
1965 &send_params);
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001966 if (!media_channel()->SetSendParameters(send_params)) {
1967 SafeSetError("Failed to set remote data description send parameters.",
1968 error_desc);
1969 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001970 }
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001971 last_send_params_ = send_params;
1972
1973 // TODO(pthatcher): Move remote streams into DataRecvParameters,
1974 // and only give it to the media channel once we have a local
1975 // description too (without a local description, we won't be able to
1976 // recv them anyway).
1977 if (!UpdateRemoteStreams_w(data->streams(), action, error_desc)) {
1978 SafeSetError("Failed to set remote data description streams.",
1979 error_desc);
1980 return false;
1981 }
1982
1983 set_remote_content_direction(content->direction());
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001984 UpdateMediaSendRecvState_w();
Peter Thatcherc2ee2c82015-08-07 16:05:34 -07001985 return true;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001986}
1987
deadbeef953c2ce2017-01-09 14:53:41 -08001988void RtpDataChannel::UpdateMediaSendRecvState_w() {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001989 // Render incoming data if we're the active call, and we have the local
1990 // content. We receive data on the default channel and multiplexed streams.
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001991 bool recv = IsReadyToReceiveMedia_w();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001992 if (!media_channel()->SetReceive(recv)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01001993 RTC_LOG(LS_ERROR) << "Failed to SetReceive on data channel";
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001994 }
1995
1996 // Send outgoing data if we're the active call, we have the remote content,
1997 // and we have had some form of connectivity.
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07001998 bool send = IsReadyToSendMedia_w();
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001999 if (!media_channel()->SetSend(send)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +01002000 RTC_LOG(LS_ERROR) << "Failed to SetSend on data channel";
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002001 }
2002
sergeyu@chromium.org9cf037b2014-02-07 19:03:26 +00002003 // Trigger SignalReadyToSendData asynchronously.
2004 OnDataChannelReadyToSend(send);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002005
Mirko Bonadei675513b2017-11-09 11:09:25 +01002006 RTC_LOG(LS_INFO) << "Changing data state, recv=" << recv << " send=" << send;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002007}
2008
deadbeef953c2ce2017-01-09 14:53:41 -08002009void RtpDataChannel::OnMessage(rtc::Message* pmsg) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002010 switch (pmsg->message_id) {
2011 case MSG_READYTOSENDDATA: {
wu@webrtc.orgd64719d2013-08-01 00:00:07 +00002012 DataChannelReadyToSendMessageData* data =
2013 static_cast<DataChannelReadyToSendMessageData*>(pmsg->pdata);
wu@webrtc.org07a6fbe2013-11-04 18:41:34 +00002014 ready_to_send_data_ = data->data();
2015 SignalReadyToSendData(ready_to_send_data_);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002016 delete data;
2017 break;
2018 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002019 case MSG_DATARECEIVED: {
2020 DataReceivedMessageData* data =
2021 static_cast<DataReceivedMessageData*>(pmsg->pdata);
deadbeef953c2ce2017-01-09 14:53:41 -08002022 SignalDataReceived(data->params, data->payload);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002023 delete data;
2024 break;
2025 }
2026 case MSG_CHANNEL_ERROR: {
2027 const DataChannelErrorMessageData* data =
2028 static_cast<DataChannelErrorMessageData*>(pmsg->pdata);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002029 delete data;
2030 break;
2031 }
2032 default:
2033 BaseChannel::OnMessage(pmsg);
2034 break;
2035 }
2036}
2037
deadbeef953c2ce2017-01-09 14:53:41 -08002038void RtpDataChannel::OnConnectionMonitorUpdate(
2039 ConnectionMonitor* monitor,
2040 const std::vector<ConnectionInfo>& infos) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002041 SignalConnectionMonitor(this, infos);
2042}
2043
deadbeef953c2ce2017-01-09 14:53:41 -08002044void RtpDataChannel::StartMediaMonitor(int cms) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002045 media_monitor_.reset(new DataMediaMonitor(media_channel(), worker_thread(),
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00002046 rtc::Thread::Current()));
deadbeef953c2ce2017-01-09 14:53:41 -08002047 media_monitor_->SignalUpdate.connect(this,
2048 &RtpDataChannel::OnMediaMonitorUpdate);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002049 media_monitor_->Start(cms);
2050}
2051
deadbeef953c2ce2017-01-09 14:53:41 -08002052void RtpDataChannel::StopMediaMonitor() {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002053 if (media_monitor_) {
2054 media_monitor_->Stop();
2055 media_monitor_->SignalUpdate.disconnect(this);
2056 media_monitor_.reset();
2057 }
2058}
2059
deadbeef953c2ce2017-01-09 14:53:41 -08002060void RtpDataChannel::OnMediaMonitorUpdate(DataMediaChannel* media_channel,
2061 const DataMediaInfo& info) {
Taylor Brandstetterbad33bf2016-08-25 13:31:14 -07002062 RTC_DCHECK(media_channel == this->media_channel());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002063 SignalMediaMonitor(this, info);
2064}
2065
deadbeef953c2ce2017-01-09 14:53:41 -08002066void RtpDataChannel::OnDataReceived(const ReceiveDataParams& params,
2067 const char* data,
2068 size_t len) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002069 DataReceivedMessageData* msg = new DataReceivedMessageData(
2070 params, data, len);
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07002071 signaling_thread()->Post(RTC_FROM_HERE, this, MSG_DATARECEIVED, msg);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002072}
2073
deadbeef953c2ce2017-01-09 14:53:41 -08002074void RtpDataChannel::OnDataChannelError(uint32_t ssrc,
2075 DataMediaChannel::Error err) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002076 DataChannelErrorMessageData* data = new DataChannelErrorMessageData(
2077 ssrc, err);
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07002078 signaling_thread()->Post(RTC_FROM_HERE, this, MSG_CHANNEL_ERROR, data);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002079}
2080
deadbeef953c2ce2017-01-09 14:53:41 -08002081void RtpDataChannel::OnDataChannelReadyToSend(bool writable) {
wu@webrtc.orgd64719d2013-08-01 00:00:07 +00002082 // This is usded for congestion control to indicate that the stream is ready
2083 // to send by the MediaChannel, as opposed to OnReadyToSend, which indicates
2084 // that the transport channel is ready.
Taylor Brandstetter5d97a9a2016-06-10 14:17:27 -07002085 signaling_thread()->Post(RTC_FROM_HERE, this, MSG_READYTOSENDDATA,
wu@webrtc.orgd64719d2013-08-01 00:00:07 +00002086 new DataChannelReadyToSendMessageData(writable));
2087}
2088
henrike@webrtc.org28e20752013-07-10 00:45:36 +00002089} // namespace cricket