#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 "StringHash.h"
#include <wtf/HashSet.h>
#include <wtf/OwnPtr.h>
#include <wtf/Noncopyable.h>
#include <wtf/PassOwnPtr.h>
#if USE(ACCELERATED_COMPOSITING)
#include "GraphicsLayer.h"
#endif
#ifdef __OBJC__
@class QTMovie;
#else
class QTMovie;
#endif
class QTMovieGWorld;
class QTMovieVisualContext;
namespace WebCore {
struct PlatformMedia {
enum {
None,
QTMovieType,
QTMovieGWorldType,
QTMovieVisualContextType
} type;
union {
QTMovie* qtMovie;
QTMovieGWorld* qtMovieGWorld;
QTMovieVisualContext* qtMovieVisualContext;
} media;
};
extern const PlatformMedia NoPlatformMedia;
class ContentType;
class FrameView;
class GraphicsContext;
class IntRect;
class IntSize;
class MediaPlayer;
class MediaPlayerPrivateInterface;
class String;
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 mediaPlayerSawUnsupportedTracks(MediaPlayer*) { }
virtual void mediaPlayerRepaint(MediaPlayer*) { }
virtual void mediaPlayerSizeChanged(MediaPlayer*) { }
#if USE(ACCELERATED_COMPOSITING)
virtual bool mediaPlayerRenderingCanBeAccelerated(MediaPlayer*) { return false; }
virtual void mediaPlayerRenderingModeChanged(MediaPlayer*) { }
#endif
};
class MediaPlayer : public Noncopyable {
public:
static PassOwnPtr<MediaPlayer> create(MediaPlayerClient* client)
{
return new MediaPlayer(client);
}
virtual ~MediaPlayer();
enum SupportsType { IsNotSupported, IsSupported, MayBeSupported };
static MediaPlayer::SupportsType supportsType(ContentType contentType);
static void getSupportedTypes(HashSet<String>&);
static bool isAvailable();
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& 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 durationChanged();
void repaint();
MediaPlayerClient* mediaPlayerClient() const { return m_mediaPlayerClient; }
bool hasAvailableVideoFrame() const;
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;
private:
MediaPlayer(MediaPlayerClient*);
static void initializeMediaEngines();
MediaPlayerClient* m_mediaPlayerClient;
OwnPtr<MediaPlayerPrivateInterface*> m_private;
void* m_currentMediaEngine;
FrameView* m_frameView;
IntSize m_size;
Preload m_preload;
bool m_visible;
float m_rate;
float m_volume;
bool m_muted;
bool m_preservesPitch;
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
WebMediaPlayerProxy* m_playerProxy; #endif
};
typedef MediaPlayerPrivateInterface* (*CreateMediaEnginePlayer)(MediaPlayer*);
typedef void (*MediaEngineSupportedTypes)(HashSet<String>& types);
typedef MediaPlayer::SupportsType (*MediaEngineSupportsType)(const String& type, const String& codecs);
typedef void (*MediaEngineRegistrar)(CreateMediaEnginePlayer, MediaEngineSupportedTypes, MediaEngineSupportsType);
}
#endif // ENABLE(VIDEO)
#endif