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-2019 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 "RealtimeMediaSourceFactory.h"
  45 #include <wtf/LoggerHelper.h>
  46 #include <wtf/RecursiveLockAdapter.h>
  47 #include <wtf/ThreadSafeRefCounted.h>
  48 #include <wtf/Vector.h>
  49 #include <wtf/WeakPtr.h>
  50 #include <wtf/text/WTFString.h>
  51
  52 namespace WTF {
  53 class MediaTime;
  54 }
  55
  56 namespace WebCore {
  57
  58 class AudioStreamDescription;
  59 class FloatRect;
  60 class GraphicsContext;
  61 class MediaStreamPrivate;
  62 class OrientationNotifier;
  63 class PlatformAudioData;
  64 class RealtimeMediaSourceSettings;
  65 class RemoteVideoSample;
  66
  67 struct CaptureSourceOrError;
  68
  69 class WEBCORE_EXPORT RealtimeMediaSource
  70     : public ThreadSafeRefCounted<RealtimeMediaSource>
  71     , public CanMakeWeakPtr<RealtimeMediaSource>
  72 #if !RELEASE_LOG_DISABLED
  73     , private LoggerHelper
  74 #endif
  75 {
  76 public:
  77     class Observer {
  78     public:
  79         virtual ~Observer();
  80
  81         // Source state changes.
  82         virtual void sourceStarted() { }
  83         virtual void sourceStopped() { }
  84         virtual void sourceMutedChanged() { }
  85         virtual void sourceSettingsChanged() { }
  86
  87         // Observer state queries.
  88         virtual bool preventSourceFromStopping() { return false; }
  89
  90         // Called on the main thread.
  91         virtual void videoSampleAvailable(MediaSample&) { }
  92
  93         // May be called on a background thread.
  94         virtual void audioSamplesAvailable(const MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t /*numberOfFrames*/) { }
  95     };
  96
  97     virtual ~RealtimeMediaSource() = default;
  98
  99     virtual Ref<RealtimeMediaSource> clone() { return *this; }
 100
 101     const String& hashedId() const;
 102     String deviceIDHashSalt() const;
 103
 104     const String& persistentID() const { return m_persistentID; }
 105
 106     enum class Type { None, Audio, Video };
 107     Type type() const { return m_type; }
 108
 109     bool isProducingData() const { return m_isProducingData; }
 110     void start();
 111     void stop();
 112     void requestToEnd(Observer& callingObserver);
 113
 114     bool muted() const { return m_muted; }
 115     void setMuted(bool);
 116
 117     bool captureDidFail() const { return m_captureDidFailed; }
 118
 119     virtual bool interrupted() const { return m_interrupted; }
 120     virtual void setInterrupted(bool, bool);
 121
 122     const String& name() const { return m_name; }
 123     void setName(String&& name) { m_name = WTFMove(name); }
 124
 125     unsigned fitnessScore() const { return m_fitnessScore; }
 126
 127     WEBCORE_EXPORT void addObserver(Observer&);
 128     WEBCORE_EXPORT void removeObserver(Observer&);
 129
 130     const IntSize size() const;
 131     void setSize(const IntSize&);
 132
 133     const IntSize intrinsicSize() const;
 134     void setIntrinsicSize(const IntSize&);
 135
 136     double frameRate() const { return m_frameRate; }
 137     void setFrameRate(double);
 138
 139     double aspectRatio() const { return m_aspectRatio; }
 140     void setAspectRatio(double);
 141
 142     RealtimeMediaSourceSettings::VideoFacingMode facingMode() const { return m_facingMode; }
 143     void setFacingMode(RealtimeMediaSourceSettings::VideoFacingMode);
 144
 145     double volume() const { return m_volume; }
 146     void setVolume(double);
 147
 148     int sampleRate() const { return m_sampleRate; }
 149     void setSampleRate(int);
 150     virtual Optional<Vector<int>> discreteSampleRates() const;
 151
 152     int sampleSize() const { return m_sampleSize; }
 153     void setSampleSize(int);
 154     virtual Optional<Vector<int>> discreteSampleSizes() const;
 155
 156     bool echoCancellation() const { return m_echoCancellation; }
 157     void setEchoCancellation(bool);
 158
 159     virtual const RealtimeMediaSourceCapabilities& capabilities() = 0;
 160     virtual const RealtimeMediaSourceSettings& settings() = 0;
 161
 162     struct ApplyConstraintsError {
 163         String badConstraint;
 164         String message;
 165     };
 166     using ApplyConstraintsHandler = CompletionHandler<void(Optional<ApplyConstraintsError>&&)>;
 167     virtual void applyConstraints(const MediaConstraints&, ApplyConstraintsHandler&&);
 168     Optional<ApplyConstraintsError> applyConstraints(const MediaConstraints&);
 169
 170     bool supportsConstraints(const MediaConstraints&, String&);
 171     bool supportsConstraint(const MediaConstraint&);
 172
 173     virtual bool isIsolated() const { return false; }
 174
 175     virtual bool isCaptureSource() const { return false; }
 176     virtual CaptureDevice::DeviceType deviceType() const { return CaptureDevice::DeviceType::Unknown; }
 177
 178     virtual void monitorOrientation(OrientationNotifier&) { }
 179
 180     virtual void captureFailed();
 181
 182     virtual bool isIncomingAudioSource() const { return false; }
 183     virtual bool isIncomingVideoSource() const { return false; }
 184
 185     void setIsRemote(bool isRemote) { m_isRemote = isRemote; }
 186     bool isRemote() const { return m_isRemote; }
 187
 188 #if !RELEASE_LOG_DISABLED
 189     void setLogger(const Logger&, const void*);
 190     const Logger* loggerPtr() const { return m_logger.get(); }
 191     const Logger& logger() const final { ASSERT(m_logger); return *m_logger.get(); }
 192     const void* logIdentifier() const final { return m_logIdentifier; }
 193     const char* logClassName() const override { return "RealtimeMediaSource"; }
 194     WTFLogChannel& logChannel() const final;
 195 #endif
 196
 197     // Testing only
 198     virtual void delaySamples(Seconds) { };
 199     void setInterruptedForTesting(bool);
 200
 201 protected:
 202     RealtimeMediaSource(Type, String&& name, String&& deviceID = { }, String&& hashSalt = { });
 203
 204     void scheduleDeferredTask(WTF::Function<void()>&&);
 205
 206     virtual void beginConfiguration() { }
 207     virtual void commitConfiguration() { }
 208
 209     bool selectSettings(const MediaConstraints&, FlattenedConstraint&, String&);
 210     double fitnessDistance(const MediaConstraint&);
 211     void applyConstraint(const MediaConstraint&);
 212     void applyConstraints(const FlattenedConstraint&);
 213     bool supportsSizeAndFrameRate(Optional<IntConstraint> width, Optional<IntConstraint> height, Optional<DoubleConstraint>, String&, double& fitnessDistance);
 214
 215     virtual bool supportsSizeAndFrameRate(Optional<int> width, Optional<int> height, Optional<double>);
 216     virtual void setSizeAndFrameRate(Optional<int> width, Optional<int> height, Optional<double>);
 217
 218     void notifyMutedObservers() const;
 219     void notifyMutedChange(bool muted);
 220     void notifySettingsDidChangeObservers(OptionSet<RealtimeMediaSourceSettings::Flag>);
 221
 222     void initializeVolume(double volume) { m_volume = volume; }
 223     void initializeSampleRate(int sampleRate) { m_sampleRate = sampleRate; }
 224     void initializeEchoCancellation(bool echoCancellation) { m_echoCancellation = echoCancellation; }
 225
 226     void videoSampleAvailable(MediaSample&);
 227     void audioSamplesAvailable(const MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t);
 228
 229     void forEachObserver(const WTF::Function<void(Observer&)>&) const;
 230
 231 private:
 232     virtual void startProducingData() { }
 233     virtual void stopProducingData() { }
 234     virtual void settingsDidChange(OptionSet<RealtimeMediaSourceSettings::Flag>) { }
 235
 236     virtual void hasEnded() { }
 237
 238 #if !RELEASE_LOG_DISABLED
 239     RefPtr<const Logger> m_logger;
 240     const void* m_logIdentifier;
 241     MonotonicTime m_lastFrameLogTime;
 242     unsigned m_frameCount { 0 };
 243 #endif
 244
 245     String m_idHashSalt;
 246     String m_hashedID;
 247     String m_persistentID;
 248     Type m_type;
 249     String m_name;
 250     mutable RecursiveLock m_observersLock;
 251     HashSet<Observer*> m_observers;
 252     IntSize m_size;
 253     IntSize m_intrinsicSize;
 254     double m_frameRate { 30 };
 255     double m_aspectRatio { 0 };
 256     double m_volume { 1 };
 257     double m_sampleRate { 0 };
 258     double m_sampleSize { 0 };
 259     double m_fitnessScore { 0 };
 260     RealtimeMediaSourceSettings::VideoFacingMode m_facingMode { RealtimeMediaSourceSettings::User};
 261
 262     bool m_muted { false };
 263     bool m_pendingSettingsDidChangeNotification { false };
 264     bool m_echoCancellation { false };
 265     bool m_isProducingData { false };
 266     bool m_interrupted { false };
 267     bool m_captureDidFailed { false };
 268     bool m_isRemote { false };
 269     bool m_isEnded { false };
 270 };
 271
 272 struct CaptureSourceOrError {
 273     CaptureSourceOrError() = default;
 274     CaptureSourceOrError(Ref<RealtimeMediaSource>&& source) : captureSource(WTFMove(source)) { }
 275     CaptureSourceOrError(String&& message) : errorMessage(WTFMove(message)) { }
 276
 277     operator bool()  const { return !!captureSource; }
 278     Ref<RealtimeMediaSource> source() { return captureSource.releaseNonNull(); }
 279
 280     RefPtr<RealtimeMediaSource> captureSource;
 281     String errorMessage;
 282 };
 283
 284 String convertEnumerationToString(RealtimeMediaSource::Type);
 285
 286 } // namespace WebCore
 287
 288 namespace WTF {
 289
 290 template<typename Type>
 291 struct LogArgument;
 292
 293 template <>
 294 struct LogArgument<WebCore::RealtimeMediaSource::Type> {
 295     static String toString(const WebCore::RealtimeMediaSource::Type type)
 296     {
 297         return convertEnumerationToString(type);
 298     }
 299 };
 300
 301 }; // namespace WTF
 302
 303 #endif // ENABLE(MEDIA_STREAM)