Use "= default" to denote default constructor or destructor
[WebKit-https.git] / Source / WebCore / platform / mediastream / RealtimeMediaSource.h
1 /*
2  * Copyright (C) 2011 Ericsson AB. All rights reserved.
3  * Copyright (C) 2012 Google Inc. All rights reserved.
4  * Copyright (C) 2013-2017 Apple Inc. All rights reserved.
5  * Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies).
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer
15  *    in the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of Ericsson nor the names of its contributors
18  *    may be used to endorse or promote products derived from this
19  *    software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33
34 #pragma once
35
36 #if ENABLE(MEDIA_STREAM)
37
38 #include "CaptureDevice.h"
39 #include "Image.h"
40 #include "MediaConstraints.h"
41 #include "MediaSample.h"
42 #include "PlatformLayer.h"
43 #include "RealtimeMediaSourceCapabilities.h"
44 #include <wtf/RefCounted.h>
45 #include <wtf/Vector.h>
46 #include <wtf/WeakPtr.h>
47 #include <wtf/text/WTFString.h>
48
49 namespace WTF {
50 class MediaTime;
51 }
52
53 namespace WebCore {
54
55 class AudioStreamDescription;
56 class FloatRect;
57 class GraphicsContext;
58 class MediaStreamPrivate;
59 class OrientationNotifier;
60 class PlatformAudioData;
61 class RealtimeMediaSourceSettings;
62
63 struct CaptureSourceOrError;
64
65 class WEBCORE_EXPORT RealtimeMediaSource : public RefCounted<RealtimeMediaSource> {
66 public:
67     class Observer {
68     public:
69         virtual ~Observer() = default;
70
71         // Source state changes.
72         virtual void sourceStarted() { }
73         virtual void sourceStopped() { }
74         virtual void sourceMutedChanged() { }
75         virtual void sourceSettingsChanged() { }
76
77         // Observer state queries.
78         virtual bool preventSourceFromStopping() { return false; }
79
80         // Called on the main thread.
81         virtual void videoSampleAvailable(MediaSample&) { }
82
83         // May be called on a background thread.
84         virtual void audioSamplesAvailable(const MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t /*numberOfFrames*/) { }
85     };
86
87     template<typename Source> class SingleSourceFactory {
88     public:
89         void setActiveSource(Source& source)
90         {
91             if (m_activeSource == &source)
92                 return;
93             if (m_activeSource && m_activeSource->isProducingData())
94                 m_activeSource->setMuted(true);
95             m_activeSource = &source;
96         }
97
98         void unsetActiveSource(Source& source)
99         {
100             if (m_activeSource == &source)
101                 m_activeSource = nullptr;
102         }
103
104         RealtimeMediaSource* activeSource() { return m_activeSource; }
105     private:
106         RealtimeMediaSource* m_activeSource { nullptr };
107     };
108
109     class AudioCaptureFactory {
110     public:
111         virtual ~AudioCaptureFactory() = default;
112         virtual CaptureSourceOrError createAudioCaptureSource(const String& audioDeviceID, const MediaConstraints*) = 0;
113
114     protected:
115         AudioCaptureFactory() = default;
116     };
117
118     class VideoCaptureFactory {
119     public:
120         virtual ~VideoCaptureFactory() = default;
121         virtual CaptureSourceOrError createVideoCaptureSource(const String& videoDeviceID, const MediaConstraints*) = 0;
122         virtual void setVideoCapturePageState(bool, bool) { }
123
124     protected:
125         VideoCaptureFactory() = default;
126     };
127
128     virtual ~RealtimeMediaSource() = default;
129
130     const String& id() const { return m_id; }
131
132     const String& persistentID() const { return m_persistentID; }
133     virtual void setPersistentID(String&& persistentID) { m_persistentID = WTFMove(persistentID); }
134
135     enum class Type { None, Audio, Video };
136     Type type() const { return m_type; }
137
138     bool isProducingData() const { return m_isProducingData; }
139     void start();
140     void stop();
141     void requestStop(Observer* callingObserver = nullptr);
142
143     bool muted() const { return m_muted; }
144     void setMuted(bool);
145
146     bool captureDidFail() const { return m_captureDidFailed; }
147
148     virtual bool interrupted() const { return m_interrupted; }
149     virtual void setInterrupted(bool, bool);
150
151     const String& name() const { return m_name; }
152     void setName(const String& name) { m_name = name; }
153
154     unsigned fitnessScore() const { return m_fitnessScore; }
155
156     WEBCORE_EXPORT void addObserver(Observer&);
157     WEBCORE_EXPORT void removeObserver(Observer&);
158
159     void setWidth(int);
160     void setHeight(int);
161     const IntSize& size() const { return m_size; }
162     virtual bool applySize(const IntSize&) { return false; }
163
164     double frameRate() const { return m_frameRate; }
165     void setFrameRate(double);
166     virtual bool applyFrameRate(double) { return false; }
167
168     double aspectRatio() const { return m_aspectRatio; }
169     void setAspectRatio(double);
170     virtual bool applyAspectRatio(double) { return false; }
171
172     RealtimeMediaSourceSettings::VideoFacingMode facingMode() const { return m_facingMode; }
173     void setFacingMode(RealtimeMediaSourceSettings::VideoFacingMode);
174     virtual bool applyFacingMode(RealtimeMediaSourceSettings::VideoFacingMode) { return false; }
175
176     double volume() const { return m_volume; }
177     void setVolume(double);
178     virtual bool applyVolume(double) { return false; }
179
180     int sampleRate() const { return m_sampleRate; }
181     void setSampleRate(int);
182     virtual bool applySampleRate(int) { return false; }
183
184     int sampleSize() const { return m_sampleSize; }
185     void setSampleSize(int);
186     virtual bool applySampleSize(int) { return false; }
187
188     bool echoCancellation() const { return m_echoCancellation; }
189     void setEchoCancellation(bool);
190     virtual bool applyEchoCancellation(bool) { return false; }
191
192     virtual const RealtimeMediaSourceCapabilities& capabilities() const = 0;
193     virtual const RealtimeMediaSourceSettings& settings() const = 0;
194
195     using SuccessHandler = WTF::Function<void()>;
196     using FailureHandler = WTF::Function<void(const String& badConstraint, const String& errorString)>;
197     virtual void applyConstraints(const MediaConstraints&, SuccessHandler&&, FailureHandler&&);
198     std::optional<std::pair<String, String>> applyConstraints(const MediaConstraints&);
199
200     virtual bool supportsConstraints(const MediaConstraints&, String&);
201     virtual bool supportsConstraint(const MediaConstraint&) const;
202
203     virtual void settingsDidChange();
204
205     virtual bool isIsolated() const { return false; }
206
207     virtual bool isCaptureSource() const { return false; }
208
209     virtual void monitorOrientation(OrientationNotifier&) { }
210
211     void captureFailed();
212
213     // Testing only
214     virtual void delaySamples(float) { };
215
216 protected:
217     RealtimeMediaSource(const String& id, Type, const String& name);
218
219     void scheduleDeferredTask(WTF::Function<void()>&&);
220
221     virtual void beginConfiguration() { }
222     virtual void commitConfiguration() { }
223
224     enum class SelectType { ForApplyConstraints, ForSupportsConstraints };
225     bool selectSettings(const MediaConstraints&, FlattenedConstraint&, String&, SelectType);
226     virtual double fitnessDistance(const MediaConstraint&);
227     virtual bool supportsSizeAndFrameRate(std::optional<IntConstraint> width, std::optional<IntConstraint> height, std::optional<DoubleConstraint>, String&, double& fitnessDistance);
228     virtual bool supportsSizeAndFrameRate(std::optional<int> width, std::optional<int> height, std::optional<double>);
229     virtual void applyConstraint(const MediaConstraint&);
230     virtual void applyConstraints(const FlattenedConstraint&);
231     virtual void applySizeAndFrameRate(std::optional<int> width, std::optional<int> height, std::optional<double>);
232
233     void notifyMutedObservers() const;
234     void notifyMutedChange(bool muted);
235
236     void initializeVolume(double volume) { m_volume = volume; }
237     void initializeSampleRate(int sampleRate) { m_sampleRate = sampleRate; }
238     void initializeEchoCancellation(bool echoCancellation) { m_echoCancellation = echoCancellation; }
239
240     void videoSampleAvailable(MediaSample&);
241     void audioSamplesAvailable(const MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t);
242
243     WeakPtr<RealtimeMediaSource> createWeakPtr() { return m_weakPtrFactory.createWeakPtr(*this); }
244
245 private:
246     virtual void startProducingData() { }
247     virtual void stopProducingData() { }
248
249     bool m_muted { false };
250
251     WeakPtrFactory<RealtimeMediaSource> m_weakPtrFactory;
252     String m_id;
253     String m_persistentID;
254     Type m_type;
255     String m_name;
256     Vector<std::reference_wrapper<Observer>> m_observers;
257     IntSize m_size;
258     double m_frameRate { 30 };
259     double m_aspectRatio { 0 };
260     double m_volume { 1 };
261     double m_sampleRate { 0 };
262     double m_sampleSize { 0 };
263     double m_fitnessScore { std::numeric_limits<double>::infinity() };
264     RealtimeMediaSourceSettings::VideoFacingMode m_facingMode { RealtimeMediaSourceSettings::User};
265
266     bool m_echoCancellation { false };
267     bool m_pendingSettingsDidChangeNotification { false };
268     bool m_isProducingData { false };
269     bool m_interrupted { false };
270     bool m_captureDidFailed { false };
271 };
272
273 struct CaptureSourceOrError {
274     CaptureSourceOrError() = default;
275     CaptureSourceOrError(Ref<RealtimeMediaSource>&& source) : captureSource(WTFMove(source)) { }
276     CaptureSourceOrError(String&& message) : errorMessage(WTFMove(message)) { }
277     
278     operator bool()  const { return !!captureSource; }
279     Ref<RealtimeMediaSource> source() { return captureSource.releaseNonNull(); }
280     
281     RefPtr<RealtimeMediaSource> captureSource;
282     String errorMessage;
283 };
284
285 } // namespace WebCore
286
287 #endif // ENABLE(MEDIA_STREAM)