Add support for unified plan transceivers
[WebKit-https.git] / Source / WebCore / Modules / mediastream / libwebrtc / LibWebRTCMediaEndpoint.h
1 /*
2  * Copyright (C) 2017-2018 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1.  Redistributions of source code must retain the above copyright
8  *     notice, this list of conditions and the following disclaimer.
9  * 2.  Redistributions in binary form must reproduce the above copyright
10  *     notice, this list of conditions and the following disclaimer in the
11  *     documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  */
24
25 #pragma once
26
27 #if USE(LIBWEBRTC)
28
29 #include "LibWebRTCObservers.h"
30 #include "LibWebRTCProvider.h"
31 #include "LibWebRTCRtpSenderBackend.h"
32 #include "RTCRtpReceiver.h"
33 #include <Timer.h>
34
35 #pragma GCC diagnostic push
36 #pragma GCC diagnostic ignored "-Wunused-parameter"
37
38 #include <webrtc/api/jsep.h>
39 #include <webrtc/api/peerconnectioninterface.h>
40 #include <webrtc/pc/peerconnectionfactory.h>
41 #include <webrtc/pc/rtcstatscollector.h>
42
43 #pragma GCC diagnostic pop
44
45 #include <wtf/LoggerHelper.h>
46 #include <wtf/ThreadSafeRefCounted.h>
47
48 namespace webrtc {
49 class CreateSessionDescriptionObserver;
50 class DataChannelInterface;
51 class IceCandidateInterface;
52 class MediaStreamInterface;
53 class PeerConnectionObserver;
54 class SessionDescriptionInterface;
55 class SetSessionDescriptionObserver;
56 }
57
58 namespace WebCore {
59
60 class LibWebRTCProvider;
61 class LibWebRTCPeerConnectionBackend;
62 class LibWebRTCRtpReceiverBackend;
63 class LibWebRTCRtpTransceiverBackend;
64 class MediaStreamTrack;
65 class RTCSessionDescription;
66
67 class LibWebRTCMediaEndpoint
68     : public ThreadSafeRefCounted<LibWebRTCMediaEndpoint, WTF::DestructionThread::Main>
69     , private webrtc::PeerConnectionObserver
70     , private webrtc::RTCStatsCollectorCallback
71 #if !RELEASE_LOG_DISABLED
72     , private LoggerHelper
73 #endif
74 {
75 public:
76     static Ref<LibWebRTCMediaEndpoint> create(LibWebRTCPeerConnectionBackend& peerConnection, LibWebRTCProvider& client) { return adoptRef(*new LibWebRTCMediaEndpoint(peerConnection, client)); }
77     virtual ~LibWebRTCMediaEndpoint() = default;
78
79     bool setConfiguration(LibWebRTCProvider&, webrtc::PeerConnectionInterface::RTCConfiguration&&);
80
81     webrtc::PeerConnectionInterface& backend() const { ASSERT(m_backend); return *m_backend.get(); }
82     void doSetLocalDescription(RTCSessionDescription&);
83     void doSetRemoteDescription(RTCSessionDescription&);
84     void doCreateOffer(const RTCOfferOptions&);
85     void doCreateAnswer();
86     void getStats(MediaStreamTrack*, Ref<DeferredPromise>&&);
87     std::unique_ptr<RTCDataChannelHandler> createDataChannel(const String&, const RTCDataChannelInit&);
88     bool addIceCandidate(webrtc::IceCandidateInterface& candidate) { return m_backend->AddIceCandidate(&candidate); }
89
90     void stop();
91     bool isStopped() const { return !m_backend; }
92
93     RefPtr<RTCSessionDescription> localDescription() const;
94     RefPtr<RTCSessionDescription> remoteDescription() const;
95     RefPtr<RTCSessionDescription> currentLocalDescription() const;
96     RefPtr<RTCSessionDescription> currentRemoteDescription() const;
97     RefPtr<RTCSessionDescription> pendingLocalDescription() const;
98     RefPtr<RTCSessionDescription> pendingRemoteDescription() const;
99
100     bool addTrack(LibWebRTCRtpSenderBackend&, MediaStreamTrack&, const Vector<String>&);
101     void removeTrack(LibWebRTCRtpSenderBackend&);
102
103     struct Backends {
104         std::unique_ptr<LibWebRTCRtpSenderBackend> senderBackend;
105         std::unique_ptr<LibWebRTCRtpReceiverBackend> receiverBackend;
106         std::unique_ptr<LibWebRTCRtpTransceiverBackend> transceiverBackend;
107     };
108     std::optional<Backends> addTransceiver(const String& trackKind, const RTCRtpTransceiverInit&);
109     std::optional<Backends> addTransceiver(MediaStreamTrack&, const RTCRtpTransceiverInit&);
110     std::unique_ptr<LibWebRTCRtpTransceiverBackend> transceiverBackendFromSender(LibWebRTCRtpSenderBackend&);
111
112 private:
113     LibWebRTCMediaEndpoint(LibWebRTCPeerConnectionBackend&, LibWebRTCProvider&);
114
115     // webrtc::PeerConnectionObserver API
116     void OnSignalingChange(webrtc::PeerConnectionInterface::SignalingState) final;
117     void OnAddStream(rtc::scoped_refptr<webrtc::MediaStreamInterface>) final;
118     void OnRemoveStream(rtc::scoped_refptr<webrtc::MediaStreamInterface>) final;
119     void OnDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface>) final;
120     void OnAddTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface>, const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&) final;
121     void OnTrack(rtc::scoped_refptr<webrtc::RtpTransceiverInterface>) final;
122
123     void OnRenegotiationNeeded() final;
124     void OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState) final;
125     void OnIceGatheringChange(webrtc::PeerConnectionInterface::IceGatheringState) final;
126     void OnIceCandidate(const webrtc::IceCandidateInterface*) final;
127     void OnIceCandidatesRemoved(const std::vector<cricket::Candidate>&) final;
128
129     void createSessionDescriptionSucceeded(std::unique_ptr<webrtc::SessionDescriptionInterface>&&);
130     void createSessionDescriptionFailed(const std::string&);
131     void setLocalSessionDescriptionSucceeded();
132     void setLocalSessionDescriptionFailed(const std::string&);
133     void setRemoteSessionDescriptionSucceeded();
134     void setRemoteSessionDescriptionFailed(const std::string&);
135     void addRemoteStream(webrtc::MediaStreamInterface&);
136     void addRemoteTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface>&&, const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&);
137     void removeRemoteStream(webrtc::MediaStreamInterface&);
138     void newTransceiver(rtc::scoped_refptr<webrtc::RtpTransceiverInterface>&&);
139
140     void fireTrackEvent(Ref<RTCRtpReceiver>&&, Ref<MediaStreamTrack>&&, const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&, RefPtr<RTCRtpTransceiver>&&);
141
142     template<typename T>
143     std::optional<Backends> createTransceiverBackends(T&&, const RTCRtpTransceiverInit&, LibWebRTCRtpSenderBackend::Source&&);
144
145     void OnStatsDelivered(const rtc::scoped_refptr<const webrtc::RTCStatsReport>&) final;
146     void gatherStatsForLogging();
147     void startLoggingStats();
148     void stopLoggingStats();
149
150     MediaStream& mediaStreamFromRTCStream(webrtc::MediaStreamInterface&);
151
152     void AddRef() const { ref(); }
153     rtc::RefCountReleaseStatus Release() const
154     {
155         auto result = refCount() - 1;
156         deref();
157         return result ? rtc::RefCountReleaseStatus::kOtherRefsRemained
158         : rtc::RefCountReleaseStatus::kDroppedLastRef;
159     }
160
161 #if !RELEASE_LOG_DISABLED
162     const Logger& logger() const final { return m_logger.get(); }
163     const void* logIdentifier() const final { return m_logIdentifier; }
164     const char* logClassName() const final { return "LibWebRTCMediaEndpoint"; }
165     WTFLogChannel& logChannel() const final;
166
167     Seconds statsLogInterval(int64_t) const;
168 #endif
169
170     LibWebRTCPeerConnectionBackend& m_peerConnectionBackend;
171     webrtc::PeerConnectionFactoryInterface& m_peerConnectionFactory;
172     rtc::scoped_refptr<webrtc::PeerConnectionInterface> m_backend;
173
174     friend CreateSessionDescriptionObserver<LibWebRTCMediaEndpoint>;
175     friend SetLocalSessionDescriptionObserver<LibWebRTCMediaEndpoint>;
176     friend SetRemoteSessionDescriptionObserver<LibWebRTCMediaEndpoint>;
177
178     CreateSessionDescriptionObserver<LibWebRTCMediaEndpoint> m_createSessionDescriptionObserver;
179     SetLocalSessionDescriptionObserver<LibWebRTCMediaEndpoint> m_setLocalSessionDescriptionObserver;
180     SetRemoteSessionDescriptionObserver<LibWebRTCMediaEndpoint> m_setRemoteSessionDescriptionObserver;
181
182     HashMap<webrtc::MediaStreamInterface*, RefPtr<MediaStream>> m_streams;
183
184     bool m_isInitiator { false };
185     Timer m_statsLogTimer;
186
187     HashMap<String, rtc::scoped_refptr<webrtc::MediaStreamInterface>> m_localStreams;
188
189 #if !RELEASE_LOG_DISABLED
190     int64_t m_statsFirstDeliveredTimestamp { 0 };
191     Ref<const Logger> m_logger;
192     const void* m_logIdentifier;
193 #endif
194 };
195
196 } // namespace WebCore
197
198 #endif // USE(LIBWEBRTC)