henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1 | /* |
kjellander | 65c7f67 | 2016-02-12 00:05:01 -0800 | [diff] [blame] | 2 | * Copyright 2004 The WebRTC project authors. All Rights Reserved. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3 | * |
kjellander | 65c7f67 | 2016-02-12 00:05:01 -0800 | [diff] [blame] | 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 9 | */ |
| 10 | |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 11 | #include <algorithm> |
| 12 | #include <iterator> |
kwiberg | 0eb15ed | 2015-12-17 03:04:15 -0800 | [diff] [blame] | 13 | #include <utility> |
| 14 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 15 | #include "pc/channel.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 16 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 17 | #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" |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 29 | // Adding 'nogncheck' to disable the gn include headers check to support modular |
| 30 | // WebRTC build targets. |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 31 | #include "media/engine/webrtcvoiceengine.h" // nogncheck |
| 32 | #include "p2p/base/packettransportinternal.h" |
| 33 | #include "pc/channelmanager.h" |
Steve Anton | 4e70a72 | 2017-11-28 14:57:10 -0800 | [diff] [blame] | 34 | #include "pc/rtpmediautils.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 35 | #include "pc/rtptransport.h" |
| 36 | #include "pc/srtptransport.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 37 | |
| 38 | namespace cricket { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 39 | using rtc::Bind; |
sergeyu@chromium.org | 9cf037b | 2014-02-07 19:03:26 +0000 | [diff] [blame] | 40 | |
deadbeef | 2d110be | 2016-01-13 12:00:26 -0800 | [diff] [blame] | 41 | namespace { |
kwiberg | 3102294 | 2016-03-11 14:18:21 -0800 | [diff] [blame] | 42 | // See comment below for why we need to use a pointer to a unique_ptr. |
deadbeef | 2d110be | 2016-01-13 12:00:26 -0800 | [diff] [blame] | 43 | bool SetRawAudioSink_w(VoiceMediaChannel* channel, |
| 44 | uint32_t ssrc, |
kwiberg | 3102294 | 2016-03-11 14:18:21 -0800 | [diff] [blame] | 45 | std::unique_ptr<webrtc::AudioSinkInterface>* sink) { |
| 46 | channel->SetRawAudioSink(ssrc, std::move(*sink)); |
deadbeef | 2d110be | 2016-01-13 12:00:26 -0800 | [diff] [blame] | 47 | return true; |
| 48 | } |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 49 | |
| 50 | struct SendPacketMessageData : public rtc::MessageData { |
| 51 | rtc::CopyOnWriteBuffer packet; |
| 52 | rtc::PacketOptions options; |
| 53 | }; |
| 54 | |
deadbeef | 2d110be | 2016-01-13 12:00:26 -0800 | [diff] [blame] | 55 | } // namespace |
| 56 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 57 | enum { |
sergeyu@chromium.org | 9cf037b | 2014-02-07 19:03:26 +0000 | [diff] [blame] | 58 | MSG_EARLYMEDIATIMEOUT = 1, |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 59 | MSG_SEND_RTP_PACKET, |
| 60 | MSG_SEND_RTCP_PACKET, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 61 | MSG_CHANNEL_ERROR, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 62 | MSG_READYTOSENDDATA, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 63 | MSG_DATARECEIVED, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 64 | MSG_FIRSTPACKETRECEIVED, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 65 | }; |
| 66 | |
| 67 | // Value specified in RFC 5764. |
| 68 | static const char kDtlsSrtpExporterLabel[] = "EXTRACTOR-dtls_srtp"; |
| 69 | |
| 70 | static const int kAgcMinus10db = -10; |
| 71 | |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 72 | static void SafeSetError(const std::string& message, std::string* error_desc) { |
| 73 | if (error_desc) { |
| 74 | *error_desc = message; |
| 75 | } |
| 76 | } |
| 77 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 78 | struct VoiceChannelErrorMessageData : public rtc::MessageData { |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 79 | VoiceChannelErrorMessageData(uint32_t in_ssrc, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 80 | VoiceMediaChannel::Error in_error) |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 81 | : ssrc(in_ssrc), error(in_error) {} |
| 82 | uint32_t ssrc; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 83 | VoiceMediaChannel::Error error; |
| 84 | }; |
| 85 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 86 | struct VideoChannelErrorMessageData : public rtc::MessageData { |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 87 | VideoChannelErrorMessageData(uint32_t in_ssrc, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 88 | VideoMediaChannel::Error in_error) |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 89 | : ssrc(in_ssrc), error(in_error) {} |
| 90 | uint32_t ssrc; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 91 | VideoMediaChannel::Error error; |
| 92 | }; |
| 93 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 94 | struct DataChannelErrorMessageData : public rtc::MessageData { |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 95 | DataChannelErrorMessageData(uint32_t in_ssrc, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 96 | DataMediaChannel::Error in_error) |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 97 | : ssrc(in_ssrc), error(in_error) {} |
| 98 | uint32_t ssrc; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 99 | DataMediaChannel::Error error; |
| 100 | }; |
| 101 | |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 102 | static bool ValidPacket(bool rtcp, const rtc::CopyOnWriteBuffer* packet) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 103 | // Check the packet size. We could check the header too if needed. |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 104 | return packet && IsValidRtpRtcpPacketSize(rtcp, packet->size()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 105 | } |
| 106 | |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 107 | template <class Codec> |
| 108 | void RtpParametersFromMediaDescription( |
| 109 | const MediaContentDescriptionImpl<Codec>* desc, |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 110 | const RtpHeaderExtensions& extensions, |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 111 | RtpParameters<Codec>* params) { |
| 112 | // TODO(pthatcher): Remove this once we're sure no one will give us |
Zhi Huang | 801b868 | 2017-11-15 11:36:43 -0800 | [diff] [blame] | 113 | // a description without codecs. Currently the ORTC implementation is relying |
| 114 | // on this. |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 115 | if (desc->has_codecs()) { |
| 116 | params->codecs = desc->codecs(); |
| 117 | } |
| 118 | // TODO(pthatcher): See if we really need |
| 119 | // rtp_header_extensions_set() and remove it if we don't. |
| 120 | if (desc->rtp_header_extensions_set()) { |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 121 | params->extensions = extensions; |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 122 | } |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 123 | params->rtcp.reduced_size = desc->rtcp_reduced_size(); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 124 | } |
| 125 | |
nisse | 0510331 | 2016-03-16 02:22:50 -0700 | [diff] [blame] | 126 | template <class Codec> |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 127 | void RtpSendParametersFromMediaDescription( |
| 128 | const MediaContentDescriptionImpl<Codec>* desc, |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 129 | const RtpHeaderExtensions& extensions, |
nisse | 0510331 | 2016-03-16 02:22:50 -0700 | [diff] [blame] | 130 | RtpSendParameters<Codec>* send_params) { |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 131 | RtpParametersFromMediaDescription(desc, extensions, send_params); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 132 | send_params->max_bandwidth_bps = desc->bandwidth(); |
| 133 | } |
| 134 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 135 | BaseChannel::BaseChannel(rtc::Thread* worker_thread, |
| 136 | rtc::Thread* network_thread, |
zhihuang | f5b251b | 2017-01-12 19:37:48 -0800 | [diff] [blame] | 137 | rtc::Thread* signaling_thread, |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 138 | std::unique_ptr<MediaChannel> media_channel, |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 139 | const std::string& content_name, |
deadbeef | ac22f70 | 2017-01-12 21:59:29 -0800 | [diff] [blame] | 140 | bool rtcp_mux_required, |
deadbeef | 7af91dd | 2016-12-13 11:29:11 -0800 | [diff] [blame] | 141 | bool srtp_required) |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 142 | : worker_thread_(worker_thread), |
| 143 | network_thread_(network_thread), |
zhihuang | f5b251b | 2017-01-12 19:37:48 -0800 | [diff] [blame] | 144 | signaling_thread_(signaling_thread), |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 145 | content_name_(content_name), |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 146 | rtcp_mux_required_(rtcp_mux_required), |
deadbeef | 7af91dd | 2016-12-13 11:29:11 -0800 | [diff] [blame] | 147 | srtp_required_(srtp_required), |
Zhi Huang | 1d88d74 | 2017-11-15 15:58:49 -0800 | [diff] [blame] | 148 | media_channel_(std::move(media_channel)) { |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 149 | RTC_DCHECK_RUN_ON(worker_thread_); |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 150 | if (srtp_required) { |
| 151 | auto transport = |
| 152 | rtc::MakeUnique<webrtc::SrtpTransport>(rtcp_mux_required, content_name); |
| 153 | srtp_transport_ = transport.get(); |
| 154 | rtp_transport_ = std::move(transport); |
jbauch | dfcab72 | 2017-03-06 00:14:10 -0800 | [diff] [blame] | 155 | #if defined(ENABLE_EXTERNAL_AUTH) |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 156 | srtp_transport_->EnableExternalAuth(); |
jbauch | dfcab72 | 2017-03-06 00:14:10 -0800 | [diff] [blame] | 157 | #endif |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 158 | } else { |
| 159 | rtp_transport_ = rtc::MakeUnique<webrtc::RtpTransport>(rtcp_mux_required); |
| 160 | srtp_transport_ = nullptr; |
| 161 | } |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 162 | rtp_transport_->SignalReadyToSend.connect( |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 163 | this, &BaseChannel::OnTransportReadyToSend); |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 164 | // TODO(zstein): RtpTransport::SignalPacketReceived will probably be replaced |
| 165 | // with a callback interface later so that the demuxer can select which |
| 166 | // channel to signal. |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 167 | rtp_transport_->SignalPacketReceived.connect(this, |
zstein | 398c3fd | 2017-07-19 13:38:02 -0700 | [diff] [blame] | 168 | &BaseChannel::OnPacketReceived); |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 169 | rtp_transport_->SignalNetworkRouteChanged.connect( |
| 170 | this, &BaseChannel::OnNetworkRouteChanged); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 171 | RTC_LOG(LS_INFO) << "Created channel for " << content_name; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 172 | } |
| 173 | |
| 174 | BaseChannel::~BaseChannel() { |
Peter Boström | ca8b404 | 2016-03-08 14:24:13 -0800 | [diff] [blame] | 175 | TRACE_EVENT0("webrtc", "BaseChannel::~BaseChannel"); |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 176 | RTC_DCHECK_RUN_ON(worker_thread_); |
wu@webrtc.org | 7818752 | 2013-10-07 23:32:02 +0000 | [diff] [blame] | 177 | Deinit(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 178 | StopConnectionMonitor(); |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 179 | // Eats any outstanding messages or packets. |
| 180 | worker_thread_->Clear(&invoker_); |
| 181 | worker_thread_->Clear(this); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 182 | // We must destroy the media channel before the transport channel, otherwise |
| 183 | // the media channel may try to send on the dead transport channel. NULLing |
| 184 | // is not an effective strategy since the sends will come on another thread. |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 185 | media_channel_.reset(); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 186 | RTC_LOG(LS_INFO) << "Destroyed channel: " << content_name_; |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 187 | } |
| 188 | |
Danil Chapovalov | dae07ba | 2016-05-14 01:43:50 +0200 | [diff] [blame] | 189 | void BaseChannel::DisconnectTransportChannels_n() { |
| 190 | // Send any outstanding RTCP packets. |
| 191 | FlushRtcpMessages_n(); |
| 192 | |
| 193 | // Stop signals from transport channels, but keep them alive because |
| 194 | // media_channel may use them from a different thread. |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 195 | if (rtp_dtls_transport_) { |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 196 | DisconnectFromDtlsTransport(rtp_dtls_transport_); |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 197 | } else if (rtp_transport_->rtp_packet_transport()) { |
| 198 | DisconnectFromPacketTransport(rtp_transport_->rtp_packet_transport()); |
Danil Chapovalov | dae07ba | 2016-05-14 01:43:50 +0200 | [diff] [blame] | 199 | } |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 200 | if (rtcp_dtls_transport_) { |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 201 | DisconnectFromDtlsTransport(rtcp_dtls_transport_); |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 202 | } else if (rtp_transport_->rtcp_packet_transport()) { |
| 203 | DisconnectFromPacketTransport(rtp_transport_->rtcp_packet_transport()); |
Danil Chapovalov | dae07ba | 2016-05-14 01:43:50 +0200 | [diff] [blame] | 204 | } |
| 205 | |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 206 | rtp_transport_->SetRtpPacketTransport(nullptr); |
| 207 | rtp_transport_->SetRtcpPacketTransport(nullptr); |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 208 | |
Danil Chapovalov | dae07ba | 2016-05-14 01:43:50 +0200 | [diff] [blame] | 209 | // Clear pending read packets/messages. |
| 210 | network_thread_->Clear(&invoker_); |
| 211 | network_thread_->Clear(this); |
| 212 | } |
| 213 | |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 214 | void BaseChannel::Init_w(DtlsTransportInternal* rtp_dtls_transport, |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 215 | DtlsTransportInternal* rtcp_dtls_transport, |
deadbeef | 5bd5ca3 | 2017-02-10 11:31:50 -0800 | [diff] [blame] | 216 | rtc::PacketTransportInternal* rtp_packet_transport, |
| 217 | rtc::PacketTransportInternal* rtcp_packet_transport) { |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 218 | RTC_DCHECK_RUN_ON(worker_thread_); |
| 219 | network_thread_->Invoke<void>(RTC_FROM_HERE, [&] { |
| 220 | return InitNetwork_n(rtp_dtls_transport, rtcp_dtls_transport, |
| 221 | rtp_packet_transport, rtcp_packet_transport); |
| 222 | }); |
| 223 | |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 224 | // Both RTP and RTCP channels should be set, we can call SetInterface on |
| 225 | // the media channel and it can set network options. |
wu@webrtc.org | de30501 | 2013-10-31 15:40:38 +0000 | [diff] [blame] | 226 | media_channel_->SetInterface(this); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 227 | } |
| 228 | |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 229 | void BaseChannel::InitNetwork_n( |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 230 | DtlsTransportInternal* rtp_dtls_transport, |
| 231 | DtlsTransportInternal* rtcp_dtls_transport, |
deadbeef | 5bd5ca3 | 2017-02-10 11:31:50 -0800 | [diff] [blame] | 232 | rtc::PacketTransportInternal* rtp_packet_transport, |
| 233 | rtc::PacketTransportInternal* rtcp_packet_transport) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 234 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 235 | SetTransports_n(rtp_dtls_transport, rtcp_dtls_transport, rtp_packet_transport, |
| 236 | rtcp_packet_transport); |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 237 | |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 238 | if (rtcp_mux_required_) { |
deadbeef | ac22f70 | 2017-01-12 21:59:29 -0800 | [diff] [blame] | 239 | rtcp_mux_filter_.SetActive(); |
| 240 | } |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 241 | } |
| 242 | |
wu@webrtc.org | 7818752 | 2013-10-07 23:32:02 +0000 | [diff] [blame] | 243 | void BaseChannel::Deinit() { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 244 | RTC_DCHECK(worker_thread_->IsCurrent()); |
wu@webrtc.org | 7818752 | 2013-10-07 23:32:02 +0000 | [diff] [blame] | 245 | media_channel_->SetInterface(NULL); |
Danil Chapovalov | dae07ba | 2016-05-14 01:43:50 +0200 | [diff] [blame] | 246 | // Packets arrive on the network thread, processing packets calls virtual |
| 247 | // functions, so need to stop this process in Deinit that is called in |
| 248 | // derived classes destructor. |
| 249 | network_thread_->Invoke<void>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 250 | RTC_FROM_HERE, Bind(&BaseChannel::DisconnectTransportChannels_n, this)); |
wu@webrtc.org | 7818752 | 2013-10-07 23:32:02 +0000 | [diff] [blame] | 251 | } |
| 252 | |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 253 | void BaseChannel::SetTransports(DtlsTransportInternal* rtp_dtls_transport, |
| 254 | DtlsTransportInternal* rtcp_dtls_transport) { |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 255 | network_thread_->Invoke<void>( |
| 256 | RTC_FROM_HERE, |
| 257 | Bind(&BaseChannel::SetTransports_n, this, rtp_dtls_transport, |
| 258 | rtcp_dtls_transport, rtp_dtls_transport, rtcp_dtls_transport)); |
pthatcher@webrtc.org | 6ad507a | 2015-03-16 20:19:12 +0000 | [diff] [blame] | 259 | } |
| 260 | |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 261 | void BaseChannel::SetTransports( |
deadbeef | 5bd5ca3 | 2017-02-10 11:31:50 -0800 | [diff] [blame] | 262 | rtc::PacketTransportInternal* rtp_packet_transport, |
| 263 | rtc::PacketTransportInternal* rtcp_packet_transport) { |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 264 | network_thread_->Invoke<void>( |
| 265 | RTC_FROM_HERE, Bind(&BaseChannel::SetTransports_n, this, nullptr, nullptr, |
| 266 | rtp_packet_transport, rtcp_packet_transport)); |
| 267 | } |
zhihuang | f5b251b | 2017-01-12 19:37:48 -0800 | [diff] [blame] | 268 | |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 269 | void BaseChannel::SetTransports_n( |
| 270 | DtlsTransportInternal* rtp_dtls_transport, |
| 271 | DtlsTransportInternal* rtcp_dtls_transport, |
deadbeef | 5bd5ca3 | 2017-02-10 11:31:50 -0800 | [diff] [blame] | 272 | rtc::PacketTransportInternal* rtp_packet_transport, |
| 273 | rtc::PacketTransportInternal* rtcp_packet_transport) { |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 274 | RTC_DCHECK(network_thread_->IsCurrent()); |
| 275 | // Validate some assertions about the input. |
| 276 | RTC_DCHECK(rtp_packet_transport); |
| 277 | RTC_DCHECK_EQ(NeedsRtcpTransport(), rtcp_packet_transport != nullptr); |
| 278 | if (rtp_dtls_transport || rtcp_dtls_transport) { |
| 279 | // DTLS/non-DTLS pointers should be to the same object. |
| 280 | RTC_DCHECK(rtp_dtls_transport == rtp_packet_transport); |
| 281 | RTC_DCHECK(rtcp_dtls_transport == rtcp_packet_transport); |
| 282 | // Can't go from non-DTLS to DTLS. |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 283 | RTC_DCHECK(!rtp_transport_->rtp_packet_transport() || rtp_dtls_transport_); |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 284 | } else { |
| 285 | // Can't go from DTLS to non-DTLS. |
| 286 | RTC_DCHECK(!rtp_dtls_transport_); |
| 287 | } |
| 288 | // Transport names should be the same. |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 289 | if (rtp_dtls_transport && rtcp_dtls_transport) { |
| 290 | RTC_DCHECK(rtp_dtls_transport->transport_name() == |
| 291 | rtcp_dtls_transport->transport_name()); |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 292 | } |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 293 | std::string debug_name; |
| 294 | if (rtp_dtls_transport) { |
| 295 | transport_name_ = rtp_dtls_transport->transport_name(); |
| 296 | debug_name = transport_name_; |
| 297 | } else { |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 298 | debug_name = rtp_packet_transport->transport_name(); |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 299 | } |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 300 | if (rtp_packet_transport == rtp_transport_->rtp_packet_transport()) { |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 301 | // Nothing to do if transport isn't changing. |
deadbeef | bad5dad | 2017-01-17 18:32:35 -0800 | [diff] [blame] | 302 | return; |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 303 | } |
| 304 | |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 305 | // When using DTLS-SRTP, we must reset the SrtpTransport every time the |
| 306 | // DtlsTransport changes and wait until the DTLS handshake is complete to set |
| 307 | // the newly negotiated parameters. |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 308 | if (ShouldSetupDtlsSrtp_n()) { |
guoweis | 4638331 | 2015-12-17 16:45:59 -0800 | [diff] [blame] | 309 | // Set |writable_| to false such that UpdateWritableState_w can set up |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 310 | // DTLS-SRTP when |writable_| becomes true again. |
guoweis | 4638331 | 2015-12-17 16:45:59 -0800 | [diff] [blame] | 311 | writable_ = false; |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 312 | dtls_active_ = false; |
| 313 | if (srtp_transport_) { |
| 314 | srtp_transport_->ResetParams(); |
| 315 | } |
Guo-wei Shieh | 1218d7a | 2015-12-05 09:59:56 -0800 | [diff] [blame] | 316 | } |
| 317 | |
deadbeef | ac22f70 | 2017-01-12 21:59:29 -0800 | [diff] [blame] | 318 | // If this BaseChannel doesn't require RTCP mux and we haven't fully |
| 319 | // negotiated RTCP mux, we need an RTCP transport. |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 320 | if (rtcp_packet_transport) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 321 | RTC_LOG(LS_INFO) << "Setting RTCP Transport for " << content_name() |
| 322 | << " on " << debug_name << " transport " |
| 323 | << rtcp_packet_transport; |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 324 | SetTransport_n(true, rtcp_dtls_transport, rtcp_packet_transport); |
pthatcher@webrtc.org | 6ad507a | 2015-03-16 20:19:12 +0000 | [diff] [blame] | 325 | } |
| 326 | |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 327 | RTC_LOG(LS_INFO) << "Setting RTP Transport for " << content_name() << " on " |
| 328 | << debug_name << " transport " << rtp_packet_transport; |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 329 | SetTransport_n(false, rtp_dtls_transport, rtp_packet_transport); |
guoweis | 4638331 | 2015-12-17 16:45:59 -0800 | [diff] [blame] | 330 | |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 331 | // Update aggregate writable/ready-to-send state between RTP and RTCP upon |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 332 | // setting new transport channels. |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 333 | UpdateWritableState_n(); |
pthatcher@webrtc.org | 6ad507a | 2015-03-16 20:19:12 +0000 | [diff] [blame] | 334 | } |
| 335 | |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 336 | void BaseChannel::SetTransport_n( |
| 337 | bool rtcp, |
| 338 | DtlsTransportInternal* new_dtls_transport, |
deadbeef | 5bd5ca3 | 2017-02-10 11:31:50 -0800 | [diff] [blame] | 339 | rtc::PacketTransportInternal* new_packet_transport) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 340 | RTC_DCHECK(network_thread_->IsCurrent()); |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 341 | if (new_dtls_transport) { |
| 342 | RTC_DCHECK(new_dtls_transport == new_packet_transport); |
| 343 | } |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 344 | DtlsTransportInternal*& old_dtls_transport = |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 345 | rtcp ? rtcp_dtls_transport_ : rtp_dtls_transport_; |
zstein | d48dbda | 2017-04-04 19:45:57 -0700 | [diff] [blame] | 346 | rtc::PacketTransportInternal* old_packet_transport = |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 347 | rtcp ? rtp_transport_->rtcp_packet_transport() |
| 348 | : rtp_transport_->rtp_packet_transport(); |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 349 | |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 350 | if (!old_packet_transport && !new_packet_transport) { |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 351 | // Nothing to do. |
pthatcher@webrtc.org | 6ad507a | 2015-03-16 20:19:12 +0000 | [diff] [blame] | 352 | return; |
| 353 | } |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 354 | |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 355 | RTC_DCHECK(old_packet_transport != new_packet_transport); |
| 356 | if (old_dtls_transport) { |
| 357 | DisconnectFromDtlsTransport(old_dtls_transport); |
| 358 | } else if (old_packet_transport) { |
| 359 | DisconnectFromPacketTransport(old_packet_transport); |
pthatcher@webrtc.org | 6ad507a | 2015-03-16 20:19:12 +0000 | [diff] [blame] | 360 | } |
| 361 | |
zstein | d48dbda | 2017-04-04 19:45:57 -0700 | [diff] [blame] | 362 | if (rtcp) { |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 363 | rtp_transport_->SetRtcpPacketTransport(new_packet_transport); |
zstein | d48dbda | 2017-04-04 19:45:57 -0700 | [diff] [blame] | 364 | } else { |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 365 | rtp_transport_->SetRtpPacketTransport(new_packet_transport); |
zstein | d48dbda | 2017-04-04 19:45:57 -0700 | [diff] [blame] | 366 | } |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 367 | old_dtls_transport = new_dtls_transport; |
pthatcher@webrtc.org | 6ad507a | 2015-03-16 20:19:12 +0000 | [diff] [blame] | 368 | |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 369 | // If there's no new transport, we're done after disconnecting from old one. |
| 370 | if (!new_packet_transport) { |
| 371 | return; |
| 372 | } |
| 373 | |
| 374 | if (rtcp && new_dtls_transport) { |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 375 | RTC_CHECK(!(ShouldSetupDtlsSrtp_n() && srtp_active())) |
| 376 | << "Setting RTCP for DTLS/SRTP after the DTLS is active " |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 377 | << "should never happen."; |
| 378 | } |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 379 | |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 380 | if (new_dtls_transport) { |
| 381 | ConnectToDtlsTransport(new_dtls_transport); |
| 382 | } else { |
| 383 | ConnectToPacketTransport(new_packet_transport); |
| 384 | } |
| 385 | auto& socket_options = rtcp ? rtcp_socket_options_ : socket_options_; |
| 386 | for (const auto& pair : socket_options) { |
| 387 | new_packet_transport->SetOption(pair.first, pair.second); |
guoweis | 4638331 | 2015-12-17 16:45:59 -0800 | [diff] [blame] | 388 | } |
pthatcher@webrtc.org | 6ad507a | 2015-03-16 20:19:12 +0000 | [diff] [blame] | 389 | } |
| 390 | |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 391 | void BaseChannel::ConnectToDtlsTransport(DtlsTransportInternal* transport) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 392 | RTC_DCHECK(network_thread_->IsCurrent()); |
pthatcher@webrtc.org | 6ad507a | 2015-03-16 20:19:12 +0000 | [diff] [blame] | 393 | |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 394 | // TODO(zstein): de-dup with ConnectToPacketTransport |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 395 | transport->SignalWritableState.connect(this, &BaseChannel::OnWritableState); |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 396 | transport->SignalDtlsState.connect(this, &BaseChannel::OnDtlsState); |
| 397 | transport->SignalSentPacket.connect(this, &BaseChannel::SignalSentPacket_n); |
pthatcher@webrtc.org | 6ad507a | 2015-03-16 20:19:12 +0000 | [diff] [blame] | 398 | } |
| 399 | |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 400 | void BaseChannel::DisconnectFromDtlsTransport( |
| 401 | DtlsTransportInternal* transport) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 402 | RTC_DCHECK(network_thread_->IsCurrent()); |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 403 | transport->SignalWritableState.disconnect(this); |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 404 | transport->SignalDtlsState.disconnect(this); |
| 405 | transport->SignalSentPacket.disconnect(this); |
pthatcher@webrtc.org | 6ad507a | 2015-03-16 20:19:12 +0000 | [diff] [blame] | 406 | } |
| 407 | |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 408 | void BaseChannel::ConnectToPacketTransport( |
deadbeef | 5bd5ca3 | 2017-02-10 11:31:50 -0800 | [diff] [blame] | 409 | rtc::PacketTransportInternal* transport) { |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 410 | RTC_DCHECK_RUN_ON(network_thread_); |
| 411 | transport->SignalWritableState.connect(this, &BaseChannel::OnWritableState); |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 412 | transport->SignalSentPacket.connect(this, &BaseChannel::SignalSentPacket_n); |
| 413 | } |
| 414 | |
| 415 | void BaseChannel::DisconnectFromPacketTransport( |
deadbeef | 5bd5ca3 | 2017-02-10 11:31:50 -0800 | [diff] [blame] | 416 | rtc::PacketTransportInternal* transport) { |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 417 | RTC_DCHECK_RUN_ON(network_thread_); |
| 418 | transport->SignalWritableState.disconnect(this); |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 419 | transport->SignalSentPacket.disconnect(this); |
| 420 | } |
| 421 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 422 | bool BaseChannel::Enable(bool enable) { |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 423 | worker_thread_->Invoke<void>( |
| 424 | RTC_FROM_HERE, |
| 425 | Bind(enable ? &BaseChannel::EnableMedia_w : &BaseChannel::DisableMedia_w, |
| 426 | this)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 427 | return true; |
| 428 | } |
| 429 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 430 | bool BaseChannel::AddRecvStream(const StreamParams& sp) { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 431 | return InvokeOnWorker<bool>(RTC_FROM_HERE, |
| 432 | Bind(&BaseChannel::AddRecvStream_w, this, sp)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 433 | } |
| 434 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 435 | bool BaseChannel::RemoveRecvStream(uint32_t ssrc) { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 436 | return InvokeOnWorker<bool>( |
| 437 | RTC_FROM_HERE, Bind(&BaseChannel::RemoveRecvStream_w, this, ssrc)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 438 | } |
| 439 | |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 440 | bool BaseChannel::AddSendStream(const StreamParams& sp) { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 441 | return InvokeOnWorker<bool>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 442 | RTC_FROM_HERE, Bind(&MediaChannel::AddSendStream, media_channel(), sp)); |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 443 | } |
| 444 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 445 | bool BaseChannel::RemoveSendStream(uint32_t ssrc) { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 446 | return InvokeOnWorker<bool>( |
| 447 | RTC_FROM_HERE, |
| 448 | Bind(&MediaChannel::RemoveSendStream, media_channel(), ssrc)); |
wu@webrtc.org | cadf904 | 2013-08-30 21:24:16 +0000 | [diff] [blame] | 449 | } |
| 450 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 451 | bool BaseChannel::SetLocalContent(const MediaContentDescription* content, |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 452 | ContentAction action, |
| 453 | std::string* error_desc) { |
Peter Boström | 9f45a45 | 2015-12-08 13:25:57 +0100 | [diff] [blame] | 454 | TRACE_EVENT0("webrtc", "BaseChannel::SetLocalContent"); |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 455 | return InvokeOnWorker<bool>( |
| 456 | RTC_FROM_HERE, |
| 457 | Bind(&BaseChannel::SetLocalContent_w, this, content, action, error_desc)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 458 | } |
| 459 | |
| 460 | bool BaseChannel::SetRemoteContent(const MediaContentDescription* content, |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 461 | ContentAction action, |
| 462 | std::string* error_desc) { |
Peter Boström | 9f45a45 | 2015-12-08 13:25:57 +0100 | [diff] [blame] | 463 | TRACE_EVENT0("webrtc", "BaseChannel::SetRemoteContent"); |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 464 | return InvokeOnWorker<bool>( |
| 465 | RTC_FROM_HERE, Bind(&BaseChannel::SetRemoteContent_w, this, content, |
| 466 | action, error_desc)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 467 | } |
| 468 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 469 | void BaseChannel::StartConnectionMonitor(int cms) { |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 470 | // We pass in the BaseChannel instead of the rtp_dtls_transport_ |
| 471 | // because if the rtp_dtls_transport_ changes, the ConnectionMonitor |
pthatcher@webrtc.org | b4aac13 | 2015-03-13 18:25:21 +0000 | [diff] [blame] | 472 | // would be pointing to the wrong TransportChannel. |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 473 | // We pass in the network thread because on that thread connection monitor |
| 474 | // will call BaseChannel::GetConnectionStats which must be called on the |
| 475 | // network thread. |
| 476 | connection_monitor_.reset( |
| 477 | new ConnectionMonitor(this, network_thread(), rtc::Thread::Current())); |
pthatcher@webrtc.org | b4aac13 | 2015-03-13 18:25:21 +0000 | [diff] [blame] | 478 | connection_monitor_->SignalUpdate.connect( |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 479 | this, &BaseChannel::OnConnectionMonitorUpdate); |
pthatcher@webrtc.org | b4aac13 | 2015-03-13 18:25:21 +0000 | [diff] [blame] | 480 | connection_monitor_->Start(cms); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 481 | } |
| 482 | |
| 483 | void BaseChannel::StopConnectionMonitor() { |
pthatcher@webrtc.org | b4aac13 | 2015-03-13 18:25:21 +0000 | [diff] [blame] | 484 | if (connection_monitor_) { |
| 485 | connection_monitor_->Stop(); |
| 486 | connection_monitor_.reset(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 487 | } |
| 488 | } |
| 489 | |
pthatcher@webrtc.org | b4aac13 | 2015-03-13 18:25:21 +0000 | [diff] [blame] | 490 | bool BaseChannel::GetConnectionStats(ConnectionInfos* infos) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 491 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 492 | if (!rtp_dtls_transport_) { |
| 493 | return false; |
| 494 | } |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 495 | return rtp_dtls_transport_->ice_transport()->GetStats(infos); |
zhihuang | f5b251b | 2017-01-12 19:37:48 -0800 | [diff] [blame] | 496 | } |
| 497 | |
| 498 | bool BaseChannel::NeedsRtcpTransport() { |
deadbeef | ac22f70 | 2017-01-12 21:59:29 -0800 | [diff] [blame] | 499 | // If this BaseChannel doesn't require RTCP mux and we haven't fully |
| 500 | // negotiated RTCP mux, we need an RTCP transport. |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 501 | return !rtcp_mux_required_ && !rtcp_mux_filter_.IsFullyActive(); |
pthatcher@webrtc.org | b4aac13 | 2015-03-13 18:25:21 +0000 | [diff] [blame] | 502 | } |
| 503 | |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 504 | bool BaseChannel::IsReadyToReceiveMedia_w() const { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 505 | // Receive data if we are enabled and have local content, |
Steve Anton | 4e70a72 | 2017-11-28 14:57:10 -0800 | [diff] [blame] | 506 | return enabled() && |
| 507 | webrtc::RtpTransceiverDirectionHasRecv(local_content_direction_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 508 | } |
| 509 | |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 510 | bool BaseChannel::IsReadyToSendMedia_w() const { |
| 511 | // Need to access some state updated on the network thread. |
| 512 | return network_thread_->Invoke<bool>( |
| 513 | RTC_FROM_HERE, Bind(&BaseChannel::IsReadyToSendMedia_n, this)); |
| 514 | } |
| 515 | |
| 516 | bool BaseChannel::IsReadyToSendMedia_n() const { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 517 | // Send outgoing data if we are enabled, have local and remote content, |
| 518 | // and we have had some form of connectivity. |
Steve Anton | 4e70a72 | 2017-11-28 14:57:10 -0800 | [diff] [blame] | 519 | return enabled() && |
| 520 | webrtc::RtpTransceiverDirectionHasRecv(remote_content_direction_) && |
| 521 | webrtc::RtpTransceiverDirectionHasSend(local_content_direction_) && |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 522 | was_ever_writable() && (srtp_active() || !ShouldSetupDtlsSrtp_n()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 523 | } |
| 524 | |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 525 | bool BaseChannel::SendPacket(rtc::CopyOnWriteBuffer* packet, |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 526 | const rtc::PacketOptions& options) { |
| 527 | return SendPacket(false, packet, options); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 528 | } |
| 529 | |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 530 | bool BaseChannel::SendRtcp(rtc::CopyOnWriteBuffer* packet, |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 531 | const rtc::PacketOptions& options) { |
| 532 | return SendPacket(true, packet, options); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 533 | } |
| 534 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 535 | int BaseChannel::SetOption(SocketType type, rtc::Socket::Option opt, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 536 | int value) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 537 | return network_thread_->Invoke<int>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 538 | RTC_FROM_HERE, Bind(&BaseChannel::SetOption_n, this, type, opt, value)); |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 539 | } |
| 540 | |
| 541 | int BaseChannel::SetOption_n(SocketType type, |
| 542 | rtc::Socket::Option opt, |
| 543 | int value) { |
| 544 | RTC_DCHECK(network_thread_->IsCurrent()); |
deadbeef | 5bd5ca3 | 2017-02-10 11:31:50 -0800 | [diff] [blame] | 545 | rtc::PacketTransportInternal* transport = nullptr; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 546 | switch (type) { |
wu@webrtc.org | 9caf276 | 2013-12-11 18:25:07 +0000 | [diff] [blame] | 547 | case ST_RTP: |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 548 | transport = rtp_transport_->rtp_packet_transport(); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 549 | socket_options_.push_back( |
| 550 | std::pair<rtc::Socket::Option, int>(opt, value)); |
wu@webrtc.org | 9caf276 | 2013-12-11 18:25:07 +0000 | [diff] [blame] | 551 | break; |
| 552 | case ST_RTCP: |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 553 | transport = rtp_transport_->rtcp_packet_transport(); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 554 | rtcp_socket_options_.push_back( |
| 555 | std::pair<rtc::Socket::Option, int>(opt, value)); |
wu@webrtc.org | 9caf276 | 2013-12-11 18:25:07 +0000 | [diff] [blame] | 556 | break; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 557 | } |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 558 | return transport ? transport->SetOption(opt, value) : -1; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 559 | } |
| 560 | |
deadbeef | 5bd5ca3 | 2017-02-10 11:31:50 -0800 | [diff] [blame] | 561 | void BaseChannel::OnWritableState(rtc::PacketTransportInternal* transport) { |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 562 | RTC_DCHECK(transport == rtp_transport_->rtp_packet_transport() || |
| 563 | transport == rtp_transport_->rtcp_packet_transport()); |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 564 | RTC_DCHECK(network_thread_->IsCurrent()); |
| 565 | UpdateWritableState_n(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 566 | } |
| 567 | |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 568 | void BaseChannel::OnDtlsState(DtlsTransportInternal* transport, |
Guo-wei Shieh | 1218d7a | 2015-12-05 09:59:56 -0800 | [diff] [blame] | 569 | DtlsTransportState state) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 570 | if (!ShouldSetupDtlsSrtp_n()) { |
Guo-wei Shieh | 1218d7a | 2015-12-05 09:59:56 -0800 | [diff] [blame] | 571 | return; |
| 572 | } |
| 573 | |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 574 | // Reset the SrtpTransport if it's not the CONNECTED state. For the CONNECTED |
Guo-wei Shieh | 1218d7a | 2015-12-05 09:59:56 -0800 | [diff] [blame] | 575 | // state, setting up DTLS-SRTP context is deferred to ChannelWritable_w to |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 576 | // cover other scenarios like the whole transport is writable (not just this |
Guo-wei Shieh | 1218d7a | 2015-12-05 09:59:56 -0800 | [diff] [blame] | 577 | // TransportChannel) or when TransportChannel is attached after DTLS is |
| 578 | // negotiated. |
| 579 | if (state != DTLS_TRANSPORT_CONNECTED) { |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 580 | dtls_active_ = false; |
| 581 | if (srtp_transport_) { |
| 582 | srtp_transport_->ResetParams(); |
| 583 | } |
Guo-wei Shieh | 1218d7a | 2015-12-05 09:59:56 -0800 | [diff] [blame] | 584 | } |
| 585 | } |
| 586 | |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 587 | void BaseChannel::OnNetworkRouteChanged( |
| 588 | rtc::Optional<rtc::NetworkRoute> network_route) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 589 | RTC_DCHECK(network_thread_->IsCurrent()); |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 590 | rtc::NetworkRoute new_route; |
| 591 | if (network_route) { |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 592 | new_route = *(network_route); |
Zhi Huang | 8c316c1 | 2017-11-13 21:13:45 +0000 | [diff] [blame] | 593 | } |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 594 | // Note: When the RTCP-muxing is not enabled, RTCP transport and RTP transport |
| 595 | // use the same transport name and MediaChannel::OnNetworkRouteChanged cannot |
| 596 | // work correctly. Intentionally leave it broken to simplify the code and |
| 597 | // encourage the users to stop using non-muxing RTCP. |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 598 | invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_, [=] { |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 599 | media_channel_->OnNetworkRouteChanged(transport_name_, new_route); |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 600 | }); |
Honghai Zhang | cc411c0 | 2016-03-29 17:27:21 -0700 | [diff] [blame] | 601 | } |
| 602 | |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 603 | void BaseChannel::OnTransportReadyToSend(bool ready) { |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 604 | invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_, |
| 605 | [=] { media_channel_->OnReadyToSend(ready); }); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 606 | } |
| 607 | |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 608 | bool BaseChannel::SendPacket(bool rtcp, |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 609 | rtc::CopyOnWriteBuffer* packet, |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 610 | const rtc::PacketOptions& options) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 611 | // SendPacket gets called from MediaEngine, on a pacer or an encoder thread. |
| 612 | // If the thread is not our network thread, we will post to our network |
| 613 | // so that the real work happens on our network. This avoids us having to |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 614 | // synchronize access to all the pieces of the send path, including |
| 615 | // SRTP and the inner workings of the transport channels. |
| 616 | // The only downside is that we can't return a proper failure code if |
| 617 | // needed. Since UDP is unreliable anyway, this should be a non-issue. |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 618 | if (!network_thread_->IsCurrent()) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 619 | // Avoid a copy by transferring the ownership of the packet data. |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 620 | int message_id = rtcp ? MSG_SEND_RTCP_PACKET : MSG_SEND_RTP_PACKET; |
| 621 | SendPacketMessageData* data = new SendPacketMessageData; |
kwiberg | 0eb15ed | 2015-12-17 03:04:15 -0800 | [diff] [blame] | 622 | data->packet = std::move(*packet); |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 623 | data->options = options; |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 624 | network_thread_->Post(RTC_FROM_HERE, this, message_id, data); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 625 | return true; |
| 626 | } |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 627 | TRACE_EVENT0("webrtc", "BaseChannel::SendPacket"); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 628 | |
| 629 | // Now that we are on the correct thread, ensure we have a place to send this |
| 630 | // packet before doing anything. (We might get RTCP packets that we don't |
| 631 | // intend to send.) If we've negotiated RTCP mux, send RTCP over the RTP |
| 632 | // transport. |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 633 | if (!rtp_transport_->IsWritable(rtcp)) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 634 | return false; |
| 635 | } |
| 636 | |
| 637 | // Protect ourselves against crazy data. |
| 638 | if (!ValidPacket(rtcp, packet)) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 639 | RTC_LOG(LS_ERROR) << "Dropping outgoing " << content_name_ << " " |
| 640 | << RtpRtcpStringLiteral(rtcp) |
| 641 | << " packet: wrong size=" << packet->size(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 642 | return false; |
| 643 | } |
| 644 | |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 645 | if (!srtp_active()) { |
| 646 | if (srtp_required_) { |
| 647 | // The audio/video engines may attempt to send RTCP packets as soon as the |
| 648 | // streams are created, so don't treat this as an error for RTCP. |
| 649 | // See: https://bugs.chromium.org/p/webrtc/issues/detail?id=6809 |
| 650 | if (rtcp) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 651 | return false; |
| 652 | } |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 653 | // However, there shouldn't be any RTP packets sent before SRTP is set up |
| 654 | // (and SetSend(true) is called). |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 655 | RTC_LOG(LS_ERROR) |
| 656 | << "Can't send outgoing RTP packet when SRTP is inactive" |
| 657 | << " and crypto is required"; |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 658 | RTC_NOTREACHED(); |
deadbeef | 8f425f9 | 2016-12-01 12:26:27 -0800 | [diff] [blame] | 659 | return false; |
| 660 | } |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 661 | // Bon voyage. |
Zhi Huang | 04eaa15 | 2017-10-04 14:08:30 -0700 | [diff] [blame] | 662 | return rtcp |
| 663 | ? rtp_transport_->SendRtcpPacket(packet, options, PF_SRTP_BYPASS) |
| 664 | : rtp_transport_->SendRtpPacket(packet, options, PF_SRTP_BYPASS); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 665 | } |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 666 | RTC_DCHECK(srtp_transport_); |
| 667 | RTC_DCHECK(srtp_transport_->IsActive()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 668 | // Bon voyage. |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 669 | return rtcp ? srtp_transport_->SendRtcpPacket(packet, options, PF_SRTP_BYPASS) |
| 670 | : srtp_transport_->SendRtpPacket(packet, options, PF_SRTP_BYPASS); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 671 | } |
| 672 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 673 | bool BaseChannel::HandlesPayloadType(int packet_type) const { |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 674 | return rtp_transport_->HandlesPayloadType(packet_type); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 675 | } |
| 676 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 677 | void BaseChannel::OnPacketReceived(bool rtcp, |
zstein | 634977b | 2017-07-14 12:30:04 -0700 | [diff] [blame] | 678 | rtc::CopyOnWriteBuffer* packet, |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 679 | const rtc::PacketTime& packet_time) { |
honghaiz@google.com | a67ca1a | 2015-01-28 19:48:33 +0000 | [diff] [blame] | 680 | if (!has_received_packet_ && !rtcp) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 681 | has_received_packet_ = true; |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 682 | signaling_thread()->Post(RTC_FROM_HERE, this, MSG_FIRSTPACKETRECEIVED); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 683 | } |
| 684 | |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 685 | if (!srtp_active() && srtp_required_) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 686 | // Our session description indicates that SRTP is required, but we got a |
| 687 | // packet before our SRTP filter is active. This means either that |
| 688 | // a) we got SRTP packets before we received the SDES keys, in which case |
| 689 | // we can't decrypt it anyway, or |
| 690 | // b) we got SRTP packets before DTLS completed on both the RTP and RTCP |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 691 | // transports, so we haven't yet extracted keys, even if DTLS did |
| 692 | // complete on the transport that the packets are being sent on. It's |
| 693 | // really good practice to wait for both RTP and RTCP to be good to go |
| 694 | // before sending media, to prevent weird failure modes, so it's fine |
| 695 | // for us to just eat packets here. This is all sidestepped if RTCP mux |
| 696 | // is used anyway. |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 697 | RTC_LOG(LS_WARNING) |
| 698 | << "Can't process incoming " << RtpRtcpStringLiteral(rtcp) |
| 699 | << " packet when SRTP is inactive and crypto is required"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 700 | return; |
| 701 | } |
| 702 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 703 | invoker_.AsyncInvoke<void>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 704 | RTC_FROM_HERE, worker_thread_, |
zstein | 634977b | 2017-07-14 12:30:04 -0700 | [diff] [blame] | 705 | Bind(&BaseChannel::ProcessPacket, this, rtcp, *packet, packet_time)); |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 706 | } |
| 707 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 708 | void BaseChannel::ProcessPacket(bool rtcp, |
| 709 | const rtc::CopyOnWriteBuffer& packet, |
| 710 | const rtc::PacketTime& packet_time) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 711 | RTC_DCHECK(worker_thread_->IsCurrent()); |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 712 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 713 | // Need to copy variable because OnRtcpReceived/OnPacketReceived |
| 714 | // requires non-const pointer to buffer. This doesn't memcpy the actual data. |
| 715 | rtc::CopyOnWriteBuffer data(packet); |
| 716 | if (rtcp) { |
| 717 | media_channel_->OnRtcpReceived(&data, packet_time); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 718 | } else { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 719 | media_channel_->OnPacketReceived(&data, packet_time); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 720 | } |
| 721 | } |
| 722 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 723 | void BaseChannel::EnableMedia_w() { |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 724 | RTC_DCHECK(worker_thread_ == rtc::Thread::Current()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 725 | if (enabled_) |
| 726 | return; |
| 727 | |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 728 | RTC_LOG(LS_INFO) << "Channel enabled"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 729 | enabled_ = true; |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 730 | UpdateMediaSendRecvState_w(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 731 | } |
| 732 | |
| 733 | void BaseChannel::DisableMedia_w() { |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 734 | RTC_DCHECK(worker_thread_ == rtc::Thread::Current()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 735 | if (!enabled_) |
| 736 | return; |
| 737 | |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 738 | RTC_LOG(LS_INFO) << "Channel disabled"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 739 | enabled_ = false; |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 740 | UpdateMediaSendRecvState_w(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 741 | } |
| 742 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 743 | void BaseChannel::UpdateWritableState_n() { |
zstein | d48dbda | 2017-04-04 19:45:57 -0700 | [diff] [blame] | 744 | rtc::PacketTransportInternal* rtp_packet_transport = |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 745 | rtp_transport_->rtp_packet_transport(); |
zstein | d48dbda | 2017-04-04 19:45:57 -0700 | [diff] [blame] | 746 | rtc::PacketTransportInternal* rtcp_packet_transport = |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 747 | rtp_transport_->rtcp_packet_transport(); |
zstein | d48dbda | 2017-04-04 19:45:57 -0700 | [diff] [blame] | 748 | if (rtp_packet_transport && rtp_packet_transport->writable() && |
| 749 | (!rtcp_packet_transport || rtcp_packet_transport->writable())) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 750 | ChannelWritable_n(); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 751 | } else { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 752 | ChannelNotWritable_n(); |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 753 | } |
| 754 | } |
| 755 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 756 | void BaseChannel::ChannelWritable_n() { |
| 757 | RTC_DCHECK(network_thread_->IsCurrent()); |
Guo-wei Shieh | 1218d7a | 2015-12-05 09:59:56 -0800 | [diff] [blame] | 758 | if (writable_) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 759 | return; |
Guo-wei Shieh | 1218d7a | 2015-12-05 09:59:56 -0800 | [diff] [blame] | 760 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 761 | |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 762 | RTC_LOG(LS_INFO) << "Channel writable (" << content_name_ << ")" |
| 763 | << (was_ever_writable_ ? "" : " for the first time"); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 764 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 765 | was_ever_writable_ = true; |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 766 | MaybeSetupDtlsSrtp_n(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 767 | writable_ = true; |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 768 | UpdateMediaSendRecvState(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 769 | } |
| 770 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 771 | void BaseChannel::SignalDtlsSrtpSetupFailure_n(bool rtcp) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 772 | RTC_DCHECK(network_thread_->IsCurrent()); |
| 773 | invoker_.AsyncInvoke<void>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 774 | RTC_FROM_HERE, signaling_thread(), |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 775 | Bind(&BaseChannel::SignalDtlsSrtpSetupFailure_s, this, rtcp)); |
pthatcher@webrtc.org | 4eeef58 | 2015-03-16 19:34:23 +0000 | [diff] [blame] | 776 | } |
| 777 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 778 | void BaseChannel::SignalDtlsSrtpSetupFailure_s(bool rtcp) { |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 779 | RTC_DCHECK(signaling_thread() == rtc::Thread::Current()); |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 780 | SignalDtlsSrtpSetupFailure(this, rtcp); |
pthatcher@webrtc.org | 4eeef58 | 2015-03-16 19:34:23 +0000 | [diff] [blame] | 781 | } |
| 782 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 783 | bool BaseChannel::ShouldSetupDtlsSrtp_n() const { |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 784 | // Since DTLS is applied to all transports, checking RTP should be enough. |
| 785 | return rtp_dtls_transport_ && rtp_dtls_transport_->IsDtlsActive(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 786 | } |
| 787 | |
| 788 | // This function returns true if either DTLS-SRTP is not in use |
| 789 | // *or* DTLS-SRTP is successfully set up. |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 790 | bool BaseChannel::SetupDtlsSrtp_n(bool rtcp) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 791 | RTC_DCHECK(network_thread_->IsCurrent()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 792 | bool ret = false; |
| 793 | |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 794 | DtlsTransportInternal* transport = |
| 795 | rtcp ? rtcp_dtls_transport_ : rtp_dtls_transport_; |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 796 | RTC_DCHECK(transport); |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 797 | RTC_DCHECK(transport->IsDtlsActive()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 798 | |
Guo-wei Shieh | 521ed7b | 2015-11-18 19:41:53 -0800 | [diff] [blame] | 799 | int selected_crypto_suite; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 800 | |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 801 | if (!transport->GetSrtpCryptoSuite(&selected_crypto_suite)) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 802 | RTC_LOG(LS_ERROR) << "No DTLS-SRTP selected crypto suite"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 803 | return false; |
| 804 | } |
| 805 | |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 806 | RTC_LOG(LS_INFO) << "Installing keys from DTLS-SRTP on " << content_name() |
| 807 | << " " << RtpRtcpStringLiteral(rtcp); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 808 | |
jbauch | cb56065 | 2016-08-04 05:20:32 -0700 | [diff] [blame] | 809 | int key_len; |
| 810 | int salt_len; |
| 811 | if (!rtc::GetSrtpKeyAndSaltLengths(selected_crypto_suite, &key_len, |
| 812 | &salt_len)) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 813 | RTC_LOG(LS_ERROR) << "Unknown DTLS-SRTP crypto suite" |
| 814 | << selected_crypto_suite; |
jbauch | cb56065 | 2016-08-04 05:20:32 -0700 | [diff] [blame] | 815 | return false; |
| 816 | } |
| 817 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 818 | // OK, we're now doing DTLS (RFC 5764) |
jbauch | cb56065 | 2016-08-04 05:20:32 -0700 | [diff] [blame] | 819 | std::vector<unsigned char> dtls_buffer(key_len * 2 + salt_len * 2); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 820 | |
| 821 | // RFC 5705 exporter using the RFC 5764 parameters |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 822 | if (!transport->ExportKeyingMaterial(kDtlsSrtpExporterLabel, NULL, 0, false, |
| 823 | &dtls_buffer[0], dtls_buffer.size())) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 824 | RTC_LOG(LS_WARNING) << "DTLS-SRTP key export failed"; |
nisse | eb4ca4e | 2017-01-12 02:24:27 -0800 | [diff] [blame] | 825 | RTC_NOTREACHED(); // This should never happen |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 826 | return false; |
| 827 | } |
| 828 | |
| 829 | // Sync up the keys with the DTLS-SRTP interface |
jbauch | cb56065 | 2016-08-04 05:20:32 -0700 | [diff] [blame] | 830 | std::vector<unsigned char> client_write_key(key_len + salt_len); |
| 831 | std::vector<unsigned char> server_write_key(key_len + salt_len); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 832 | size_t offset = 0; |
jbauch | cb56065 | 2016-08-04 05:20:32 -0700 | [diff] [blame] | 833 | memcpy(&client_write_key[0], &dtls_buffer[offset], key_len); |
| 834 | offset += key_len; |
| 835 | memcpy(&server_write_key[0], &dtls_buffer[offset], key_len); |
| 836 | offset += key_len; |
| 837 | memcpy(&client_write_key[key_len], &dtls_buffer[offset], salt_len); |
| 838 | offset += salt_len; |
| 839 | memcpy(&server_write_key[key_len], &dtls_buffer[offset], salt_len); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 840 | |
| 841 | std::vector<unsigned char> *send_key, *recv_key; |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 842 | rtc::SSLRole role; |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 843 | if (!transport->GetSslRole(&role)) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 844 | RTC_LOG(LS_WARNING) << "GetSslRole failed"; |
sergeyu@chromium.org | 0be6aa0 | 2013-08-23 23:21:25 +0000 | [diff] [blame] | 845 | return false; |
| 846 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 847 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 848 | if (role == rtc::SSL_SERVER) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 849 | send_key = &server_write_key; |
| 850 | recv_key = &client_write_key; |
| 851 | } else { |
| 852 | send_key = &client_write_key; |
| 853 | recv_key = &server_write_key; |
| 854 | } |
| 855 | |
Zhi Huang | c99b6c7 | 2017-11-10 16:44:46 -0800 | [diff] [blame] | 856 | // Use an empty encrypted header extension ID vector if not set. This could |
| 857 | // happen when the DTLS handshake is completed before processing the |
| 858 | // Offer/Answer which contains the encrypted header extension IDs. |
| 859 | std::vector<int> send_extension_ids; |
| 860 | std::vector<int> recv_extension_ids; |
| 861 | if (catched_send_extension_ids_) { |
| 862 | send_extension_ids = *catched_send_extension_ids_; |
| 863 | } |
| 864 | if (catched_recv_extension_ids_) { |
| 865 | recv_extension_ids = *catched_recv_extension_ids_; |
| 866 | } |
| 867 | |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 868 | if (rtcp) { |
| 869 | if (!dtls_active()) { |
| 870 | RTC_DCHECK(srtp_transport_); |
| 871 | ret = srtp_transport_->SetRtcpParams( |
| 872 | selected_crypto_suite, &(*send_key)[0], |
Zhi Huang | c99b6c7 | 2017-11-10 16:44:46 -0800 | [diff] [blame] | 873 | static_cast<int>(send_key->size()), send_extension_ids, |
| 874 | selected_crypto_suite, &(*recv_key)[0], |
| 875 | static_cast<int>(recv_key->size()), recv_extension_ids); |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 876 | } else { |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 877 | // RTCP doesn't need to call SetRtpParam because it is only used |
| 878 | // to make the updated encrypted RTP header extension IDs take effect. |
| 879 | ret = true; |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 880 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 881 | } else { |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 882 | RTC_DCHECK(srtp_transport_); |
Zhi Huang | c99b6c7 | 2017-11-10 16:44:46 -0800 | [diff] [blame] | 883 | ret = srtp_transport_->SetRtpParams( |
| 884 | selected_crypto_suite, &(*send_key)[0], |
| 885 | static_cast<int>(send_key->size()), send_extension_ids, |
| 886 | selected_crypto_suite, &(*recv_key)[0], |
| 887 | static_cast<int>(recv_key->size()), recv_extension_ids); |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 888 | dtls_active_ = ret; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 889 | } |
| 890 | |
michaelt | 79e0588 | 2016-11-08 02:50:09 -0800 | [diff] [blame] | 891 | if (!ret) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 892 | RTC_LOG(LS_WARNING) << "DTLS-SRTP key installation failed"; |
michaelt | 79e0588 | 2016-11-08 02:50:09 -0800 | [diff] [blame] | 893 | } |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 894 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 895 | return ret; |
| 896 | } |
| 897 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 898 | void BaseChannel::MaybeSetupDtlsSrtp_n() { |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 899 | if (dtls_active()) { |
Guo-wei Shieh | 1218d7a | 2015-12-05 09:59:56 -0800 | [diff] [blame] | 900 | return; |
| 901 | } |
| 902 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 903 | if (!ShouldSetupDtlsSrtp_n()) { |
Guo-wei Shieh | 1218d7a | 2015-12-05 09:59:56 -0800 | [diff] [blame] | 904 | return; |
| 905 | } |
| 906 | |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 907 | if (!srtp_transport_) { |
| 908 | EnableSrtpTransport_n(); |
| 909 | } |
| 910 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 911 | if (!SetupDtlsSrtp_n(false)) { |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 912 | SignalDtlsSrtpSetupFailure_n(false); |
Guo-wei Shieh | 1218d7a | 2015-12-05 09:59:56 -0800 | [diff] [blame] | 913 | return; |
| 914 | } |
| 915 | |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 916 | if (rtcp_dtls_transport_) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 917 | if (!SetupDtlsSrtp_n(true)) { |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 918 | SignalDtlsSrtpSetupFailure_n(true); |
Guo-wei Shieh | 1218d7a | 2015-12-05 09:59:56 -0800 | [diff] [blame] | 919 | return; |
| 920 | } |
| 921 | } |
| 922 | } |
| 923 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 924 | void BaseChannel::ChannelNotWritable_n() { |
| 925 | RTC_DCHECK(network_thread_->IsCurrent()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 926 | if (!writable_) |
| 927 | return; |
| 928 | |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 929 | RTC_LOG(LS_INFO) << "Channel not writable (" << content_name_ << ")"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 930 | writable_ = false; |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 931 | UpdateMediaSendRecvState(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 932 | } |
| 933 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 934 | bool BaseChannel::SetRtpTransportParameters( |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 935 | const MediaContentDescription* content, |
| 936 | ContentAction action, |
| 937 | ContentSource src, |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 938 | const RtpHeaderExtensions& extensions, |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 939 | std::string* error_desc) { |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 940 | std::vector<int> encrypted_extension_ids; |
| 941 | for (const webrtc::RtpExtension& extension : extensions) { |
| 942 | if (extension.encrypt) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 943 | RTC_LOG(LS_INFO) << "Using " << (src == CS_LOCAL ? "local" : "remote") |
| 944 | << " encrypted extension: " << extension.ToString(); |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 945 | encrypted_extension_ids.push_back(extension.id); |
| 946 | } |
| 947 | } |
| 948 | |
deadbeef | 7af91dd | 2016-12-13 11:29:11 -0800 | [diff] [blame] | 949 | // Cache srtp_required_ for belt and suspenders check on SendPacket |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 950 | return network_thread_->Invoke<bool>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 951 | RTC_FROM_HERE, Bind(&BaseChannel::SetRtpTransportParameters_n, this, |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 952 | content, action, src, encrypted_extension_ids, |
| 953 | error_desc)); |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 954 | } |
| 955 | |
| 956 | bool BaseChannel::SetRtpTransportParameters_n( |
| 957 | const MediaContentDescription* content, |
| 958 | ContentAction action, |
| 959 | ContentSource src, |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 960 | const std::vector<int>& encrypted_extension_ids, |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 961 | std::string* error_desc) { |
| 962 | RTC_DCHECK(network_thread_->IsCurrent()); |
| 963 | |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 964 | if (!SetSrtp_n(content->cryptos(), action, src, encrypted_extension_ids, |
| 965 | error_desc)) { |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 966 | return false; |
| 967 | } |
| 968 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 969 | if (!SetRtcpMux_n(content->rtcp_mux(), action, src, error_desc)) { |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 970 | return false; |
| 971 | } |
| 972 | |
| 973 | return true; |
| 974 | } |
| 975 | |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 976 | // |dtls| will be set to true if DTLS is active for transport and crypto is |
| 977 | // empty. |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 978 | bool BaseChannel::CheckSrtpConfig_n(const std::vector<CryptoParams>& cryptos, |
| 979 | bool* dtls, |
| 980 | std::string* error_desc) { |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 981 | *dtls = rtp_dtls_transport_ && rtp_dtls_transport_->IsDtlsActive(); |
mallinath@webrtc.org | 19f27e6 | 2013-10-13 17:18:27 +0000 | [diff] [blame] | 982 | if (*dtls && !cryptos.empty()) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 983 | SafeSetError("Cryptos must be empty when DTLS is active.", error_desc); |
mallinath@webrtc.org | 19f27e6 | 2013-10-13 17:18:27 +0000 | [diff] [blame] | 984 | return false; |
| 985 | } |
| 986 | return true; |
| 987 | } |
| 988 | |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 989 | void BaseChannel::EnableSrtpTransport_n() { |
| 990 | if (srtp_transport_ == nullptr) { |
| 991 | rtp_transport_->SignalReadyToSend.disconnect(this); |
| 992 | rtp_transport_->SignalPacketReceived.disconnect(this); |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 993 | rtp_transport_->SignalNetworkRouteChanged.disconnect(this); |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 994 | |
| 995 | auto transport = rtc::MakeUnique<webrtc::SrtpTransport>( |
| 996 | std::move(rtp_transport_), content_name_); |
| 997 | srtp_transport_ = transport.get(); |
| 998 | rtp_transport_ = std::move(transport); |
| 999 | |
| 1000 | rtp_transport_->SignalReadyToSend.connect( |
| 1001 | this, &BaseChannel::OnTransportReadyToSend); |
| 1002 | rtp_transport_->SignalPacketReceived.connect( |
| 1003 | this, &BaseChannel::OnPacketReceived); |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 1004 | rtp_transport_->SignalNetworkRouteChanged.connect( |
| 1005 | this, &BaseChannel::OnNetworkRouteChanged); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1006 | RTC_LOG(LS_INFO) << "Wrapping RtpTransport in SrtpTransport."; |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 1007 | } |
| 1008 | } |
| 1009 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1010 | bool BaseChannel::SetSrtp_n(const std::vector<CryptoParams>& cryptos, |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1011 | ContentAction action, |
| 1012 | ContentSource src, |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 1013 | const std::vector<int>& encrypted_extension_ids, |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1014 | std::string* error_desc) { |
Peter Boström | ca8b404 | 2016-03-08 14:24:13 -0800 | [diff] [blame] | 1015 | TRACE_EVENT0("webrtc", "BaseChannel::SetSrtp_w"); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1016 | bool ret = false; |
mallinath@webrtc.org | 19f27e6 | 2013-10-13 17:18:27 +0000 | [diff] [blame] | 1017 | bool dtls = false; |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1018 | ret = CheckSrtpConfig_n(cryptos, &dtls, error_desc); |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1019 | if (!ret) { |
| 1020 | return false; |
| 1021 | } |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 1022 | |
| 1023 | // If SRTP was not required, but we're setting a description that uses SDES, |
| 1024 | // we need to upgrade to an SrtpTransport. |
| 1025 | if (!srtp_transport_ && !dtls && !cryptos.empty()) { |
| 1026 | EnableSrtpTransport_n(); |
| 1027 | } |
Zhi Huang | c99b6c7 | 2017-11-10 16:44:46 -0800 | [diff] [blame] | 1028 | |
| 1029 | bool encrypted_header_extensions_id_changed = |
| 1030 | EncryptedHeaderExtensionIdsChanged(src, encrypted_extension_ids); |
| 1031 | CacheEncryptedHeaderExtensionIds(src, encrypted_extension_ids); |
| 1032 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1033 | switch (action) { |
| 1034 | case CA_OFFER: |
mallinath@webrtc.org | 19f27e6 | 2013-10-13 17:18:27 +0000 | [diff] [blame] | 1035 | // If DTLS is already active on the channel, we could be renegotiating |
| 1036 | // here. We don't update the srtp filter. |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1037 | if (!dtls) { |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 1038 | ret = sdes_negotiator_.SetOffer(cryptos, src); |
mallinath@webrtc.org | 19f27e6 | 2013-10-13 17:18:27 +0000 | [diff] [blame] | 1039 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1040 | break; |
| 1041 | case CA_PRANSWER: |
| 1042 | // If we're doing DTLS-SRTP, we don't want to update the filter |
| 1043 | // with an answer, because we already have SRTP parameters. |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1044 | if (!dtls) { |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 1045 | ret = sdes_negotiator_.SetProvisionalAnswer(cryptos, src); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1046 | } |
| 1047 | break; |
| 1048 | case CA_ANSWER: |
| 1049 | // If we're doing DTLS-SRTP, we don't want to update the filter |
| 1050 | // with an answer, because we already have SRTP parameters. |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1051 | if (!dtls) { |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 1052 | ret = sdes_negotiator_.SetAnswer(cryptos, src); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1053 | } |
| 1054 | break; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1055 | default: |
| 1056 | break; |
| 1057 | } |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 1058 | |
| 1059 | // If setting an SDES answer succeeded, apply the negotiated parameters |
| 1060 | // to the SRTP transport. |
| 1061 | if ((action == CA_PRANSWER || action == CA_ANSWER) && !dtls && ret) { |
| 1062 | if (sdes_negotiator_.send_cipher_suite() && |
| 1063 | sdes_negotiator_.recv_cipher_suite()) { |
Zhi Huang | c99b6c7 | 2017-11-10 16:44:46 -0800 | [diff] [blame] | 1064 | RTC_DCHECK(catched_send_extension_ids_); |
| 1065 | RTC_DCHECK(catched_recv_extension_ids_); |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 1066 | ret = srtp_transport_->SetRtpParams( |
| 1067 | *(sdes_negotiator_.send_cipher_suite()), |
| 1068 | sdes_negotiator_.send_key().data(), |
| 1069 | static_cast<int>(sdes_negotiator_.send_key().size()), |
Zhi Huang | c99b6c7 | 2017-11-10 16:44:46 -0800 | [diff] [blame] | 1070 | *(catched_send_extension_ids_), |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 1071 | *(sdes_negotiator_.recv_cipher_suite()), |
| 1072 | sdes_negotiator_.recv_key().data(), |
Zhi Huang | c99b6c7 | 2017-11-10 16:44:46 -0800 | [diff] [blame] | 1073 | static_cast<int>(sdes_negotiator_.recv_key().size()), |
| 1074 | *(catched_recv_extension_ids_)); |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 1075 | } else { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1076 | RTC_LOG(LS_INFO) << "No crypto keys are provided for SDES."; |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 1077 | if (action == CA_ANSWER && srtp_transport_) { |
| 1078 | // Explicitly reset the |srtp_transport_| if no crypto param is |
| 1079 | // provided in the answer. No need to call |ResetParams()| for |
| 1080 | // |sdes_negotiator_| because it resets the params inside |SetAnswer|. |
| 1081 | srtp_transport_->ResetParams(); |
| 1082 | } |
| 1083 | } |
| 1084 | } |
| 1085 | |
Zhi Huang | c99b6c7 | 2017-11-10 16:44:46 -0800 | [diff] [blame] | 1086 | // Only update SRTP transport if using DTLS. SDES is handled internally |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 1087 | // by the SRTP filter. |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 1088 | if (ret && dtls_active() && rtp_dtls_transport_ && |
Zhi Huang | c99b6c7 | 2017-11-10 16:44:46 -0800 | [diff] [blame] | 1089 | rtp_dtls_transport_->dtls_state() == DTLS_TRANSPORT_CONNECTED && |
| 1090 | encrypted_header_extensions_id_changed) { |
| 1091 | ret = SetupDtlsSrtp_n(/*rtcp=*/false); |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 1092 | } |
Zhi Huang | c99b6c7 | 2017-11-10 16:44:46 -0800 | [diff] [blame] | 1093 | |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1094 | if (!ret) { |
Zhi Huang | c99b6c7 | 2017-11-10 16:44:46 -0800 | [diff] [blame] | 1095 | SafeSetError("Failed to setup SRTP.", error_desc); |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1096 | return false; |
| 1097 | } |
| 1098 | return true; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1099 | } |
| 1100 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1101 | bool BaseChannel::SetRtcpMux_n(bool enable, |
| 1102 | ContentAction action, |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1103 | ContentSource src, |
| 1104 | std::string* error_desc) { |
deadbeef | 8e814d7 | 2017-01-13 11:34:39 -0800 | [diff] [blame] | 1105 | // Provide a more specific error message for the RTCP mux "require" policy |
| 1106 | // case. |
zstein | 56162b9 | 2017-04-24 16:54:35 -0700 | [diff] [blame] | 1107 | if (rtcp_mux_required_ && !enable) { |
deadbeef | 8e814d7 | 2017-01-13 11:34:39 -0800 | [diff] [blame] | 1108 | SafeSetError( |
| 1109 | "rtcpMuxPolicy is 'require', but media description does not " |
| 1110 | "contain 'a=rtcp-mux'.", |
| 1111 | error_desc); |
| 1112 | return false; |
| 1113 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1114 | bool ret = false; |
| 1115 | switch (action) { |
| 1116 | case CA_OFFER: |
| 1117 | ret = rtcp_mux_filter_.SetOffer(enable, src); |
| 1118 | break; |
| 1119 | case CA_PRANSWER: |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 1120 | // This may activate RTCP muxing, but we don't yet destroy the transport |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1121 | // because the final answer may deactivate it. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1122 | ret = rtcp_mux_filter_.SetProvisionalAnswer(enable, src); |
| 1123 | break; |
| 1124 | case CA_ANSWER: |
| 1125 | ret = rtcp_mux_filter_.SetAnswer(enable, src); |
| 1126 | if (ret && rtcp_mux_filter_.IsActive()) { |
deadbeef | e814a0d | 2017-02-25 18:15:09 -0800 | [diff] [blame] | 1127 | // We permanently activated RTCP muxing; signal that we no longer need |
| 1128 | // the RTCP transport. |
zstein | d48dbda | 2017-04-04 19:45:57 -0700 | [diff] [blame] | 1129 | std::string debug_name = |
| 1130 | transport_name_.empty() |
Zhi Huang | 942bc2e | 2017-11-13 13:26:07 -0800 | [diff] [blame] | 1131 | ? rtp_transport_->rtp_packet_transport()->transport_name() |
zstein | d48dbda | 2017-04-04 19:45:57 -0700 | [diff] [blame] | 1132 | : transport_name_; |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1133 | RTC_LOG(LS_INFO) << "Enabling rtcp-mux for " << content_name() |
| 1134 | << "; no longer need RTCP transport for " |
| 1135 | << debug_name; |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 1136 | if (rtp_transport_->rtcp_packet_transport()) { |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 1137 | SetTransport_n(true, nullptr, nullptr); |
| 1138 | SignalRtcpMuxFullyActive(transport_name_); |
zhihuang | f5b251b | 2017-01-12 19:37:48 -0800 | [diff] [blame] | 1139 | } |
deadbeef | 062ce9f | 2016-08-26 21:42:15 -0700 | [diff] [blame] | 1140 | UpdateWritableState_n(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1141 | } |
| 1142 | break; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1143 | default: |
| 1144 | break; |
| 1145 | } |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1146 | if (!ret) { |
| 1147 | SafeSetError("Failed to setup RTCP mux filter.", error_desc); |
| 1148 | return false; |
| 1149 | } |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 1150 | rtp_transport_->SetRtcpMuxEnabled(rtcp_mux_filter_.IsActive()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1151 | // |rtcp_mux_filter_| can be active if |action| is CA_PRANSWER or |
zhihuang | b2cdd93 | 2017-01-19 16:54:25 -0800 | [diff] [blame] | 1152 | // CA_ANSWER, but we only want to tear down the RTCP transport if we received |
| 1153 | // a final answer. |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1154 | if (rtcp_mux_filter_.IsActive()) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1155 | // If the RTP transport is already writable, then so are we. |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 1156 | if (rtp_transport_->rtp_packet_transport()->writable()) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1157 | ChannelWritable_n(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1158 | } |
| 1159 | } |
| 1160 | |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1161 | return true; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1162 | } |
| 1163 | |
| 1164 | bool BaseChannel::AddRecvStream_w(const StreamParams& sp) { |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1165 | RTC_DCHECK(worker_thread() == rtc::Thread::Current()); |
pbos | 482b12e | 2015-11-16 10:19:58 -0800 | [diff] [blame] | 1166 | return media_channel()->AddRecvStream(sp); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1167 | } |
| 1168 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1169 | bool BaseChannel::RemoveRecvStream_w(uint32_t ssrc) { |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1170 | RTC_DCHECK(worker_thread() == rtc::Thread::Current()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1171 | return media_channel()->RemoveRecvStream(ssrc); |
| 1172 | } |
| 1173 | |
| 1174 | bool BaseChannel::UpdateLocalStreams_w(const std::vector<StreamParams>& streams, |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1175 | ContentAction action, |
| 1176 | std::string* error_desc) { |
Zhi Huang | 801b868 | 2017-11-15 11:36:43 -0800 | [diff] [blame] | 1177 | if (!(action == CA_OFFER || action == CA_ANSWER || action == CA_PRANSWER)) |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1178 | return false; |
| 1179 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1180 | // Check for streams that have been removed. |
| 1181 | bool ret = true; |
| 1182 | for (StreamParamsVec::const_iterator it = local_streams_.begin(); |
| 1183 | it != local_streams_.end(); ++it) { |
tommi@webrtc.org | 586f2ed | 2015-01-22 23:00:41 +0000 | [diff] [blame] | 1184 | if (!GetStreamBySsrc(streams, it->first_ssrc())) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1185 | if (!media_channel()->RemoveSendStream(it->first_ssrc())) { |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1186 | std::ostringstream desc; |
| 1187 | desc << "Failed to remove send stream with ssrc " |
| 1188 | << it->first_ssrc() << "."; |
| 1189 | SafeSetError(desc.str(), error_desc); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1190 | ret = false; |
| 1191 | } |
| 1192 | } |
| 1193 | } |
| 1194 | // Check for new streams. |
| 1195 | for (StreamParamsVec::const_iterator it = streams.begin(); |
| 1196 | it != streams.end(); ++it) { |
tommi@webrtc.org | 586f2ed | 2015-01-22 23:00:41 +0000 | [diff] [blame] | 1197 | if (!GetStreamBySsrc(local_streams_, it->first_ssrc())) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1198 | if (media_channel()->AddSendStream(*it)) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1199 | RTC_LOG(LS_INFO) << "Add send stream ssrc: " << it->ssrcs[0]; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1200 | } else { |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1201 | std::ostringstream desc; |
| 1202 | desc << "Failed to add send stream ssrc: " << it->first_ssrc(); |
| 1203 | SafeSetError(desc.str(), error_desc); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1204 | ret = false; |
| 1205 | } |
| 1206 | } |
| 1207 | } |
| 1208 | local_streams_ = streams; |
| 1209 | return ret; |
| 1210 | } |
| 1211 | |
| 1212 | bool BaseChannel::UpdateRemoteStreams_w( |
| 1213 | const std::vector<StreamParams>& streams, |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1214 | ContentAction action, |
| 1215 | std::string* error_desc) { |
Zhi Huang | 801b868 | 2017-11-15 11:36:43 -0800 | [diff] [blame] | 1216 | if (!(action == CA_OFFER || action == CA_ANSWER || action == CA_PRANSWER)) |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1217 | return false; |
| 1218 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1219 | // Check for streams that have been removed. |
| 1220 | bool ret = true; |
| 1221 | for (StreamParamsVec::const_iterator it = remote_streams_.begin(); |
| 1222 | it != remote_streams_.end(); ++it) { |
tommi@webrtc.org | 586f2ed | 2015-01-22 23:00:41 +0000 | [diff] [blame] | 1223 | if (!GetStreamBySsrc(streams, it->first_ssrc())) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1224 | if (!RemoveRecvStream_w(it->first_ssrc())) { |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1225 | std::ostringstream desc; |
| 1226 | desc << "Failed to remove remote stream with ssrc " |
| 1227 | << it->first_ssrc() << "."; |
| 1228 | SafeSetError(desc.str(), error_desc); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1229 | ret = false; |
| 1230 | } |
| 1231 | } |
| 1232 | } |
| 1233 | // Check for new streams. |
| 1234 | for (StreamParamsVec::const_iterator it = streams.begin(); |
| 1235 | it != streams.end(); ++it) { |
tommi@webrtc.org | 586f2ed | 2015-01-22 23:00:41 +0000 | [diff] [blame] | 1236 | if (!GetStreamBySsrc(remote_streams_, it->first_ssrc())) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1237 | if (AddRecvStream_w(*it)) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1238 | RTC_LOG(LS_INFO) << "Add remote ssrc: " << it->ssrcs[0]; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1239 | } else { |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1240 | std::ostringstream desc; |
| 1241 | desc << "Failed to add remote stream ssrc: " << it->first_ssrc(); |
| 1242 | SafeSetError(desc.str(), error_desc); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1243 | ret = false; |
| 1244 | } |
| 1245 | } |
| 1246 | } |
| 1247 | remote_streams_ = streams; |
| 1248 | return ret; |
| 1249 | } |
| 1250 | |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 1251 | RtpHeaderExtensions BaseChannel::GetFilteredRtpHeaderExtensions( |
| 1252 | const RtpHeaderExtensions& extensions) { |
| 1253 | if (!rtp_dtls_transport_ || |
| 1254 | !rtp_dtls_transport_->crypto_options() |
| 1255 | .enable_encrypted_rtp_header_extensions) { |
| 1256 | RtpHeaderExtensions filtered; |
| 1257 | auto pred = [](const webrtc::RtpExtension& extension) { |
| 1258 | return !extension.encrypt; |
| 1259 | }; |
| 1260 | std::copy_if(extensions.begin(), extensions.end(), |
| 1261 | std::back_inserter(filtered), pred); |
| 1262 | return filtered; |
| 1263 | } |
| 1264 | |
| 1265 | return webrtc::RtpExtension::FilterDuplicateNonEncrypted(extensions); |
| 1266 | } |
| 1267 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1268 | void BaseChannel::MaybeCacheRtpAbsSendTimeHeaderExtension_w( |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 1269 | const std::vector<webrtc::RtpExtension>& extensions) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1270 | // Absolute Send Time extension id is used only with external auth, |
| 1271 | // so do not bother searching for it and making asyncronious call to set |
| 1272 | // something that is not used. |
| 1273 | #if defined(ENABLE_EXTERNAL_AUTH) |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 1274 | const webrtc::RtpExtension* send_time_extension = |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 1275 | webrtc::RtpExtension::FindHeaderExtensionByUri( |
| 1276 | extensions, webrtc::RtpExtension::kAbsSendTimeUri); |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1277 | int rtp_abs_sendtime_extn_id = |
henrike@webrtc.org | d43aa9d | 2014-02-21 23:43:24 +0000 | [diff] [blame] | 1278 | send_time_extension ? send_time_extension->id : -1; |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1279 | invoker_.AsyncInvoke<void>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 1280 | RTC_FROM_HERE, network_thread_, |
| 1281 | Bind(&BaseChannel::CacheRtpAbsSendTimeHeaderExtension_n, this, |
| 1282 | rtp_abs_sendtime_extn_id)); |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1283 | #endif |
| 1284 | } |
| 1285 | |
| 1286 | void BaseChannel::CacheRtpAbsSendTimeHeaderExtension_n( |
| 1287 | int rtp_abs_sendtime_extn_id) { |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 1288 | if (srtp_transport_) { |
| 1289 | srtp_transport_->CacheRtpAbsSendTimeHeaderExtension( |
| 1290 | rtp_abs_sendtime_extn_id); |
| 1291 | } else { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1292 | RTC_LOG(LS_WARNING) |
| 1293 | << "Trying to cache the Absolute Send Time extension id " |
| 1294 | "but the SRTP is not active."; |
Zhi Huang | cf990f5 | 2017-09-22 12:12:30 -0700 | [diff] [blame] | 1295 | } |
henrike@webrtc.org | d43aa9d | 2014-02-21 23:43:24 +0000 | [diff] [blame] | 1296 | } |
| 1297 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1298 | void BaseChannel::OnMessage(rtc::Message *pmsg) { |
Peter Boström | 6f28cf0 | 2015-12-07 23:17:15 +0100 | [diff] [blame] | 1299 | TRACE_EVENT0("webrtc", "BaseChannel::OnMessage"); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1300 | switch (pmsg->message_id) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1301 | case MSG_SEND_RTP_PACKET: |
| 1302 | case MSG_SEND_RTCP_PACKET: { |
| 1303 | RTC_DCHECK(network_thread_->IsCurrent()); |
| 1304 | SendPacketMessageData* data = |
| 1305 | static_cast<SendPacketMessageData*>(pmsg->pdata); |
| 1306 | bool rtcp = pmsg->message_id == MSG_SEND_RTCP_PACKET; |
| 1307 | SendPacket(rtcp, &data->packet, data->options); |
| 1308 | delete data; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1309 | break; |
| 1310 | } |
| 1311 | case MSG_FIRSTPACKETRECEIVED: { |
| 1312 | SignalFirstPacketReceived(this); |
| 1313 | break; |
| 1314 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1315 | } |
| 1316 | } |
| 1317 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 1318 | void BaseChannel::AddHandledPayloadType(int payload_type) { |
zstein | e8ab543 | 2017-07-12 11:48:11 -0700 | [diff] [blame] | 1319 | rtp_transport_->AddHandledPayloadType(payload_type); |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 1320 | } |
| 1321 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1322 | void BaseChannel::FlushRtcpMessages_n() { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1323 | // Flush all remaining RTCP messages. This should only be called in |
| 1324 | // destructor. |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1325 | RTC_DCHECK(network_thread_->IsCurrent()); |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1326 | rtc::MessageList rtcp_messages; |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1327 | network_thread_->Clear(this, MSG_SEND_RTCP_PACKET, &rtcp_messages); |
| 1328 | for (const auto& message : rtcp_messages) { |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 1329 | network_thread_->Send(RTC_FROM_HERE, this, MSG_SEND_RTCP_PACKET, |
| 1330 | message.pdata); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1331 | } |
| 1332 | } |
| 1333 | |
johan | d89ab14 | 2016-10-25 10:50:32 -0700 | [diff] [blame] | 1334 | void BaseChannel::SignalSentPacket_n( |
deadbeef | 5bd5ca3 | 2017-02-10 11:31:50 -0800 | [diff] [blame] | 1335 | rtc::PacketTransportInternal* /* transport */, |
johan | d89ab14 | 2016-10-25 10:50:32 -0700 | [diff] [blame] | 1336 | const rtc::SentPacket& sent_packet) { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1337 | RTC_DCHECK(network_thread_->IsCurrent()); |
| 1338 | invoker_.AsyncInvoke<void>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 1339 | RTC_FROM_HERE, worker_thread_, |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1340 | rtc::Bind(&BaseChannel::SignalSentPacket_w, this, sent_packet)); |
| 1341 | } |
| 1342 | |
| 1343 | void BaseChannel::SignalSentPacket_w(const rtc::SentPacket& sent_packet) { |
| 1344 | RTC_DCHECK(worker_thread_->IsCurrent()); |
| 1345 | SignalSentPacket(sent_packet); |
| 1346 | } |
| 1347 | |
Zhi Huang | c99b6c7 | 2017-11-10 16:44:46 -0800 | [diff] [blame] | 1348 | void BaseChannel::CacheEncryptedHeaderExtensionIds( |
| 1349 | cricket::ContentSource source, |
| 1350 | const std::vector<int>& extension_ids) { |
| 1351 | source == ContentSource::CS_LOCAL |
| 1352 | ? catched_recv_extension_ids_.emplace(extension_ids) |
| 1353 | : catched_send_extension_ids_.emplace(extension_ids); |
| 1354 | } |
| 1355 | |
| 1356 | bool BaseChannel::EncryptedHeaderExtensionIdsChanged( |
| 1357 | cricket::ContentSource source, |
| 1358 | const std::vector<int>& new_extension_ids) { |
| 1359 | if (source == ContentSource::CS_LOCAL) { |
| 1360 | return !catched_recv_extension_ids_ || |
| 1361 | (*catched_recv_extension_ids_) != new_extension_ids; |
| 1362 | } else { |
| 1363 | return !catched_send_extension_ids_ || |
| 1364 | (*catched_send_extension_ids_) != new_extension_ids; |
| 1365 | } |
| 1366 | } |
| 1367 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1368 | VoiceChannel::VoiceChannel(rtc::Thread* worker_thread, |
| 1369 | rtc::Thread* network_thread, |
zhihuang | f5b251b | 2017-01-12 19:37:48 -0800 | [diff] [blame] | 1370 | rtc::Thread* signaling_thread, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1371 | MediaEngineInterface* media_engine, |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 1372 | std::unique_ptr<VoiceMediaChannel> media_channel, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1373 | const std::string& content_name, |
deadbeef | ac22f70 | 2017-01-12 21:59:29 -0800 | [diff] [blame] | 1374 | bool rtcp_mux_required, |
deadbeef | 7af91dd | 2016-12-13 11:29:11 -0800 | [diff] [blame] | 1375 | bool srtp_required) |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1376 | : BaseChannel(worker_thread, |
| 1377 | network_thread, |
zhihuang | f5b251b | 2017-01-12 19:37:48 -0800 | [diff] [blame] | 1378 | signaling_thread, |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 1379 | std::move(media_channel), |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 1380 | content_name, |
deadbeef | ac22f70 | 2017-01-12 21:59:29 -0800 | [diff] [blame] | 1381 | rtcp_mux_required, |
deadbeef | 7af91dd | 2016-12-13 11:29:11 -0800 | [diff] [blame] | 1382 | srtp_required), |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 1383 | media_engine_(media_engine) {} |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1384 | |
| 1385 | VoiceChannel::~VoiceChannel() { |
Peter Boström | ca8b404 | 2016-03-08 14:24:13 -0800 | [diff] [blame] | 1386 | TRACE_EVENT0("webrtc", "VoiceChannel::~VoiceChannel"); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1387 | StopAudioMonitor(); |
| 1388 | StopMediaMonitor(); |
| 1389 | // this can't be done in the base class, since it calls a virtual |
| 1390 | DisableMedia_w(); |
wu@webrtc.org | 7818752 | 2013-10-07 23:32:02 +0000 | [diff] [blame] | 1391 | Deinit(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1392 | } |
| 1393 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1394 | bool VoiceChannel::SetAudioSend(uint32_t ssrc, |
solenberg | dfc8f4f | 2015-10-01 02:31:10 -0700 | [diff] [blame] | 1395 | bool enable, |
solenberg | 1dd98f3 | 2015-09-10 01:57:14 -0700 | [diff] [blame] | 1396 | const AudioOptions* options, |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 1397 | AudioSource* source) { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 1398 | return InvokeOnWorker<bool>( |
| 1399 | RTC_FROM_HERE, Bind(&VoiceMediaChannel::SetAudioSend, media_channel(), |
| 1400 | ssrc, enable, options, source)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1401 | } |
| 1402 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1403 | // TODO(juberti): Handle early media the right way. We should get an explicit |
| 1404 | // ringing message telling us to start playing local ringback, which we cancel |
| 1405 | // if any early media actually arrives. For now, we do the opposite, which is |
| 1406 | // to wait 1 second for early media, and start playing local ringback if none |
| 1407 | // arrives. |
| 1408 | void VoiceChannel::SetEarlyMedia(bool enable) { |
| 1409 | if (enable) { |
| 1410 | // Start the early media timeout |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 1411 | worker_thread()->PostDelayed(RTC_FROM_HERE, kEarlyMediaTimeout, this, |
| 1412 | MSG_EARLYMEDIATIMEOUT); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1413 | } else { |
| 1414 | // Stop the timeout if currently going. |
sergeyu@chromium.org | 9cf037b | 2014-02-07 19:03:26 +0000 | [diff] [blame] | 1415 | worker_thread()->Clear(this, MSG_EARLYMEDIATIMEOUT); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1416 | } |
| 1417 | } |
| 1418 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1419 | bool VoiceChannel::CanInsertDtmf() { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 1420 | return InvokeOnWorker<bool>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 1421 | RTC_FROM_HERE, Bind(&VoiceMediaChannel::CanInsertDtmf, media_channel())); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1422 | } |
| 1423 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1424 | bool VoiceChannel::InsertDtmf(uint32_t ssrc, |
| 1425 | int event_code, |
solenberg | 1d63dd0 | 2015-12-02 12:35:09 -0800 | [diff] [blame] | 1426 | int duration) { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 1427 | return InvokeOnWorker<bool>( |
| 1428 | RTC_FROM_HERE, |
| 1429 | Bind(&VoiceChannel::InsertDtmf_w, this, ssrc, event_code, duration)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1430 | } |
| 1431 | |
solenberg | 4bac9c5 | 2015-10-09 02:32:53 -0700 | [diff] [blame] | 1432 | bool VoiceChannel::SetOutputVolume(uint32_t ssrc, double volume) { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 1433 | return InvokeOnWorker<bool>( |
| 1434 | RTC_FROM_HERE, |
| 1435 | Bind(&VoiceMediaChannel::SetOutputVolume, media_channel(), ssrc, volume)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1436 | } |
sergeyu@chromium.org | 9cf037b | 2014-02-07 19:03:26 +0000 | [diff] [blame] | 1437 | |
Tommi | f888bb5 | 2015-12-12 01:37:01 +0100 | [diff] [blame] | 1438 | void VoiceChannel::SetRawAudioSink( |
| 1439 | uint32_t ssrc, |
kwiberg | 3102294 | 2016-03-11 14:18:21 -0800 | [diff] [blame] | 1440 | std::unique_ptr<webrtc::AudioSinkInterface> sink) { |
| 1441 | // We need to work around Bind's lack of support for unique_ptr and ownership |
deadbeef | 2d110be | 2016-01-13 12:00:26 -0800 | [diff] [blame] | 1442 | // passing. So we invoke to our own little routine that gets a pointer to |
| 1443 | // our local variable. This is OK since we're synchronously invoking. |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 1444 | InvokeOnWorker<bool>(RTC_FROM_HERE, |
| 1445 | Bind(&SetRawAudioSink_w, media_channel(), ssrc, &sink)); |
Tommi | f888bb5 | 2015-12-12 01:37:01 +0100 | [diff] [blame] | 1446 | } |
| 1447 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1448 | webrtc::RtpParameters VoiceChannel::GetRtpSendParameters(uint32_t ssrc) const { |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1449 | return worker_thread()->Invoke<webrtc::RtpParameters>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 1450 | RTC_FROM_HERE, Bind(&VoiceChannel::GetRtpSendParameters_w, this, ssrc)); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1451 | } |
| 1452 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1453 | webrtc::RtpParameters VoiceChannel::GetRtpSendParameters_w( |
| 1454 | uint32_t ssrc) const { |
| 1455 | return media_channel()->GetRtpSendParameters(ssrc); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1456 | } |
| 1457 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1458 | bool VoiceChannel::SetRtpSendParameters( |
| 1459 | uint32_t ssrc, |
| 1460 | const webrtc::RtpParameters& parameters) { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 1461 | return InvokeOnWorker<bool>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 1462 | RTC_FROM_HERE, |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1463 | Bind(&VoiceChannel::SetRtpSendParameters_w, this, ssrc, parameters)); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1464 | } |
| 1465 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1466 | bool VoiceChannel::SetRtpSendParameters_w(uint32_t ssrc, |
| 1467 | webrtc::RtpParameters parameters) { |
| 1468 | return media_channel()->SetRtpSendParameters(ssrc, parameters); |
| 1469 | } |
| 1470 | |
| 1471 | webrtc::RtpParameters VoiceChannel::GetRtpReceiveParameters( |
| 1472 | uint32_t ssrc) const { |
| 1473 | return worker_thread()->Invoke<webrtc::RtpParameters>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 1474 | RTC_FROM_HERE, |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1475 | Bind(&VoiceChannel::GetRtpReceiveParameters_w, this, ssrc)); |
| 1476 | } |
| 1477 | |
| 1478 | webrtc::RtpParameters VoiceChannel::GetRtpReceiveParameters_w( |
| 1479 | uint32_t ssrc) const { |
| 1480 | return media_channel()->GetRtpReceiveParameters(ssrc); |
| 1481 | } |
| 1482 | |
| 1483 | bool VoiceChannel::SetRtpReceiveParameters( |
| 1484 | uint32_t ssrc, |
| 1485 | const webrtc::RtpParameters& parameters) { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 1486 | return InvokeOnWorker<bool>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 1487 | RTC_FROM_HERE, |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1488 | Bind(&VoiceChannel::SetRtpReceiveParameters_w, this, ssrc, parameters)); |
| 1489 | } |
| 1490 | |
| 1491 | bool VoiceChannel::SetRtpReceiveParameters_w(uint32_t ssrc, |
| 1492 | webrtc::RtpParameters parameters) { |
| 1493 | return media_channel()->SetRtpReceiveParameters(ssrc, parameters); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1494 | } |
| 1495 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1496 | bool VoiceChannel::GetStats(VoiceMediaInfo* stats) { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 1497 | return InvokeOnWorker<bool>(RTC_FROM_HERE, Bind(&VoiceMediaChannel::GetStats, |
| 1498 | media_channel(), stats)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1499 | } |
| 1500 | |
hbos | 8d609f6 | 2017-04-10 07:39:05 -0700 | [diff] [blame] | 1501 | std::vector<webrtc::RtpSource> VoiceChannel::GetSources(uint32_t ssrc) const { |
| 1502 | return worker_thread()->Invoke<std::vector<webrtc::RtpSource>>( |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 1503 | RTC_FROM_HERE, Bind(&VoiceChannel::GetSources_w, this, ssrc)); |
| 1504 | } |
| 1505 | |
| 1506 | std::vector<webrtc::RtpSource> VoiceChannel::GetSources_w(uint32_t ssrc) const { |
| 1507 | RTC_DCHECK(worker_thread()->IsCurrent()); |
| 1508 | return media_channel()->GetSources(ssrc); |
hbos | 8d609f6 | 2017-04-10 07:39:05 -0700 | [diff] [blame] | 1509 | } |
| 1510 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1511 | void VoiceChannel::StartMediaMonitor(int cms) { |
| 1512 | media_monitor_.reset(new VoiceMediaMonitor(media_channel(), worker_thread(), |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1513 | rtc::Thread::Current())); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1514 | media_monitor_->SignalUpdate.connect( |
| 1515 | this, &VoiceChannel::OnMediaMonitorUpdate); |
| 1516 | media_monitor_->Start(cms); |
| 1517 | } |
| 1518 | |
| 1519 | void VoiceChannel::StopMediaMonitor() { |
| 1520 | if (media_monitor_) { |
| 1521 | media_monitor_->Stop(); |
| 1522 | media_monitor_->SignalUpdate.disconnect(this); |
| 1523 | media_monitor_.reset(); |
| 1524 | } |
| 1525 | } |
| 1526 | |
| 1527 | void VoiceChannel::StartAudioMonitor(int cms) { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1528 | audio_monitor_.reset(new AudioMonitor(this, rtc::Thread::Current())); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1529 | audio_monitor_ |
| 1530 | ->SignalUpdate.connect(this, &VoiceChannel::OnAudioMonitorUpdate); |
| 1531 | audio_monitor_->Start(cms); |
| 1532 | } |
| 1533 | |
| 1534 | void VoiceChannel::StopAudioMonitor() { |
| 1535 | if (audio_monitor_) { |
| 1536 | audio_monitor_->Stop(); |
| 1537 | audio_monitor_.reset(); |
| 1538 | } |
| 1539 | } |
| 1540 | |
| 1541 | bool VoiceChannel::IsAudioMonitorRunning() const { |
| 1542 | return (audio_monitor_.get() != NULL); |
| 1543 | } |
| 1544 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1545 | int VoiceChannel::GetInputLevel_w() { |
Fredrik Solenberg | 0c02264 | 2015-08-05 12:25:22 +0200 | [diff] [blame] | 1546 | return media_engine_->GetInputLevel(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1547 | } |
| 1548 | |
| 1549 | int VoiceChannel::GetOutputLevel_w() { |
| 1550 | return media_channel()->GetOutputLevel(); |
| 1551 | } |
| 1552 | |
| 1553 | void VoiceChannel::GetActiveStreams_w(AudioInfo::StreamList* actives) { |
| 1554 | media_channel()->GetActiveStreams(actives); |
| 1555 | } |
| 1556 | |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 1557 | void VoiceChannel::OnPacketReceived(bool rtcp, |
zstein | 634977b | 2017-07-14 12:30:04 -0700 | [diff] [blame] | 1558 | rtc::CopyOnWriteBuffer* packet, |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 1559 | const rtc::PacketTime& packet_time) { |
| 1560 | BaseChannel::OnPacketReceived(rtcp, packet, packet_time); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1561 | // Set a flag when we've received an RTP packet. If we're waiting for early |
| 1562 | // media, this will disable the timeout. |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 1563 | if (!received_media_ && !rtcp) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1564 | received_media_ = true; |
| 1565 | } |
| 1566 | } |
| 1567 | |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1568 | void BaseChannel::UpdateMediaSendRecvState() { |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1569 | RTC_DCHECK(network_thread_->IsCurrent()); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1570 | invoker_.AsyncInvoke<void>( |
| 1571 | RTC_FROM_HERE, worker_thread_, |
| 1572 | Bind(&BaseChannel::UpdateMediaSendRecvState_w, this)); |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1573 | } |
| 1574 | |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1575 | void VoiceChannel::UpdateMediaSendRecvState_w() { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1576 | // Render incoming data if we're the active call, and we have the local |
| 1577 | // content. We receive data on the default channel and multiplexed streams. |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1578 | bool recv = IsReadyToReceiveMedia_w(); |
solenberg | 5b14b42 | 2015-10-01 04:10:31 -0700 | [diff] [blame] | 1579 | media_channel()->SetPlayout(recv); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1580 | |
| 1581 | // Send outgoing data if we're the active call, we have the remote content, |
| 1582 | // and we have had some form of connectivity. |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1583 | bool send = IsReadyToSendMedia_w(); |
Taylor Brandstetter | 1a018dc | 2016-03-08 12:37:39 -0800 | [diff] [blame] | 1584 | media_channel()->SetSend(send); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1585 | |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1586 | RTC_LOG(LS_INFO) << "Changing voice state, recv=" << recv << " send=" << send; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1587 | } |
| 1588 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1589 | bool VoiceChannel::SetLocalContent_w(const MediaContentDescription* content, |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1590 | ContentAction action, |
| 1591 | std::string* error_desc) { |
Peter Boström | 9f45a45 | 2015-12-08 13:25:57 +0100 | [diff] [blame] | 1592 | TRACE_EVENT0("webrtc", "VoiceChannel::SetLocalContent_w"); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1593 | RTC_DCHECK(worker_thread() == rtc::Thread::Current()); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1594 | RTC_LOG(LS_INFO) << "Setting local voice description"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1595 | |
| 1596 | const AudioContentDescription* audio = |
| 1597 | static_cast<const AudioContentDescription*>(content); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1598 | RTC_DCHECK(audio != NULL); |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1599 | if (!audio) { |
| 1600 | SafeSetError("Can't find audio content in local description.", error_desc); |
| 1601 | return false; |
| 1602 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1603 | |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 1604 | RtpHeaderExtensions rtp_header_extensions = |
| 1605 | GetFilteredRtpHeaderExtensions(audio->rtp_header_extensions()); |
| 1606 | |
| 1607 | if (!SetRtpTransportParameters(content, action, CS_LOCAL, |
| 1608 | rtp_header_extensions, error_desc)) { |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1609 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1610 | } |
| 1611 | |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1612 | AudioRecvParameters recv_params = last_recv_params_; |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 1613 | RtpParametersFromMediaDescription(audio, rtp_header_extensions, &recv_params); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1614 | if (!media_channel()->SetRecvParameters(recv_params)) { |
Peter Thatcher | bfab5cb | 2015-08-20 17:40:24 -0700 | [diff] [blame] | 1615 | SafeSetError("Failed to set local audio description recv parameters.", |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1616 | error_desc); |
| 1617 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1618 | } |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1619 | for (const AudioCodec& codec : audio->codecs()) { |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 1620 | AddHandledPayloadType(codec.id); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1621 | } |
| 1622 | last_recv_params_ = recv_params; |
| 1623 | |
| 1624 | // TODO(pthatcher): Move local streams into AudioSendParameters, and |
| 1625 | // only give it to the media channel once we have a remote |
| 1626 | // description too (without a remote description, we won't be able |
| 1627 | // to send them anyway). |
| 1628 | if (!UpdateLocalStreams_w(audio->streams(), action, error_desc)) { |
| 1629 | SafeSetError("Failed to set local audio description streams.", error_desc); |
| 1630 | return false; |
| 1631 | } |
| 1632 | |
| 1633 | set_local_content_direction(content->direction()); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1634 | UpdateMediaSendRecvState_w(); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1635 | return true; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1636 | } |
| 1637 | |
| 1638 | bool VoiceChannel::SetRemoteContent_w(const MediaContentDescription* content, |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1639 | ContentAction action, |
| 1640 | std::string* error_desc) { |
Peter Boström | 9f45a45 | 2015-12-08 13:25:57 +0100 | [diff] [blame] | 1641 | TRACE_EVENT0("webrtc", "VoiceChannel::SetRemoteContent_w"); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1642 | RTC_DCHECK(worker_thread() == rtc::Thread::Current()); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1643 | RTC_LOG(LS_INFO) << "Setting remote voice description"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1644 | |
| 1645 | const AudioContentDescription* audio = |
| 1646 | static_cast<const AudioContentDescription*>(content); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1647 | RTC_DCHECK(audio != NULL); |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1648 | if (!audio) { |
| 1649 | SafeSetError("Can't find audio content in remote description.", error_desc); |
| 1650 | return false; |
| 1651 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1652 | |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 1653 | RtpHeaderExtensions rtp_header_extensions = |
| 1654 | GetFilteredRtpHeaderExtensions(audio->rtp_header_extensions()); |
| 1655 | |
| 1656 | if (!SetRtpTransportParameters(content, action, CS_REMOTE, |
| 1657 | rtp_header_extensions, error_desc)) { |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1658 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1659 | } |
| 1660 | |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1661 | AudioSendParameters send_params = last_send_params_; |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 1662 | RtpSendParametersFromMediaDescription(audio, rtp_header_extensions, |
| 1663 | &send_params); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1664 | if (audio->agc_minus_10db()) { |
Oskar Sundbom | 36f8f3e | 2017-11-16 10:54:27 +0100 | [diff] [blame] | 1665 | send_params.options.adjust_agc_delta = kAgcMinus10db; |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1666 | } |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1667 | |
| 1668 | bool parameters_applied = media_channel()->SetSendParameters(send_params); |
| 1669 | if (!parameters_applied) { |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1670 | SafeSetError("Failed to set remote audio description send parameters.", |
| 1671 | error_desc); |
| 1672 | return false; |
| 1673 | } |
| 1674 | last_send_params_ = send_params; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1675 | |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1676 | // TODO(pthatcher): Move remote streams into AudioRecvParameters, |
| 1677 | // and only give it to the media channel once we have a local |
| 1678 | // description too (without a local description, we won't be able to |
| 1679 | // recv them anyway). |
| 1680 | if (!UpdateRemoteStreams_w(audio->streams(), action, error_desc)) { |
| 1681 | SafeSetError("Failed to set remote audio description streams.", error_desc); |
| 1682 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1683 | } |
| 1684 | |
Peter Thatcher | bfab5cb | 2015-08-20 17:40:24 -0700 | [diff] [blame] | 1685 | if (audio->rtp_header_extensions_set()) { |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 1686 | MaybeCacheRtpAbsSendTimeHeaderExtension_w(rtp_header_extensions); |
Peter Thatcher | bfab5cb | 2015-08-20 17:40:24 -0700 | [diff] [blame] | 1687 | } |
| 1688 | |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1689 | set_remote_content_direction(content->direction()); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1690 | UpdateMediaSendRecvState_w(); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1691 | return true; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1692 | } |
| 1693 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1694 | void VoiceChannel::HandleEarlyMediaTimeout() { |
| 1695 | // This occurs on the main thread, not the worker thread. |
| 1696 | if (!received_media_) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1697 | RTC_LOG(LS_INFO) << "No early media received before timeout"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1698 | SignalEarlyMediaTimeout(this); |
| 1699 | } |
| 1700 | } |
| 1701 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1702 | bool VoiceChannel::InsertDtmf_w(uint32_t ssrc, |
| 1703 | int event, |
solenberg | 1d63dd0 | 2015-12-02 12:35:09 -0800 | [diff] [blame] | 1704 | int duration) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1705 | if (!enabled()) { |
| 1706 | return false; |
| 1707 | } |
solenberg | 1d63dd0 | 2015-12-02 12:35:09 -0800 | [diff] [blame] | 1708 | return media_channel()->InsertDtmf(ssrc, event, duration); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1709 | } |
| 1710 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1711 | void VoiceChannel::OnMessage(rtc::Message *pmsg) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1712 | switch (pmsg->message_id) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1713 | case MSG_EARLYMEDIATIMEOUT: |
| 1714 | HandleEarlyMediaTimeout(); |
| 1715 | break; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1716 | case MSG_CHANNEL_ERROR: { |
| 1717 | VoiceChannelErrorMessageData* data = |
| 1718 | static_cast<VoiceChannelErrorMessageData*>(pmsg->pdata); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1719 | delete data; |
| 1720 | break; |
| 1721 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1722 | default: |
| 1723 | BaseChannel::OnMessage(pmsg); |
| 1724 | break; |
| 1725 | } |
| 1726 | } |
| 1727 | |
| 1728 | void VoiceChannel::OnConnectionMonitorUpdate( |
pthatcher@webrtc.org | b4aac13 | 2015-03-13 18:25:21 +0000 | [diff] [blame] | 1729 | ConnectionMonitor* monitor, const std::vector<ConnectionInfo>& infos) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1730 | SignalConnectionMonitor(this, infos); |
| 1731 | } |
| 1732 | |
| 1733 | void VoiceChannel::OnMediaMonitorUpdate( |
| 1734 | VoiceMediaChannel* media_channel, const VoiceMediaInfo& info) { |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1735 | RTC_DCHECK(media_channel == this->media_channel()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1736 | SignalMediaMonitor(this, info); |
| 1737 | } |
| 1738 | |
| 1739 | void VoiceChannel::OnAudioMonitorUpdate(AudioMonitor* monitor, |
| 1740 | const AudioInfo& info) { |
| 1741 | SignalAudioMonitor(this, info); |
| 1742 | } |
| 1743 | |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1744 | VideoChannel::VideoChannel(rtc::Thread* worker_thread, |
| 1745 | rtc::Thread* network_thread, |
zhihuang | f5b251b | 2017-01-12 19:37:48 -0800 | [diff] [blame] | 1746 | rtc::Thread* signaling_thread, |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 1747 | std::unique_ptr<VideoMediaChannel> media_channel, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1748 | const std::string& content_name, |
deadbeef | ac22f70 | 2017-01-12 21:59:29 -0800 | [diff] [blame] | 1749 | bool rtcp_mux_required, |
deadbeef | 7af91dd | 2016-12-13 11:29:11 -0800 | [diff] [blame] | 1750 | bool srtp_required) |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1751 | : BaseChannel(worker_thread, |
| 1752 | network_thread, |
zhihuang | f5b251b | 2017-01-12 19:37:48 -0800 | [diff] [blame] | 1753 | signaling_thread, |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 1754 | std::move(media_channel), |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 1755 | content_name, |
deadbeef | ac22f70 | 2017-01-12 21:59:29 -0800 | [diff] [blame] | 1756 | rtcp_mux_required, |
deadbeef | 7af91dd | 2016-12-13 11:29:11 -0800 | [diff] [blame] | 1757 | srtp_required) {} |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1758 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1759 | VideoChannel::~VideoChannel() { |
Peter Boström | ca8b404 | 2016-03-08 14:24:13 -0800 | [diff] [blame] | 1760 | TRACE_EVENT0("webrtc", "VideoChannel::~VideoChannel"); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1761 | StopMediaMonitor(); |
| 1762 | // this can't be done in the base class, since it calls a virtual |
| 1763 | DisableMedia_w(); |
wu@webrtc.org | 7818752 | 2013-10-07 23:32:02 +0000 | [diff] [blame] | 1764 | |
| 1765 | Deinit(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1766 | } |
| 1767 | |
nisse | 08582ff | 2016-02-04 01:24:52 -0800 | [diff] [blame] | 1768 | bool VideoChannel::SetSink(uint32_t ssrc, |
nisse | acd935b | 2016-11-11 03:55:13 -0800 | [diff] [blame] | 1769 | rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { |
nisse | 08582ff | 2016-02-04 01:24:52 -0800 | [diff] [blame] | 1770 | worker_thread()->Invoke<void>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 1771 | RTC_FROM_HERE, |
nisse | 08582ff | 2016-02-04 01:24:52 -0800 | [diff] [blame] | 1772 | Bind(&VideoMediaChannel::SetSink, media_channel(), ssrc, sink)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1773 | return true; |
| 1774 | } |
| 1775 | |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1776 | bool VideoChannel::SetVideoSend( |
nisse | 2ded9b1 | 2016-04-08 02:23:55 -0700 | [diff] [blame] | 1777 | uint32_t ssrc, |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1778 | bool mute, |
| 1779 | const VideoOptions* options, |
nisse | acd935b | 2016-11-11 03:55:13 -0800 | [diff] [blame] | 1780 | rtc::VideoSourceInterface<webrtc::VideoFrame>* source) { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 1781 | return InvokeOnWorker<bool>( |
| 1782 | RTC_FROM_HERE, Bind(&VideoMediaChannel::SetVideoSend, media_channel(), |
| 1783 | ssrc, mute, options, source)); |
solenberg | 1dd98f3 | 2015-09-10 01:57:14 -0700 | [diff] [blame] | 1784 | } |
| 1785 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1786 | webrtc::RtpParameters VideoChannel::GetRtpSendParameters(uint32_t ssrc) const { |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1787 | return worker_thread()->Invoke<webrtc::RtpParameters>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 1788 | RTC_FROM_HERE, Bind(&VideoChannel::GetRtpSendParameters_w, this, ssrc)); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1789 | } |
| 1790 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1791 | webrtc::RtpParameters VideoChannel::GetRtpSendParameters_w( |
| 1792 | uint32_t ssrc) const { |
| 1793 | return media_channel()->GetRtpSendParameters(ssrc); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1794 | } |
| 1795 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1796 | bool VideoChannel::SetRtpSendParameters( |
| 1797 | uint32_t ssrc, |
| 1798 | const webrtc::RtpParameters& parameters) { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 1799 | return InvokeOnWorker<bool>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 1800 | RTC_FROM_HERE, |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1801 | Bind(&VideoChannel::SetRtpSendParameters_w, this, ssrc, parameters)); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1802 | } |
| 1803 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1804 | bool VideoChannel::SetRtpSendParameters_w(uint32_t ssrc, |
| 1805 | webrtc::RtpParameters parameters) { |
| 1806 | return media_channel()->SetRtpSendParameters(ssrc, parameters); |
| 1807 | } |
| 1808 | |
| 1809 | webrtc::RtpParameters VideoChannel::GetRtpReceiveParameters( |
| 1810 | uint32_t ssrc) const { |
| 1811 | return worker_thread()->Invoke<webrtc::RtpParameters>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 1812 | RTC_FROM_HERE, |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1813 | Bind(&VideoChannel::GetRtpReceiveParameters_w, this, ssrc)); |
| 1814 | } |
| 1815 | |
| 1816 | webrtc::RtpParameters VideoChannel::GetRtpReceiveParameters_w( |
| 1817 | uint32_t ssrc) const { |
| 1818 | return media_channel()->GetRtpReceiveParameters(ssrc); |
| 1819 | } |
| 1820 | |
| 1821 | bool VideoChannel::SetRtpReceiveParameters( |
| 1822 | uint32_t ssrc, |
| 1823 | const webrtc::RtpParameters& parameters) { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 1824 | return InvokeOnWorker<bool>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 1825 | RTC_FROM_HERE, |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1826 | Bind(&VideoChannel::SetRtpReceiveParameters_w, this, ssrc, parameters)); |
| 1827 | } |
| 1828 | |
| 1829 | bool VideoChannel::SetRtpReceiveParameters_w(uint32_t ssrc, |
| 1830 | webrtc::RtpParameters parameters) { |
| 1831 | return media_channel()->SetRtpReceiveParameters(ssrc, parameters); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1832 | } |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 1833 | |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1834 | void VideoChannel::UpdateMediaSendRecvState_w() { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1835 | // Send outgoing data if we're the active call, we have the remote content, |
| 1836 | // and we have had some form of connectivity. |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1837 | bool send = IsReadyToSendMedia_w(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1838 | if (!media_channel()->SetSend(send)) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1839 | RTC_LOG(LS_ERROR) << "Failed to SetSend on video channel"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1840 | // TODO(gangji): Report error back to server. |
| 1841 | } |
| 1842 | |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1843 | RTC_LOG(LS_INFO) << "Changing video state, send=" << send; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1844 | } |
| 1845 | |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 1846 | void VideoChannel::FillBitrateInfo(BandwidthEstimationInfo* bwe_info) { |
| 1847 | InvokeOnWorker<void>(RTC_FROM_HERE, Bind(&VideoMediaChannel::FillBitrateInfo, |
| 1848 | media_channel(), bwe_info)); |
| 1849 | } |
| 1850 | |
pbos@webrtc.org | 058b1f1 | 2015-03-04 08:54:32 +0000 | [diff] [blame] | 1851 | bool VideoChannel::GetStats(VideoMediaInfo* stats) { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 1852 | return InvokeOnWorker<bool>(RTC_FROM_HERE, Bind(&VideoMediaChannel::GetStats, |
| 1853 | media_channel(), stats)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1854 | } |
| 1855 | |
| 1856 | void VideoChannel::StartMediaMonitor(int cms) { |
| 1857 | media_monitor_.reset(new VideoMediaMonitor(media_channel(), worker_thread(), |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1858 | rtc::Thread::Current())); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1859 | media_monitor_->SignalUpdate.connect( |
| 1860 | this, &VideoChannel::OnMediaMonitorUpdate); |
| 1861 | media_monitor_->Start(cms); |
| 1862 | } |
| 1863 | |
| 1864 | void VideoChannel::StopMediaMonitor() { |
| 1865 | if (media_monitor_) { |
| 1866 | media_monitor_->Stop(); |
| 1867 | media_monitor_.reset(); |
| 1868 | } |
| 1869 | } |
| 1870 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1871 | bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content, |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1872 | ContentAction action, |
| 1873 | std::string* error_desc) { |
Peter Boström | 9f45a45 | 2015-12-08 13:25:57 +0100 | [diff] [blame] | 1874 | TRACE_EVENT0("webrtc", "VideoChannel::SetLocalContent_w"); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1875 | RTC_DCHECK(worker_thread() == rtc::Thread::Current()); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1876 | RTC_LOG(LS_INFO) << "Setting local video description"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1877 | |
| 1878 | const VideoContentDescription* video = |
| 1879 | static_cast<const VideoContentDescription*>(content); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1880 | RTC_DCHECK(video != NULL); |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1881 | if (!video) { |
| 1882 | SafeSetError("Can't find video content in local description.", error_desc); |
| 1883 | return false; |
| 1884 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1885 | |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 1886 | RtpHeaderExtensions rtp_header_extensions = |
| 1887 | GetFilteredRtpHeaderExtensions(video->rtp_header_extensions()); |
| 1888 | |
| 1889 | if (!SetRtpTransportParameters(content, action, CS_LOCAL, |
| 1890 | rtp_header_extensions, error_desc)) { |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1891 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1892 | } |
| 1893 | |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1894 | VideoRecvParameters recv_params = last_recv_params_; |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 1895 | RtpParametersFromMediaDescription(video, rtp_header_extensions, &recv_params); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1896 | if (!media_channel()->SetRecvParameters(recv_params)) { |
| 1897 | SafeSetError("Failed to set local video description recv parameters.", |
| 1898 | error_desc); |
| 1899 | return false; |
| 1900 | } |
| 1901 | for (const VideoCodec& codec : video->codecs()) { |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 1902 | AddHandledPayloadType(codec.id); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1903 | } |
| 1904 | last_recv_params_ = recv_params; |
| 1905 | |
| 1906 | // TODO(pthatcher): Move local streams into VideoSendParameters, and |
| 1907 | // only give it to the media channel once we have a remote |
| 1908 | // description too (without a remote description, we won't be able |
| 1909 | // to send them anyway). |
| 1910 | if (!UpdateLocalStreams_w(video->streams(), action, error_desc)) { |
| 1911 | SafeSetError("Failed to set local video description streams.", error_desc); |
| 1912 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1913 | } |
| 1914 | |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1915 | set_local_content_direction(content->direction()); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1916 | UpdateMediaSendRecvState_w(); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1917 | return true; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1918 | } |
| 1919 | |
| 1920 | bool VideoChannel::SetRemoteContent_w(const MediaContentDescription* content, |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1921 | ContentAction action, |
| 1922 | std::string* error_desc) { |
Peter Boström | 9f45a45 | 2015-12-08 13:25:57 +0100 | [diff] [blame] | 1923 | TRACE_EVENT0("webrtc", "VideoChannel::SetRemoteContent_w"); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1924 | RTC_DCHECK(worker_thread() == rtc::Thread::Current()); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1925 | RTC_LOG(LS_INFO) << "Setting remote video description"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1926 | |
| 1927 | const VideoContentDescription* video = |
| 1928 | static_cast<const VideoContentDescription*>(content); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1929 | RTC_DCHECK(video != NULL); |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 1930 | if (!video) { |
| 1931 | SafeSetError("Can't find video content in remote description.", error_desc); |
| 1932 | return false; |
| 1933 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1934 | |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 1935 | RtpHeaderExtensions rtp_header_extensions = |
| 1936 | GetFilteredRtpHeaderExtensions(video->rtp_header_extensions()); |
| 1937 | |
| 1938 | if (!SetRtpTransportParameters(content, action, CS_REMOTE, |
| 1939 | rtp_header_extensions, error_desc)) { |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1940 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1941 | } |
| 1942 | |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1943 | VideoSendParameters send_params = last_send_params_; |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 1944 | RtpSendParametersFromMediaDescription(video, rtp_header_extensions, |
| 1945 | &send_params); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1946 | if (video->conference_mode()) { |
nisse | 4b4dc86 | 2016-02-17 05:25:36 -0800 | [diff] [blame] | 1947 | send_params.conference_mode = true; |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1948 | } |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1949 | |
| 1950 | bool parameters_applied = media_channel()->SetSendParameters(send_params); |
| 1951 | |
| 1952 | if (!parameters_applied) { |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1953 | SafeSetError("Failed to set remote video description send parameters.", |
| 1954 | error_desc); |
| 1955 | return false; |
| 1956 | } |
| 1957 | last_send_params_ = send_params; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1958 | |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1959 | // TODO(pthatcher): Move remote streams into VideoRecvParameters, |
| 1960 | // and only give it to the media channel once we have a local |
| 1961 | // description too (without a local description, we won't be able to |
| 1962 | // recv them anyway). |
| 1963 | if (!UpdateRemoteStreams_w(video->streams(), action, error_desc)) { |
| 1964 | SafeSetError("Failed to set remote video description streams.", error_desc); |
| 1965 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1966 | } |
| 1967 | |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1968 | if (video->rtp_header_extensions_set()) { |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 1969 | MaybeCacheRtpAbsSendTimeHeaderExtension_w(rtp_header_extensions); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1970 | } |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1971 | |
| 1972 | set_remote_content_direction(content->direction()); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 1973 | UpdateMediaSendRecvState_w(); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1974 | return true; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1975 | } |
| 1976 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1977 | void VideoChannel::OnMessage(rtc::Message *pmsg) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1978 | switch (pmsg->message_id) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1979 | case MSG_CHANNEL_ERROR: { |
| 1980 | const VideoChannelErrorMessageData* data = |
| 1981 | static_cast<VideoChannelErrorMessageData*>(pmsg->pdata); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1982 | delete data; |
| 1983 | break; |
| 1984 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1985 | default: |
| 1986 | BaseChannel::OnMessage(pmsg); |
| 1987 | break; |
| 1988 | } |
| 1989 | } |
| 1990 | |
| 1991 | void VideoChannel::OnConnectionMonitorUpdate( |
pthatcher@webrtc.org | b4aac13 | 2015-03-13 18:25:21 +0000 | [diff] [blame] | 1992 | ConnectionMonitor* monitor, const std::vector<ConnectionInfo> &infos) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1993 | SignalConnectionMonitor(this, infos); |
| 1994 | } |
| 1995 | |
| 1996 | // TODO(pthatcher): Look into removing duplicate code between |
| 1997 | // audio, video, and data, perhaps by using templates. |
| 1998 | void VideoChannel::OnMediaMonitorUpdate( |
| 1999 | VideoMediaChannel* media_channel, const VideoMediaInfo &info) { |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 2000 | RTC_DCHECK(media_channel == this->media_channel()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2001 | SignalMediaMonitor(this, info); |
| 2002 | } |
| 2003 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2004 | RtpDataChannel::RtpDataChannel(rtc::Thread* worker_thread, |
| 2005 | rtc::Thread* network_thread, |
zhihuang | f5b251b | 2017-01-12 19:37:48 -0800 | [diff] [blame] | 2006 | rtc::Thread* signaling_thread, |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 2007 | std::unique_ptr<DataMediaChannel> media_channel, |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2008 | const std::string& content_name, |
deadbeef | ac22f70 | 2017-01-12 21:59:29 -0800 | [diff] [blame] | 2009 | bool rtcp_mux_required, |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2010 | bool srtp_required) |
Danil Chapovalov | 33b01f2 | 2016-05-11 19:55:27 +0200 | [diff] [blame] | 2011 | : BaseChannel(worker_thread, |
| 2012 | network_thread, |
zhihuang | f5b251b | 2017-01-12 19:37:48 -0800 | [diff] [blame] | 2013 | signaling_thread, |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 2014 | std::move(media_channel), |
deadbeef | cbecd35 | 2015-09-23 11:50:27 -0700 | [diff] [blame] | 2015 | content_name, |
deadbeef | ac22f70 | 2017-01-12 21:59:29 -0800 | [diff] [blame] | 2016 | rtcp_mux_required, |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2017 | srtp_required) {} |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2018 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2019 | RtpDataChannel::~RtpDataChannel() { |
| 2020 | TRACE_EVENT0("webrtc", "RtpDataChannel::~RtpDataChannel"); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2021 | StopMediaMonitor(); |
| 2022 | // this can't be done in the base class, since it calls a virtual |
| 2023 | DisableMedia_w(); |
wu@webrtc.org | 7818752 | 2013-10-07 23:32:02 +0000 | [diff] [blame] | 2024 | |
| 2025 | Deinit(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2026 | } |
| 2027 | |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 2028 | void RtpDataChannel::Init_w( |
deadbeef | f534659 | 2017-01-24 21:51:21 -0800 | [diff] [blame] | 2029 | DtlsTransportInternal* rtp_dtls_transport, |
| 2030 | DtlsTransportInternal* rtcp_dtls_transport, |
deadbeef | 5bd5ca3 | 2017-02-10 11:31:50 -0800 | [diff] [blame] | 2031 | rtc::PacketTransportInternal* rtp_packet_transport, |
| 2032 | rtc::PacketTransportInternal* rtcp_packet_transport) { |
Steve Anton | 8699a32 | 2017-11-06 15:53:33 -0800 | [diff] [blame] | 2033 | BaseChannel::Init_w(rtp_dtls_transport, rtcp_dtls_transport, |
| 2034 | rtp_packet_transport, rtcp_packet_transport); |
| 2035 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2036 | media_channel()->SignalDataReceived.connect(this, |
| 2037 | &RtpDataChannel::OnDataReceived); |
wu@webrtc.org | d64719d | 2013-08-01 00:00:07 +0000 | [diff] [blame] | 2038 | media_channel()->SignalReadyToSend.connect( |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2039 | this, &RtpDataChannel::OnDataChannelReadyToSend); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2040 | } |
| 2041 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2042 | bool RtpDataChannel::SendData(const SendDataParams& params, |
| 2043 | const rtc::CopyOnWriteBuffer& payload, |
| 2044 | SendDataResult* result) { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 2045 | return InvokeOnWorker<bool>( |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 2046 | RTC_FROM_HERE, Bind(&DataMediaChannel::SendData, media_channel(), params, |
| 2047 | payload, result)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2048 | } |
| 2049 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2050 | bool RtpDataChannel::CheckDataChannelTypeFromContent( |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 2051 | const DataContentDescription* content, |
| 2052 | std::string* error_desc) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2053 | bool is_sctp = ((content->protocol() == kMediaProtocolSctp) || |
| 2054 | (content->protocol() == kMediaProtocolDtlsSctp)); |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2055 | // It's been set before, but doesn't match. That's bad. |
| 2056 | if (is_sctp) { |
| 2057 | SafeSetError("Data channel type mismatch. Expected RTP, got SCTP.", |
| 2058 | error_desc); |
| 2059 | return false; |
| 2060 | } |
| 2061 | return true; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2062 | } |
| 2063 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2064 | bool RtpDataChannel::SetLocalContent_w(const MediaContentDescription* content, |
| 2065 | ContentAction action, |
| 2066 | std::string* error_desc) { |
| 2067 | TRACE_EVENT0("webrtc", "RtpDataChannel::SetLocalContent_w"); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 2068 | RTC_DCHECK(worker_thread() == rtc::Thread::Current()); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 2069 | RTC_LOG(LS_INFO) << "Setting local data description"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2070 | |
| 2071 | const DataContentDescription* data = |
| 2072 | static_cast<const DataContentDescription*>(content); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 2073 | RTC_DCHECK(data != NULL); |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 2074 | if (!data) { |
| 2075 | SafeSetError("Can't find data content in local description.", error_desc); |
| 2076 | return false; |
| 2077 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2078 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2079 | if (!CheckDataChannelTypeFromContent(data, error_desc)) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2080 | return false; |
| 2081 | } |
| 2082 | |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 2083 | RtpHeaderExtensions rtp_header_extensions = |
| 2084 | GetFilteredRtpHeaderExtensions(data->rtp_header_extensions()); |
| 2085 | |
| 2086 | if (!SetRtpTransportParameters(content, action, CS_LOCAL, |
| 2087 | rtp_header_extensions, error_desc)) { |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2088 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2089 | } |
| 2090 | |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 2091 | DataRecvParameters recv_params = last_recv_params_; |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 2092 | RtpParametersFromMediaDescription(data, rtp_header_extensions, &recv_params); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 2093 | if (!media_channel()->SetRecvParameters(recv_params)) { |
| 2094 | SafeSetError("Failed to set remote data description recv parameters.", |
| 2095 | error_desc); |
| 2096 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2097 | } |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2098 | for (const DataCodec& codec : data->codecs()) { |
zstein | 3dcf0e9 | 2017-06-01 13:22:42 -0700 | [diff] [blame] | 2099 | AddHandledPayloadType(codec.id); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 2100 | } |
| 2101 | last_recv_params_ = recv_params; |
| 2102 | |
| 2103 | // TODO(pthatcher): Move local streams into DataSendParameters, and |
| 2104 | // only give it to the media channel once we have a remote |
| 2105 | // description too (without a remote description, we won't be able |
| 2106 | // to send them anyway). |
| 2107 | if (!UpdateLocalStreams_w(data->streams(), action, error_desc)) { |
| 2108 | SafeSetError("Failed to set local data description streams.", error_desc); |
| 2109 | return false; |
| 2110 | } |
| 2111 | |
| 2112 | set_local_content_direction(content->direction()); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 2113 | UpdateMediaSendRecvState_w(); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 2114 | return true; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2115 | } |
| 2116 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2117 | bool RtpDataChannel::SetRemoteContent_w(const MediaContentDescription* content, |
| 2118 | ContentAction action, |
| 2119 | std::string* error_desc) { |
| 2120 | TRACE_EVENT0("webrtc", "RtpDataChannel::SetRemoteContent_w"); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 2121 | RTC_DCHECK(worker_thread() == rtc::Thread::Current()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2122 | |
| 2123 | const DataContentDescription* data = |
| 2124 | static_cast<const DataContentDescription*>(content); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 2125 | RTC_DCHECK(data != NULL); |
sergeyu@chromium.org | 4b26e2e | 2014-01-15 23:15:54 +0000 | [diff] [blame] | 2126 | if (!data) { |
| 2127 | SafeSetError("Can't find data content in remote description.", error_desc); |
| 2128 | return false; |
| 2129 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2130 | |
Zhi Huang | 801b868 | 2017-11-15 11:36:43 -0800 | [diff] [blame] | 2131 | // If the remote data doesn't have codecs, it must be empty, so ignore it. |
| 2132 | if (!data->has_codecs()) { |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 2133 | return true; |
| 2134 | } |
| 2135 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2136 | if (!CheckDataChannelTypeFromContent(data, error_desc)) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2137 | return false; |
| 2138 | } |
| 2139 | |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 2140 | RtpHeaderExtensions rtp_header_extensions = |
| 2141 | GetFilteredRtpHeaderExtensions(data->rtp_header_extensions()); |
| 2142 | |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 2143 | RTC_LOG(LS_INFO) << "Setting remote data description"; |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 2144 | if (!SetRtpTransportParameters(content, action, CS_REMOTE, |
| 2145 | rtp_header_extensions, error_desc)) { |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 2146 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2147 | } |
| 2148 | |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 2149 | DataSendParameters send_params = last_send_params_; |
jbauch | 5869f50 | 2017-06-29 12:31:36 -0700 | [diff] [blame] | 2150 | RtpSendParametersFromMediaDescription<DataCodec>(data, rtp_header_extensions, |
| 2151 | &send_params); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 2152 | if (!media_channel()->SetSendParameters(send_params)) { |
| 2153 | SafeSetError("Failed to set remote data description send parameters.", |
| 2154 | error_desc); |
| 2155 | return false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2156 | } |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 2157 | last_send_params_ = send_params; |
| 2158 | |
| 2159 | // TODO(pthatcher): Move remote streams into DataRecvParameters, |
| 2160 | // and only give it to the media channel once we have a local |
| 2161 | // description too (without a local description, we won't be able to |
| 2162 | // recv them anyway). |
| 2163 | if (!UpdateRemoteStreams_w(data->streams(), action, error_desc)) { |
| 2164 | SafeSetError("Failed to set remote data description streams.", |
| 2165 | error_desc); |
| 2166 | return false; |
| 2167 | } |
| 2168 | |
| 2169 | set_remote_content_direction(content->direction()); |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 2170 | UpdateMediaSendRecvState_w(); |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 2171 | return true; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2172 | } |
| 2173 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2174 | void RtpDataChannel::UpdateMediaSendRecvState_w() { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2175 | // Render incoming data if we're the active call, and we have the local |
| 2176 | // content. We receive data on the default channel and multiplexed streams. |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 2177 | bool recv = IsReadyToReceiveMedia_w(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2178 | if (!media_channel()->SetReceive(recv)) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 2179 | RTC_LOG(LS_ERROR) << "Failed to SetReceive on data channel"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2180 | } |
| 2181 | |
| 2182 | // Send outgoing data if we're the active call, we have the remote content, |
| 2183 | // and we have had some form of connectivity. |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 2184 | bool send = IsReadyToSendMedia_w(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2185 | if (!media_channel()->SetSend(send)) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 2186 | RTC_LOG(LS_ERROR) << "Failed to SetSend on data channel"; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2187 | } |
| 2188 | |
sergeyu@chromium.org | 9cf037b | 2014-02-07 19:03:26 +0000 | [diff] [blame] | 2189 | // Trigger SignalReadyToSendData asynchronously. |
| 2190 | OnDataChannelReadyToSend(send); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2191 | |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 2192 | RTC_LOG(LS_INFO) << "Changing data state, recv=" << recv << " send=" << send; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2193 | } |
| 2194 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2195 | void RtpDataChannel::OnMessage(rtc::Message* pmsg) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2196 | switch (pmsg->message_id) { |
| 2197 | case MSG_READYTOSENDDATA: { |
wu@webrtc.org | d64719d | 2013-08-01 00:00:07 +0000 | [diff] [blame] | 2198 | DataChannelReadyToSendMessageData* data = |
| 2199 | static_cast<DataChannelReadyToSendMessageData*>(pmsg->pdata); |
wu@webrtc.org | 07a6fbe | 2013-11-04 18:41:34 +0000 | [diff] [blame] | 2200 | ready_to_send_data_ = data->data(); |
| 2201 | SignalReadyToSendData(ready_to_send_data_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2202 | delete data; |
| 2203 | break; |
| 2204 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2205 | case MSG_DATARECEIVED: { |
| 2206 | DataReceivedMessageData* data = |
| 2207 | static_cast<DataReceivedMessageData*>(pmsg->pdata); |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2208 | SignalDataReceived(data->params, data->payload); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2209 | delete data; |
| 2210 | break; |
| 2211 | } |
| 2212 | case MSG_CHANNEL_ERROR: { |
| 2213 | const DataChannelErrorMessageData* data = |
| 2214 | static_cast<DataChannelErrorMessageData*>(pmsg->pdata); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2215 | delete data; |
| 2216 | break; |
| 2217 | } |
| 2218 | default: |
| 2219 | BaseChannel::OnMessage(pmsg); |
| 2220 | break; |
| 2221 | } |
| 2222 | } |
| 2223 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2224 | void RtpDataChannel::OnConnectionMonitorUpdate( |
| 2225 | ConnectionMonitor* monitor, |
| 2226 | const std::vector<ConnectionInfo>& infos) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2227 | SignalConnectionMonitor(this, infos); |
| 2228 | } |
| 2229 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2230 | void RtpDataChannel::StartMediaMonitor(int cms) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2231 | media_monitor_.reset(new DataMediaMonitor(media_channel(), worker_thread(), |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 2232 | rtc::Thread::Current())); |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2233 | media_monitor_->SignalUpdate.connect(this, |
| 2234 | &RtpDataChannel::OnMediaMonitorUpdate); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2235 | media_monitor_->Start(cms); |
| 2236 | } |
| 2237 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2238 | void RtpDataChannel::StopMediaMonitor() { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2239 | if (media_monitor_) { |
| 2240 | media_monitor_->Stop(); |
| 2241 | media_monitor_->SignalUpdate.disconnect(this); |
| 2242 | media_monitor_.reset(); |
| 2243 | } |
| 2244 | } |
| 2245 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2246 | void RtpDataChannel::OnMediaMonitorUpdate(DataMediaChannel* media_channel, |
| 2247 | const DataMediaInfo& info) { |
Taylor Brandstetter | bad33bf | 2016-08-25 13:31:14 -0700 | [diff] [blame] | 2248 | RTC_DCHECK(media_channel == this->media_channel()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2249 | SignalMediaMonitor(this, info); |
| 2250 | } |
| 2251 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2252 | void RtpDataChannel::OnDataReceived(const ReceiveDataParams& params, |
| 2253 | const char* data, |
| 2254 | size_t len) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2255 | DataReceivedMessageData* msg = new DataReceivedMessageData( |
| 2256 | params, data, len); |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 2257 | signaling_thread()->Post(RTC_FROM_HERE, this, MSG_DATARECEIVED, msg); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2258 | } |
| 2259 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2260 | void RtpDataChannel::OnDataChannelError(uint32_t ssrc, |
| 2261 | DataMediaChannel::Error err) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2262 | DataChannelErrorMessageData* data = new DataChannelErrorMessageData( |
| 2263 | ssrc, err); |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 2264 | signaling_thread()->Post(RTC_FROM_HERE, this, MSG_CHANNEL_ERROR, data); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2265 | } |
| 2266 | |
deadbeef | 953c2ce | 2017-01-09 14:53:41 -0800 | [diff] [blame] | 2267 | void RtpDataChannel::OnDataChannelReadyToSend(bool writable) { |
wu@webrtc.org | d64719d | 2013-08-01 00:00:07 +0000 | [diff] [blame] | 2268 | // This is usded for congestion control to indicate that the stream is ready |
| 2269 | // to send by the MediaChannel, as opposed to OnReadyToSend, which indicates |
| 2270 | // that the transport channel is ready. |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 2271 | signaling_thread()->Post(RTC_FROM_HERE, this, MSG_READYTOSENDDATA, |
wu@webrtc.org | d64719d | 2013-08-01 00:00:07 +0000 | [diff] [blame] | 2272 | new DataChannelReadyToSendMessageData(writable)); |
| 2273 | } |
| 2274 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 2275 | } // namespace cricket |