#ifndef MediaPlayer_h
#define MediaPlayer_h
#if ENABLE(VIDEO)
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
#include "MediaPlayerProxy.h"
#endif
#include "Document.h"
#include "IntRect.h"
#include <wtf/Forward.h>
#include <wtf/HashSet.h>
#include <wtf/OwnPtr.h>
#include <wtf/Noncopyable.h>
#include <wtf/PassOwnPtr.h>
#include <wtf/text/StringHash.h>
#if USE(ACCELERATED_COMPOSITING)
#include "GraphicsLayer.h"
#endif
#ifdef __OBJC__
@class AVPlayer;
@class QTMovie;
#else
class AVPlayer;
class QTMovie;
#endif
class QTMovieGWorld;
class QTMovieVisualContext;
namespace WebCore {
class GStreamerGWorld;
class MediaPlayerPrivateInterface;
struct PlatformMedia {
enum {
None,
QTMovieType,
QTMovieGWorldType,
QTMovieVisualContextType,
GStreamerGWorldType,
ChromiumMediaPlayerType,
QtMediaPlayerType,
AVFoundationMediaPlayerType,
} type;
union {
QTMovie* qtMovie;
QTMovieGWorld* qtMovieGWorld;
QTMovieVisualContext* qtMovieVisualContext;
GStreamerGWorld* gstreamerGWorld;
MediaPlayerPrivateInterface* chromiumMediaPlayer;
MediaPlayerPrivateInterface* qtMediaPlayer;
AVPlayer* avfMediaPlayer;
} media;
};
extern const PlatformMedia NoPlatformMedia;
class ContentType;
class FrameView;
class GraphicsContext;
class IntRect;
class IntSize;
class MediaPlayer;
struct MediaPlayerFactory;
class TimeRanges;
class MediaPlayerClient {
public:
virtual ~MediaPlayerClient() { }
virtual Document* mediaPlayerOwningDocument() { return 0; }
virtual void mediaPlayerNetworkStateChanged(MediaPlayer*) { }
virtual void mediaPlayerReadyStateChanged(MediaPlayer*) { }
virtual void mediaPlayerVolumeChanged(MediaPlayer*) { }
virtual void mediaPlayerMuteChanged(MediaPlayer*) { }
virtual void mediaPlayerTimeChanged(MediaPlayer*) { }
virtual void mediaPlayerDurationChanged(MediaPlayer*) { }
virtual void mediaPlayerRateChanged(MediaPlayer*) { }
virtual void mediaPlayerPlaybackStateChanged(MediaPlayer*) { }
virtual void mediaPlayerSawUnsupportedTracks(MediaPlayer*) { }
virtual void mediaPlayerRepaint(MediaPlayer*) { }
virtual void mediaPlayerSizeChanged(MediaPlayer*) { }
virtual void mediaPlayerEngineUpdated(MediaPlayer*) { }
virtual void mediaPlayerFirstVideoFrameAvailable(MediaPlayer*) { }
virtual void mediaPlayerCharacteristicChanged(MediaPlayer*) { }
#if USE(ACCELERATED_COMPOSITING)
virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) { return false; }
virtual void mediaPlayerRenderingModeChanged(MediaPlayer*) { }
#endif
};
class MediaPlayer {
WTF_MAKE_NONCOPYABLE(MediaPlayer); WTF_MAKE_FAST_ALLOCATED;
public:
static PassOwnPtr<MediaPlayer> create(MediaPlayerClient* client)
{
return adoptPtr(new MediaPlayer(client));
}
virtual ~MediaPlayer();
enum SupportsType { IsNotSupported, IsSupported, MayBeSupported };
static MediaPlayer::SupportsType supportsType(const ContentType&);
static void getSupportedTypes(HashSet<String>&);
static bool isAvailable();
static void getSitesInMediaCache(Vector<String>&);
static void clearMediaCache();
static void clearMediaCacheForSite(const String&);
bool supportsFullscreen() const;
bool supportsSave() const;
PlatformMedia platformMedia() const;
#if USE(ACCELERATED_COMPOSITING)
PlatformLayer* platformLayer() const;
#endif
IntSize naturalSize();
bool hasVideo() const;
bool hasAudio() const;
void setFrameView(FrameView* frameView) { m_frameView = frameView; }
FrameView* frameView() { return m_frameView; }
bool inMediaDocument();
IntSize size() const { return m_size; }
void setSize(const IntSize& size);
void load(const String& url, const ContentType&);
void cancelLoad();
bool visible() const;
void setVisible(bool);
void prepareToPlay();
void play();
void pause();
bool paused() const;
bool seeking() const;
float duration() const;
float currentTime() const;
void seek(float time);
float startTime() const;
float rate() const;
void setRate(float);
bool preservesPitch() const;
void setPreservesPitch(bool);
PassRefPtr<TimeRanges> buffered();
float maxTimeSeekable();
unsigned bytesLoaded();
float volume() const;
void setVolume(float);
bool muted() const;
void setMuted(bool);
bool hasClosedCaptions() const;
void setClosedCaptionsVisible(bool closedCaptionsVisible);
bool autoplay() const;
void setAutoplay(bool);
void paint(GraphicsContext*, const IntRect&);
void paintCurrentFrameInContext(GraphicsContext*, const IntRect&);
enum NetworkState { Empty, Idle, Loading, Loaded, FormatError, NetworkError, DecodeError };
NetworkState networkState();
enum ReadyState { HaveNothing, HaveMetadata, HaveCurrentData, HaveFutureData, HaveEnoughData };
ReadyState readyState();
enum MovieLoadType { Unknown, Download, StoredStream, LiveStream };
MovieLoadType movieLoadType() const;
enum Preload { None, MetaData, Auto };
Preload preload() const;
void setPreload(Preload);
void networkStateChanged();
void readyStateChanged();
void volumeChanged(float);
void muteChanged(bool);
void timeChanged();
void sizeChanged();
void rateChanged();
void playbackStateChanged();
void durationChanged();
void firstVideoFrameAvailable();
void characteristicChanged();
void repaint();
MediaPlayerClient* mediaPlayerClient() const { return m_mediaPlayerClient; }
bool hasAvailableVideoFrame() const;
void prepareForRendering();
bool canLoadPoster() const;
void setPoster(const String&);
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
void deliverNotification(MediaPlayerProxyNotificationType notification);
void setMediaPlayerProxy(WebMediaPlayerProxy* proxy);
void setControls(bool);
void enterFullscreen();
void exitFullscreen();
#endif
#if USE(ACCELERATED_COMPOSITING)
bool supportsAcceleratedRendering() const;
void acceleratedRenderingStateChanged();
#endif
bool hasSingleSecurityOrigin() const;
float mediaTimeForTimeValue(float) const;
double maximumDurationToCacheMediaTime() const;
unsigned decodedFrameCount() const;
unsigned droppedFrameCount() const;
unsigned audioDecodedByteCount() const;
unsigned videoDecodedByteCount() const;
void setPrivateBrowsingMode(bool);
private:
MediaPlayer(MediaPlayerClient*);
void loadWithNextMediaEngine(MediaPlayerFactory*);
void reloadTimerFired(Timer<MediaPlayer>*);
static void initializeMediaEngines();
MediaPlayerClient* m_mediaPlayerClient;
Timer<MediaPlayer> m_reloadTimer;
OwnPtr<MediaPlayerPrivateInterface> m_private;
MediaPlayerFactory* m_currentMediaEngine;
String m_url;
String m_contentMIMEType;
String m_contentTypeCodecs;
FrameView* m_frameView;
IntSize m_size;
Preload m_preload;
bool m_visible;
float m_rate;
float m_volume;
bool m_muted;
bool m_preservesPitch;
bool m_privateBrowsing;
bool m_shouldPrepareToRender;
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
WebMediaPlayerProxy* m_playerProxy; #endif
};
typedef PassOwnPtr<MediaPlayerPrivateInterface> (*CreateMediaEnginePlayer)(MediaPlayer*);
typedef void (*MediaEngineSupportedTypes)(HashSet<String>& types);
typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const String& type, const String& codecs);
typedef void (*MediaEngineGetSitesInMediaCache)(Vector<String>&);
typedef void (*MediaEngineClearMediaCache)();
typedef void (*MediaEngineClearMediaCacheForSite)(const String&);
typedef void (*MediaEngineRegistrar)(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType,
MediaEngineGetSitesInMediaCache, MediaEngineClearMediaCache, MediaEngineClearMediaCacheForSite);
}
#endif // ENABLE(VIDEO)
#endif