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