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