Use "= default" to denote default constructor or destructor
[WebKit-https.git] / Source / WebCore / platform / graphics / MediaPlayer.h
1 /*
2  * Copyright (C) 2007-2014 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. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef MediaPlayer_h
27 #define MediaPlayer_h
28
29 #if ENABLE(VIDEO)
30 #include "GraphicsTypes3D.h"
31
32 #include "AudioTrackPrivate.h"
33 #include "ContentType.h"
34 #include "LegacyCDMSession.h"
35 #include "InbandTextTrackPrivate.h"
36 #include "IntRect.h"
37 #include "URL.h"
38 #include "LayoutRect.h"
39 #include "MediaPlayerEnums.h"
40 #include "NativeImage.h"
41 #include "PlatformLayer.h"
42 #include "PlatformMediaResourceLoader.h"
43 #include "PlatformMediaSession.h"
44 #include "SecurityOriginHash.h"
45 #include "Timer.h"
46 #include "VideoTrackPrivate.h"
47 #include <pal/Logger.h>
48 #include <runtime/Uint8Array.h>
49 #include <wtf/Forward.h>
50 #include <wtf/Function.h>
51 #include <wtf/HashSet.h>
52 #include <wtf/MediaTime.h>
53 #include <wtf/Noncopyable.h>
54 #include <wtf/Ref.h>
55 #include <wtf/RefCounted.h>
56 #include <wtf/text/StringHash.h>
57
58 #if ENABLE(AVF_CAPTIONS)
59 #include "PlatformTextTrack.h"
60 #endif
61
62 OBJC_CLASS AVAsset;
63 OBJC_CLASS AVPlayer;
64 OBJC_CLASS NSArray;
65 OBJC_CLASS QTMovie;
66
67 class AVCFPlayer;
68 class QTMovieGWorld;
69 class QTMovieVisualContext;
70
71 namespace WebCore {
72
73 class AudioSourceProvider;
74 class AuthenticationChallenge;
75 #if ENABLE(ENCRYPTED_MEDIA)
76 class CDMInstance;
77 #endif
78 class MediaPlaybackTarget;
79 #if ENABLE(MEDIA_SOURCE)
80 class MediaSourcePrivateClient;
81 #endif
82 #if ENABLE(MEDIA_STREAM)
83 class MediaStreamPrivate;
84 #endif
85 class MediaPlayerPrivateInterface;
86 class TextTrackRepresentation;
87 struct Cookie;
88
89 // Structure that will hold every native
90 // types supported by the current media player.
91 // We have to do that has multiple media players
92 // backend can live at runtime.
93 struct PlatformMedia {
94     enum {
95         None,
96         QTMovieType,
97         QTMovieGWorldType,
98         QTMovieVisualContextType,
99         AVFoundationMediaPlayerType,
100         AVFoundationCFMediaPlayerType,
101         AVFoundationAssetType,
102     } type;
103
104     union {
105         QTMovie* qtMovie;
106         QTMovieGWorld* qtMovieGWorld;
107         QTMovieVisualContext* qtMovieVisualContext;
108         AVPlayer* avfMediaPlayer;
109         AVCFPlayer* avcfMediaPlayer;
110         AVAsset* avfAsset;
111     } media;
112 };
113
114 struct MediaEngineSupportParameters {
115
116     MediaEngineSupportParameters() = default;
117
118     ContentType type;
119     URL url;
120     bool isMediaSource { false };
121     bool isMediaStream { false };
122     Vector<ContentType> contentTypesRequiringHardwareSupport;
123 };
124
125 struct PlatformVideoPlaybackQualityMetrics {
126     PlatformVideoPlaybackQualityMetrics(unsigned long totalVideoFrames, unsigned long droppedVideoFrames, unsigned long corruptedVideoFrames, double totalFrameDelay)
127         : totalVideoFrames(totalVideoFrames)
128         , droppedVideoFrames(droppedVideoFrames)
129         , corruptedVideoFrames(corruptedVideoFrames)
130         , totalFrameDelay(totalFrameDelay)
131     {
132     }
133
134     unsigned long totalVideoFrames;
135     unsigned long droppedVideoFrames;
136     unsigned long corruptedVideoFrames;
137     double totalFrameDelay;
138 };
139
140 extern const PlatformMedia NoPlatformMedia;
141
142 class LegacyCDMSessionClient;
143 class CachedResourceLoader;
144 class ContentType;
145 class GraphicsContext;
146 class GraphicsContext3D;
147 class IntRect;
148 class IntSize;
149 class MediaPlayer;
150 class PlatformTimeRanges;
151
152 struct MediaPlayerFactory;
153
154 #if PLATFORM(WIN) && USE(AVFOUNDATION)
155 struct GraphicsDeviceAdapter;
156 #endif
157
158 #if USE(GSTREAMER)
159 class MediaPlayerRequestInstallMissingPluginsCallback;
160 #endif
161
162 class MediaPlayerClient {
163 public:
164     virtual ~MediaPlayerClient() = default;
165
166     // the network state has changed
167     virtual void mediaPlayerNetworkStateChanged(MediaPlayer*) { }
168
169     // the ready state has changed
170     virtual void mediaPlayerReadyStateChanged(MediaPlayer*) { }
171
172     // the volume state has changed
173     virtual void mediaPlayerVolumeChanged(MediaPlayer*) { }
174
175     // the mute state has changed
176     virtual void mediaPlayerMuteChanged(MediaPlayer*) { }
177
178     // time has jumped, eg. not as a result of normal playback
179     virtual void mediaPlayerTimeChanged(MediaPlayer*) { }
180
181     // the media file duration has changed, or is now known
182     virtual void mediaPlayerDurationChanged(MediaPlayer*) { }
183
184     // the playback rate has changed
185     virtual void mediaPlayerRateChanged(MediaPlayer*) { }
186
187     // the play/pause status changed
188     virtual void mediaPlayerPlaybackStateChanged(MediaPlayer*) { }
189
190     // The MediaPlayer has found potentially problematic media content.
191     // This is used internally to trigger swapping from a <video>
192     // element to an <embed> in standalone documents
193     virtual void mediaPlayerSawUnsupportedTracks(MediaPlayer*) { }
194
195     // The MediaPlayer could not discover an engine which supports the requested resource.
196     virtual void mediaPlayerResourceNotSupported(MediaPlayer*) { }
197
198 // Presentation-related methods
199     // a new frame of video is available
200     virtual void mediaPlayerRepaint(MediaPlayer*) { }
201
202     // the movie size has changed
203     virtual void mediaPlayerSizeChanged(MediaPlayer*) { }
204
205     virtual void mediaPlayerEngineUpdated(MediaPlayer*) { }
206
207     // The first frame of video is available to render. A media engine need only make this callback if the
208     // first frame is not available immediately when prepareForRendering is called.
209     virtual void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*) { }
210
211     // A characteristic of the media file, eg. video, audio, closed captions, etc, has changed.
212     virtual void mediaPlayerCharacteristicChanged(MediaPlayer*) { }
213     
214     // whether the rendering system can accelerate the display of this MediaPlayer.
215     virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) { return false; }
216
217     // called when the media player's rendering mode changed, which indicates a change in the
218     // availability of the platformLayer().
219     virtual void mediaPlayerRenderingModeChanged(MediaPlayer*) { }
220
221     // whether accelerated compositing is enabled for video rendering
222     virtual bool mediaPlayerAcceleratedCompositingEnabled() { return false; }
223
224     virtual void mediaPlayerActiveSourceBuffersChanged(const MediaPlayer*) { }
225
226 #if PLATFORM(WIN) && USE(AVFOUNDATION)
227     virtual GraphicsDeviceAdapter* mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const { return 0; }
228 #endif
229
230 #if ENABLE(LEGACY_ENCRYPTED_MEDIA)
231     virtual RefPtr<ArrayBuffer> mediaPlayerCachedKeyForKeyId(const String&) const { return nullptr; }
232     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, Uint8Array*) { return false; }
233     virtual String mediaPlayerMediaKeysStorageDirectory() const { return emptyString(); }
234 #endif
235
236 #if ENABLE(ENCRYPTED_MEDIA)
237     virtual void mediaPlayerInitializationDataEncountered(const String&, RefPtr<ArrayBuffer>&&) { }
238 #endif
239     
240 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
241     virtual void mediaPlayerCurrentPlaybackTargetIsWirelessChanged(MediaPlayer*) { };
242 #endif
243
244     virtual String mediaPlayerReferrer() const { return String(); }
245     virtual String mediaPlayerUserAgent() const { return String(); }
246     virtual void mediaPlayerEnterFullscreen() { }
247     virtual void mediaPlayerExitFullscreen() { }
248     virtual bool mediaPlayerIsFullscreen() const { return false; }
249     virtual bool mediaPlayerIsFullscreenPermitted() const { return false; }
250     virtual bool mediaPlayerIsVideo() const { return false; }
251     virtual LayoutRect mediaPlayerContentBoxRect() const { return LayoutRect(); }
252     virtual float mediaPlayerContentsScale() const { return 1; }
253     virtual void mediaPlayerSetSize(const IntSize&) { }
254     virtual void mediaPlayerPause() { }
255     virtual void mediaPlayerPlay() { }
256     virtual bool mediaPlayerPlatformVolumeConfigurationRequired() const { return false; }
257     virtual bool mediaPlayerIsPaused() const { return true; }
258     virtual bool mediaPlayerIsLooping() const { return false; }
259     virtual CachedResourceLoader* mediaPlayerCachedResourceLoader() { return 0; }
260     virtual RefPtr<PlatformMediaResourceLoader> mediaPlayerCreateResourceLoader() { return nullptr; }
261     virtual bool doesHaveAttribute(const AtomicString&, AtomicString* = 0) const { return false; }
262     virtual bool mediaPlayerShouldUsePersistentCache() const { return true; }
263     virtual const String& mediaPlayerMediaCacheDirectory() const { return emptyString(); }
264
265 #if ENABLE(VIDEO_TRACK)
266     virtual void mediaPlayerDidAddAudioTrack(AudioTrackPrivate&) { }
267     virtual void mediaPlayerDidAddTextTrack(InbandTextTrackPrivate&) { }
268     virtual void mediaPlayerDidAddVideoTrack(VideoTrackPrivate&) { }
269     virtual void mediaPlayerDidRemoveAudioTrack(AudioTrackPrivate&) { }
270     virtual void mediaPlayerDidRemoveTextTrack(InbandTextTrackPrivate&) { }
271     virtual void mediaPlayerDidRemoveVideoTrack(VideoTrackPrivate&) { }
272
273     virtual void textTrackRepresentationBoundsChanged(const IntRect&) { }
274 #if ENABLE(AVF_CAPTIONS)
275     virtual Vector<RefPtr<PlatformTextTrack>> outOfBandTrackSources() { return Vector<RefPtr<PlatformTextTrack>>(); }
276 #endif
277 #endif
278
279 #if PLATFORM(IOS)
280     virtual String mediaPlayerNetworkInterfaceName() const { return String(); }
281     virtual bool mediaPlayerGetRawCookies(const URL&, Vector<Cookie>&) const { return false; }
282 #endif
283     
284     virtual bool mediaPlayerShouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge&) { return false; }
285     virtual void mediaPlayerHandlePlaybackCommand(PlatformMediaSession::RemoteControlCommandType) { }
286
287     virtual String mediaPlayerSourceApplicationIdentifier() const { return emptyString(); }
288
289     virtual bool mediaPlayerIsInMediaDocument() const { return false; }
290     virtual void mediaPlayerEngineFailedToLoad() const { }
291
292     virtual double mediaPlayerRequestedPlaybackRate() const { return 0; }
293     virtual MediaPlayerEnums::VideoFullscreenMode mediaPlayerFullscreenMode() const { return MediaPlayerEnums::VideoFullscreenModeNone; }
294     virtual Vector<String> mediaPlayerPreferredAudioCharacteristics() const { return Vector<String>(); }
295
296 #if USE(GSTREAMER)
297     virtual void requestInstallMissingPlugins(const String&, const String&, MediaPlayerRequestInstallMissingPluginsCallback&) { };
298 #endif
299
300     virtual bool mediaPlayerShouldDisableSleep() const { return false; }
301     virtual const Vector<ContentType>& mediaContentTypesRequiringHardwareSupport() const;
302     virtual bool mediaPlayerShouldCheckHardwareSupport() const { return false; }
303
304 #if !RELEASE_LOG_DISABLED
305     virtual const void* mediaPlayerLogIdentifier() { return nullptr; }
306     virtual const PAL::Logger& mediaPlayerLogger() = 0;
307 #endif
308 };
309
310 class MediaPlayerSupportsTypeClient {
311 public:
312     virtual ~MediaPlayerSupportsTypeClient() = default;
313
314     virtual bool mediaPlayerNeedsSiteSpecificHacks() const { return false; }
315     virtual String mediaPlayerDocumentHost() const { return String(); }
316 };
317
318 class MediaPlayer : public MediaPlayerEnums, public RefCounted<MediaPlayer> {
319     WTF_MAKE_NONCOPYABLE(MediaPlayer); WTF_MAKE_FAST_ALLOCATED;
320 public:
321     static Ref<MediaPlayer> create(MediaPlayerClient&);
322     virtual ~MediaPlayer();
323
324     void invalidate();
325
326     // Media engine support.
327     enum SupportsType { IsNotSupported, IsSupported, MayBeSupported };
328     static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&, const MediaPlayerSupportsTypeClient*);
329     static void getSupportedTypes(HashSet<String, ASCIICaseInsensitiveHash>&);
330     static bool isAvailable();
331     static HashSet<RefPtr<SecurityOrigin>> originsInMediaCache(const String& path);
332     static void clearMediaCache(const String& path, std::chrono::system_clock::time_point modifiedSince);
333     static void clearMediaCacheForOrigins(const String& path, const HashSet<RefPtr<SecurityOrigin>>&);
334     static bool supportsKeySystem(const String& keySystem, const String& mimeType);
335
336     bool supportsPictureInPicture() const;
337     bool supportsFullscreen() const;
338     bool supportsScanning() const;
339     bool canSaveMediaData() const;
340     bool requiresImmediateCompositing() const;
341     bool doesHaveAttribute(const AtomicString&, AtomicString* value = nullptr) const;
342     PlatformMedia platformMedia() const;
343     PlatformLayer* platformLayer() const;
344
345 #if PLATFORM(IOS) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
346     void setVideoFullscreenLayer(PlatformLayer*, WTF::Function<void()>&& completionHandler = [] { });
347     void setVideoFullscreenFrame(FloatRect);
348     using MediaPlayerEnums::VideoGravity;
349     void setVideoFullscreenGravity(VideoGravity);
350     void setVideoFullscreenMode(VideoFullscreenMode);
351     VideoFullscreenMode fullscreenMode() const;
352 #endif
353
354 #if PLATFORM(IOS)
355     NSArray *timedMetadata() const;
356     String accessLog() const;
357     String errorLog() const;
358 #endif
359
360     FloatSize naturalSize();
361     bool hasVideo() const;
362     bool hasAudio() const;
363
364     bool inMediaDocument() const;
365
366     IntSize size() const { return m_size; }
367     void setSize(const IntSize& size);
368
369     bool load(const URL&, const ContentType&, const String& keySystem);
370 #if ENABLE(MEDIA_SOURCE)
371     bool load(const URL&, const ContentType&, MediaSourcePrivateClient*);
372 #endif
373 #if ENABLE(MEDIA_STREAM)
374     bool load(MediaStreamPrivate&);
375 #endif
376     void cancelLoad();
377
378     bool visible() const;
379     void setVisible(bool);
380
381     void prepareToPlay();
382     void play();
383     void pause();
384     void setShouldBufferData(bool);
385
386 #if ENABLE(LEGACY_ENCRYPTED_MEDIA)
387     // Represents synchronous exceptions that can be thrown from the Encrypted Media methods.
388     // This is different from the asynchronous MediaKeyError.
389     enum MediaKeyException { NoError, InvalidPlayerState, KeySystemNotSupported };
390
391     std::unique_ptr<LegacyCDMSession> createSession(const String& keySystem, LegacyCDMSessionClient*);
392     void setCDMSession(LegacyCDMSession*);
393     void keyAdded();
394 #endif
395
396 #if ENABLE(ENCRYPTED_MEDIA)
397     void cdmInstanceAttached(const CDMInstance&);
398     void cdmInstanceDetached(const CDMInstance&);
399     void attemptToDecryptWithInstance(const CDMInstance&);
400 #endif
401
402     bool paused() const;
403     bool seeking() const;
404
405     static double invalidTime() { return -1.0;}
406     MediaTime duration() const;
407     MediaTime currentTime() const;
408     void seek(const MediaTime&);
409     void seekWithTolerance(const MediaTime&, const MediaTime& negativeTolerance, const MediaTime& positiveTolerance);
410
411     MediaTime startTime() const;
412     MediaTime initialTime() const;
413
414     MediaTime getStartDate() const;
415
416     double rate() const;
417     void setRate(double);
418     double requestedRate() const;
419
420     bool preservesPitch() const;
421     void setPreservesPitch(bool);
422
423     std::unique_ptr<PlatformTimeRanges> buffered();
424     std::unique_ptr<PlatformTimeRanges> seekable();
425     MediaTime minTimeSeekable();
426     MediaTime maxTimeSeekable();
427
428     double seekableTimeRangesLastModifiedTime();
429     double liveUpdateInterval();
430
431     bool didLoadingProgress();
432
433     double volume() const;
434     void setVolume(double);
435     bool platformVolumeConfigurationRequired() const { return client().mediaPlayerPlatformVolumeConfigurationRequired(); }
436
437     bool muted() const;
438     void setMuted(bool);
439
440     bool hasClosedCaptions() const;
441     void setClosedCaptionsVisible(bool closedCaptionsVisible);
442
443     void paint(GraphicsContext&, const FloatRect&);
444     void paintCurrentFrameInContext(GraphicsContext&, const FloatRect&);
445
446     // copyVideoTextureToPlatformTexture() is used to do the GPU-GPU textures copy without a readback to system memory.
447     // The first five parameters denote the corresponding GraphicsContext, destination texture, requested level, requested type and the required internalFormat for destination texture.
448     // The last two parameters premultiplyAlpha and flipY denote whether addtional premultiplyAlpha and flip operation are required during the copy.
449     // It returns true on success and false on failure.
450
451     // In the GPU-GPU textures copy, the source texture(Video texture) should have valid target, internalFormat and size, etc.
452     // The destination texture may need to be resized to to the dimensions of the source texture or re-defined to the required internalFormat.
453     // The current restrictions require that format shoud be RGB or RGBA, type should be UNSIGNED_BYTE and level should be 0. It may be lifted in the future.
454
455     // Each platform port can have its own implementation on this function. The default implementation for it is a single "return false" in MediaPlayerPrivate.h.
456     // In chromium, the implementation is based on GL_CHROMIUM_copy_texture extension which is documented at
457     // http://src.chromium.org/viewvc/chrome/trunk/src/gpu/GLES2/extensions/CHROMIUM/CHROMIUM_copy_texture.txt and implemented at
458     // http://src.chromium.org/viewvc/chrome/trunk/src/gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.cc via shaders.
459     bool copyVideoTextureToPlatformTexture(GraphicsContext3D*, Platform3DObject texture, GC3Denum target, GC3Dint level, GC3Denum internalFormat, GC3Denum format, GC3Denum type, bool premultiplyAlpha, bool flipY);
460
461     NativeImagePtr nativeImageForCurrentTime();
462
463     using MediaPlayerEnums::NetworkState;
464     NetworkState networkState();
465
466     using MediaPlayerEnums::ReadyState;
467     ReadyState readyState();
468
469     using MediaPlayerEnums::MovieLoadType;
470     MovieLoadType movieLoadType() const;
471
472     using MediaPlayerEnums::Preload;
473     Preload preload() const;
474     void setPreload(Preload);
475
476     void networkStateChanged();
477     void readyStateChanged();
478     void volumeChanged(double);
479     void muteChanged(bool);
480     void timeChanged();
481     void sizeChanged();
482     void rateChanged();
483     void playbackStateChanged();
484     void durationChanged();
485     void firstVideoFrameAvailable();
486     void characteristicChanged();
487
488     void repaint();
489
490     MediaPlayerClient& client() const { return *m_client; }
491
492     bool hasAvailableVideoFrame() const;
493     void prepareForRendering();
494
495     bool canLoadPoster() const;
496     void setPoster(const String&);
497
498 #if USE(NATIVE_FULLSCREEN_VIDEO)
499     void enterFullscreen();
500     void exitFullscreen();
501 #endif
502
503 #if ENABLE(WIRELESS_PLAYBACK_TARGET)
504     enum WirelessPlaybackTargetType { TargetTypeNone, TargetTypeAirPlay, TargetTypeTVOut };
505     WirelessPlaybackTargetType wirelessPlaybackTargetType() const;
506
507     String wirelessPlaybackTargetName() const;
508
509     bool wirelessVideoPlaybackDisabled() const;
510     void setWirelessVideoPlaybackDisabled(bool);
511
512     void currentPlaybackTargetIsWirelessChanged();
513     void playbackTargetAvailabilityChanged();
514
515     bool isCurrentPlaybackTargetWireless() const;
516     bool canPlayToWirelessPlaybackTarget() const;
517     void setWirelessPlaybackTarget(Ref<MediaPlaybackTarget>&&);
518
519     void setShouldPlayToPlaybackTarget(bool);
520 #endif
521
522     double minFastReverseRate() const;
523     double maxFastForwardRate() const;
524
525 #if USE(NATIVE_FULLSCREEN_VIDEO)
526     bool canEnterFullscreen() const;
527 #endif
528
529     // whether accelerated rendering is supported by the media engine for the current media.
530     bool supportsAcceleratedRendering() const;
531     // called when the rendering system flips the into or out of accelerated rendering mode.
532     void acceleratedRenderingStateChanged();
533
534     bool shouldMaintainAspectRatio() const;
535     void setShouldMaintainAspectRatio(bool);
536
537 #if PLATFORM(WIN) && USE(AVFOUNDATION)
538     GraphicsDeviceAdapter* graphicsDeviceAdapter() const;
539 #endif
540
541     bool hasSingleSecurityOrigin() const;
542
543     bool didPassCORSAccessCheck() const;
544
545     MediaTime mediaTimeForTimeValue(const MediaTime&) const;
546
547     double maximumDurationToCacheMediaTime() const;
548
549     unsigned decodedFrameCount() const;
550     unsigned droppedFrameCount() const;
551     unsigned audioDecodedByteCount() const;
552     unsigned videoDecodedByteCount() const;
553
554     void setPrivateBrowsingMode(bool);
555
556 #if ENABLE(WEB_AUDIO)
557     AudioSourceProvider* audioSourceProvider();
558 #endif
559
560 #if ENABLE(LEGACY_ENCRYPTED_MEDIA)
561     RefPtr<ArrayBuffer> cachedKeyForKeyId(const String& keyId) const;
562     bool keyNeeded(Uint8Array* initData);
563     String mediaKeysStorageDirectory() const;
564 #endif
565
566 #if ENABLE(ENCRYPTED_MEDIA)
567     void initializationDataEncountered(const String&, RefPtr<ArrayBuffer>&&);
568 #endif
569
570     String referrer() const;
571     String userAgent() const;
572
573     String engineDescription() const;
574     long platformErrorCode() const;
575
576     CachedResourceLoader* cachedResourceLoader();
577     RefPtr<PlatformMediaResourceLoader> createResourceLoader();
578
579 #if ENABLE(VIDEO_TRACK)
580     void addAudioTrack(AudioTrackPrivate&);
581     void addTextTrack(InbandTextTrackPrivate&);
582     void addVideoTrack(VideoTrackPrivate&);
583     void removeAudioTrack(AudioTrackPrivate&);
584     void removeTextTrack(InbandTextTrackPrivate&);
585     void removeVideoTrack(VideoTrackPrivate&);
586
587     bool requiresTextTrackRepresentation() const;
588     void setTextTrackRepresentation(TextTrackRepresentation*);
589     void syncTextTrackBounds();
590     void tracksChanged();
591 #if ENABLE(AVF_CAPTIONS)
592     void notifyTrackModeChanged();
593     Vector<RefPtr<PlatformTextTrack>> outOfBandTrackSources();
594 #endif
595 #endif
596
597 #if PLATFORM(IOS)
598     String mediaPlayerNetworkInterfaceName() const;
599     bool getRawCookies(const URL&, Vector<Cookie>&) const;
600 #endif
601
602     static void resetMediaEngines();
603
604 #if USE(GSTREAMER)
605     WEBCORE_EXPORT void simulateAudioInterruption();
606 #endif
607
608     String languageOfPrimaryAudioTrack() const;
609
610     size_t extraMemoryCost() const;
611
612     unsigned long long fileSize() const;
613
614 #if ENABLE(MEDIA_SOURCE)
615     std::optional<PlatformVideoPlaybackQualityMetrics> videoPlaybackQualityMetrics();
616 #endif
617
618     bool shouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge&);
619     void handlePlaybackCommand(PlatformMediaSession::RemoteControlCommandType);
620     String sourceApplicationIdentifier() const;
621     Vector<String> preferredAudioCharacteristics() const;
622
623     bool ended() const;
624
625     void setShouldDisableSleep(bool);
626     bool shouldDisableSleep() const;
627
628     String contentMIMEType() const { return m_contentType.containerType(); }
629     String contentTypeCodecs() const { return m_contentType.parameter(ContentType::codecsParameter()); }
630     bool contentMIMETypeWasInferredFromExtension() const { return m_contentMIMETypeWasInferredFromExtension; }
631
632     const Vector<ContentType>& mediaContentTypesRequiringHardwareSupport() const;
633     bool shouldCheckHardwareSupport() const;
634
635 #if !RELEASE_LOG_DISABLED
636     const PAL::Logger& mediaPlayerLogger();
637     const void* mediaPlayerLogIdentifier() { return client().mediaPlayerLogIdentifier(); }
638 #endif
639
640 private:
641     MediaPlayer(MediaPlayerClient&);
642
643     const MediaPlayerFactory* nextBestMediaEngine(const MediaPlayerFactory*) const;
644     void loadWithNextMediaEngine(const MediaPlayerFactory*);
645     void reloadTimerFired();
646
647     MediaPlayerClient* m_client;
648     Timer m_reloadTimer;
649     std::unique_ptr<MediaPlayerPrivateInterface> m_private;
650     const MediaPlayerFactory* m_currentMediaEngine;
651     URL m_url;
652     ContentType m_contentType;
653     String m_keySystem;
654     IntSize m_size;
655     Preload m_preload;
656     bool m_visible;
657     double m_volume;
658     bool m_muted;
659     bool m_preservesPitch;
660     bool m_privateBrowsing;
661     bool m_shouldPrepareToRender;
662     bool m_contentMIMETypeWasInferredFromExtension;
663     bool m_initializingMediaEngine { false };
664
665 #if ENABLE(MEDIA_SOURCE)
666     RefPtr<MediaSourcePrivateClient> m_mediaSource;
667 #endif
668 #if ENABLE(MEDIA_STREAM)
669     RefPtr<MediaStreamPrivate> m_mediaStream;
670 #endif
671 };
672
673 using CreateMediaEnginePlayer = WTF::Function<std::unique_ptr<MediaPlayerPrivateInterface> (MediaPlayer*)>;
674 typedef void (*MediaEngineSupportedTypes)(HashSet<String, ASCIICaseInsensitiveHash>& types);
675 typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const MediaEngineSupportParameters& parameters);
676 typedef HashSet<RefPtr<SecurityOrigin>> (*MediaEngineOriginsInMediaCache)(const String& path);
677 typedef void (*MediaEngineClearMediaCache)(const String& path, std::chrono::system_clock::time_point modifiedSince);
678 typedef void (*MediaEngineClearMediaCacheForOrigins)(const String& path, const HashSet<RefPtr<SecurityOrigin>>&);
679 typedef bool (*MediaEngineSupportsKeySystem)(const String& keySystem, const String& mimeType);
680
681 typedef void (*MediaEngineRegistrar)(CreateMediaEnginePlayer&&, MediaEngineSupportedTypes, MediaEngineSupportsType,
682     MediaEngineOriginsInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForOrigins, MediaEngineSupportsKeySystem);
683 typedef void (*MediaEngineRegister)(MediaEngineRegistrar);
684
685 class MediaPlayerFactorySupport {
686 public:
687     WEBCORE_EXPORT static void callRegisterMediaEngine(MediaEngineRegister);
688 };
689
690 } // namespace WebCore
691
692 namespace PAL {
693
694 template<typename Type>
695 struct LogArgument;
696
697 template <>
698 struct LogArgument<WTF::MediaTime> {
699     static String toString(const WTF::MediaTime& time)
700     {
701         return time.toString();
702     }
703 };
704 }
705
706 #endif // ENABLE(VIDEO)
707
708 #endif