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