henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1 | /* |
kjellander | b24317b | 2016-02-10 07:54:43 -0800 | [diff] [blame] | 2 | * Copyright 2012 The WebRTC project authors. All Rights Reserved. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3 | * |
kjellander | b24317b | 2016-02-10 07:54:43 -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 | |
| 11 | // This file contains the PeerConnection interface as defined in |
| 12 | // http://dev.w3.org/2011/webrtc/editor/webrtc.html#peer-to-peer-connections. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 13 | // |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 14 | // The PeerConnectionFactory class provides factory methods to create |
| 15 | // PeerConnection, MediaStream and MediaStreamTrack objects. |
| 16 | // |
| 17 | // The following steps are needed to setup a typical call using WebRTC: |
| 18 | // |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 19 | // 1. Create a PeerConnectionFactoryInterface. Check constructors for more |
| 20 | // information about input parameters. |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 21 | // |
| 22 | // 2. Create a PeerConnection object. Provide a configuration struct which |
| 23 | // points to STUN and/or TURN servers used to generate ICE candidates, and |
| 24 | // provide an object that implements the PeerConnectionObserver interface, |
| 25 | // which is used to receive callbacks from the PeerConnection. |
| 26 | // |
| 27 | // 3. Create local MediaStreamTracks using the PeerConnectionFactory and add |
| 28 | // them to PeerConnection by calling AddTrack (or legacy method, AddStream). |
| 29 | // |
| 30 | // 4. Create an offer, call SetLocalDescription with it, serialize it, and send |
| 31 | // it to the remote peer |
| 32 | // |
| 33 | // 5. Once an ICE candidate has been gathered, the PeerConnection will call the |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 34 | // observer function OnIceCandidate. The candidates must also be serialized and |
| 35 | // sent to the remote peer. |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 36 | // |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 37 | // 6. Once an answer is received from the remote peer, call |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 38 | // SetRemoteDescription with the remote answer. |
| 39 | // |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 40 | // 7. Once a remote candidate is received from the remote peer, provide it to |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 41 | // the PeerConnection by calling AddIceCandidate. |
| 42 | // |
| 43 | // The receiver of a call (assuming the application is "call"-based) can decide |
| 44 | // to accept or reject the call; this decision will be taken by the application, |
| 45 | // not the PeerConnection. |
| 46 | // |
| 47 | // If the application decides to accept the call, it should: |
| 48 | // |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 49 | // 1. Create PeerConnectionFactoryInterface if it doesn't exist. |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 50 | // |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 51 | // 2. Create a new PeerConnection. |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 52 | // |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 53 | // 3. Provide the remote offer to the new PeerConnection object by calling |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 54 | // SetRemoteDescription. |
| 55 | // |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 56 | // 4. Generate an answer to the remote offer by calling CreateAnswer and send it |
| 57 | // back to the remote peer. |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 58 | // |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 59 | // 5. Provide the local answer to the new PeerConnection by calling |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 60 | // SetLocalDescription with the answer. |
| 61 | // |
| 62 | // 6. Provide the remote ICE candidates by calling AddIceCandidate. |
| 63 | // |
| 64 | // 7. Once a candidate has been gathered, the PeerConnection will call the |
| 65 | // observer function OnIceCandidate. Send these candidates to the remote peer. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 66 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 67 | #ifndef API_PEERCONNECTIONINTERFACE_H_ |
| 68 | #define API_PEERCONNECTIONINTERFACE_H_ |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 69 | |
Sami Kalliomäki | 02879f9 | 2018-01-11 10:02:19 +0100 | [diff] [blame] | 70 | // TODO(sakal): Remove this define after migration to virtual PeerConnection |
| 71 | // observer is complete. |
| 72 | #define VIRTUAL_PEERCONNECTION_OBSERVER_DESTRUCTOR |
| 73 | |
kwiberg | d1fe281 | 2016-04-27 06:47:29 -0700 | [diff] [blame] | 74 | #include <memory> |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 75 | #include <string> |
kwiberg | 0eb15ed | 2015-12-17 03:04:15 -0800 | [diff] [blame] | 76 | #include <utility> |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 77 | #include <vector> |
| 78 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 79 | #include "api/audio_codecs/audio_decoder_factory.h" |
| 80 | #include "api/audio_codecs/audio_encoder_factory.h" |
Niels Möller | a6fe261 | 2018-01-19 11:28:54 +0100 | [diff] [blame] | 81 | #include "api/audio_options.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 82 | #include "api/datachannelinterface.h" |
| 83 | #include "api/dtmfsenderinterface.h" |
| 84 | #include "api/jsep.h" |
| 85 | #include "api/mediastreaminterface.h" |
| 86 | #include "api/rtcerror.h" |
Elad Alon | 99c3fe5 | 2017-10-13 16:29:40 +0200 | [diff] [blame] | 87 | #include "api/rtceventlogoutput.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 88 | #include "api/rtpreceiverinterface.h" |
| 89 | #include "api/rtpsenderinterface.h" |
Steve Anton | 9158ef6 | 2017-11-27 13:01:52 -0800 | [diff] [blame] | 90 | #include "api/rtptransceiverinterface.h" |
Henrik Boström | 3163867 | 2017-11-23 17:48:32 +0100 | [diff] [blame] | 91 | #include "api/setremotedescriptionobserverinterface.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 92 | #include "api/stats/rtcstatscollectorcallback.h" |
| 93 | #include "api/statstypes.h" |
Jonas Oreland | bdcee28 | 2017-10-10 14:01:40 +0200 | [diff] [blame] | 94 | #include "api/turncustomizer.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 95 | #include "api/umametrics.h" |
| 96 | #include "call/callfactoryinterface.h" |
| 97 | #include "logging/rtc_event_log/rtc_event_log_factory_interface.h" |
Niels Möller | 6daa278 | 2018-01-23 10:37:42 +0100 | [diff] [blame] | 98 | #include "media/base/mediaconfig.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 99 | #include "media/base/videocapturer.h" |
| 100 | #include "p2p/base/portallocator.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 101 | #include "rtc_base/network.h" |
| 102 | #include "rtc_base/rtccertificate.h" |
| 103 | #include "rtc_base/rtccertificategenerator.h" |
| 104 | #include "rtc_base/socketaddress.h" |
| 105 | #include "rtc_base/sslstreamadapter.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 106 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 107 | namespace rtc { |
jiayl@webrtc.org | 61e00b0 | 2015-03-04 22:17:38 +0000 | [diff] [blame] | 108 | class SSLIdentity; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 109 | class Thread; |
| 110 | } |
| 111 | |
| 112 | namespace cricket { |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 113 | class MediaEngineInterface; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 114 | class WebRtcVideoDecoderFactory; |
| 115 | class WebRtcVideoEncoderFactory; |
| 116 | } |
| 117 | |
| 118 | namespace webrtc { |
| 119 | class AudioDeviceModule; |
gyzhou | 95aa964 | 2016-12-13 14:06:26 -0800 | [diff] [blame] | 120 | class AudioMixer; |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 121 | class CallFactoryInterface; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 122 | class MediaConstraintsInterface; |
Magnus Jedvert | 58b0316 | 2017-09-15 19:02:47 +0200 | [diff] [blame] | 123 | class VideoDecoderFactory; |
| 124 | class VideoEncoderFactory; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 125 | |
| 126 | // MediaStream container interface. |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 127 | class StreamCollectionInterface : public rtc::RefCountInterface { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 128 | public: |
| 129 | // TODO(ronghuawu): Update the function names to c++ style, e.g. find -> Find. |
| 130 | virtual size_t count() = 0; |
| 131 | virtual MediaStreamInterface* at(size_t index) = 0; |
| 132 | virtual MediaStreamInterface* find(const std::string& label) = 0; |
| 133 | virtual MediaStreamTrackInterface* FindAudioTrack( |
| 134 | const std::string& id) = 0; |
| 135 | virtual MediaStreamTrackInterface* FindVideoTrack( |
| 136 | const std::string& id) = 0; |
| 137 | |
| 138 | protected: |
| 139 | // Dtor protected as objects shouldn't be deleted via this interface. |
| 140 | ~StreamCollectionInterface() {} |
| 141 | }; |
| 142 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 143 | class StatsObserver : public rtc::RefCountInterface { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 144 | public: |
nisse | e8abe3e | 2017-01-18 05:00:34 -0800 | [diff] [blame] | 145 | virtual void OnComplete(const StatsReports& reports) = 0; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 146 | |
| 147 | protected: |
| 148 | virtual ~StatsObserver() {} |
| 149 | }; |
| 150 | |
Steve Anton | 79e7960 | 2017-11-20 10:25:56 -0800 | [diff] [blame] | 151 | // For now, kDefault is interpreted as kPlanB. |
| 152 | // TODO(bugs.webrtc.org/8530): Switch default to kUnifiedPlan. |
| 153 | enum class SdpSemantics { kDefault, kPlanB, kUnifiedPlan }; |
| 154 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 155 | class PeerConnectionInterface : public rtc::RefCountInterface { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 156 | public: |
| 157 | // See http://dev.w3.org/2011/webrtc/editor/webrtc.html#state-definitions . |
| 158 | enum SignalingState { |
| 159 | kStable, |
| 160 | kHaveLocalOffer, |
| 161 | kHaveLocalPrAnswer, |
| 162 | kHaveRemoteOffer, |
| 163 | kHaveRemotePrAnswer, |
| 164 | kClosed, |
| 165 | }; |
| 166 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 167 | enum IceGatheringState { |
| 168 | kIceGatheringNew, |
| 169 | kIceGatheringGathering, |
| 170 | kIceGatheringComplete |
| 171 | }; |
| 172 | |
| 173 | enum IceConnectionState { |
| 174 | kIceConnectionNew, |
| 175 | kIceConnectionChecking, |
| 176 | kIceConnectionConnected, |
| 177 | kIceConnectionCompleted, |
| 178 | kIceConnectionFailed, |
| 179 | kIceConnectionDisconnected, |
| 180 | kIceConnectionClosed, |
Guo-wei Shieh | 3d564c1 | 2015-08-19 16:51:15 -0700 | [diff] [blame] | 181 | kIceConnectionMax, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 182 | }; |
| 183 | |
hnsl | 0483362 | 2017-01-09 08:35:45 -0800 | [diff] [blame] | 184 | // TLS certificate policy. |
| 185 | enum TlsCertPolicy { |
| 186 | // For TLS based protocols, ensure the connection is secure by not |
| 187 | // circumventing certificate validation. |
| 188 | kTlsCertPolicySecure, |
| 189 | // For TLS based protocols, disregard security completely by skipping |
| 190 | // certificate validation. This is insecure and should never be used unless |
| 191 | // security is irrelevant in that particular context. |
| 192 | kTlsCertPolicyInsecureNoCheck, |
| 193 | }; |
| 194 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 195 | struct IceServer { |
Joachim Bauch | 7c4e745 | 2015-05-28 23:06:30 +0200 | [diff] [blame] | 196 | // TODO(jbauch): Remove uri when all code using it has switched to urls. |
Emad Omara | dab1d2d | 2017-06-16 15:43:11 -0700 | [diff] [blame] | 197 | // List of URIs associated with this server. Valid formats are described |
| 198 | // in RFC7064 and RFC7065, and more may be added in the future. The "host" |
| 199 | // part of the URI may contain either an IP address or a hostname. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 200 | std::string uri; |
Joachim Bauch | 7c4e745 | 2015-05-28 23:06:30 +0200 | [diff] [blame] | 201 | std::vector<std::string> urls; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 202 | std::string username; |
| 203 | std::string password; |
hnsl | 0483362 | 2017-01-09 08:35:45 -0800 | [diff] [blame] | 204 | TlsCertPolicy tls_cert_policy = kTlsCertPolicySecure; |
Emad Omara | dab1d2d | 2017-06-16 15:43:11 -0700 | [diff] [blame] | 205 | // If the URIs in |urls| only contain IP addresses, this field can be used |
| 206 | // to indicate the hostname, which may be necessary for TLS (using the SNI |
| 207 | // extension). If |urls| itself contains the hostname, this isn't |
| 208 | // necessary. |
| 209 | std::string hostname; |
Diogo Real | 1dca9d5 | 2017-08-29 12:18:32 -0700 | [diff] [blame] | 210 | // List of protocols to be used in the TLS ALPN extension. |
| 211 | std::vector<std::string> tls_alpn_protocols; |
Diogo Real | 7bd1f1b | 2017-09-08 12:50:41 -0700 | [diff] [blame] | 212 | // List of elliptic curves to be used in the TLS elliptic curves extension. |
| 213 | std::vector<std::string> tls_elliptic_curves; |
hnsl | 0483362 | 2017-01-09 08:35:45 -0800 | [diff] [blame] | 214 | |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 215 | bool operator==(const IceServer& o) const { |
| 216 | return uri == o.uri && urls == o.urls && username == o.username && |
Emad Omara | dab1d2d | 2017-06-16 15:43:11 -0700 | [diff] [blame] | 217 | password == o.password && tls_cert_policy == o.tls_cert_policy && |
Diogo Real | 1dca9d5 | 2017-08-29 12:18:32 -0700 | [diff] [blame] | 218 | hostname == o.hostname && |
Diogo Real | 7bd1f1b | 2017-09-08 12:50:41 -0700 | [diff] [blame] | 219 | tls_alpn_protocols == o.tls_alpn_protocols && |
| 220 | tls_elliptic_curves == o.tls_elliptic_curves; |
deadbeef | d1a38b5 | 2016-12-10 13:15:33 -0800 | [diff] [blame] | 221 | } |
| 222 | bool operator!=(const IceServer& o) const { return !(*this == o); } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 223 | }; |
| 224 | typedef std::vector<IceServer> IceServers; |
| 225 | |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 +0000 | [diff] [blame] | 226 | enum IceTransportsType { |
pthatcher@webrtc.org | fd630a5 | 2015-01-14 23:19:06 +0000 | [diff] [blame] | 227 | // TODO(pthatcher): Rename these kTransporTypeXXX, but update |
| 228 | // Chromium at the same time. |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 +0000 | [diff] [blame] | 229 | kNone, |
| 230 | kRelay, |
| 231 | kNoHost, |
| 232 | kAll |
| 233 | }; |
| 234 | |
pthatcher@webrtc.org | fd630a5 | 2015-01-14 23:19:06 +0000 | [diff] [blame] | 235 | // https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-08#section-4.1.1 |
| 236 | enum BundlePolicy { |
| 237 | kBundlePolicyBalanced, |
| 238 | kBundlePolicyMaxBundle, |
| 239 | kBundlePolicyMaxCompat |
| 240 | }; |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 +0000 | [diff] [blame] | 241 | |
Peter Thatcher | af55ccc | 2015-05-21 07:48:41 -0700 | [diff] [blame] | 242 | // https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-09#section-4.1.1 |
| 243 | enum RtcpMuxPolicy { |
| 244 | kRtcpMuxPolicyNegotiate, |
| 245 | kRtcpMuxPolicyRequire, |
| 246 | }; |
| 247 | |
Jiayang Liu | cac1b38 | 2015-04-30 12:35:24 -0700 | [diff] [blame] | 248 | enum TcpCandidatePolicy { |
| 249 | kTcpCandidatePolicyEnabled, |
| 250 | kTcpCandidatePolicyDisabled |
| 251 | }; |
| 252 | |
honghaiz | 6034705 | 2016-05-31 18:29:12 -0700 | [diff] [blame] | 253 | enum CandidateNetworkPolicy { |
| 254 | kCandidateNetworkPolicyAll, |
| 255 | kCandidateNetworkPolicyLowCost |
| 256 | }; |
| 257 | |
honghaiz | 1f429e3 | 2015-09-28 07:57:34 -0700 | [diff] [blame] | 258 | enum ContinualGatheringPolicy { |
| 259 | GATHER_ONCE, |
| 260 | GATHER_CONTINUALLY |
| 261 | }; |
| 262 | |
Honghai Zhang | f7ddc06 | 2016-09-01 15:34:01 -0700 | [diff] [blame] | 263 | enum class RTCConfigurationType { |
| 264 | // A configuration that is safer to use, despite not having the best |
| 265 | // performance. Currently this is the default configuration. |
| 266 | kSafe, |
| 267 | // An aggressive configuration that has better performance, although it |
| 268 | // may be riskier and may need extra support in the application. |
| 269 | kAggressive |
| 270 | }; |
| 271 | |
Henrik Boström | 87713d0 | 2015-08-25 09:53:21 +0200 | [diff] [blame] | 272 | // TODO(hbos): Change into class with private data and public getters. |
nisse | c36b31b | 2016-04-11 23:25:29 -0700 | [diff] [blame] | 273 | // TODO(nisse): In particular, accessing fields directly from an |
| 274 | // application is brittle, since the organization mirrors the |
| 275 | // organization of the implementation, which isn't stable. So we |
| 276 | // need getters and setters at least for fields which applications |
| 277 | // are interested in. |
pthatcher@webrtc.org | fd630a5 | 2015-01-14 23:19:06 +0000 | [diff] [blame] | 278 | struct RTCConfiguration { |
Niels Möller | 71bdda0 | 2016-03-31 12:59:59 +0200 | [diff] [blame] | 279 | // This struct is subject to reorganization, both for naming |
| 280 | // consistency, and to group settings to match where they are used |
| 281 | // in the implementation. To do that, we need getter and setter |
| 282 | // methods for all settings which are of interest to applications, |
| 283 | // Chrome in particular. |
| 284 | |
Honghai Zhang | f7ddc06 | 2016-09-01 15:34:01 -0700 | [diff] [blame] | 285 | RTCConfiguration() = default; |
oprypin | 803dc29 | 2017-02-01 01:55:59 -0800 | [diff] [blame] | 286 | explicit RTCConfiguration(RTCConfigurationType type) { |
Honghai Zhang | f7ddc06 | 2016-09-01 15:34:01 -0700 | [diff] [blame] | 287 | if (type == RTCConfigurationType::kAggressive) { |
Honghai Zhang | aecd982 | 2016-09-02 16:58:17 -0700 | [diff] [blame] | 288 | // These parameters are also defined in Java and IOS configurations, |
| 289 | // so their values may be overwritten by the Java or IOS configuration. |
| 290 | bundle_policy = kBundlePolicyMaxBundle; |
| 291 | rtcp_mux_policy = kRtcpMuxPolicyRequire; |
| 292 | ice_connection_receiving_timeout = |
| 293 | kAggressiveIceConnectionReceivingTimeout; |
| 294 | |
| 295 | // These parameters are not defined in Java or IOS configuration, |
| 296 | // so their values will not be overwritten. |
| 297 | enable_ice_renomination = true; |
Honghai Zhang | f7ddc06 | 2016-09-01 15:34:01 -0700 | [diff] [blame] | 298 | redetermine_role_on_ice_restart = false; |
| 299 | } |
Honghai Zhang | bfd398c | 2016-08-30 22:07:42 -0700 | [diff] [blame] | 300 | } |
| 301 | |
deadbeef | 293e926 | 2017-01-11 12:28:30 -0800 | [diff] [blame] | 302 | bool operator==(const RTCConfiguration& o) const; |
| 303 | bool operator!=(const RTCConfiguration& o) const; |
| 304 | |
Niels Möller | 6539f69 | 2018-01-18 08:58:50 +0100 | [diff] [blame] | 305 | bool dscp() const { return media_config.enable_dscp; } |
nisse | c36b31b | 2016-04-11 23:25:29 -0700 | [diff] [blame] | 306 | void set_dscp(bool enable) { media_config.enable_dscp = enable; } |
Niels Möller | 71bdda0 | 2016-03-31 12:59:59 +0200 | [diff] [blame] | 307 | |
Niels Möller | 6539f69 | 2018-01-18 08:58:50 +0100 | [diff] [blame] | 308 | bool cpu_adaptation() const { |
Niels Möller | 1d7ecd2 | 2018-01-18 15:25:12 +0100 | [diff] [blame] | 309 | return media_config.video.enable_cpu_adaptation; |
nisse | c36b31b | 2016-04-11 23:25:29 -0700 | [diff] [blame] | 310 | } |
Niels Möller | 71bdda0 | 2016-03-31 12:59:59 +0200 | [diff] [blame] | 311 | void set_cpu_adaptation(bool enable) { |
Niels Möller | 1d7ecd2 | 2018-01-18 15:25:12 +0100 | [diff] [blame] | 312 | media_config.video.enable_cpu_adaptation = enable; |
Niels Möller | 71bdda0 | 2016-03-31 12:59:59 +0200 | [diff] [blame] | 313 | } |
| 314 | |
Niels Möller | 6539f69 | 2018-01-18 08:58:50 +0100 | [diff] [blame] | 315 | bool suspend_below_min_bitrate() const { |
nisse | c36b31b | 2016-04-11 23:25:29 -0700 | [diff] [blame] | 316 | return media_config.video.suspend_below_min_bitrate; |
| 317 | } |
Niels Möller | 71bdda0 | 2016-03-31 12:59:59 +0200 | [diff] [blame] | 318 | void set_suspend_below_min_bitrate(bool enable) { |
nisse | c36b31b | 2016-04-11 23:25:29 -0700 | [diff] [blame] | 319 | media_config.video.suspend_below_min_bitrate = enable; |
Niels Möller | 71bdda0 | 2016-03-31 12:59:59 +0200 | [diff] [blame] | 320 | } |
| 321 | |
Niels Möller | 6539f69 | 2018-01-18 08:58:50 +0100 | [diff] [blame] | 322 | bool prerenderer_smoothing() const { |
Niels Möller | 1d7ecd2 | 2018-01-18 15:25:12 +0100 | [diff] [blame] | 323 | return media_config.video.enable_prerenderer_smoothing; |
nisse | c36b31b | 2016-04-11 23:25:29 -0700 | [diff] [blame] | 324 | } |
Niels Möller | 71bdda0 | 2016-03-31 12:59:59 +0200 | [diff] [blame] | 325 | void set_prerenderer_smoothing(bool enable) { |
Niels Möller | 1d7ecd2 | 2018-01-18 15:25:12 +0100 | [diff] [blame] | 326 | media_config.video.enable_prerenderer_smoothing = enable; |
Niels Möller | 71bdda0 | 2016-03-31 12:59:59 +0200 | [diff] [blame] | 327 | } |
| 328 | |
Niels Möller | 6539f69 | 2018-01-18 08:58:50 +0100 | [diff] [blame] | 329 | bool experiment_cpu_load_estimator() const { |
| 330 | return media_config.video.experiment_cpu_load_estimator; |
| 331 | } |
| 332 | void set_experiment_cpu_load_estimator(bool enable) { |
| 333 | media_config.video.experiment_cpu_load_estimator = enable; |
| 334 | } |
honghaiz | 4edc39c | 2015-09-01 09:53:56 -0700 | [diff] [blame] | 335 | static const int kUndefined = -1; |
| 336 | // Default maximum number of packets in the audio jitter buffer. |
| 337 | static const int kAudioJitterBufferMaxPackets = 50; |
Honghai Zhang | aecd982 | 2016-09-02 16:58:17 -0700 | [diff] [blame] | 338 | // ICE connection receiving timeout for aggressive configuration. |
| 339 | static const int kAggressiveIceConnectionReceivingTimeout = 1000; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 340 | |
| 341 | //////////////////////////////////////////////////////////////////////// |
| 342 | // The below few fields mirror the standard RTCConfiguration dictionary: |
| 343 | // https://www.w3.org/TR/webrtc/#rtcconfiguration-dictionary |
| 344 | //////////////////////////////////////////////////////////////////////// |
| 345 | |
pthatcher@webrtc.org | fd630a5 | 2015-01-14 23:19:06 +0000 | [diff] [blame] | 346 | // TODO(pthatcher): Rename this ice_servers, but update Chromium |
| 347 | // at the same time. |
| 348 | IceServers servers; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 349 | // TODO(pthatcher): Rename this ice_transport_type, but update |
| 350 | // Chromium at the same time. |
| 351 | IceTransportsType type = kAll; |
Taylor Brandstetter | a1c3035 | 2016-05-13 08:15:11 -0700 | [diff] [blame] | 352 | BundlePolicy bundle_policy = kBundlePolicyBalanced; |
zhihuang | 4dfb8ce | 2016-11-23 10:30:12 -0800 | [diff] [blame] | 353 | RtcpMuxPolicy rtcp_mux_policy = kRtcpMuxPolicyRequire; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 354 | std::vector<rtc::scoped_refptr<rtc::RTCCertificate>> certificates; |
| 355 | int ice_candidate_pool_size = 0; |
| 356 | |
| 357 | ////////////////////////////////////////////////////////////////////////// |
| 358 | // The below fields correspond to constraints from the deprecated |
| 359 | // constraints interface for constructing a PeerConnection. |
| 360 | // |
| 361 | // rtc::Optional fields can be "missing", in which case the implementation |
| 362 | // default will be used. |
| 363 | ////////////////////////////////////////////////////////////////////////// |
| 364 | |
| 365 | // If set to true, don't gather IPv6 ICE candidates. |
| 366 | // TODO(deadbeef): Remove this? IPv6 support has long stopped being |
| 367 | // experimental |
| 368 | bool disable_ipv6 = false; |
| 369 | |
zhihuang | b09b3f9 | 2017-03-07 14:40:51 -0800 | [diff] [blame] | 370 | // If set to true, don't gather IPv6 ICE candidates on Wi-Fi. |
| 371 | // Only intended to be used on specific devices. Certain phones disable IPv6 |
| 372 | // when the screen is turned off and it would be better to just disable the |
| 373 | // IPv6 ICE candidates on Wi-Fi in those cases. |
| 374 | bool disable_ipv6_on_wifi = false; |
| 375 | |
deadbeef | d21eab3 | 2017-07-26 16:50:11 -0700 | [diff] [blame] | 376 | // By default, the PeerConnection will use a limited number of IPv6 network |
| 377 | // interfaces, in order to avoid too many ICE candidate pairs being created |
| 378 | // and delaying ICE completion. |
| 379 | // |
| 380 | // Can be set to INT_MAX to effectively disable the limit. |
| 381 | int max_ipv6_networks = cricket::kDefaultMaxIPv6Networks; |
| 382 | |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 383 | // If set to true, use RTP data channels instead of SCTP. |
| 384 | // TODO(deadbeef): Remove this. We no longer commit to supporting RTP data |
| 385 | // channels, though some applications are still working on moving off of |
| 386 | // them. |
| 387 | bool enable_rtp_data_channel = false; |
| 388 | |
| 389 | // Minimum bitrate at which screencast video tracks will be encoded at. |
| 390 | // This means adding padding bits up to this bitrate, which can help |
| 391 | // when switching from a static scene to one with motion. |
| 392 | rtc::Optional<int> screencast_min_bitrate; |
| 393 | |
| 394 | // Use new combined audio/video bandwidth estimation? |
| 395 | rtc::Optional<bool> combined_audio_video_bwe; |
| 396 | |
| 397 | // Can be used to disable DTLS-SRTP. This should never be done, but can be |
| 398 | // useful for testing purposes, for example in setting up a loopback call |
| 399 | // with a single PeerConnection. |
| 400 | rtc::Optional<bool> enable_dtls_srtp; |
| 401 | |
| 402 | ///////////////////////////////////////////////// |
| 403 | // The below fields are not part of the standard. |
| 404 | ///////////////////////////////////////////////// |
| 405 | |
| 406 | // Can be used to disable TCP candidate generation. |
Taylor Brandstetter | a1c3035 | 2016-05-13 08:15:11 -0700 | [diff] [blame] | 407 | TcpCandidatePolicy tcp_candidate_policy = kTcpCandidatePolicyEnabled; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 408 | |
| 409 | // Can be used to avoid gathering candidates for a "higher cost" network, |
| 410 | // if a lower cost one exists. For example, if both Wi-Fi and cellular |
| 411 | // interfaces are available, this could be used to avoid using the cellular |
| 412 | // interface. |
honghaiz | 6034705 | 2016-05-31 18:29:12 -0700 | [diff] [blame] | 413 | CandidateNetworkPolicy candidate_network_policy = |
| 414 | kCandidateNetworkPolicyAll; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 415 | |
| 416 | // The maximum number of packets that can be stored in the NetEq audio |
| 417 | // jitter buffer. Can be reduced to lower tolerated audio latency. |
Taylor Brandstetter | a1c3035 | 2016-05-13 08:15:11 -0700 | [diff] [blame] | 418 | int audio_jitter_buffer_max_packets = kAudioJitterBufferMaxPackets; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 419 | |
| 420 | // Whether to use the NetEq "fast mode" which will accelerate audio quicker |
| 421 | // if it falls behind. |
Taylor Brandstetter | a1c3035 | 2016-05-13 08:15:11 -0700 | [diff] [blame] | 422 | bool audio_jitter_buffer_fast_accelerate = false; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 423 | |
| 424 | // Timeout in milliseconds before an ICE candidate pair is considered to be |
| 425 | // "not receiving", after which a lower priority candidate pair may be |
| 426 | // selected. |
| 427 | int ice_connection_receiving_timeout = kUndefined; |
| 428 | |
| 429 | // Interval in milliseconds at which an ICE "backup" candidate pair will be |
| 430 | // pinged. This is a candidate pair which is not actively in use, but may |
| 431 | // be switched to if the active candidate pair becomes unusable. |
| 432 | // |
| 433 | // This is relevant mainly to Wi-Fi/cell handoff; the application may not |
| 434 | // want this backup cellular candidate pair pinged frequently, since it |
| 435 | // consumes data/battery. |
| 436 | int ice_backup_candidate_pair_ping_interval = kUndefined; |
| 437 | |
| 438 | // Can be used to enable continual gathering, which means new candidates |
| 439 | // will be gathered as network interfaces change. Note that if continual |
| 440 | // gathering is used, the candidate removal API should also be used, to |
| 441 | // avoid an ever-growing list of candidates. |
Taylor Brandstetter | a1c3035 | 2016-05-13 08:15:11 -0700 | [diff] [blame] | 442 | ContinualGatheringPolicy continual_gathering_policy = GATHER_ONCE; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 443 | |
| 444 | // If set to true, candidate pairs will be pinged in order of most likely |
| 445 | // to work (which means using a TURN server, generally), rather than in |
| 446 | // standard priority order. |
Taylor Brandstetter | a1c3035 | 2016-05-13 08:15:11 -0700 | [diff] [blame] | 447 | bool prioritize_most_likely_ice_candidate_pairs = false; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 448 | |
Niels Möller | 6daa278 | 2018-01-23 10:37:42 +0100 | [diff] [blame] | 449 | // Implementation defined settings. A public member only for the benefit of |
| 450 | // the implementation. Applications must not access it directly, and should |
| 451 | // instead use provided accessor methods, e.g., set_cpu_adaptation. |
nisse | c36b31b | 2016-04-11 23:25:29 -0700 | [diff] [blame] | 452 | struct cricket::MediaConfig media_config; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 453 | |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 454 | // If set to true, only one preferred TURN allocation will be used per |
| 455 | // network interface. UDP is preferred over TCP and IPv6 over IPv4. This |
| 456 | // can be used to cut down on the number of candidate pairings. |
Honghai Zhang | b9e7b4a | 2016-06-30 20:52:02 -0700 | [diff] [blame] | 457 | bool prune_turn_ports = false; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 458 | |
Taylor Brandstetter | e985111 | 2016-07-01 11:11:13 -0700 | [diff] [blame] | 459 | // If set to true, this means the ICE transport should presume TURN-to-TURN |
| 460 | // candidate pairs will succeed, even before a binding response is received. |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 461 | // This can be used to optimize the initial connection time, since the DTLS |
| 462 | // handshake can begin immediately. |
Taylor Brandstetter | e985111 | 2016-07-01 11:11:13 -0700 | [diff] [blame] | 463 | bool presume_writable_when_fully_relayed = false; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 464 | |
Honghai Zhang | 4cedf2b | 2016-08-31 08:18:11 -0700 | [diff] [blame] | 465 | // If true, "renomination" will be added to the ice options in the transport |
| 466 | // description. |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 467 | // See: https://tools.ietf.org/html/draft-thatcher-ice-renomination-00 |
Honghai Zhang | 4cedf2b | 2016-08-31 08:18:11 -0700 | [diff] [blame] | 468 | bool enable_ice_renomination = false; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 469 | |
| 470 | // If true, the ICE role is re-determined when the PeerConnection sets a |
| 471 | // local transport description that indicates an ICE restart. |
| 472 | // |
| 473 | // This is standard RFC5245 ICE behavior, but causes unnecessary role |
| 474 | // thrashing, so an application may wish to avoid it. This role |
| 475 | // re-determining was removed in ICEbis (ICE v2). |
Honghai Zhang | bfd398c | 2016-08-30 22:07:42 -0700 | [diff] [blame] | 476 | bool redetermine_role_on_ice_restart = true; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 477 | |
skvlad | 5107246 | 2017-02-02 11:50:14 -0800 | [diff] [blame] | 478 | // If set, the min interval (max rate) at which we will send ICE checks |
| 479 | // (STUN pings), in milliseconds. |
| 480 | rtc::Optional<int> ice_check_min_interval; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 481 | |
Steve Anton | 300bf8e | 2017-07-14 10:13:10 -0700 | [diff] [blame] | 482 | // ICE Periodic Regathering |
| 483 | // If set, WebRTC will periodically create and propose candidates without |
| 484 | // starting a new ICE generation. The regathering happens continuously with |
| 485 | // interval specified in milliseconds by the uniform distribution [a, b]. |
| 486 | rtc::Optional<rtc::IntervalRange> ice_regather_interval_range; |
| 487 | |
Jonas Oreland | bdcee28 | 2017-10-10 14:01:40 +0200 | [diff] [blame] | 488 | // Optional TurnCustomizer. |
| 489 | // With this class one can modify outgoing TURN messages. |
| 490 | // The object passed in must remain valid until PeerConnection::Close() is |
| 491 | // called. |
| 492 | webrtc::TurnCustomizer* turn_customizer = nullptr; |
| 493 | |
Qingsi Wang | 9a5c6f8 | 2018-02-01 10:38:40 -0800 | [diff] [blame^] | 494 | // Preferred network interface. |
| 495 | // A candidate pair on a preferred network has a higher precedence in ICE |
| 496 | // than one on an un-preferred network, regardless of priority or network |
| 497 | // cost. |
| 498 | rtc::Optional<rtc::AdapterType> network_preference; |
| 499 | |
Steve Anton | 79e7960 | 2017-11-20 10:25:56 -0800 | [diff] [blame] | 500 | // Configure the SDP semantics used by this PeerConnection. Note that the |
| 501 | // WebRTC 1.0 specification requires kUnifiedPlan semantics. The |
| 502 | // RtpTransceiver API is only available with kUnifiedPlan semantics. |
| 503 | // |
| 504 | // kPlanB will cause PeerConnection to create offers and answers with at |
| 505 | // most one audio and one video m= section with multiple RtpSenders and |
| 506 | // RtpReceivers specified as multiple a=ssrc lines within the section. This |
| 507 | // will also cause PeerConnection to reject offers/answers with multiple m= |
| 508 | // sections of the same media type. |
| 509 | // |
| 510 | // kUnifiedPlan will cause PeerConnection to create offers and answers with |
| 511 | // multiple m= sections where each m= section maps to one RtpSender and one |
| 512 | // RtpReceiver (an RtpTransceiver), either both audio or both video. Plan B |
| 513 | // style offers or answers will be rejected in calls to SetLocalDescription |
| 514 | // or SetRemoteDescription. |
| 515 | // |
| 516 | // For users who only send at most one audio and one video track, this |
| 517 | // choice does not matter and should be left as kDefault. |
| 518 | // |
| 519 | // For users who wish to send multiple audio/video streams and need to stay |
| 520 | // interoperable with legacy WebRTC implementations, specify kPlanB. |
| 521 | // |
| 522 | // For users who wish to send multiple audio/video streams and/or wish to |
| 523 | // use the new RtpTransceiver API, specify kUnifiedPlan. |
| 524 | // |
| 525 | // TODO(steveanton): Implement support for kUnifiedPlan. |
| 526 | SdpSemantics sdp_semantics = SdpSemantics::kDefault; |
| 527 | |
deadbeef | 293e926 | 2017-01-11 12:28:30 -0800 | [diff] [blame] | 528 | // |
| 529 | // Don't forget to update operator== if adding something. |
| 530 | // |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 +0000 | [diff] [blame] | 531 | }; |
| 532 | |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 533 | // See: https://www.w3.org/TR/webrtc/#idl-def-rtcofferansweroptions |
jiayl@webrtc.org | b18bf5e | 2014-08-04 18:34:16 +0000 | [diff] [blame] | 534 | struct RTCOfferAnswerOptions { |
| 535 | static const int kUndefined = -1; |
| 536 | static const int kMaxOfferToReceiveMedia = 1; |
| 537 | |
| 538 | // The default value for constraint offerToReceiveX:true. |
| 539 | static const int kOfferToReceiveMediaTrue = 1; |
| 540 | |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 541 | // These have been removed from the standard in favor of the "transceiver" |
| 542 | // API, but given that we don't support that API, we still have them here. |
| 543 | // |
| 544 | // offer_to_receive_X set to 1 will cause a media description to be |
| 545 | // generated in the offer, even if no tracks of that type have been added. |
| 546 | // Values greater than 1 are treated the same. |
| 547 | // |
| 548 | // If set to 0, the generated directional attribute will not include the |
| 549 | // "recv" direction (meaning it will be "sendonly" or "inactive". |
Honghai Zhang | 4cedf2b | 2016-08-31 08:18:11 -0700 | [diff] [blame] | 550 | int offer_to_receive_video = kUndefined; |
| 551 | int offer_to_receive_audio = kUndefined; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 552 | |
Honghai Zhang | 4cedf2b | 2016-08-31 08:18:11 -0700 | [diff] [blame] | 553 | bool voice_activity_detection = true; |
| 554 | bool ice_restart = false; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 555 | |
| 556 | // If true, will offer to BUNDLE audio/video/data together. Not to be |
| 557 | // confused with RTCP mux (multiplexing RTP and RTCP together). |
Honghai Zhang | 4cedf2b | 2016-08-31 08:18:11 -0700 | [diff] [blame] | 558 | bool use_rtp_mux = true; |
jiayl@webrtc.org | b18bf5e | 2014-08-04 18:34:16 +0000 | [diff] [blame] | 559 | |
Honghai Zhang | 4cedf2b | 2016-08-31 08:18:11 -0700 | [diff] [blame] | 560 | RTCOfferAnswerOptions() = default; |
jiayl@webrtc.org | b18bf5e | 2014-08-04 18:34:16 +0000 | [diff] [blame] | 561 | |
| 562 | RTCOfferAnswerOptions(int offer_to_receive_video, |
| 563 | int offer_to_receive_audio, |
| 564 | bool voice_activity_detection, |
| 565 | bool ice_restart, |
| 566 | bool use_rtp_mux) |
| 567 | : offer_to_receive_video(offer_to_receive_video), |
| 568 | offer_to_receive_audio(offer_to_receive_audio), |
| 569 | voice_activity_detection(voice_activity_detection), |
| 570 | ice_restart(ice_restart), |
| 571 | use_rtp_mux(use_rtp_mux) {} |
| 572 | }; |
| 573 | |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 +0000 | [diff] [blame] | 574 | // Used by GetStats to decide which stats to include in the stats reports. |
| 575 | // |kStatsOutputLevelStandard| includes the standard stats for Javascript API; |
| 576 | // |kStatsOutputLevelDebug| includes both the standard stats and additional |
| 577 | // stats for debugging purposes. |
| 578 | enum StatsOutputLevel { |
| 579 | kStatsOutputLevelStandard, |
| 580 | kStatsOutputLevelDebug, |
| 581 | }; |
| 582 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 583 | // Accessor methods to active local streams. |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 584 | virtual rtc::scoped_refptr<StreamCollectionInterface> |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 585 | local_streams() = 0; |
| 586 | |
| 587 | // Accessor methods to remote streams. |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 588 | virtual rtc::scoped_refptr<StreamCollectionInterface> |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 589 | remote_streams() = 0; |
| 590 | |
| 591 | // Add a new MediaStream to be sent on this PeerConnection. |
| 592 | // Note that a SessionDescription negotiation is needed before the |
| 593 | // remote peer can receive the stream. |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 594 | // |
| 595 | // This has been removed from the standard in favor of a track-based API. So, |
| 596 | // this is equivalent to simply calling AddTrack for each track within the |
| 597 | // stream, with the one difference that if "stream->AddTrack(...)" is called |
| 598 | // later, the PeerConnection will automatically pick up the new track. Though |
| 599 | // this functionality will be deprecated in the future. |
perkj@webrtc.org | fd0efb6 | 2014-11-06 12:16:36 +0000 | [diff] [blame] | 600 | virtual bool AddStream(MediaStreamInterface* stream) = 0; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 601 | |
| 602 | // Remove a MediaStream from this PeerConnection. |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 603 | // Note that a SessionDescription negotiation is needed before the |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 604 | // remote peer is notified. |
| 605 | virtual void RemoveStream(MediaStreamInterface* stream) = 0; |
| 606 | |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 607 | // Add a new MediaStreamTrack to be sent on this PeerConnection, and return |
Steve Anton | f9381f0 | 2017-12-14 10:23:57 -0800 | [diff] [blame] | 608 | // the newly created RtpSender. The RtpSender will be associated with the |
| 609 | // streams specified in the |stream_labels| list. |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 610 | // |
Steve Anton | f9381f0 | 2017-12-14 10:23:57 -0800 | [diff] [blame] | 611 | // Errors: |
| 612 | // - INVALID_PARAMETER: |track| is null, has a kind other than audio or video, |
| 613 | // or a sender already exists for the track. |
| 614 | // - INVALID_STATE: The PeerConnection is closed. |
| 615 | // TODO(steveanton): Remove default implementation once downstream |
| 616 | // implementations have been updated. |
Steve Anton | 2d6c76a | 2018-01-05 17:10:52 -0800 | [diff] [blame] | 617 | virtual RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrack( |
| 618 | rtc::scoped_refptr<MediaStreamTrackInterface> track, |
| 619 | const std::vector<std::string>& stream_labels) { |
Steve Anton | f9381f0 | 2017-12-14 10:23:57 -0800 | [diff] [blame] | 620 | return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented"); |
| 621 | } |
deadbeef | e1f9d83 | 2016-01-14 15:35:42 -0800 | [diff] [blame] | 622 | // |streams| indicates which stream labels the track should be associated |
| 623 | // with. |
Steve Anton | f9381f0 | 2017-12-14 10:23:57 -0800 | [diff] [blame] | 624 | // TODO(steveanton): Remove this overload once callers have moved to the |
| 625 | // signature with stream labels. |
deadbeef | e1f9d83 | 2016-01-14 15:35:42 -0800 | [diff] [blame] | 626 | virtual rtc::scoped_refptr<RtpSenderInterface> AddTrack( |
| 627 | MediaStreamTrackInterface* track, |
nisse | 7f06766 | 2017-03-08 06:59:45 -0800 | [diff] [blame] | 628 | std::vector<MediaStreamInterface*> streams) = 0; |
deadbeef | e1f9d83 | 2016-01-14 15:35:42 -0800 | [diff] [blame] | 629 | |
| 630 | // Remove an RtpSender from this PeerConnection. |
| 631 | // Returns true on success. |
nisse | 7f06766 | 2017-03-08 06:59:45 -0800 | [diff] [blame] | 632 | virtual bool RemoveTrack(RtpSenderInterface* sender) = 0; |
deadbeef | e1f9d83 | 2016-01-14 15:35:42 -0800 | [diff] [blame] | 633 | |
Steve Anton | 9158ef6 | 2017-11-27 13:01:52 -0800 | [diff] [blame] | 634 | // AddTransceiver creates a new RtpTransceiver and adds it to the set of |
| 635 | // transceivers. Adding a transceiver will cause future calls to CreateOffer |
| 636 | // to add a media description for the corresponding transceiver. |
| 637 | // |
| 638 | // The initial value of |mid| in the returned transceiver is null. Setting a |
| 639 | // new session description may change it to a non-null value. |
| 640 | // |
| 641 | // https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-addtransceiver |
| 642 | // |
| 643 | // Optionally, an RtpTransceiverInit structure can be specified to configure |
| 644 | // the transceiver from construction. If not specified, the transceiver will |
| 645 | // default to having a direction of kSendRecv and not be part of any streams. |
| 646 | // |
| 647 | // These methods are only available when Unified Plan is enabled (see |
| 648 | // RTCConfiguration). |
| 649 | // |
| 650 | // Common errors: |
| 651 | // - INTERNAL_ERROR: The configuration does not have Unified Plan enabled. |
| 652 | // TODO(steveanton): Make these pure virtual once downstream projects have |
| 653 | // updated. |
| 654 | |
| 655 | // Adds a transceiver with a sender set to transmit the given track. The kind |
| 656 | // of the transceiver (and sender/receiver) will be derived from the kind of |
| 657 | // the track. |
| 658 | // Errors: |
| 659 | // - INVALID_PARAMETER: |track| is null. |
| 660 | virtual RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> |
| 661 | AddTransceiver(rtc::scoped_refptr<MediaStreamTrackInterface> track) { |
| 662 | return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented"); |
| 663 | } |
| 664 | virtual RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> |
| 665 | AddTransceiver(rtc::scoped_refptr<MediaStreamTrackInterface> track, |
| 666 | const RtpTransceiverInit& init) { |
| 667 | return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented"); |
| 668 | } |
| 669 | |
| 670 | // Adds a transceiver with the given kind. Can either be MEDIA_TYPE_AUDIO or |
| 671 | // MEDIA_TYPE_VIDEO. |
| 672 | // Errors: |
| 673 | // - INVALID_PARAMETER: |media_type| is not MEDIA_TYPE_AUDIO or |
| 674 | // MEDIA_TYPE_VIDEO. |
| 675 | virtual RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> |
| 676 | AddTransceiver(cricket::MediaType media_type) { |
| 677 | return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented"); |
| 678 | } |
| 679 | virtual RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> |
| 680 | AddTransceiver(cricket::MediaType media_type, |
| 681 | const RtpTransceiverInit& init) { |
| 682 | return RTCError(RTCErrorType::INTERNAL_ERROR, "not implemented"); |
| 683 | } |
| 684 | |
deadbeef | 8d60a94 | 2017-02-27 14:47:33 -0800 | [diff] [blame] | 685 | // Returns pointer to a DtmfSender on success. Otherwise returns null. |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 686 | // |
| 687 | // This API is no longer part of the standard; instead DtmfSenders are |
| 688 | // obtained from RtpSenders. Which is what the implementation does; it finds |
| 689 | // an RtpSender for |track| and just returns its DtmfSender. |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 690 | virtual rtc::scoped_refptr<DtmfSenderInterface> CreateDtmfSender( |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 691 | AudioTrackInterface* track) = 0; |
| 692 | |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 693 | // TODO(deadbeef): Make these pure virtual once all subclasses implement them. |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 694 | |
| 695 | // Creates a sender without a track. Can be used for "early media"/"warmup" |
| 696 | // use cases, where the application may want to negotiate video attributes |
| 697 | // before a track is available to send. |
| 698 | // |
| 699 | // The standard way to do this would be through "addTransceiver", but we |
| 700 | // don't support that API yet. |
| 701 | // |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 702 | // |kind| must be "audio" or "video". |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 703 | // |
deadbeef | bd7d8f7 | 2015-12-18 16:58:44 -0800 | [diff] [blame] | 704 | // |stream_id| is used to populate the msid attribute; if empty, one will |
| 705 | // be generated automatically. |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 706 | virtual rtc::scoped_refptr<RtpSenderInterface> CreateSender( |
deadbeef | bd7d8f7 | 2015-12-18 16:58:44 -0800 | [diff] [blame] | 707 | const std::string& kind, |
| 708 | const std::string& stream_id) { |
deadbeef | fac0655 | 2015-11-25 11:26:01 -0800 | [diff] [blame] | 709 | return rtc::scoped_refptr<RtpSenderInterface>(); |
| 710 | } |
| 711 | |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 712 | // Get all RtpSenders, created either through AddStream, AddTrack, or |
| 713 | // CreateSender. Note that these are "Plan B SDP" RtpSenders, not "Unified |
| 714 | // Plan SDP" RtpSenders, which means that all senders of a specific media |
| 715 | // type share the same media description. |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 716 | virtual std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders() |
| 717 | const { |
| 718 | return std::vector<rtc::scoped_refptr<RtpSenderInterface>>(); |
| 719 | } |
| 720 | |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 721 | // Get all RtpReceivers, created when a remote description is applied. |
| 722 | // Note that these are "Plan B SDP" RtpReceivers, not "Unified Plan SDP" |
| 723 | // RtpReceivers, which means that all receivers of a specific media type |
| 724 | // share the same media description. |
| 725 | // |
| 726 | // It is also possible to have a media description with no associated |
| 727 | // RtpReceivers, if the directional attribute does not indicate that the |
| 728 | // remote peer is sending any media. |
deadbeef | 70ab1a1 | 2015-09-28 16:53:55 -0700 | [diff] [blame] | 729 | virtual std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers() |
| 730 | const { |
| 731 | return std::vector<rtc::scoped_refptr<RtpReceiverInterface>>(); |
| 732 | } |
| 733 | |
Steve Anton | 9158ef6 | 2017-11-27 13:01:52 -0800 | [diff] [blame] | 734 | // Get all RtpTransceivers, created either through AddTransceiver, AddTrack or |
| 735 | // by a remote description applied with SetRemoteDescription. |
| 736 | // Note: This method is only available when Unified Plan is enabled (see |
| 737 | // RTCConfiguration). |
| 738 | virtual std::vector<rtc::scoped_refptr<RtpTransceiverInterface>> |
| 739 | GetTransceivers() const { |
| 740 | return {}; |
| 741 | } |
| 742 | |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 +0000 | [diff] [blame] | 743 | virtual bool GetStats(StatsObserver* observer, |
| 744 | MediaStreamTrackInterface* track, |
| 745 | StatsOutputLevel level) = 0; |
hbos | 74e1a4f | 2016-09-15 23:33:01 -0700 | [diff] [blame] | 746 | // Gets stats using the new stats collection API, see webrtc/api/stats/. These |
| 747 | // will replace old stats collection API when the new API has matured enough. |
hbos | e381015 | 2016-12-13 02:35:19 -0800 | [diff] [blame] | 748 | // TODO(hbos): Default implementation that does nothing only exists as to not |
| 749 | // break third party projects. As soon as they have been updated this should |
| 750 | // be changed to "= 0;". |
| 751 | virtual void GetStats(RTCStatsCollectorCallback* callback) {} |
Harald Alvestrand | 8906187 | 2018-01-02 14:08:34 +0100 | [diff] [blame] | 752 | // Clear cached stats in the rtcstatscollector. |
| 753 | // Exposed for testing while waiting for automatic cache clear to work. |
| 754 | // https://bugs.webrtc.org/8693 |
| 755 | virtual void ClearStatsCache() {} |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 +0000 | [diff] [blame] | 756 | |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 757 | // Create a data channel with the provided config, or default config if none |
| 758 | // is provided. Note that an offer/answer negotiation is still necessary |
| 759 | // before the data channel can be used. |
| 760 | // |
| 761 | // Also, calling CreateDataChannel is the only way to get a data "m=" section |
| 762 | // in SDP, so it should be done before CreateOffer is called, if the |
| 763 | // application plans to use data channels. |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 764 | virtual rtc::scoped_refptr<DataChannelInterface> CreateDataChannel( |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 765 | const std::string& label, |
| 766 | const DataChannelInit* config) = 0; |
| 767 | |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 768 | // Returns the more recently applied description; "pending" if it exists, and |
| 769 | // otherwise "current". See below. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 770 | virtual const SessionDescriptionInterface* local_description() const = 0; |
| 771 | virtual const SessionDescriptionInterface* remote_description() const = 0; |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 772 | |
deadbeef | fe4a8a4 | 2016-12-20 17:56:17 -0800 | [diff] [blame] | 773 | // A "current" description the one currently negotiated from a complete |
| 774 | // offer/answer exchange. |
| 775 | virtual const SessionDescriptionInterface* current_local_description() const { |
| 776 | return nullptr; |
| 777 | } |
| 778 | virtual const SessionDescriptionInterface* current_remote_description() |
| 779 | const { |
| 780 | return nullptr; |
| 781 | } |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 782 | |
deadbeef | fe4a8a4 | 2016-12-20 17:56:17 -0800 | [diff] [blame] | 783 | // A "pending" description is one that's part of an incomplete offer/answer |
| 784 | // exchange (thus, either an offer or a pranswer). Once the offer/answer |
| 785 | // exchange is finished, the "pending" description will become "current". |
| 786 | virtual const SessionDescriptionInterface* pending_local_description() const { |
| 787 | return nullptr; |
| 788 | } |
| 789 | virtual const SessionDescriptionInterface* pending_remote_description() |
| 790 | const { |
| 791 | return nullptr; |
| 792 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 793 | |
| 794 | // Create a new offer. |
| 795 | // The CreateSessionDescriptionObserver callback will be called when done. |
| 796 | virtual void CreateOffer(CreateSessionDescriptionObserver* observer, |
jiayl@webrtc.org | b18bf5e | 2014-08-04 18:34:16 +0000 | [diff] [blame] | 797 | const MediaConstraintsInterface* constraints) {} |
| 798 | |
| 799 | // TODO(jiayl): remove the default impl and the old interface when chromium |
| 800 | // code is updated. |
| 801 | virtual void CreateOffer(CreateSessionDescriptionObserver* observer, |
| 802 | const RTCOfferAnswerOptions& options) {} |
| 803 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 804 | // Create an answer to an offer. |
| 805 | // The CreateSessionDescriptionObserver callback will be called when done. |
| 806 | virtual void CreateAnswer(CreateSessionDescriptionObserver* observer, |
hta | a2a49d9 | 2016-03-04 02:51:39 -0800 | [diff] [blame] | 807 | const RTCOfferAnswerOptions& options) {} |
| 808 | // Deprecated - use version above. |
| 809 | // TODO(hta): Remove and remove default implementations when all callers |
| 810 | // are updated. |
| 811 | virtual void CreateAnswer(CreateSessionDescriptionObserver* observer, |
| 812 | const MediaConstraintsInterface* constraints) {} |
| 813 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 814 | // Sets the local session description. |
deadbeef | 1dcb164 | 2017-03-29 21:08:16 -0700 | [diff] [blame] | 815 | // The PeerConnection takes the ownership of |desc| even if it fails. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 816 | // The |observer| callback will be called when done. |
deadbeef | 1dcb164 | 2017-03-29 21:08:16 -0700 | [diff] [blame] | 817 | // TODO(deadbeef): Change |desc| to be a unique_ptr, to make it clear |
| 818 | // that this method always takes ownership of it. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 819 | virtual void SetLocalDescription(SetSessionDescriptionObserver* observer, |
| 820 | SessionDescriptionInterface* desc) = 0; |
| 821 | // Sets the remote session description. |
deadbeef | 1dcb164 | 2017-03-29 21:08:16 -0700 | [diff] [blame] | 822 | // The PeerConnection takes the ownership of |desc| even if it fails. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 823 | // The |observer| callback will be called when done. |
Henrik Boström | 3163867 | 2017-11-23 17:48:32 +0100 | [diff] [blame] | 824 | // TODO(hbos): Remove when Chrome implements the new signature. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 825 | virtual void SetRemoteDescription(SetSessionDescriptionObserver* observer, |
Henrik Boström | 0710965 | 2017-11-27 09:52:02 +0100 | [diff] [blame] | 826 | SessionDescriptionInterface* desc) {} |
Henrik Boström | 3163867 | 2017-11-23 17:48:32 +0100 | [diff] [blame] | 827 | // TODO(hbos): Make pure virtual when Chrome has updated its signature. |
| 828 | virtual void SetRemoteDescription( |
| 829 | std::unique_ptr<SessionDescriptionInterface> desc, |
| 830 | rtc::scoped_refptr<SetRemoteDescriptionObserverInterface> observer) {} |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 831 | // Deprecated; Replaced by SetConfiguration. |
deadbeef | a67696b | 2015-09-29 11:56:26 -0700 | [diff] [blame] | 832 | // TODO(deadbeef): Remove once Chrome is moved over to SetConfiguration. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 833 | virtual bool UpdateIce(const IceServers& configuration, |
deadbeef | a67696b | 2015-09-29 11:56:26 -0700 | [diff] [blame] | 834 | const MediaConstraintsInterface* constraints) { |
| 835 | return false; |
| 836 | } |
hta | a2a49d9 | 2016-03-04 02:51:39 -0800 | [diff] [blame] | 837 | virtual bool UpdateIce(const IceServers& configuration) { return false; } |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 838 | |
deadbeef | 46c7389 | 2016-11-16 19:42:04 -0800 | [diff] [blame] | 839 | // TODO(deadbeef): Make this pure virtual once all Chrome subclasses of |
| 840 | // PeerConnectionInterface implement it. |
| 841 | virtual PeerConnectionInterface::RTCConfiguration GetConfiguration() { |
| 842 | return PeerConnectionInterface::RTCConfiguration(); |
| 843 | } |
deadbeef | 293e926 | 2017-01-11 12:28:30 -0800 | [diff] [blame] | 844 | |
deadbeef | a67696b | 2015-09-29 11:56:26 -0700 | [diff] [blame] | 845 | // Sets the PeerConnection's global configuration to |config|. |
deadbeef | 293e926 | 2017-01-11 12:28:30 -0800 | [diff] [blame] | 846 | // |
| 847 | // The members of |config| that may be changed are |type|, |servers|, |
| 848 | // |ice_candidate_pool_size| and |prune_turn_ports| (though the candidate |
| 849 | // pool size can't be changed after the first call to SetLocalDescription). |
| 850 | // Note that this means the BUNDLE and RTCP-multiplexing policies cannot be |
| 851 | // changed with this method. |
| 852 | // |
deadbeef | a67696b | 2015-09-29 11:56:26 -0700 | [diff] [blame] | 853 | // Any changes to STUN/TURN servers or ICE candidate policy will affect the |
| 854 | // next gathering phase, and cause the next call to createOffer to generate |
deadbeef | 293e926 | 2017-01-11 12:28:30 -0800 | [diff] [blame] | 855 | // new ICE credentials, as described in JSEP. This also occurs when |
| 856 | // |prune_turn_ports| changes, for the same reasoning. |
| 857 | // |
| 858 | // If an error occurs, returns false and populates |error| if non-null: |
| 859 | // - INVALID_MODIFICATION if |config| contains a modified parameter other |
| 860 | // than one of the parameters listed above. |
| 861 | // - INVALID_RANGE if |ice_candidate_pool_size| is out of range. |
| 862 | // - SYNTAX_ERROR if parsing an ICE server URL failed. |
| 863 | // - INVALID_PARAMETER if a TURN server is missing |username| or |password|. |
| 864 | // - INTERNAL_ERROR if an unexpected error occurred. |
| 865 | // |
deadbeef | a67696b | 2015-09-29 11:56:26 -0700 | [diff] [blame] | 866 | // TODO(deadbeef): Make this pure virtual once all Chrome subclasses of |
| 867 | // PeerConnectionInterface implement it. |
| 868 | virtual bool SetConfiguration( |
deadbeef | 293e926 | 2017-01-11 12:28:30 -0800 | [diff] [blame] | 869 | const PeerConnectionInterface::RTCConfiguration& config, |
| 870 | RTCError* error) { |
| 871 | return false; |
| 872 | } |
| 873 | // Version without error output param for backwards compatibility. |
| 874 | // TODO(deadbeef): Remove once chromium is updated. |
| 875 | virtual bool SetConfiguration( |
deadbeef | 1e23461 | 2016-12-24 01:43:32 -0800 | [diff] [blame] | 876 | const PeerConnectionInterface::RTCConfiguration& config) { |
deadbeef | a67696b | 2015-09-29 11:56:26 -0700 | [diff] [blame] | 877 | return false; |
| 878 | } |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 879 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 880 | // Provides a remote candidate to the ICE Agent. |
| 881 | // A copy of the |candidate| will be created and added to the remote |
| 882 | // description. So the caller of this method still has the ownership of the |
| 883 | // |candidate|. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 884 | virtual bool AddIceCandidate(const IceCandidateInterface* candidate) = 0; |
| 885 | |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 886 | // Removes a group of remote candidates from the ICE agent. Needed mainly for |
| 887 | // continual gathering, to avoid an ever-growing list of candidates as |
| 888 | // networks come and go. |
Honghai Zhang | 7fb69db | 2016-03-14 11:59:18 -0700 | [diff] [blame] | 889 | virtual bool RemoveIceCandidates( |
| 890 | const std::vector<cricket::Candidate>& candidates) { |
| 891 | return false; |
| 892 | } |
| 893 | |
Taylor Brandstetter | 215fda7 | 2018-01-03 17:14:20 -0800 | [diff] [blame] | 894 | // Register a metric observer (used by chromium). It's reference counted, and |
| 895 | // this method takes a reference. RegisterUMAObserver(nullptr) will release |
| 896 | // the reference. |
| 897 | // TODO(deadbeef): Take argument as scoped_refptr? |
buildbot@webrtc.org | 1567b8c | 2014-05-08 19:54:16 +0000 | [diff] [blame] | 898 | virtual void RegisterUMAObserver(UMAObserver* observer) = 0; |
| 899 | |
zstein | 4b97980 | 2017-06-02 14:37:37 -0700 | [diff] [blame] | 900 | // 0 <= min <= current <= max should hold for set parameters. |
| 901 | struct BitrateParameters { |
| 902 | rtc::Optional<int> min_bitrate_bps; |
| 903 | rtc::Optional<int> current_bitrate_bps; |
| 904 | rtc::Optional<int> max_bitrate_bps; |
| 905 | }; |
| 906 | |
| 907 | // SetBitrate limits the bandwidth allocated for all RTP streams sent by |
| 908 | // this PeerConnection. Other limitations might affect these limits and |
| 909 | // are respected (for example "b=AS" in SDP). |
| 910 | // |
| 911 | // Setting |current_bitrate_bps| will reset the current bitrate estimate |
| 912 | // to the provided value. |
zstein | 83dc6b6 | 2017-07-17 15:09:30 -0700 | [diff] [blame] | 913 | virtual RTCError SetBitrate(const BitrateParameters& bitrate) = 0; |
zstein | 4b97980 | 2017-06-02 14:37:37 -0700 | [diff] [blame] | 914 | |
Alex Narest | 78609d5 | 2017-10-20 10:37:47 +0200 | [diff] [blame] | 915 | // Sets current strategy. If not set default WebRTC allocator will be used. |
| 916 | // May be changed during an active session. The strategy |
| 917 | // ownership is passed with std::unique_ptr |
| 918 | // TODO(alexnarest): Make this pure virtual when tests will be updated |
| 919 | virtual void SetBitrateAllocationStrategy( |
| 920 | std::unique_ptr<rtc::BitrateAllocationStrategy> |
| 921 | bitrate_allocation_strategy) {} |
| 922 | |
henrika | 5f6bf24 | 2017-11-01 11:06:56 +0100 | [diff] [blame] | 923 | // Enable/disable playout of received audio streams. Enabled by default. Note |
| 924 | // that even if playout is enabled, streams will only be played out if the |
| 925 | // appropriate SDP is also applied. Setting |playout| to false will stop |
| 926 | // playout of the underlying audio device but starts a task which will poll |
| 927 | // for audio data every 10ms to ensure that audio processing happens and the |
| 928 | // audio statistics are updated. |
| 929 | // TODO(henrika): deprecate and remove this. |
| 930 | virtual void SetAudioPlayout(bool playout) {} |
| 931 | |
| 932 | // Enable/disable recording of transmitted audio streams. Enabled by default. |
| 933 | // Note that even if recording is enabled, streams will only be recorded if |
| 934 | // the appropriate SDP is also applied. |
| 935 | // TODO(henrika): deprecate and remove this. |
| 936 | virtual void SetAudioRecording(bool recording) {} |
| 937 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 938 | // Returns the current SignalingState. |
| 939 | virtual SignalingState signaling_state() = 0; |
Taylor Brandstetter | cb423c4 | 2017-10-22 11:52:32 -0700 | [diff] [blame] | 940 | |
| 941 | // Returns the aggregate state of all ICE *and* DTLS transports. |
| 942 | // TODO(deadbeef): Implement "PeerConnectionState" according to the standard, |
| 943 | // to aggregate ICE+DTLS state, and change the scope of IceConnectionState to |
| 944 | // be just the ICE layer. See: crbug.com/webrtc/6145 |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 945 | virtual IceConnectionState ice_connection_state() = 0; |
Taylor Brandstetter | cb423c4 | 2017-10-22 11:52:32 -0700 | [diff] [blame] | 946 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 947 | virtual IceGatheringState ice_gathering_state() = 0; |
| 948 | |
ivoc | 14d5dbe | 2016-07-04 07:06:55 -0700 | [diff] [blame] | 949 | // Starts RtcEventLog using existing file. Takes ownership of |file| and |
| 950 | // passes it on to Call, which will take the ownership. If the |
| 951 | // operation fails the file will be closed. The logging will stop |
| 952 | // automatically after 10 minutes have passed, or when the StopRtcEventLog |
| 953 | // function is called. |
Elad Alon | 99c3fe5 | 2017-10-13 16:29:40 +0200 | [diff] [blame] | 954 | // TODO(eladalon): Deprecate and remove this. |
ivoc | 14d5dbe | 2016-07-04 07:06:55 -0700 | [diff] [blame] | 955 | virtual bool StartRtcEventLog(rtc::PlatformFile file, |
| 956 | int64_t max_size_bytes) { |
| 957 | return false; |
| 958 | } |
| 959 | |
Elad Alon | 99c3fe5 | 2017-10-13 16:29:40 +0200 | [diff] [blame] | 960 | // Start RtcEventLog using an existing output-sink. Takes ownership of |
| 961 | // |output| and passes it on to Call, which will take the ownership. If the |
Bjorn Terelius | de93943 | 2017-11-20 17:38:14 +0100 | [diff] [blame] | 962 | // operation fails the output will be closed and deallocated. The event log |
| 963 | // will send serialized events to the output object every |output_period_ms|. |
| 964 | virtual bool StartRtcEventLog(std::unique_ptr<RtcEventLogOutput> output, |
| 965 | int64_t output_period_ms) { |
Elad Alon | 99c3fe5 | 2017-10-13 16:29:40 +0200 | [diff] [blame] | 966 | return false; |
| 967 | } |
| 968 | |
ivoc | 14d5dbe | 2016-07-04 07:06:55 -0700 | [diff] [blame] | 969 | // Stops logging the RtcEventLog. |
| 970 | // TODO(ivoc): Make this pure virtual when Chrome is updated. |
| 971 | virtual void StopRtcEventLog() {} |
| 972 | |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 973 | // Terminates all media, closes the transports, and in general releases any |
| 974 | // resources used by the PeerConnection. This is an irreversible operation. |
deadbeef | d07061c | 2017-04-20 13:19:00 -0700 | [diff] [blame] | 975 | // |
| 976 | // Note that after this method completes, the PeerConnection will no longer |
| 977 | // use the PeerConnectionObserver interface passed in on construction, and |
| 978 | // thus the observer object can be safely destroyed. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 979 | virtual void Close() = 0; |
| 980 | |
| 981 | protected: |
| 982 | // Dtor protected as objects shouldn't be deleted via this interface. |
| 983 | ~PeerConnectionInterface() {} |
| 984 | }; |
| 985 | |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 986 | // PeerConnection callback interface, used for RTCPeerConnection events. |
| 987 | // Application should implement these methods. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 988 | class PeerConnectionObserver { |
| 989 | public: |
Sami Kalliomäki | 02879f9 | 2018-01-11 10:02:19 +0100 | [diff] [blame] | 990 | virtual ~PeerConnectionObserver() = default; |
| 991 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 992 | // Triggered when the SignalingState changed. |
| 993 | virtual void OnSignalingChange( |
perkj | dfb769d | 2016-02-09 03:09:43 -0800 | [diff] [blame] | 994 | PeerConnectionInterface::SignalingState new_state) = 0; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 995 | |
| 996 | // Triggered when media is received on a new stream from remote peer. |
Steve Anton | 772eb21 | 2018-01-16 10:11:06 -0800 | [diff] [blame] | 997 | // Deprecated: This callback will no longer be fired with Unified Plan |
| 998 | // semantics. Consider switching to OnAddTrack. |
| 999 | virtual void OnAddStream(rtc::scoped_refptr<MediaStreamInterface> stream) {} |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1000 | |
| 1001 | // Triggered when a remote peer close a stream. |
Steve Anton | 772eb21 | 2018-01-16 10:11:06 -0800 | [diff] [blame] | 1002 | // Deprecated: This callback will no longer be fired with Unified Plan |
| 1003 | // semantics. |
| 1004 | virtual void OnRemoveStream(rtc::scoped_refptr<MediaStreamInterface> stream) { |
| 1005 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1006 | |
Taylor Brandstetter | 98cde26 | 2016-05-31 13:02:21 -0700 | [diff] [blame] | 1007 | // Triggered when a remote peer opens a data channel. |
| 1008 | virtual void OnDataChannel( |
nisse | 7f06766 | 2017-03-08 06:59:45 -0800 | [diff] [blame] | 1009 | rtc::scoped_refptr<DataChannelInterface> data_channel) = 0; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1010 | |
Taylor Brandstetter | 98cde26 | 2016-05-31 13:02:21 -0700 | [diff] [blame] | 1011 | // Triggered when renegotiation is needed. For example, an ICE restart |
| 1012 | // has begun. |
fischman@webrtc.org | d7568a0 | 2014-01-13 22:04:12 +0000 | [diff] [blame] | 1013 | virtual void OnRenegotiationNeeded() = 0; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1014 | |
Taylor Brandstetter | 98cde26 | 2016-05-31 13:02:21 -0700 | [diff] [blame] | 1015 | // Called any time the IceConnectionState changes. |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 1016 | // |
| 1017 | // Note that our ICE states lag behind the standard slightly. The most |
| 1018 | // notable differences include the fact that "failed" occurs after 15 |
| 1019 | // seconds, not 30, and this actually represents a combination ICE + DTLS |
| 1020 | // state, so it may be "failed" if DTLS fails while ICE succeeds. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1021 | virtual void OnIceConnectionChange( |
perkj | dfb769d | 2016-02-09 03:09:43 -0800 | [diff] [blame] | 1022 | PeerConnectionInterface::IceConnectionState new_state) = 0; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1023 | |
Taylor Brandstetter | 98cde26 | 2016-05-31 13:02:21 -0700 | [diff] [blame] | 1024 | // Called any time the IceGatheringState changes. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1025 | virtual void OnIceGatheringChange( |
perkj | dfb769d | 2016-02-09 03:09:43 -0800 | [diff] [blame] | 1026 | PeerConnectionInterface::IceGatheringState new_state) = 0; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1027 | |
Taylor Brandstetter | 98cde26 | 2016-05-31 13:02:21 -0700 | [diff] [blame] | 1028 | // A new ICE candidate has been gathered. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1029 | virtual void OnIceCandidate(const IceCandidateInterface* candidate) = 0; |
| 1030 | |
Honghai Zhang | 7fb69db | 2016-03-14 11:59:18 -0700 | [diff] [blame] | 1031 | // Ice candidates have been removed. |
| 1032 | // TODO(honghaiz): Make this a pure virtual method when all its subclasses |
| 1033 | // implement it. |
| 1034 | virtual void OnIceCandidatesRemoved( |
| 1035 | const std::vector<cricket::Candidate>& candidates) {} |
| 1036 | |
Peter Thatcher | 5436051 | 2015-07-08 11:08:35 -0700 | [diff] [blame] | 1037 | // Called when the ICE connection receiving status changes. |
| 1038 | virtual void OnIceConnectionReceivingChange(bool receiving) {} |
| 1039 | |
Henrik Boström | 933d8b0 | 2017-10-10 10:05:16 -0700 | [diff] [blame] | 1040 | // This is called when a receiver and its track is created. |
| 1041 | // TODO(zhihuang): Make this pure virtual when all subclasses implement it. |
zhihuang | 81c3a03 | 2016-11-17 12:06:24 -0800 | [diff] [blame] | 1042 | virtual void OnAddTrack( |
| 1043 | rtc::scoped_refptr<RtpReceiverInterface> receiver, |
zhihuang | c63b894 | 2016-12-02 15:41:10 -0800 | [diff] [blame] | 1044 | const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {} |
zhihuang | 81c3a03 | 2016-11-17 12:06:24 -0800 | [diff] [blame] | 1045 | |
Henrik Boström | 933d8b0 | 2017-10-10 10:05:16 -0700 | [diff] [blame] | 1046 | // TODO(hbos,deadbeef): Add |OnAssociatedStreamsUpdated| with |receiver| and |
| 1047 | // |streams| as arguments. This should be called when an existing receiver its |
| 1048 | // associated streams updated. https://crbug.com/webrtc/8315 |
| 1049 | // This may be blocked on supporting multiple streams per sender or else |
| 1050 | // this may count as the removal and addition of a track? |
| 1051 | // https://crbug.com/webrtc/7932 |
| 1052 | |
| 1053 | // Called when a receiver is completely removed. This is current (Plan B SDP) |
| 1054 | // behavior that occurs when processing the removal of a remote track, and is |
| 1055 | // called when the receiver is removed and the track is muted. When Unified |
| 1056 | // Plan SDP is supported, transceivers can change direction (and receivers |
| 1057 | // stopped) but receivers are never removed. |
| 1058 | // https://w3c.github.io/webrtc-pc/#process-remote-track-removal |
| 1059 | // TODO(hbos,deadbeef): When Unified Plan SDP is supported and receivers are |
| 1060 | // no longer removed, deprecate and remove this callback. |
| 1061 | // TODO(hbos,deadbeef): Make pure virtual when all subclasses implement it. |
| 1062 | virtual void OnRemoveTrack( |
| 1063 | rtc::scoped_refptr<RtpReceiverInterface> receiver) {} |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1064 | }; |
| 1065 | |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 1066 | // PeerConnectionFactoryInterface is the factory interface used for creating |
| 1067 | // PeerConnection, MediaStream and MediaStreamTrack objects. |
| 1068 | // |
| 1069 | // The simplest method for obtaiing one, CreatePeerConnectionFactory will |
| 1070 | // create the required libjingle threads, socket and network manager factory |
| 1071 | // classes for networking if none are provided, though it requires that the |
| 1072 | // application runs a message loop on the thread that called the method (see |
| 1073 | // explanation below) |
| 1074 | // |
| 1075 | // If an application decides to provide its own threads and/or implementation |
| 1076 | // of networking classes, it should use the alternate |
| 1077 | // CreatePeerConnectionFactory method which accepts threads as input, and use |
| 1078 | // the CreatePeerConnection version that takes a PortAllocator as an argument. |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1079 | class PeerConnectionFactoryInterface : public rtc::RefCountInterface { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1080 | public: |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 1081 | class Options { |
| 1082 | public: |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 1083 | Options() : crypto_options(rtc::CryptoOptions::NoGcm()) {} |
| 1084 | |
| 1085 | // If set to true, created PeerConnections won't enforce any SRTP |
| 1086 | // requirement, allowing unsecured media. Should only be used for |
| 1087 | // testing/debugging. |
| 1088 | bool disable_encryption = false; |
| 1089 | |
| 1090 | // Deprecated. The only effect of setting this to true is that |
| 1091 | // CreateDataChannel will fail, which is not that useful. |
| 1092 | bool disable_sctp_data_channels = false; |
| 1093 | |
| 1094 | // If set to true, any platform-supported network monitoring capability |
| 1095 | // won't be used, and instead networks will only be updated via polling. |
| 1096 | // |
| 1097 | // This only has an effect if a PeerConnection is created with the default |
| 1098 | // PortAllocator implementation. |
| 1099 | bool disable_network_monitor = false; |
phoglund@webrtc.org | 006521d | 2015-02-12 09:23:59 +0000 | [diff] [blame] | 1100 | |
| 1101 | // Sets the network types to ignore. For instance, calling this with |
| 1102 | // ADAPTER_TYPE_ETHERNET | ADAPTER_TYPE_LOOPBACK will ignore Ethernet and |
| 1103 | // loopback interfaces. |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 1104 | int network_ignore_mask = rtc::kDefaultNetworkIgnoreMask; |
Joachim Bauch | 04e5b49 | 2015-05-29 09:40:39 +0200 | [diff] [blame] | 1105 | |
| 1106 | // Sets the maximum supported protocol version. The highest version |
| 1107 | // supported by both ends will be used for the connection, i.e. if one |
| 1108 | // party supports DTLS 1.0 and the other DTLS 1.2, DTLS 1.0 will be used. |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 1109 | rtc::SSLProtocolVersion ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12; |
jbauch | cb56065 | 2016-08-04 05:20:32 -0700 | [diff] [blame] | 1110 | |
| 1111 | // Sets crypto related options, e.g. enabled cipher suites. |
| 1112 | rtc::CryptoOptions crypto_options; |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 1113 | }; |
| 1114 | |
deadbeef | 7914b8c | 2017-04-21 03:23:33 -0700 | [diff] [blame] | 1115 | // Set the options to be used for subsequently created PeerConnections. |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 1116 | virtual void SetOptions(const Options& options) = 0; |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 +0000 | [diff] [blame] | 1117 | |
deadbeef | d07061c | 2017-04-20 13:19:00 -0700 | [diff] [blame] | 1118 | // |allocator| and |cert_generator| may be null, in which case default |
| 1119 | // implementations will be used. |
| 1120 | // |
| 1121 | // |observer| must not be null. |
| 1122 | // |
| 1123 | // Note that this method does not take ownership of |observer|; it's the |
| 1124 | // responsibility of the caller to delete it. It can be safely deleted after |
| 1125 | // Close has been called on the returned PeerConnection, which ensures no |
| 1126 | // more observer callbacks will be invoked. |
deadbeef | 41b0798 | 2015-12-01 15:01:24 -0800 | [diff] [blame] | 1127 | virtual rtc::scoped_refptr<PeerConnectionInterface> CreatePeerConnection( |
| 1128 | const PeerConnectionInterface::RTCConfiguration& configuration, |
kwiberg | d1fe281 | 2016-04-27 06:47:29 -0700 | [diff] [blame] | 1129 | std::unique_ptr<cricket::PortAllocator> allocator, |
Henrik Boström | d03c23b | 2016-06-01 11:44:18 +0200 | [diff] [blame] | 1130 | std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator, |
hbos | d7973cc | 2016-05-27 06:08:53 -0700 | [diff] [blame] | 1131 | PeerConnectionObserver* observer) = 0; |
buildbot@webrtc.org | 41451d4 | 2014-05-03 05:39:45 +0000 | [diff] [blame] | 1132 | |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 1133 | // Deprecated; should use RTCConfiguration for everything that previously |
| 1134 | // used constraints. |
hta | a2a49d9 | 2016-03-04 02:51:39 -0800 | [diff] [blame] | 1135 | virtual rtc::scoped_refptr<PeerConnectionInterface> CreatePeerConnection( |
| 1136 | const PeerConnectionInterface::RTCConfiguration& configuration, |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 1137 | const MediaConstraintsInterface* constraints, |
kwiberg | d1fe281 | 2016-04-27 06:47:29 -0700 | [diff] [blame] | 1138 | std::unique_ptr<cricket::PortAllocator> allocator, |
Henrik Boström | d03c23b | 2016-06-01 11:44:18 +0200 | [diff] [blame] | 1139 | std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator, |
hbos | d7973cc | 2016-05-27 06:08:53 -0700 | [diff] [blame] | 1140 | PeerConnectionObserver* observer) = 0; |
hta | a2a49d9 | 2016-03-04 02:51:39 -0800 | [diff] [blame] | 1141 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1142 | virtual rtc::scoped_refptr<MediaStreamInterface> |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1143 | CreateLocalMediaStream(const std::string& label) = 0; |
| 1144 | |
deadbeef | e814a0d | 2017-02-25 18:15:09 -0800 | [diff] [blame] | 1145 | // Creates an AudioSourceInterface. |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 1146 | // |options| decides audio processing settings. |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1147 | virtual rtc::scoped_refptr<AudioSourceInterface> CreateAudioSource( |
hta | a2a49d9 | 2016-03-04 02:51:39 -0800 | [diff] [blame] | 1148 | const cricket::AudioOptions& options) = 0; |
| 1149 | // Deprecated - use version above. |
deadbeef | fe0fd41 | 2017-01-13 11:47:56 -0800 | [diff] [blame] | 1150 | // Can use CopyConstraintsIntoAudioOptions to bridge the gap. |
hta | a2a49d9 | 2016-03-04 02:51:39 -0800 | [diff] [blame] | 1151 | virtual rtc::scoped_refptr<AudioSourceInterface> CreateAudioSource( |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1152 | const MediaConstraintsInterface* constraints) = 0; |
| 1153 | |
deadbeef | 39e14da | 2017-02-13 09:49:58 -0800 | [diff] [blame] | 1154 | // Creates a VideoTrackSourceInterface from |capturer|. |
| 1155 | // TODO(deadbeef): We should aim to remove cricket::VideoCapturer from the |
| 1156 | // API. It's mainly used as a wrapper around webrtc's provided |
| 1157 | // platform-specific capturers, but these should be refactored to use |
| 1158 | // VideoTrackSourceInterface directly. |
deadbeef | 112b2e9 | 2017-02-10 20:13:37 -0800 | [diff] [blame] | 1159 | // TODO(deadbeef): Make pure virtual once downstream mock PC factory classes |
| 1160 | // are updated. |
perkj | a3ede6c | 2016-03-08 01:27:48 +0100 | [diff] [blame] | 1161 | virtual rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource( |
deadbeef | 112b2e9 | 2017-02-10 20:13:37 -0800 | [diff] [blame] | 1162 | std::unique_ptr<cricket::VideoCapturer> capturer) { |
| 1163 | return nullptr; |
| 1164 | } |
| 1165 | |
hta | a2a49d9 | 2016-03-04 02:51:39 -0800 | [diff] [blame] | 1166 | // A video source creator that allows selection of resolution and frame rate. |
deadbeef | 8d60a94 | 2017-02-27 14:47:33 -0800 | [diff] [blame] | 1167 | // |constraints| decides video resolution and frame rate but can be null. |
| 1168 | // In the null case, use the version above. |
deadbeef | 112b2e9 | 2017-02-10 20:13:37 -0800 | [diff] [blame] | 1169 | // |
| 1170 | // |constraints| is only used for the invocation of this method, and can |
| 1171 | // safely be destroyed afterwards. |
| 1172 | virtual rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource( |
| 1173 | std::unique_ptr<cricket::VideoCapturer> capturer, |
| 1174 | const MediaConstraintsInterface* constraints) { |
| 1175 | return nullptr; |
| 1176 | } |
| 1177 | |
| 1178 | // Deprecated; please use the versions that take unique_ptrs above. |
| 1179 | // TODO(deadbeef): Remove these once safe to do so. |
| 1180 | virtual rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource( |
| 1181 | cricket::VideoCapturer* capturer) { |
| 1182 | return CreateVideoSource(std::unique_ptr<cricket::VideoCapturer>(capturer)); |
| 1183 | } |
perkj | a3ede6c | 2016-03-08 01:27:48 +0100 | [diff] [blame] | 1184 | virtual rtc::scoped_refptr<VideoTrackSourceInterface> CreateVideoSource( |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1185 | cricket::VideoCapturer* capturer, |
deadbeef | 112b2e9 | 2017-02-10 20:13:37 -0800 | [diff] [blame] | 1186 | const MediaConstraintsInterface* constraints) { |
| 1187 | return CreateVideoSource(std::unique_ptr<cricket::VideoCapturer>(capturer), |
| 1188 | constraints); |
| 1189 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1190 | |
| 1191 | // Creates a new local VideoTrack. The same |source| can be used in several |
| 1192 | // tracks. |
perkj | a3ede6c | 2016-03-08 01:27:48 +0100 | [diff] [blame] | 1193 | virtual rtc::scoped_refptr<VideoTrackInterface> CreateVideoTrack( |
| 1194 | const std::string& label, |
| 1195 | VideoTrackSourceInterface* source) = 0; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1196 | |
deadbeef | 8d60a94 | 2017-02-27 14:47:33 -0800 | [diff] [blame] | 1197 | // Creates an new AudioTrack. At the moment |source| can be null. |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1198 | virtual rtc::scoped_refptr<AudioTrackInterface> |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1199 | CreateAudioTrack(const std::string& label, |
| 1200 | AudioSourceInterface* source) = 0; |
| 1201 | |
wu@webrtc.org | a989080 | 2013-12-13 00:21:03 +0000 | [diff] [blame] | 1202 | // Starts AEC dump using existing file. Takes ownership of |file| and passes |
| 1203 | // it on to VoiceEngine (via other objects) immediately, which will take |
wu@webrtc.org | a8910d2 | 2014-01-23 22:12:45 +0000 | [diff] [blame] | 1204 | // the ownerhip. If the operation fails, the file will be closed. |
ivoc | d66b44d | 2016-01-15 03:06:36 -0800 | [diff] [blame] | 1205 | // A maximum file size in bytes can be specified. When the file size limit is |
| 1206 | // reached, logging is stopped automatically. If max_size_bytes is set to a |
| 1207 | // value <= 0, no limit will be used, and logging will continue until the |
| 1208 | // StopAecDump function is called. |
| 1209 | virtual bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes) = 0; |
wu@webrtc.org | a989080 | 2013-12-13 00:21:03 +0000 | [diff] [blame] | 1210 | |
ivoc | 797ef12 | 2015-10-22 03:25:41 -0700 | [diff] [blame] | 1211 | // Stops logging the AEC dump. |
| 1212 | virtual void StopAecDump() = 0; |
| 1213 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1214 | protected: |
| 1215 | // Dtor and ctor protected as objects shouldn't be created or deleted via |
| 1216 | // this interface. |
| 1217 | PeerConnectionFactoryInterface() {} |
| 1218 | ~PeerConnectionFactoryInterface() {} // NOLINT |
| 1219 | }; |
| 1220 | |
| 1221 | // Create a new instance of PeerConnectionFactoryInterface. |
Taylor Brandstetter | a8415fe | 2016-03-23 10:38:07 -0700 | [diff] [blame] | 1222 | // |
| 1223 | // This method relies on the thread it's called on as the "signaling thread" |
| 1224 | // for the PeerConnectionFactory it creates. |
| 1225 | // |
| 1226 | // As such, if the current thread is not already running an rtc::Thread message |
| 1227 | // loop, an application using this method must eventually either call |
| 1228 | // rtc::Thread::Current()->Run(), or call |
| 1229 | // rtc::Thread::Current()->ProcessMessages() within the application's own |
| 1230 | // message loop. |
kwiberg | 1e4e8cb | 2017-01-31 01:48:08 -0800 | [diff] [blame] | 1231 | rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory( |
| 1232 | rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory, |
| 1233 | rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory); |
| 1234 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1235 | // Create a new instance of PeerConnectionFactoryInterface. |
Taylor Brandstetter | a8415fe | 2016-03-23 10:38:07 -0700 | [diff] [blame] | 1236 | // |
danilchap | e9021a3 | 2016-05-17 01:52:02 -0700 | [diff] [blame] | 1237 | // |network_thread|, |worker_thread| and |signaling_thread| are |
| 1238 | // the only mandatory parameters. |
Taylor Brandstetter | a8415fe | 2016-03-23 10:38:07 -0700 | [diff] [blame] | 1239 | // |
deadbeef | b10f32f | 2017-02-08 01:38:21 -0800 | [diff] [blame] | 1240 | // If non-null, a reference is added to |default_adm|, and ownership of |
| 1241 | // |video_encoder_factory| and |video_decoder_factory| is transferred to the |
| 1242 | // returned factory. |
| 1243 | // TODO(deadbeef): Use rtc::scoped_refptr<> and std::unique_ptr<> to make this |
| 1244 | // ownership transfer and ref counting more obvious. |
danilchap | e9021a3 | 2016-05-17 01:52:02 -0700 | [diff] [blame] | 1245 | rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory( |
| 1246 | rtc::Thread* network_thread, |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1247 | rtc::Thread* worker_thread, |
| 1248 | rtc::Thread* signaling_thread, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1249 | AudioDeviceModule* default_adm, |
kwiberg | 1e4e8cb | 2017-01-31 01:48:08 -0800 | [diff] [blame] | 1250 | rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory, |
| 1251 | rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory, |
| 1252 | cricket::WebRtcVideoEncoderFactory* video_encoder_factory, |
| 1253 | cricket::WebRtcVideoDecoderFactory* video_decoder_factory); |
| 1254 | |
peah | 17675ce | 2017-06-30 07:24:04 -0700 | [diff] [blame] | 1255 | // Create a new instance of PeerConnectionFactoryInterface with optional |
| 1256 | // external audio mixed and audio processing modules. |
| 1257 | // |
| 1258 | // If |audio_mixer| is null, an internal audio mixer will be created and used. |
| 1259 | // If |audio_processing| is null, an internal audio processing module will be |
| 1260 | // created and used. |
| 1261 | rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory( |
| 1262 | rtc::Thread* network_thread, |
| 1263 | rtc::Thread* worker_thread, |
| 1264 | rtc::Thread* signaling_thread, |
| 1265 | AudioDeviceModule* default_adm, |
| 1266 | rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory, |
| 1267 | rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory, |
| 1268 | cricket::WebRtcVideoEncoderFactory* video_encoder_factory, |
| 1269 | cricket::WebRtcVideoDecoderFactory* video_decoder_factory, |
| 1270 | rtc::scoped_refptr<AudioMixer> audio_mixer, |
| 1271 | rtc::scoped_refptr<AudioProcessing> audio_processing); |
| 1272 | |
Magnus Jedvert | 58b0316 | 2017-09-15 19:02:47 +0200 | [diff] [blame] | 1273 | // Create a new instance of PeerConnectionFactoryInterface with optional video |
| 1274 | // codec factories. These video factories represents all video codecs, i.e. no |
| 1275 | // extra internal video codecs will be added. |
| 1276 | rtc::scoped_refptr<PeerConnectionFactoryInterface> CreatePeerConnectionFactory( |
| 1277 | rtc::Thread* network_thread, |
| 1278 | rtc::Thread* worker_thread, |
| 1279 | rtc::Thread* signaling_thread, |
| 1280 | rtc::scoped_refptr<AudioDeviceModule> default_adm, |
| 1281 | rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory, |
| 1282 | rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory, |
| 1283 | std::unique_ptr<VideoEncoderFactory> video_encoder_factory, |
| 1284 | std::unique_ptr<VideoDecoderFactory> video_decoder_factory, |
| 1285 | rtc::scoped_refptr<AudioMixer> audio_mixer, |
| 1286 | rtc::scoped_refptr<AudioProcessing> audio_processing); |
| 1287 | |
gyzhou | 95aa964 | 2016-12-13 14:06:26 -0800 | [diff] [blame] | 1288 | // Create a new instance of PeerConnectionFactoryInterface with external audio |
| 1289 | // mixer. |
| 1290 | // |
| 1291 | // If |audio_mixer| is null, an internal audio mixer will be created and used. |
| 1292 | rtc::scoped_refptr<PeerConnectionFactoryInterface> |
| 1293 | CreatePeerConnectionFactoryWithAudioMixer( |
| 1294 | rtc::Thread* network_thread, |
| 1295 | rtc::Thread* worker_thread, |
| 1296 | rtc::Thread* signaling_thread, |
| 1297 | AudioDeviceModule* default_adm, |
kwiberg | 1e4e8cb | 2017-01-31 01:48:08 -0800 | [diff] [blame] | 1298 | rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory, |
| 1299 | rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory, |
| 1300 | cricket::WebRtcVideoEncoderFactory* video_encoder_factory, |
| 1301 | cricket::WebRtcVideoDecoderFactory* video_decoder_factory, |
| 1302 | rtc::scoped_refptr<AudioMixer> audio_mixer); |
| 1303 | |
danilchap | e9021a3 | 2016-05-17 01:52:02 -0700 | [diff] [blame] | 1304 | // Create a new instance of PeerConnectionFactoryInterface. |
| 1305 | // Same thread is used as worker and network thread. |
danilchap | e9021a3 | 2016-05-17 01:52:02 -0700 | [diff] [blame] | 1306 | inline rtc::scoped_refptr<PeerConnectionFactoryInterface> |
| 1307 | CreatePeerConnectionFactory( |
| 1308 | rtc::Thread* worker_and_network_thread, |
| 1309 | rtc::Thread* signaling_thread, |
| 1310 | AudioDeviceModule* default_adm, |
kwiberg | 1e4e8cb | 2017-01-31 01:48:08 -0800 | [diff] [blame] | 1311 | rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory, |
| 1312 | rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory, |
| 1313 | cricket::WebRtcVideoEncoderFactory* video_encoder_factory, |
| 1314 | cricket::WebRtcVideoDecoderFactory* video_decoder_factory) { |
| 1315 | return CreatePeerConnectionFactory( |
| 1316 | worker_and_network_thread, worker_and_network_thread, signaling_thread, |
| 1317 | default_adm, audio_encoder_factory, audio_decoder_factory, |
| 1318 | video_encoder_factory, video_decoder_factory); |
| 1319 | } |
| 1320 | |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 1321 | // This is a lower-level version of the CreatePeerConnectionFactory functions |
| 1322 | // above. It's implemented in the "peerconnection" build target, whereas the |
| 1323 | // above methods are only implemented in the broader "libjingle_peerconnection" |
| 1324 | // build target, which pulls in the implementations of every module webrtc may |
| 1325 | // use. |
| 1326 | // |
| 1327 | // If an application knows it will only require certain modules, it can reduce |
| 1328 | // webrtc's impact on its binary size by depending only on the "peerconnection" |
| 1329 | // target and the modules the application requires, using |
| 1330 | // CreateModularPeerConnectionFactory instead of one of the |
| 1331 | // CreatePeerConnectionFactory methods above. For example, if an application |
| 1332 | // only uses WebRTC for audio, it can pass in null pointers for the |
| 1333 | // video-specific interfaces, and omit the corresponding modules from its |
| 1334 | // build. |
| 1335 | // |
| 1336 | // If |network_thread| or |worker_thread| are null, the PeerConnectionFactory |
| 1337 | // will create the necessary thread internally. If |signaling_thread| is null, |
| 1338 | // the PeerConnectionFactory will use the thread on which this method is called |
| 1339 | // as the signaling thread, wrapping it in an rtc::Thread object if needed. |
| 1340 | // |
| 1341 | // If non-null, a reference is added to |default_adm|, and ownership of |
| 1342 | // |video_encoder_factory| and |video_decoder_factory| is transferred to the |
| 1343 | // returned factory. |
| 1344 | // |
peah | a9cc40b | 2017-06-29 08:32:09 -0700 | [diff] [blame] | 1345 | // If |audio_mixer| is null, an internal audio mixer will be created and used. |
| 1346 | // |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 1347 | // TODO(deadbeef): Use rtc::scoped_refptr<> and std::unique_ptr<> to make this |
| 1348 | // ownership transfer and ref counting more obvious. |
| 1349 | // |
| 1350 | // TODO(deadbeef): Encapsulate these modules in a struct, so that when a new |
| 1351 | // module is inevitably exposed, we can just add a field to the struct instead |
| 1352 | // of adding a whole new CreateModularPeerConnectionFactory overload. |
| 1353 | rtc::scoped_refptr<PeerConnectionFactoryInterface> |
| 1354 | CreateModularPeerConnectionFactory( |
| 1355 | rtc::Thread* network_thread, |
| 1356 | rtc::Thread* worker_thread, |
| 1357 | rtc::Thread* signaling_thread, |
zhihuang | 38ede13 | 2017-06-15 12:52:32 -0700 | [diff] [blame] | 1358 | std::unique_ptr<cricket::MediaEngineInterface> media_engine, |
| 1359 | std::unique_ptr<CallFactoryInterface> call_factory, |
| 1360 | std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory); |
| 1361 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1362 | } // namespace webrtc |
| 1363 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 1364 | #endif // API_PEERCONNECTIONINTERFACE_H_ |