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 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
  32 #include "MediaPlayerProxy.h"
  33 #endif
  34
  35 #include "AudioTrackPrivate.h"
  36 #include "CDMSession.h"
  37 #include "InbandTextTrackPrivate.h"
  38 #include "IntRect.h"
  39 #include "URL.h"
  40 #include "LayoutRect.h"
  41 #include "MediaSession.h"
  42 #include "NativeImagePtr.h"
  43 #include "PlatformLayer.h"
  44 #include "Timer.h"
  45 #include "VideoTrackPrivate.h"
  46 #include <runtime/Uint8Array.h>
  47 #include <wtf/Forward.h>
  48 #include <wtf/HashSet.h>
  49 #include <wtf/MediaTime.h>
  50 #include <wtf/Noncopyable.h>
  51 #include <wtf/OwnPtr.h>
  52 #include <wtf/PassOwnPtr.h>
  53 #include <wtf/text/StringHash.h>
  54
  55 #if ENABLE(AVF_CAPTIONS)
  56 #include "PlatformTextTrack.h"
  57 #endif
  58
  59 #if USE(PLATFORM_TEXT_TRACK_MENU)
  60 #include "PlatformTextTrackMenu.h"
  61 #endif
  62
  63 OBJC_CLASS AVAsset;
  64 OBJC_CLASS AVPlayer;
  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 class Document;
  76 #if ENABLE(MEDIA_SOURCE)
  77 class MediaSourcePrivateClient;
  78 #endif
  79 class MediaPlayerPrivateInterface;
  80 class TextTrackRepresentation;
  81
  82 // Structure that will hold every native
  83 // types supported by the current media player.
  84 // We have to do that has multiple media players
  85 // backend can live at runtime.
  86 struct PlatformMedia {
  87     enum {
  88         None,
  89         QTMovieType,
  90         QTMovieGWorldType,
  91         QTMovieVisualContextType,
  92         ChromiumMediaPlayerType,
  93         QtMediaPlayerType,
  94         AVFoundationMediaPlayerType,
  95         AVFoundationCFMediaPlayerType,
  96         AVFoundationAssetType,
  97     } type;
  98
  99     union {
 100         QTMovie* qtMovie;
 101         QTMovieGWorld* qtMovieGWorld;
 102         QTMovieVisualContext* qtMovieVisualContext;
 103         MediaPlayerPrivateInterface* chromiumMediaPlayer;
 104         MediaPlayerPrivateInterface* qtMediaPlayer;
 105         AVPlayer* avfMediaPlayer;
 106         AVCFPlayer* avcfMediaPlayer;
 107         AVAsset* avfAsset;
 108     } media;
 109 };
 110
 111 struct MediaEngineSupportParameters {
 112     String type;
 113     String codecs;
 114     URL url;
 115 #if ENABLE(ENCRYPTED_MEDIA)
 116     String keySystem;
 117 #endif
 118 #if ENABLE(MEDIA_SOURCE)
 119     bool isMediaSource;
 120 #endif
 121
 122     MediaEngineSupportParameters()
 123 #if ENABLE(MEDIA_SOURCE)
 124         : isMediaSource(false)
 125 #endif
 126     {
 127     }
 128 };
 129
 130 extern const PlatformMedia NoPlatformMedia;
 131
 132 class CachedResourceLoader;
 133 class ContentType;
 134 class FrameView;
 135 class GraphicsContext;
 136 class GraphicsContext3D;
 137 class HostWindow;
 138 class IntRect;
 139 class IntSize;
 140 class MediaPlayer;
 141 struct MediaPlayerFactory;
 142 class PlatformTimeRanges;
 143
 144 #if PLATFORM(WIN) && USE(AVFOUNDATION)
 145 struct GraphicsDeviceAdapter;
 146 #endif
 147
 148 class MediaPlayerClient {
 149 public:
 150     enum CORSMode { Unspecified, Anonymous, UseCredentials };
 151
 152     virtual ~MediaPlayerClient() { }
 153
 154     // Get the document which the media player is owned by
 155     virtual Document* mediaPlayerOwningDocument() { return 0; }
 156
 157     // the network state has changed
 158     virtual void mediaPlayerNetworkStateChanged(MediaPlayer*) { }
 159
 160     // the ready state has changed
 161     virtual void mediaPlayerReadyStateChanged(MediaPlayer*) { }
 162
 163     // the volume state has changed
 164     virtual void mediaPlayerVolumeChanged(MediaPlayer*) { }
 165
 166     // the mute state has changed
 167     virtual void mediaPlayerMuteChanged(MediaPlayer*) { }
 168
 169     // time has jumped, eg. not as a result of normal playback
 170     virtual void mediaPlayerTimeChanged(MediaPlayer*) { }
 171
 172     // the media file duration has changed, or is now known
 173     virtual void mediaPlayerDurationChanged(MediaPlayer*) { }
 174
 175     // the playback rate has changed
 176     virtual void mediaPlayerRateChanged(MediaPlayer*) { }
 177
 178     // the play/pause status changed
 179     virtual void mediaPlayerPlaybackStateChanged(MediaPlayer*) { }
 180
 181     // The MediaPlayer has found potentially problematic media content.
 182     // This is used internally to trigger swapping from a <video>
 183     // element to an <embed> in standalone documents
 184     virtual void mediaPlayerSawUnsupportedTracks(MediaPlayer*) { }
 185
 186     // The MediaPlayer could not discover an engine which supports the requested resource.
 187     virtual void mediaPlayerResourceNotSupported(MediaPlayer*) { }
 188
 189 // Presentation-related methods
 190     // a new frame of video is available
 191     virtual void mediaPlayerRepaint(MediaPlayer*) { }
 192
 193     // the movie size has changed
 194     virtual void mediaPlayerSizeChanged(MediaPlayer*) { }
 195
 196     virtual void mediaPlayerEngineUpdated(MediaPlayer*) { }
 197
 198     // The first frame of video is available to render. A media engine need only make this callback if the
 199     // first frame is not available immediately when prepareForRendering is called.
 200     virtual void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*) { }
 201
 202     // A characteristic of the media file, eg. video, audio, closed captions, etc, has changed.
 203     virtual void mediaPlayerCharacteristicChanged(MediaPlayer*) { }
 204
 205     // whether the rendering system can accelerate the display of this MediaPlayer.
 206     virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) { return false; }
 207
 208     // called when the media player's rendering mode changed, which indicates a change in the
 209     // availability of the platformLayer().
 210     virtual void mediaPlayerRenderingModeChanged(MediaPlayer*) { }
 211
 212 #if PLATFORM(WIN) && USE(AVFOUNDATION)
 213     virtual GraphicsDeviceAdapter* mediaPlayerGraphicsDeviceAdapter(const MediaPlayer*) const { return 0; }
 214 #endif
 215
 216 #if ENABLE(ENCRYPTED_MEDIA)
 217     enum MediaKeyErrorCode { UnknownError = 1, ClientError, ServiceError, OutputError, HardwareChangeError, DomainError };
 218     virtual void mediaPlayerKeyAdded(MediaPlayer*, const String& /* keySystem */, const String& /* sessionId */) { }
 219     virtual void mediaPlayerKeyError(MediaPlayer*, const String& /* keySystem */, const String& /* sessionId */, MediaKeyErrorCode, unsigned short /* systemCode */) { }
 220     virtual void mediaPlayerKeyMessage(MediaPlayer*, const String& /* keySystem */, const String& /* sessionId */, const unsigned char* /* message */, unsigned /* messageLength */, const URL& /* defaultURL */) { }
 221     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, const String& /* keySystem */, const String& /* sessionId */, const unsigned char* /* initData */, unsigned /* initDataLength */) { return false; }
 222 #endif
 223
 224 #if ENABLE(ENCRYPTED_MEDIA_V2)
 225     virtual bool mediaPlayerKeyNeeded(MediaPlayer*, Uint8Array*) { return false; }
 226 #endif
 227
 228 #if ENABLE(IOS_AIRPLAY)
 229     virtual void mediaPlayerCurrentPlaybackTargetIsWirelessChanged(MediaPlayer*) { };
 230     virtual void mediaPlayerPlaybackTargetAvailabilityChanged(MediaPlayer*) { };
 231 #endif
 232
 233     virtual String mediaPlayerReferrer() const { return String(); }
 234     virtual String mediaPlayerUserAgent() const { return String(); }
 235     virtual CORSMode mediaPlayerCORSMode() const { return Unspecified; }
 236     virtual void mediaPlayerEnterFullscreen() { }
 237     virtual void mediaPlayerExitFullscreen() { }
 238     virtual bool mediaPlayerIsFullscreen() const { return false; }
 239     virtual bool mediaPlayerIsFullscreenPermitted() const { return false; }
 240     virtual bool mediaPlayerIsVideo() const { return false; }
 241     virtual LayoutRect mediaPlayerContentBoxRect() const { return LayoutRect(); }
 242     virtual void mediaPlayerSetSize(const IntSize&) { }
 243     virtual void mediaPlayerPause() { }
 244     virtual void mediaPlayerPlay() { }
 245     virtual bool mediaPlayerPlatformVolumeConfigurationRequired() const { return false; }
 246     virtual bool mediaPlayerIsPaused() const { return true; }
 247     virtual bool mediaPlayerIsLooping() const { return false; }
 248     virtual HostWindow* mediaPlayerHostWindow() { return 0; }
 249     virtual IntRect mediaPlayerWindowClipRect() { return IntRect(); }
 250     virtual CachedResourceLoader* mediaPlayerCachedResourceLoader() { return 0; }
 251     virtual bool doesHaveAttribute(const AtomicString&, AtomicString* = 0) const { return false; }
 252
 253 #if ENABLE(VIDEO_TRACK)
 254     virtual void mediaPlayerDidAddAudioTrack(PassRefPtr<AudioTrackPrivate>) { }
 255     virtual void mediaPlayerDidAddTextTrack(PassRefPtr<InbandTextTrackPrivate>) { }
 256     virtual void mediaPlayerDidAddVideoTrack(PassRefPtr<VideoTrackPrivate>) { }
 257     virtual void mediaPlayerDidRemoveAudioTrack(PassRefPtr<AudioTrackPrivate>) { }
 258     virtual void mediaPlayerDidRemoveTextTrack(PassRefPtr<InbandTextTrackPrivate>) { }
 259     virtual void mediaPlayerDidRemoveVideoTrack(PassRefPtr<VideoTrackPrivate>) { }
 260
 261     virtual void textTrackRepresentationBoundsChanged(const IntRect&) { }
 262 #if ENABLE(AVF_CAPTIONS)
 263     virtual Vector<RefPtr<PlatformTextTrack>> outOfBandTrackSources() { return Vector<RefPtr<PlatformTextTrack>>(); }
 264 #endif
 265 #endif
 266
 267     virtual bool mediaPlayerShouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge&) { return false; }
 268     virtual void mediaPlayerHandlePlaybackCommand(MediaSession::RemoteControlCommandType) { }
 269 };
 270
 271 class MediaPlayerSupportsTypeClient {
 272 public:
 273     virtual ~MediaPlayerSupportsTypeClient() { }
 274
 275     virtual bool mediaPlayerNeedsSiteSpecificHacks() const { return false; }
 276     virtual String mediaPlayerDocumentHost() const { return String(); }
 277 };
 278
 279 class MediaPlayer {
 280     WTF_MAKE_NONCOPYABLE(MediaPlayer); WTF_MAKE_FAST_ALLOCATED;
 281 public:
 282
 283     static PassOwnPtr<MediaPlayer> create(MediaPlayerClient* client)
 284     {
 285         return adoptPtr(new MediaPlayer(client));
 286     }
 287     virtual ~MediaPlayer();
 288
 289     // Media engine support.
 290     enum SupportsType { IsNotSupported, IsSupported, MayBeSupported };
 291     static MediaPlayer::SupportsType supportsType(const MediaEngineSupportParameters&, const MediaPlayerSupportsTypeClient*);
 292     static void getSupportedTypes(HashSet<String>&);
 293     static bool isAvailable();
 294     static void getSitesInMediaCache(Vector<String>&);
 295     static void clearMediaCache();
 296     static void clearMediaCacheForSite(const String&);
 297     static bool supportsKeySystem(const String& keySystem, const String& mimeType);
 298
 299     bool supportsFullscreen() const;
 300     bool supportsSave() const;
 301     bool supportsScanning() const;
 302     bool requiresImmediateCompositing() const;
 303     bool doesHaveAttribute(const AtomicString&, AtomicString* value = nullptr) const;
 304     PlatformMedia platformMedia() const;
 305     PlatformLayer* platformLayer() const;
 306 #if PLATFORM(IOS)
 307     void setVideoFullscreenLayer(PlatformLayer*);
 308     void setVideoFullscreenFrame(FloatRect);
 309     enum VideoGravity { VideoGravityResize, VideoGravityResizeAspect, VideoGravityResizeAspectFill };
 310     void setVideoFullscreenGravity(VideoGravity);
 311 #endif
 312     IntSize naturalSize();
 313     bool hasVideo() const;
 314     bool hasAudio() const;
 315
 316     void setFrameView(FrameView* frameView) { m_frameView = frameView; }
 317     FrameView* frameView() { return m_frameView; }
 318     bool inMediaDocument();
 319
 320     IntSize size() const { return m_size; }
 321     void setSize(const IntSize& size);
 322
 323     bool load(const URL&, const ContentType&, const String& keySystem);
 324 #if ENABLE(MEDIA_SOURCE)
 325     bool load(const URL&, const ContentType&, MediaSourcePrivateClient*);
 326 #endif
 327     void cancelLoad();
 328
 329     bool visible() const;
 330     void setVisible(bool);
 331
 332     void prepareToPlay();
 333     void play();
 334     void pause();
 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 #endif
 351
 352     bool paused() const;
 353     bool seeking() const;
 354
 355     static double invalidTime() { return -1.0;}
 356     double duration() const;
 357     double currentTime() const;
 358     void seek(double time);
 359     void seekWithTolerance(double time, double negativeTolerance, double positiveTolerance);
 360
 361     double startTime() const;
 362
 363     double 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     double minTimeSeekable();
 374     double maxTimeSeekable();
 375
 376     bool didLoadingProgress();
 377
 378     double volume() const;
 379     void setVolume(double);
 380     bool platformVolumeConfigurationRequired() const { return m_mediaPlayerClient->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* mediaPlayerClient() const { return m_mediaPlayerClient; }
 439     void clearMediaPlayerClient() { m_mediaPlayerClient = 0; }
 440
 441     bool hasAvailableVideoFrame() const;
 442     void prepareForRendering();
 443
 444     bool canLoadPoster() const;
 445     void setPoster(const String&);
 446
 447 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
 448     void deliverNotification(MediaPlayerProxyNotificationType notification);
 449     void setMediaPlayerProxy(WebMediaPlayerProxy* proxy);
 450     void setControls(bool);
 451 #endif
 452
 453 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO) || USE(NATIVE_FULLSCREEN_VIDEO)
 454     void enterFullscreen();
 455     void exitFullscreen();
 456 #endif
 457
 458 #if ENABLE(IOS_AIRPLAY)
 459     bool isCurrentPlaybackTargetWireless() const;
 460
 461     enum WirelessPlaybackTargetType { TargetTypeNone, TargetTypeAirPlay, TargetTypeTVOut };
 462     WirelessPlaybackTargetType wirelessPlaybackTargetType() const;
 463
 464     String wirelessPlaybackTargetName() const;
 465
 466     void showPlaybackTargetPicker();
 467
 468     bool hasWirelessPlaybackTargets() const;
 469
 470     bool wirelessVideoPlaybackDisabled() const;
 471     void setWirelessVideoPlaybackDisabled(bool);
 472
 473     void currentPlaybackTargetIsWirelessChanged();
 474     void playbackTargetAvailabilityChanged();
 475
 476     void setHasPlaybackTargetAvailabilityListeners(bool);
 477 #endif
 478
 479 #if USE(NATIVE_FULLSCREEN_VIDEO)
 480     bool canEnterFullscreen() const;
 481 #endif
 482
 483     // whether accelerated rendering is supported by the media engine for the current media.
 484     bool supportsAcceleratedRendering() const;
 485     // called when the rendering system flips the into or out of accelerated rendering mode.
 486     void acceleratedRenderingStateChanged();
 487
 488     bool shouldMaintainAspectRatio() const;
 489     void setShouldMaintainAspectRatio(bool);
 490
 491 #if PLATFORM(WIN) && USE(AVFOUNDATION)
 492     GraphicsDeviceAdapter* graphicsDeviceAdapter() const;
 493 #endif
 494
 495     bool hasSingleSecurityOrigin() const;
 496
 497     bool didPassCORSAccessCheck() const;
 498
 499     double mediaTimeForTimeValue(double) const;
 500
 501     double maximumDurationToCacheMediaTime() const;
 502
 503     unsigned decodedFrameCount() const;
 504     unsigned droppedFrameCount() const;
 505     unsigned audioDecodedByteCount() const;
 506     unsigned videoDecodedByteCount() const;
 507
 508     void setPrivateBrowsingMode(bool);
 509
 510 #if ENABLE(WEB_AUDIO)
 511     AudioSourceProvider* audioSourceProvider();
 512 #endif
 513
 514 #if ENABLE(ENCRYPTED_MEDIA)
 515     void keyAdded(const String& keySystem, const String& sessionId);
 516     void keyError(const String& keySystem, const String& sessionId, MediaPlayerClient::MediaKeyErrorCode, unsigned short systemCode);
 517     void keyMessage(const String& keySystem, const String& sessionId, const unsigned char* message, unsigned messageLength, const URL& defaultURL);
 518     bool keyNeeded(const String& keySystem, const String& sessionId, const unsigned char* initData, unsigned initDataLength);
 519 #endif
 520
 521 #if ENABLE(ENCRYPTED_MEDIA_V2)
 522     bool keyNeeded(Uint8Array* initData);
 523 #endif
 524
 525     String referrer() const;
 526     String userAgent() const;
 527
 528     String engineDescription() const;
 529
 530 #if PLATFORM(IOS)
 531     void attributeChanged(const String& name, const String& value);
 532     bool readyForPlayback() const;
 533 #endif
 534
 535     CachedResourceLoader* cachedResourceLoader();
 536
 537 #if ENABLE(VIDEO_TRACK)
 538     void addAudioTrack(PassRefPtr<AudioTrackPrivate>);
 539     void addTextTrack(PassRefPtr<InbandTextTrackPrivate>);
 540     void addVideoTrack(PassRefPtr<VideoTrackPrivate>);
 541     void removeAudioTrack(PassRefPtr<AudioTrackPrivate>);
 542     void removeTextTrack(PassRefPtr<InbandTextTrackPrivate>);
 543     void removeVideoTrack(PassRefPtr<VideoTrackPrivate>);
 544
 545     bool requiresTextTrackRepresentation() const;
 546     void setTextTrackRepresentation(TextTrackRepresentation*);
 547 #if ENABLE(AVF_CAPTIONS)
 548     void notifyTrackModeChanged();
 549     Vector<RefPtr<PlatformTextTrack>> outOfBandTrackSources();
 550 #endif
 551 #endif
 552
 553     static void resetMediaEngines();
 554
 555 #if USE(PLATFORM_TEXT_TRACK_MENU)
 556     bool implementsTextTrackControls() const;
 557     PassRefPtr<PlatformTextTrackMenuInterface> textTrackMenu();
 558 #endif
 559
 560 #if USE(GSTREAMER)
 561     void simulateAudioInterruption();
 562 #endif
 563
 564     String languageOfPrimaryAudioTrack() const;
 565
 566     size_t extraMemoryCost() const;
 567
 568     unsigned long long fileSize() const;
 569
 570 #if ENABLE(MEDIA_SOURCE)
 571     unsigned long totalVideoFrames();
 572     unsigned long droppedVideoFrames();
 573     unsigned long corruptedVideoFrames();
 574     double totalFrameDelay();
 575 #endif
 576
 577     bool shouldWaitForResponseToAuthenticationChallenge(const AuthenticationChallenge&);
 578     void handlePlaybackCommand(MediaSession::RemoteControlCommandType);
 579
 580 private:
 581     MediaPlayer(MediaPlayerClient*);
 582     MediaPlayerFactory* nextBestMediaEngine(MediaPlayerFactory*) const;
 583     void loadWithNextMediaEngine(MediaPlayerFactory*);
 584     void reloadTimerFired(Timer<MediaPlayer>&);
 585
 586     static void initializeMediaEngines();
 587
 588     MediaPlayerClient* m_mediaPlayerClient;
 589     Timer<MediaPlayer> m_reloadTimer;
 590     OwnPtr<MediaPlayerPrivateInterface> m_private;
 591     MediaPlayerFactory* m_currentMediaEngine;
 592     URL m_url;
 593     String m_contentMIMEType;
 594     String m_contentTypeCodecs;
 595     String m_keySystem;
 596     FrameView* m_frameView;
 597     IntSize m_size;
 598     Preload m_preload;
 599     bool m_visible;
 600     double m_rate;
 601     double m_volume;
 602     bool m_muted;
 603     bool m_preservesPitch;
 604     bool m_privateBrowsing;
 605     bool m_shouldPrepareToRender;
 606     bool m_contentMIMETypeWasInferredFromExtension;
 607 #if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
 608     WebMediaPlayerProxy* m_playerProxy;    // not owned or used, passed to m_private
 609 #endif
 610
 611 #if ENABLE(MEDIA_SOURCE)
 612     RefPtr<MediaSourcePrivateClient> m_mediaSource;
 613 #endif
 614 };
 615
 616 typedef PassOwnPtr<MediaPlayerPrivateInterface> (*CreateMediaEnginePlayer)(MediaPlayer*);
 617 typedef void (*MediaEngineSupportedTypes)(HashSet<String>& types);
 618 typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const MediaEngineSupportParameters& parameters);
 619 typedef void (*MediaEngineGetSitesInMediaCache)(Vector<String>&);
 620 typedef void (*MediaEngineClearMediaCache)();
 621 typedef void (*MediaEngineClearMediaCacheForSite)(const String&);
 622 typedef bool (*MediaEngineSupportsKeySystem)(const String& keySystem, const String& mimeType);
 623
 624 typedef void (*MediaEngineRegistrar)(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType,
 625     MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite, MediaEngineSupportsKeySystem);
 626 typedef void (*MediaEngineRegister)(MediaEngineRegistrar);
 627
 628 class MediaPlayerFactorySupport {
 629 public:
 630     static void callRegisterMediaEngine(MediaEngineRegister);
 631 };
 632
 633 }
 634
 635 #endif // ENABLE(VIDEO)
 636
 637 #endif