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